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