git.oblomov.eu Git - wine/blob - 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 /**************************************************************************
 132  *                      MCI_MapMsg16To32W                       [internal]
 133  */
 134 static MMSYSTEM_MapType MCI_MapMsg16To32W(WORD wMsg, DWORD dwFlags, DWORD_PTR* lParam)
 135 {
 136     if (*lParam == 0)
 137         return MMSYSTEM_MAP_OK;
 138     /* FIXME: to add also (with seg/linear modifications to do):
 139      * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
 140      * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
 141      */
 142     switch (wMsg) {
 143         /* case MCI_CAPTURE */
 144     case MCI_CLOSE:
 145     case MCI_CLOSE_DRIVER:
 146     case MCI_CONFIGURE:
 147     case MCI_COPY:
 148     case MCI_CUE:
 149     case MCI_CUT:
 150     case MCI_DELETE:
 151     case MCI_GETDEVCAPS:
 152         /* case MCI_INDEX: */
 153         /* case MCI_MARK: */
 154         /* case MCI_MONITOR: */
 155     case MCI_PASTE:
 156     case MCI_PAUSE:
 157     case MCI_PLAY:
 158     case MCI_REALIZE:
 159     case MCI_RECORD:
 160     case MCI_RESUME:
 161     case MCI_SEEK:
 162     case MCI_SET:
 163         /* case MCI_SETTIMECODE:*/
 164         /* case MCI_SIGNAL:*/
 165     case MCI_SPIN:
 166     case MCI_STATUS:            /* FIXME: is wrong for digital video */
 167     case MCI_STEP:
 168     case MCI_STOP:
 169         /* case MCI_UNDO: */
 170     case MCI_UPDATE:
 171         *lParam = (DWORD)MapSL(*lParam);
 172         return MMSYSTEM_MAP_OK;
 173     case MCI_WHERE:
 174     case MCI_FREEZE:
 175     case MCI_UNFREEZE:
 176     case MCI_PUT:
 177         {
 178             LPMCI_DGV_RECT_PARMS mdrp32 = HeapAlloc(GetProcessHeap(), 0,
 179                 sizeof(LPMCI_DGV_RECT_PARMS16) + sizeof(MCI_DGV_RECT_PARMS));
 180             LPMCI_DGV_RECT_PARMS16 mdrp16 = MapSL(*lParam);
 181             if (mdrp32) {
 182                 *(LPMCI_DGV_RECT_PARMS16*)(mdrp32) = mdrp16;
 183                 mdrp32 = (LPMCI_DGV_RECT_PARMS)((char*)mdrp32 + sizeof(LPMCI_DGV_RECT_PARMS16));
 184                 mdrp32->dwCallback = mdrp16->dwCallback;
 185                 mdrp32->rc.left = mdrp16->rc.left;
 186                 mdrp32->rc.top = mdrp16->rc.top;
 187                 mdrp32->rc.right = mdrp16->rc.right;
 188                 mdrp32->rc.bottom = mdrp16->rc.bottom;
 189             } else {
 190                 return MMSYSTEM_MAP_NOMEM;
 191             }
 192             *lParam = (DWORD)mdrp32;
 193         }
 194         return MMSYSTEM_MAP_OKMEM;
 195     case MCI_WINDOW:
 196         /* in fact, I would also need the dwFlags... to see
 197          * which members of lParam are effectively used
 198          */
 199         *lParam = (DWORD)MapSL(*lParam);
 200         FIXME("Current mapping may be wrong\n");
 201         break;
 202     case MCI_BREAK:
 203         {
 204             LPMCI_BREAK_PARMS           mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
 205             LPMCI_BREAK_PARMS16         mbp16 = MapSL(*lParam);
 206
 207             if (mbp32) {
 208                 mbp32->dwCallback = mbp16->dwCallback;
 209                 mbp32->nVirtKey = mbp16->nVirtKey;
 210                 mbp32->hwndBreak = HWND_32(mbp16->hwndBreak);
 211             } else {
 212                 return MMSYSTEM_MAP_NOMEM;
 213             }
 214             *lParam = (DWORD)mbp32;
 215         }
 216         return MMSYSTEM_MAP_OKMEM;
 217     case MCI_ESCAPE:
 218         {
 219             LPMCI_VD_ESCAPE_PARMSW      mvep32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSW));
 220             LPMCI_VD_ESCAPE_PARMS16     mvep16  = MapSL(*lParam);
 221
 222             if (mvep32w) {
 223                 mvep32w->dwCallback       = mvep16->dwCallback;
 224                 mvep32w->lpstrCommand     = MCI_strdupAtoW(MapSL(mvep16->lpstrCommand));
 225             } else {
 226                 return MMSYSTEM_MAP_NOMEM;
 227             }
 228             *lParam = (DWORD)mvep32w;
 229         }
 230         return MMSYSTEM_MAP_OKMEM;
 231     case MCI_INFO:
 232         {
 233             LPMCI_INFO_PARMSW   mip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_INFO_PARMSW));
 234             LPMCI_INFO_PARMS16  mip16  = MapSL(*lParam);
 235
 236             /* FIXME this is wrong if device is of type
 237              * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
 238              */
 239             if (mip32w) {
 240                 *(LPMCI_INFO_PARMS16*)(mip32w) = mip16;
 241                 mip32w = (LPMCI_INFO_PARMSW)((char*)mip32w + sizeof(LPMCI_INFO_PARMS16));
 242                 mip32w->dwCallback  = mip16->dwCallback;
 243                 mip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mip16->dwRetSize * sizeof(WCHAR));
 244                 mip32w->dwRetSize   = mip16->dwRetSize * sizeof(WCHAR);
 245             } else {
 246                 return MMSYSTEM_MAP_NOMEM;
 247             }
 248             *lParam = (DWORD)mip32w;
 249         }
 250         return MMSYSTEM_MAP_OKMEM;
 251     case MCI_OPEN:
 252     case MCI_OPEN_DRIVER:
 253         {
 254             LPMCI_OPEN_PARMSW   mop32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSW) + 2 * sizeof(DWORD));
 255             LPMCI_OPEN_PARMS16  mop16  = MapSL(*lParam);
 256
 257             if (mop32w) {
 258                 *(LPMCI_OPEN_PARMS16*)(mop32w) = mop16;
 259                 mop32w = (LPMCI_OPEN_PARMSW)((char*)mop32w + sizeof(LPMCI_OPEN_PARMS16));
 260                 mop32w->dwCallback       = mop16->dwCallback;
 261                 mop32w->wDeviceID        = mop16->wDeviceID;
 262                 if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
 263                     mop32w->lpstrDeviceType  = MCI_strdupAtoW(MapSL(mop16->lpstrDeviceType));
 264                 else
 265                     mop32w->lpstrDeviceType  = (LPWSTR) mop16->lpstrDeviceType;
 266                 if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
 267                     mop32w->lpstrElementName = MCI_strdupAtoW(MapSL(mop16->lpstrElementName));
 268                 else
 269                     mop32w->lpstrElementName = (LPWSTR) mop16->lpstrElementName;
 270                 if( ( dwFlags &  MCI_OPEN_ALIAS))
 271                     mop32w->lpstrAlias = MCI_strdupAtoW(MapSL(mop16->lpstrAlias));
 272                 else
 273                     mop32w->lpstrAlias = (LPWSTR) mop16->lpstrAlias;
 274                 /* copy extended information if any...
 275                  * FIXME: this may seg fault if initial structure does not contain them and
 276                  * the reads after msip16 fail under LDT limits...
 277                  * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
 278                  * should not take care of extended parameters, and should be used by MCI_Open
 279                  * to fetch uDevType. When, this is known, the mapping for sending the
 280                  * MCI_OPEN_DRIVER shall be done depending on uDevType.
 281                  */
 282                 memcpy(mop32w + 1, mop16 + 1, 2 * sizeof(DWORD));
 283             } else {
 284                 return MMSYSTEM_MAP_NOMEM;
 285             }
 286             *lParam = (DWORD)mop32w;
 287         }
 288         return MMSYSTEM_MAP_OKMEM;
 289     case MCI_SYSINFO:
 290     {
 291         MCI_SYSINFO_PARMSW *msip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_OPEN_PARMS16 *) + sizeof(MCI_SYSINFO_PARMSW));
 292         MCI_SYSINFO_PARMS16 *msip16 = MapSL(*lParam);
 293
 294         if (!msip32w)
 295             return MMSYSTEM_MAP_NOMEM;
 296
 297         *(MCI_SYSINFO_PARMS16 **)msip32w = msip16;
 298         msip32w = (MCI_SYSINFO_PARMSW *)((char *)msip32w + sizeof(MCI_OPEN_PARMS16 *));
 299         msip32w->dwCallback       = msip16->dwCallback;
 300         msip32w->lpstrReturn      = HeapAlloc(GetProcessHeap(), 0, (dwFlags & MCI_SYSINFO_QUANTITY) ?
 301                                                                     sizeof(DWORD) :
 302                                                                     msip16->dwRetSize * sizeof(WCHAR));
 303         if (!msip32w->lpstrReturn)
 304         {
 305             HeapFree(GetProcessHeap(), 0, msip32w);
 306             return MMSYSTEM_MAP_NOMEM;
 307         }
 308         msip32w->dwRetSize        = (dwFlags & MCI_SYSINFO_QUANTITY) ? sizeof(DWORD) : msip16->dwRetSize;
 309         msip32w->dwNumber         = msip16->dwNumber;
 310         msip32w->wDeviceType      = msip16->wDeviceType;
 311
 312         *lParam = (DWORD)msip32w;
 313     }
 314         return MMSYSTEM_MAP_OKMEM;
 315     case MCI_SOUND:
 316         {
 317             LPMCI_SOUND_PARMSW          mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMSW));
 318             LPMCI_SOUND_PARMS16         mbp16 = MapSL(*lParam);
 319
 320             if (mbp32) {
 321                 mbp32->dwCallback = mbp16->dwCallback;
 322                 mbp32->lpstrSoundName = MCI_strdupAtoW(MapSL(mbp16->lpstrSoundName));
 323             } else {
 324                 return MMSYSTEM_MAP_NOMEM;
 325             }
 326             *lParam = (DWORD)mbp32;
 327         }
 328         return MMSYSTEM_MAP_OKMEM;
 329     case DRV_LOAD:
 330     case DRV_ENABLE:
 331     case DRV_OPEN:
 332     case DRV_CLOSE:
 333     case DRV_DISABLE:
 334     case DRV_FREE:
 335     case DRV_CONFIGURE:
 336     case DRV_QUERYCONFIGURE:
 337     case DRV_INSTALL:
 338     case DRV_REMOVE:
 339     case DRV_EXITSESSION:
 340     case DRV_EXITAPPLICATION:
 341     case DRV_POWER:
 342         FIXME("This is a hack\n");
 343         return MMSYSTEM_MAP_OK;
 344     default:
 345         FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
 346     }
 347     return MMSYSTEM_MAP_MSGERROR;
 348 }
 349
 350 /**************************************************************************
 351  *                      MCI_UnMapMsg16To32W                     [internal]
 352  */
 353 static  MMSYSTEM_MapType        MCI_UnMapMsg16To32W(WORD wMsg, DWORD dwFlags, DWORD_PTR lParam)
 354 {
 355     switch (wMsg) {
 356         /* case MCI_CAPTURE */
 357     case MCI_CLOSE:
 358     case MCI_CLOSE_DRIVER:
 359     case MCI_CONFIGURE:
 360     case MCI_COPY:
 361     case MCI_CUE:
 362     case MCI_CUT:
 363     case MCI_DELETE:
 364     case MCI_GETDEVCAPS:
 365         /* case MCI_INDEX: */
 366         /* case MCI_MARK: */
 367         /* case MCI_MONITOR: */
 368     case MCI_PASTE:
 369     case MCI_PAUSE:
 370     case MCI_PLAY:
 371     case MCI_REALIZE:
 372     case MCI_RECORD:
 373     case MCI_RESUME:
 374     case MCI_SEEK:
 375     case MCI_SET:
 376         /* case MCI_SETTIMECODE:*/
 377         /* case MCI_SIGNAL:*/
 378     case MCI_SPIN:
 379     case MCI_STATUS:
 380     case MCI_STEP:
 381     case MCI_STOP:
 382         /* case MCI_UNDO: */
 383     case MCI_UPDATE:
 384         return MMSYSTEM_MAP_OK;
 385
 386     case MCI_WHERE:
 387     case MCI_FREEZE:
 388     case MCI_UNFREEZE:
 389     case MCI_PUT:
 390         if (lParam) {
 391             LPMCI_DGV_RECT_PARMS16 mdrp16 = (LPMCI_DGV_RECT_PARMS16)lParam;
 392             LPMCI_DGV_RECT_PARMS mdrp32 = (LPMCI_DGV_RECT_PARMS)((char*)lParam + sizeof(LPMCI_DGV_RECT_PARMS16));
 393             mdrp16->dwCallback = mdrp32->dwCallback;
 394             mdrp16->rc.left = mdrp32->rc.left;
 395             mdrp16->rc.top = mdrp32->rc.top;
 396             mdrp16->rc.right = mdrp32->rc.right;
 397             mdrp16->rc.bottom = mdrp32->rc.bottom;
 398             HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
 399         }
 400         return MMSYSTEM_MAP_OK;
 401     case MCI_WINDOW:
 402         /* FIXME ?? see Map function */
 403         return MMSYSTEM_MAP_OK;
 404
 405     case MCI_BREAK:
 406         HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
 407         return MMSYSTEM_MAP_OK;
 408     case MCI_ESCAPE:
 409         if (lParam) {
 410             LPMCI_VD_ESCAPE_PARMSW      mvep32W = (LPMCI_VD_ESCAPE_PARMSW)lParam;
 411             HeapFree(GetProcessHeap(), 0, (LPVOID)mvep32W->lpstrCommand);
 412             HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
 413         }
 414         return MMSYSTEM_MAP_OK;
 415     case MCI_INFO:
 416         if (lParam) {
 417             LPMCI_INFO_PARMSW           mip32w = (LPMCI_INFO_PARMSW)lParam;
 418             LPMCI_INFO_PARMS16          mip16  = *(LPMCI_INFO_PARMS16*)((char*)mip32w - sizeof(LPMCI_INFO_PARMS16));
 419
 420             WideCharToMultiByte(CP_ACP, 0,
 421                                 mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR),
 422                                 MapSL(mip16->lpstrReturn), mip16->dwRetSize,
 423                                 NULL, NULL);
 424             HeapFree(GetProcessHeap(), 0, mip32w->lpstrReturn);
 425             HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
 426         }
 427         return MMSYSTEM_MAP_OK;
 428     case MCI_SYSINFO:
 429         if (lParam) {
 430             MCI_SYSINFO_PARMSW *msip32w = (MCI_SYSINFO_PARMSW *)lParam;
 431             MCI_SYSINFO_PARMS16 *msip16  = *(MCI_SYSINFO_PARMS16 **)((char *)msip32w - sizeof(MCI_SYSINFO_PARMS16 *));
 432
 433             if (dwFlags & MCI_SYSINFO_QUANTITY) {
 434                 DWORD *quantity = MapSL(msip16->lpstrReturn);
 435
 436                 *quantity = *(DWORD *)msip32w->lpstrReturn;
 437             }
 438             else {
 439                 WideCharToMultiByte(CP_ACP, 0,
 440                                     msip32w->lpstrReturn, msip32w->dwRetSize,
 441                                     MapSL(msip16->lpstrReturn), msip16->dwRetSize,
 442                                     NULL, NULL);
 443             }
 444
 445             HeapFree(GetProcessHeap(), 0, msip32w->lpstrReturn);
 446             HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
 447         }
 448         return MMSYSTEM_MAP_OK;
 449     case MCI_SOUND:
 450         if (lParam) {
 451             LPMCI_SOUND_PARMSW          msp32W = (LPMCI_SOUND_PARMSW)lParam;
 452             HeapFree(GetProcessHeap(), 0, (LPVOID)msp32W->lpstrSoundName);
 453             HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
 454         }
 455         return MMSYSTEM_MAP_OK;
 456     case MCI_OPEN:
 457     case MCI_OPEN_DRIVER:
 458         if (lParam) {
 459             LPMCI_OPEN_PARMSW   mop32w = (LPMCI_OPEN_PARMSW)lParam;
 460             LPMCI_OPEN_PARMS16  mop16  = *(LPMCI_OPEN_PARMS16*)((char*)mop32w - sizeof(LPMCI_OPEN_PARMS16));
 461
 462             mop16->wDeviceID = mop32w->wDeviceID;
 463             if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
 464                 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrDeviceType);
 465             if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
 466                 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrElementName);
 467             if( ( dwFlags &  MCI_OPEN_ALIAS))
 468                 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrAlias);
 469             if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
 470                 FIXME("bad free line=%d\n", __LINE__);
 471         }
 472         return MMSYSTEM_MAP_OK;
 473     case DRV_LOAD:
 474     case DRV_ENABLE:
 475     case DRV_OPEN:
 476     case DRV_CLOSE:
 477     case DRV_DISABLE:
 478     case DRV_FREE:
 479     case DRV_CONFIGURE:
 480     case DRV_QUERYCONFIGURE:
 481     case DRV_INSTALL:
 482     case DRV_REMOVE:
 483     case DRV_EXITSESSION:
 484     case DRV_EXITAPPLICATION:
 485     case DRV_POWER:
 486         FIXME("This is a hack\n");
 487         return MMSYSTEM_MAP_OK;
 488     default:
 489         FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
 490     }
 491     return MMSYSTEM_MAP_MSGERROR;
 492 }
 493
 494 /* ###################################################
 495  * #                     MCI                         #
 496  * ###################################################
 497  */
 498
 499 #include <pshpack1.h>
 500 #define MCI_MAX_THUNKS      32
 501
 502 static struct mci_thunk
 503 {
 504     BYTE        popl_eax;       /* popl  %eax (return address) */
 505     BYTE        pushl_func;     /* pushl $pfn16 (16bit callback function) */
 506     YIELDPROC16 yield16;
 507     BYTE        pushl_eax;      /* pushl %eax */
 508     BYTE        jmp;            /* ljmp MCI_Yield1632 */
 509     DWORD       callback;
 510     MCIDEVICEID id;
 511 } *MCI_Thunks;
 512
 513 #include <poppack.h>
 514
 515 static CRITICAL_SECTION mci_cs;
 516 static CRITICAL_SECTION_DEBUG mci_critsect_debug =
 517 {
 518     0, 0, &mci_cs,
 519     { &mci_critsect_debug.ProcessLocksList, &mci_critsect_debug.ProcessLocksList },
 520       0, 0, { (DWORD_PTR)(__FILE__ ": mmsystem_mci_cs") }
 521 };
 522 static CRITICAL_SECTION mci_cs = { &mci_critsect_debug, -1, 0, 0, 0, 0 };
 523
 524 static UINT MCI_Yield1632(DWORD pfn16, MCIDEVICEID id, DWORD yield_data)
 525 {
 526     WORD args[8];
 527
 528     if (!pfn16)
 529     {
 530         MSG msg;
 531         PeekMessageW( &msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE );
 532         return 0;
 533     }
 534
 535     /* 16 bit func, call it */
 536     TRACE("Function (16 bit) !\n");
 537
 538     args[2] = (MCIDEVICEID16)id;
 539     args[1] = HIWORD(yield_data);
 540     args[0] = LOWORD(yield_data);
 541     return WOWCallback16Ex(pfn16, WCB16_PASCAL, sizeof(args), args, NULL);
 542 }
 543
 544 /******************************************************************
 545  *              MCI_AddThunk
 546  *
 547  */
 548 static struct mci_thunk*       MCI_AddThunk(MCIDEVICEID id, YIELDPROC16 pfn16)
 549 {
 550      struct mci_thunk* thunk;
 551
 552      if (!MCI_Thunks)
 553      {
 554          MCI_Thunks = VirtualAlloc(NULL, MCI_MAX_THUNKS * sizeof(*MCI_Thunks), MEM_COMMIT,
 555                                    PAGE_EXECUTE_READWRITE);
 556          if (!MCI_Thunks) return NULL;
 557          for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
 558          {
 559              thunk->popl_eax     = 0x58;   /* popl  %eax */
 560              thunk->pushl_func   = 0x68;   /* pushl $pfn16 */
 561              thunk->yield16      = 0;
 562              thunk->pushl_eax    = 0x50;   /* pushl %eax */
 563              thunk->jmp          = 0xe9;   /* jmp MCI_Yield1632 */
 564              thunk->callback     = (char *)MCI_Yield1632 - (char *)(&thunk->callback + 1);
 565              thunk->id           = 0;
 566          }
 567      }
 568      for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
 569      {
 570          if (thunk->yield16 == 0)
 571          {
 572              thunk->yield16 = pfn16;
 573              thunk->id      = id;
 574              return thunk;
 575          }
 576      }
 577      FIXME("Out of mci-thunks. Bump MCI_MAX_THUNKS\n");
 578      return NULL;
 579 }
 580
 581 /******************************************************************
 582  *              MCI_HasThunk
 583  *
 584  */
 585 static struct mci_thunk*    MCI_HasThunk(YIELDPROC pfn)
 586 {
 587     struct mci_thunk* thunk;
 588
 589     if (!MCI_Thunks) return NULL;
 590     for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
 591     {
 592         if ((YIELDPROC)thunk == pfn) return thunk;
 593     }
 594     return NULL;
 595 }
 596
 597 /**************************************************************************
 598  *                              mciSetYieldProc                 [MMSYSTEM.714]
 599  */
 600 BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD dwYieldData)
 601 {
 602     struct mci_thunk*   thunk;
 603     BOOL                ret;
 604
 605     TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData);
 606
 607     if (!(thunk = MCI_AddThunk(uDeviceID, fpYieldProc)))
 608         return FALSE;
 609     ret = mciSetYieldProc(uDeviceID, (YIELDPROC)thunk, dwYieldData);
 610     if (!ret) thunk->yield16 = NULL;
 611     return ret;
 612 }
 613
 614 /**************************************************************************
 615  *                              mciGetYieldProc                 [MMSYSTEM.716]
 616  */
 617 YIELDPROC16 WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData)
 618 {
 619     YIELDPROC           yield;
 620     DWORD               data;
 621     struct mci_thunk*   thunk;
 622
 623     TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData);
 624
 625     yield = mciGetYieldProc(uDeviceID, &data);
 626     if (!yield || !(thunk = MCI_HasThunk(yield))) return NULL;
 627
 628     if (lpdwYieldData) *lpdwYieldData = data;
 629     return thunk->yield16;
 630 }
 631
 632 /**************************************************************************
 633  *                              mciGetErrorString               [MMSYSTEM.706]
 634  */
 635 BOOL16 WINAPI mciGetErrorString16(DWORD wError, LPSTR lpstrBuffer, UINT16 uLength)
 636 {
 637     return mciGetErrorStringA(wError, lpstrBuffer, uLength);
 638 }
 639
 640 /**************************************************************************
 641  *                              mciDriverNotify                 [MMSYSTEM.711]
 642  */
 643 BOOL16 WINAPI mciDriverNotify16(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus)
 644 {
 645     TRACE("(%04X, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
 646
 647     return PostMessageA(HWND_32(hWndCallBack), MM_MCINOTIFY, wStatus, wDevID);
 648 }
 649
 650 /**************************************************************************
 651  *                      mciGetDriverData                        [MMSYSTEM.708]
 652  */
 653 DWORD WINAPI mciGetDriverData16(UINT16 uDeviceID)
 654 {
 655     return mciGetDriverData(uDeviceID);
 656 }
 657
 658 /**************************************************************************
 659  *                      mciSetDriverData                        [MMSYSTEM.707]
 660  */
 661 BOOL16 WINAPI mciSetDriverData16(UINT16 uDeviceID, DWORD data)
 662 {
 663     return mciSetDriverData(uDeviceID, data);
 664 }
 665
 666 /**************************************************************************
 667  *                              mciSendCommand                  [MMSYSTEM.701]
 668  */
 669 DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD p2)
 670 {
 671     DWORD               dwRet;
 672     BOOL                to32;
 673     DWORD_PTR           dwParam2 = p2;
 674
 675     TRACE("(%04X, %s, %08X, %08lX)\n", wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
 676
 677     switch (wMsg) {
 678     case MCI_CLOSE:
 679     case MCI_OPEN:
 680     case MCI_SYSINFO:
 681     case MCI_BREAK:
 682     case MCI_SOUND:
 683         to32 = TRUE;
 684         break;
 685     default:
 686         /* FIXME: this is suboptimal. If MCI driver is a 16bit one, we'll be
 687          * doing 16=>32W, then 32W=>16 conversions.
 688          * We could directly call the 16bit driver if we had the information.
 689          */
 690         to32 = TRUE;
 691     }
 692     if (to32) {
 693         MMSYSTEM_MapType res;
 694
 695         dwRet = MCIERR_INVALID_DEVICE_ID;
 696
 697         switch (res = MCI_MapMsg16To32W(wMsg, dwParam1, &dwParam2)) {
 698         case MMSYSTEM_MAP_MSGERROR:
 699             TRACE("%s not handled yet\n", MCI_MessageToString(wMsg));
 700             dwRet = MCIERR_DRIVER_INTERNAL;
 701             break;
 702         case MMSYSTEM_MAP_NOMEM:
 703             TRACE("Problem mapping %s from 16 to 32a\n", MCI_MessageToString(wMsg));
 704             dwRet = MCIERR_OUT_OF_MEMORY;
 705             break;
 706         case MMSYSTEM_MAP_OK:
 707         case MMSYSTEM_MAP_OKMEM:
 708             dwRet = mciSendCommandW(wDevID, wMsg, dwParam1, dwParam2);
 709             if (res == MMSYSTEM_MAP_OKMEM)
 710                 MCI_UnMapMsg16To32W(wMsg, dwParam1, dwParam2);
 711             break;
 712         }
 713     }
 714     else
 715     {
 716 #if 0
 717         if (wDevID == MCI_ALL_DEVICE_ID) {
 718             FIXME("unhandled MCI_ALL_DEVICE_ID\n");
 719             dwRet = MCIERR_CANNOT_USE_ALL;
 720         } else {
 721             dwRet = SendDriverMessage(hdrv, wMsg, dwParam1, dwParam2);
 722         }
 723 #endif
 724     }
 725     if (wMsg == MCI_CLOSE && dwRet == 0 && MCI_Thunks)
 726     {
 727         /* free yield thunks, if any */
 728         unsigned    i;
 729         for (i = 0; i < MCI_MAX_THUNKS; i++)
 730         {
 731             if (MCI_Thunks[i].id == wDevID)
 732                 MCI_Thunks[i].yield16 = NULL;
 733         }
 734     }
 735     return dwRet;
 736 }
 737
 738 /**************************************************************************
 739  *                              mciGetDeviceID                  [MMSYSTEM.703]
 740  */
 741 UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName)
 742 {
 743     TRACE("(\"%s\")\n", lpstrName);
 744
 745     return mciGetDeviceIDA(lpstrName);
 746 }
 747
 748 /**************************************************************************
 749  *                              mciGetDeviceIDFromElementID     [MMSYSTEM.715]
 750  */
 751 UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType)
 752 {
 753     return mciGetDeviceIDFromElementIDA(dwElementID, lpstrType);
 754 }
 755
 756 /**************************************************************************
 757  *                              mciGetCreatorTask               [MMSYSTEM.717]
 758  */
 759 HTASK16 WINAPI mciGetCreatorTask16(UINT16 uDeviceID)
 760 {
 761     return HTASK_16(mciGetCreatorTask(uDeviceID));
 762 }
 763
 764 /**************************************************************************
 765  *                              mciDriverYield                  [MMSYSTEM.710]
 766  */
 767 UINT16 WINAPI mciDriverYield16(UINT16 uDeviceID)
 768 {
 769     return mciDriverYield(uDeviceID);
 770 }
 771
 772 /**************************************************************************
 773  *                              mciSendString                   [MMSYSTEM.702]
 774  */
 775 DWORD WINAPI mciSendString16(LPCSTR lpstrCommand, LPSTR lpstrRet,
 776                              UINT16 uRetLen, HWND16 hwndCallback)
 777 {
 778     return mciSendStringA(lpstrCommand, lpstrRet, uRetLen, HWND_32(hwndCallback));
 779 }
 780
 781 /**************************************************************************
 782  *                      mciLoadCommandResource                  [MMSYSTEM.705]
 783  */
 784 UINT16 WINAPI mciLoadCommandResource16(HINSTANCE16 hInst, LPCSTR resname, UINT16 type)
 785 {
 786     TRACE("(%04x, %s, %x)!\n", hInst, resname, type);
 787     return MCI_NO_COMMAND_TABLE;
 788 }
 789
 790 /**************************************************************************
 791  *                      mciFreeCommandResource                  [MMSYSTEM.713]
 792  */
 793 BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable)
 794 {
 795     TRACE("(%04x)!\n", uTable);
 796
 797     return FALSE;
 798 }
 799
 800 /**************************************************************************
 801  *                              mciExecute                      [MMSYSTEM.712]
 802  */
 803 BOOL16 WINAPI mciExecute16(LPCSTR lpstrCommand)
 804 {
 805     return mciExecute(lpstrCommand);
 806 }