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

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * MCI internal functions
   5  *
   6  * Copyright 1998/1999 Eric Pouech
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26
  27 #include "mmsystem.h"
  28 #include "winbase.h"
  29 #include "wingdi.h"
  30 #include "winreg.h"
  31 #include "winuser.h"
  32
  33 #include "wine/mmsystem16.h"
  34 #include "wine/winbase16.h"
  35 #include "digitalv.h"
  36 #include "winemm.h"
  37
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(mci);
  41
  42 static  int                     MCI_InstalledCount;
  43 static  LPSTR                   MCI_lpInstallNames = NULL;
  44
  45 typedef enum {
  46     MCI_MAP_NOMEM,      /* ko, memory problem */
  47     MCI_MAP_MSGERROR,   /* ko, unknown message */
  48     MCI_MAP_OK,         /* ok, no memory allocated. to be sent to the proc. */
  49     MCI_MAP_OKMEM,      /* ok, some memory allocated, need to call UnMapMsg. to be sent to the proc. */
  50 } MCI_MapType;
  51
  52 static  MCI_MapType     MCI_MapMsg16To32A  (WORD uDevType, WORD wMsg,                DWORD* lParam);
  53 static  MCI_MapType     MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg,                DWORD  lParam);
  54 static  MCI_MapType     MCI_MapMsg32ATo16  (WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam);
  55 static  MCI_MapType     MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD  lParam);
  56
  57 /* First MCI valid device ID (0 means error) */
  58 #define MCI_MAGIC 0x0001
  59
  60 /* dup a string and uppercase it */
  61 inline static LPSTR str_dup_upper( LPCSTR str )
  62 {
  63     INT len = strlen(str) + 1;
  64     LPSTR p = HeapAlloc( GetProcessHeap(), 0, len );
  65     if (p)
  66     {
  67         memcpy( p, str, len );
  68         CharUpperA( p );
  69     }
  70     return p;
  71 }
  72
  73 /**************************************************************************
  74  *                              MCI_GetDriver                   [internal]
  75  */
  76 LPWINE_MCIDRIVER        MCI_GetDriver(UINT16 wDevID)
  77 {
  78     LPWINE_MCIDRIVER    wmd = 0;
  79     LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIData();
  80
  81     EnterCriticalSection(&iData->cs);
  82     for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
  83         if (wmd->wDeviceID == wDevID)
  84             break;
  85     }
  86     LeaveCriticalSection(&iData->cs);
  87     return wmd;
  88 }
  89
  90 /**************************************************************************
  91  *                              MCI_GetDriverFromString         [internal]
  92  */
  93 UINT    MCI_GetDriverFromString(LPCSTR lpstrName)
  94 {
  95     LPWINE_MCIDRIVER    wmd;
  96     LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIData();
  97     UINT                ret = 0;
  98
  99     if (!lpstrName)
 100         return 0;
 101
 102     if (!lstrcmpiA(lpstrName, "ALL"))
 103         return MCI_ALL_DEVICE_ID;
 104
 105     EnterCriticalSection(&iData->cs);
 106     for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
 107         if (wmd->lpstrElementName && strcmp(wmd->lpstrElementName, lpstrName) == 0) {
 108             ret = wmd->wDeviceID;
 109             break;
 110         }
 111         if (wmd->lpstrDeviceType && strcasecmp(wmd->lpstrDeviceType, lpstrName) == 0) {
 112             ret = wmd->wDeviceID;
 113             break;
 114         }
 115         if (wmd->lpstrAlias && strcasecmp(wmd->lpstrAlias, lpstrName) == 0) {
 116             ret = wmd->wDeviceID;
 117             break;
 118         }
 119     }
 120     LeaveCriticalSection(&iData->cs);
 121
 122     return ret;
 123 }
 124
 125 /**************************************************************************
 126  *                      MCI_MessageToString                     [internal]
 127  */
 128 const char* MCI_MessageToString(UINT16 wMsg)
 129 {
 130     static char buffer[100];
 131
 132 #define CASE(s) case (s): return #s
 133
 134     switch (wMsg) {
 135         CASE(MCI_BREAK);
 136         CASE(MCI_CLOSE);
 137         CASE(MCI_CLOSE_DRIVER);
 138         CASE(MCI_COPY);
 139         CASE(MCI_CUE);
 140         CASE(MCI_CUT);
 141         CASE(MCI_DELETE);
 142         CASE(MCI_ESCAPE);
 143         CASE(MCI_FREEZE);
 144         CASE(MCI_PAUSE);
 145         CASE(MCI_PLAY);
 146         CASE(MCI_GETDEVCAPS);
 147         CASE(MCI_INFO);
 148         CASE(MCI_LOAD);
 149         CASE(MCI_OPEN);
 150         CASE(MCI_OPEN_DRIVER);
 151         CASE(MCI_PASTE);
 152         CASE(MCI_PUT);
 153         CASE(MCI_REALIZE);
 154         CASE(MCI_RECORD);
 155         CASE(MCI_RESUME);
 156         CASE(MCI_SAVE);
 157         CASE(MCI_SEEK);
 158         CASE(MCI_SET);
 159         CASE(MCI_SPIN);
 160         CASE(MCI_STATUS);
 161         CASE(MCI_STEP);
 162         CASE(MCI_STOP);
 163         CASE(MCI_SYSINFO);
 164         CASE(MCI_UNFREEZE);
 165         CASE(MCI_UPDATE);
 166         CASE(MCI_WHERE);
 167         CASE(MCI_WINDOW);
 168         /* constants for digital video */
 169         CASE(MCI_CAPTURE);
 170         CASE(MCI_MONITOR);
 171         CASE(MCI_RESERVE);
 172         CASE(MCI_SETAUDIO);
 173         CASE(MCI_SIGNAL);
 174         CASE(MCI_SETVIDEO);
 175         CASE(MCI_QUALITY);
 176         CASE(MCI_LIST);
 177         CASE(MCI_UNDO);
 178         CASE(MCI_CONFIGURE);
 179         CASE(MCI_RESTORE);
 180 #undef CASE
 181     default:
 182         sprintf(buffer, "MCI_<<%04X>>", wMsg);
 183         return buffer;
 184     }
 185 }
 186
 187 /**************************************************************************
 188  *                              MCI_GetDevTypeFromFileName      [internal]
 189  */
 190 static  DWORD   MCI_GetDevTypeFromFileName(LPCSTR fileName, LPSTR buf, UINT len)
 191 {
 192     LPSTR       tmp;
 193
 194     if ((tmp = strrchr(fileName, '.'))) {
 195         GetProfileStringA("mci extensions", tmp + 1, "*", buf, len);
 196         if (strcmp(buf, "*") != 0) {
 197             return 0;
 198         }
 199         TRACE("No [mci extensions] entry for '%s' found.\n", tmp);
 200     }
 201     return MCIERR_EXTENSION_NOT_FOUND;
 202 }
 203
 204 #define MAX_MCICMDTABLE                 20
 205 #define MCI_COMMAND_TABLE_NOT_LOADED    0xFFFE
 206
 207 typedef struct tagWINE_MCICMDTABLE {
 208     HANDLE              hMem;
 209     UINT                uDevType;
 210     LPCSTR              lpTable;
 211     UINT                nVerbs;         /* number of verbs in command table */
 212     LPCSTR*             aVerbs;         /* array of verbs to speed up the verb look up process */
 213 } WINE_MCICMDTABLE, *LPWINE_MCICMDTABLE;
 214 WINE_MCICMDTABLE        S_MciCmdTable[MAX_MCICMDTABLE];
 215
 216 /**************************************************************************
 217  *                              MCI_IsCommandTableValid         [internal]
 218  */
 219 static  BOOL            MCI_IsCommandTableValid(UINT uTbl)
 220 {
 221     LPCSTR      lmem, str;
 222     DWORD       flg;
 223     WORD        eid;
 224     int         idx = 0;
 225     BOOL        inCst = FALSE;
 226
 227     TRACE("Dumping cmdTbl=%d [hMem=%08x devType=%d]\n",
 228           uTbl, S_MciCmdTable[uTbl].hMem, S_MciCmdTable[uTbl].uDevType);
 229
 230     if (uTbl >= MAX_MCICMDTABLE || !S_MciCmdTable[uTbl].hMem || !S_MciCmdTable[uTbl].lpTable)
 231         return FALSE;
 232
 233     lmem = S_MciCmdTable[uTbl].lpTable;
 234     do {
 235         do {
 236             str = lmem;
 237             lmem += strlen(lmem) + 1;
 238             flg = *(LPDWORD)lmem;
 239             eid = *(LPWORD)(lmem + sizeof(DWORD));
 240             lmem += sizeof(DWORD) + sizeof(WORD);
 241             idx ++;
 242             /* EPP          TRACE("cmd='%s' %08lx %04x\n", str, flg, eid); */
 243             switch (eid) {
 244             case MCI_COMMAND_HEAD:      if (!*str || !flg) return FALSE; idx = 0;                       break;  /* check unicity of str in table */
 245             case MCI_STRING:            if (inCst) return FALSE;                                        break;
 246             case MCI_INTEGER:           if (!*str) return FALSE;                                        break;
 247             case MCI_END_COMMAND:       if (*str || flg || idx == 0) return FALSE; idx = 0;             break;
 248             case MCI_RETURN:            if (*str || idx != 1) return FALSE;                             break;
 249             case MCI_FLAG:              if (!*str) return FALSE;                                        break;
 250             case MCI_END_COMMAND_LIST:  if (*str || flg) return FALSE;  idx = 0;                        break;
 251             case MCI_RECT:              if (!*str || inCst) return FALSE;                               break;
 252             case MCI_CONSTANT:          if (inCst) return FALSE; inCst = TRUE;                          break;
 253             case MCI_END_CONSTANT:      if (*str || flg || !inCst) return FALSE; inCst = FALSE;         break;
 254             default:                    return FALSE;
 255             }
 256         } while (eid != MCI_END_COMMAND_LIST);
 257     } while (eid != MCI_END_COMMAND_LIST);
 258     return TRUE;
 259 }
 260
 261 /**************************************************************************
 262  *                              MCI_DumpCommandTable            [internal]
 263  */
 264 static  BOOL            MCI_DumpCommandTable(UINT uTbl)
 265 {
 266     LPCSTR      lmem;
 267     LPCSTR      str;
 268     DWORD       flg;
 269     WORD        eid;
 270
 271     if (!MCI_IsCommandTableValid(uTbl)) {
 272         ERR("Ooops: %d is not valid\n", uTbl);
 273         return FALSE;
 274     }
 275
 276     lmem = S_MciCmdTable[uTbl].lpTable;
 277     do {
 278         do {
 279             str = lmem;
 280             lmem += strlen(lmem) + 1;
 281             flg = *(LPDWORD)lmem;
 282             eid = *(LPWORD)(lmem + sizeof(DWORD));
 283             TRACE("cmd='%s' %08lx %04x\n", str, flg, eid);
 284             lmem += sizeof(DWORD) + sizeof(WORD);
 285         } while (eid != MCI_END_COMMAND && eid != MCI_END_COMMAND_LIST);
 286         TRACE(" => end of command%s\n", (eid == MCI_END_COMMAND_LIST) ? " list" : "");
 287     } while (eid != MCI_END_COMMAND_LIST);
 288     return TRUE;
 289 }
 290
 291 static  UINT            MCI_SetCommandTable(LPWINE_MM_IDATA iData, HANDLE hMem, UINT uDevType);
 292
 293 /**************************************************************************
 294  *                              MCI_GetCommandTable             [internal]
 295  */
 296 static  UINT            MCI_GetCommandTable(LPWINE_MM_IDATA iData, UINT uDevType)
 297 {
 298     UINT        uTbl;
 299     char        buf[32];
 300     LPSTR       str = NULL;
 301
 302     /* first look up existing for existing devType */
 303     for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) {
 304         if (S_MciCmdTable[uTbl].hMem && S_MciCmdTable[uTbl].uDevType == uDevType)
 305             return uTbl;
 306     }
 307
 308     /* well try to load id */
 309     if (uDevType >= MCI_DEVTYPE_FIRST && uDevType <= MCI_DEVTYPE_LAST) {
 310         if (LoadStringA(iData->hWinMM32Instance, uDevType, buf, sizeof(buf))) {
 311             str = buf;
 312         }
 313     } else if (uDevType == 0) {
 314         str = "CORE";
 315     }
 316     uTbl = MCI_NO_COMMAND_TABLE;
 317     if (str) {
 318         HRSRC   hRsrc = FindResourceA(iData->hWinMM32Instance, str, (LPCSTR)RT_RCDATAA);
 319         HANDLE  hMem = 0;
 320
 321         if (hRsrc) hMem = LoadResource(iData->hWinMM32Instance, hRsrc);
 322         if (hMem) {
 323             uTbl = MCI_SetCommandTable(iData, hMem, uDevType);
 324         } else {
 325             WARN("No command table found in resource %04x[%s]\n",
 326                  iData->hWinMM32Instance, str);
 327         }
 328     }
 329     TRACE("=> %d\n", uTbl);
 330     return uTbl;
 331 }
 332
 333 /**************************************************************************
 334  *                              MCI_SetCommandTable             [internal]
 335  */
 336 static  UINT            MCI_SetCommandTable(LPWINE_MM_IDATA iData, HANDLE hMem,
 337                                             UINT uDevType)
 338 {
 339     int                 uTbl;
 340     static      BOOL    bInitDone = FALSE;
 341
 342     /* <HACK>
 343      * The CORE command table must be loaded first, so that MCI_GetCommandTable()
 344      * can be called with 0 as a uDevType to retrieve it.
 345      * </HACK>
 346      */
 347     if (!bInitDone) {
 348         bInitDone = TRUE;
 349         for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) {
 350             S_MciCmdTable[uTbl].hMem = 0;
 351         }
 352         MCI_GetCommandTable(iData, 0);
 353     }
 354
 355     for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) {
 356         if (S_MciCmdTable[uTbl].hMem == 0) {
 357             LPCSTR      lmem, str;
 358             WORD        eid;
 359             WORD        count;
 360
 361             S_MciCmdTable[uTbl].hMem = hMem;
 362             S_MciCmdTable[uTbl].uDevType = uDevType;
 363             S_MciCmdTable[uTbl].lpTable = LockResource(hMem);
 364
 365             if (TRACE_ON(mci)) {
 366                 MCI_DumpCommandTable(uTbl);
 367             }
 368
 369             /* create the verbs table */
 370             /* get # of entries */
 371             lmem = S_MciCmdTable[uTbl].lpTable;
 372             count = 0;
 373             do {
 374                 lmem += strlen(lmem) + 1;
 375                 eid = *(LPWORD)(lmem + sizeof(DWORD));
 376                 lmem += sizeof(DWORD) + sizeof(WORD);
 377                 if (eid == MCI_COMMAND_HEAD)
 378                     count++;
 379             } while (eid != MCI_END_COMMAND_LIST);
 380
 381             S_MciCmdTable[uTbl].aVerbs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(LPCSTR));
 382             S_MciCmdTable[uTbl].nVerbs = count;
 383
 384             lmem = S_MciCmdTable[uTbl].lpTable;
 385             count = 0;
 386             do {
 387                 str = lmem;
 388                 lmem += strlen(lmem) + 1;
 389                 eid = *(LPWORD)(lmem + sizeof(DWORD));
 390                 lmem += sizeof(DWORD) + sizeof(WORD);
 391                 if (eid == MCI_COMMAND_HEAD)
 392                     S_MciCmdTable[uTbl].aVerbs[count++] = str;
 393             } while (eid != MCI_END_COMMAND_LIST);
 394             /* assert(count == S_MciCmdTable[uTbl].nVerbs); */
 395             return uTbl;
 396         }
 397     }
 398
 399     return MCI_NO_COMMAND_TABLE;
 400 }
 401
 402 /**************************************************************************
 403  *                              MCI_DeleteCommandTable          [internal]
 404  */
 405 static  BOOL    MCI_DeleteCommandTable(UINT uTbl)
 406 {
 407     if (uTbl >= MAX_MCICMDTABLE || !S_MciCmdTable[uTbl].hMem)
 408         return FALSE;
 409
 410     FreeResource(S_MciCmdTable[uTbl].hMem);
 411     S_MciCmdTable[uTbl].hMem = 0;
 412     if (S_MciCmdTable[uTbl].aVerbs) {
 413         HeapFree(GetProcessHeap(), 0, S_MciCmdTable[uTbl].aVerbs);
 414         S_MciCmdTable[uTbl].aVerbs = 0;
 415     }
 416     return TRUE;
 417 }
 418
 419 /**************************************************************************
 420  *                              MCI_UnLoadMciDriver             [internal]
 421  */
 422 static  BOOL    MCI_UnLoadMciDriver(LPWINE_MM_IDATA iData, LPWINE_MCIDRIVER wmd)
 423 {
 424     LPWINE_MCIDRIVER*           tmp;
 425
 426     if (!wmd)
 427         return TRUE;
 428
 429     CloseDriver(wmd->hDriver, 0, 0);
 430
 431     if (wmd->dwPrivate != 0)
 432         WARN("Unloading mci driver with non nul dwPrivate field\n");
 433
 434     EnterCriticalSection(&iData->cs);
 435     for (tmp = &iData->lpMciDrvs; *tmp; tmp = &(*tmp)->lpNext) {
 436         if (*tmp == wmd) {
 437             *tmp = wmd->lpNext;
 438             break;
 439         }
 440     }
 441     LeaveCriticalSection(&iData->cs);
 442
 443     HeapFree(GetProcessHeap(), 0, wmd->lpstrDeviceType);
 444     HeapFree(GetProcessHeap(), 0, wmd->lpstrAlias);
 445     HeapFree(GetProcessHeap(), 0, wmd->lpstrElementName);
 446
 447     HeapFree(GetProcessHeap(), 0, wmd);
 448     return TRUE;
 449 }
 450
 451 /**************************************************************************
 452  *                              MCI_OpenMciDriver               [internal]
 453  */
 454 static  BOOL    MCI_OpenMciDriver(LPWINE_MCIDRIVER wmd, LPCSTR drvTyp, LPARAM lp)
 455 {
 456     char        libName[128];
 457
 458     if (!DRIVER_GetLibName(drvTyp, "mci", libName, sizeof(libName)))
 459         return FALSE;
 460
 461     wmd->bIs32 = 0xFFFF;
 462     /* First load driver */
 463     if ((wmd->hDriver = (HDRVR)DRIVER_TryOpenDriver32(libName, lp))) {
 464         wmd->bIs32 = TRUE;
 465     } else {
 466         MCI_MapType     res;
 467
 468         switch (res = MCI_MapMsg32ATo16(0, DRV_OPEN, 0, &lp)) {
 469         case MCI_MAP_MSGERROR:
 470             TRACE("Not handled yet (DRV_OPEN)\n");
 471             break;
 472         case MCI_MAP_NOMEM:
 473             TRACE("Problem mapping msg=DRV_OPEN from 32a to 16\n");
 474             break;
 475         case MCI_MAP_OK:
 476         case MCI_MAP_OKMEM:
 477             if ((wmd->hDriver = OpenDriverA(drvTyp, "mci", lp)))
 478                 wmd->bIs32 = FALSE;
 479             if (res == MCI_MAP_OKMEM)
 480                 MCI_UnMapMsg32ATo16(0, DRV_OPEN, 0, lp);
 481             break;
 482         }
 483     }
 484     return (wmd->bIs32 == 0xFFFF) ? FALSE : TRUE;
 485 }
 486
 487 /**************************************************************************
 488  *                              MCI_LoadMciDriver               [internal]
 489  */
 490 static  DWORD   MCI_LoadMciDriver(LPWINE_MM_IDATA iData, LPCSTR _strDevTyp,
 491                                   LPWINE_MCIDRIVER* lpwmd)
 492 {
 493     LPSTR                       strDevTyp = str_dup_upper(_strDevTyp);
 494     LPWINE_MCIDRIVER            wmd = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wmd));
 495     MCI_OPEN_DRIVER_PARMSA      modp;
 496     DWORD                       dwRet = 0;
 497
 498     if (!wmd || !strDevTyp) {
 499         dwRet = MCIERR_OUT_OF_MEMORY;
 500         goto errCleanUp;
 501     }
 502
 503     wmd->lpfnYieldProc = MCI_DefYieldProc;
 504     wmd->dwYieldData = VK_CANCEL;
 505     wmd->hCreatorTask = GetCurrentTask();
 506
 507     EnterCriticalSection(&iData->cs);
 508     /* wmd must be inserted in list before sending opening the driver, coz' it
 509      * may want to lookup at wDevID
 510      */
 511     wmd->lpNext = iData->lpMciDrvs;
 512     iData->lpMciDrvs = wmd;
 513
 514     for (modp.wDeviceID = MCI_MAGIC;
 515          MCI_GetDriver(modp.wDeviceID) != 0;
 516          modp.wDeviceID++);
 517
 518     wmd->wDeviceID = modp.wDeviceID;
 519
 520     LeaveCriticalSection(&iData->cs);
 521
 522     TRACE("wDevID=%04X \n", modp.wDeviceID);
 523
 524     modp.lpstrParams = NULL;
 525
 526     if (!MCI_OpenMciDriver(wmd, strDevTyp, (LPARAM)&modp)) {
 527         /* silence warning if all is used... some bogus program use commands like
 528          * 'open all'...
 529          */
 530         if (strcasecmp(strDevTyp, "all") != 0) {
 531             dwRet = MCIERR_CANNOT_USE_ALL;
 532         } else {
 533             FIXME("Couldn't load driver for type %s.\n"
 534                   "If you don't have a windows installation accessible from Wine,\n"
 535                   "you perhaps forgot to create a [mci] section in system.ini\n",
 536                   strDevTyp);
 537             dwRet = MCIERR_DEVICE_NOT_INSTALLED;
 538         }
 539         goto errCleanUp;
 540     }
 541
 542     /* FIXME: should also check that module's description is of the form
 543      * MODULENAME:[MCI] comment
 544      */
 545
 546     /* some drivers will return 0x0000FFFF, some others 0xFFFFFFFF */
 547     wmd->uSpecificCmdTable = LOWORD(modp.wCustomCommandTable);
 548     wmd->uTypeCmdTable = MCI_COMMAND_TABLE_NOT_LOADED;
 549
 550     TRACE("Loaded driver %x (%s), type is %d, cmdTable=%08x\n",
 551           wmd->hDriver, strDevTyp, modp.wType, modp.wCustomCommandTable);
 552
 553     wmd->lpstrDeviceType = strDevTyp;
 554     wmd->wType = modp.wType;
 555
 556     TRACE("mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
 557           modp.wDeviceID, modp.wType, modp.wDeviceID);
 558     *lpwmd = wmd;
 559     return 0;
 560 errCleanUp:
 561     MCI_UnLoadMciDriver(iData, wmd);
 562     HeapFree(GetProcessHeap(), 0, strDevTyp);
 563     *lpwmd = 0;
 564     return dwRet;
 565 }
 566
 567 /**************************************************************************
 568  *                      MCI_FinishOpen                          [internal]
 569  */
 570 static  DWORD   MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSA lpParms,
 571                                DWORD dwParam)
 572 {
 573     if (dwParam & MCI_OPEN_ELEMENT)
 574     {
 575         wmd->lpstrElementName = HeapAlloc(GetProcessHeap(),0,strlen(lpParms->lpstrElementName)+1);
 576         strcpy( wmd->lpstrElementName, lpParms->lpstrElementName );
 577     }
 578     if (dwParam & MCI_OPEN_ALIAS)
 579     {
 580         wmd->lpstrAlias = HeapAlloc(GetProcessHeap(), 0, strlen(lpParms->lpstrAlias)+1);
 581         strcpy( wmd->lpstrAlias, lpParms->lpstrAlias);
 582     }
 583     lpParms->wDeviceID = wmd->wDeviceID;
 584
 585     return MCI_SendCommandFrom32(wmd->wDeviceID, MCI_OPEN_DRIVER, dwParam,
 586                                  (DWORD)lpParms);
 587 }
 588
 589 /**************************************************************************
 590  *                              MCI_FindCommand         [internal]
 591  */
 592 static  LPCSTR          MCI_FindCommand(UINT uTbl, LPCSTR verb)
 593 {
 594     UINT        idx;
 595
 596     if (uTbl >= MAX_MCICMDTABLE || S_MciCmdTable[uTbl].hMem == 0)
 597         return NULL;
 598
 599     /* another improvement would be to have the aVerbs array sorted,
 600      * so that we could use a dichotomic search on it, rather than this dumb
 601      * array look up
 602      */
 603     for (idx = 0; idx < S_MciCmdTable[uTbl].nVerbs; idx++) {
 604         if (strcmp(S_MciCmdTable[uTbl].aVerbs[idx], verb) == 0)
 605             return S_MciCmdTable[uTbl].aVerbs[idx];
 606     }
 607
 608     return NULL;
 609 }
 610
 611 /**************************************************************************
 612  *                              MCI_GetReturnType               [internal]
 613  */
 614 static  DWORD           MCI_GetReturnType(LPCSTR lpCmd)
 615 {
 616     lpCmd += strlen(lpCmd) + 1 + sizeof(DWORD) + sizeof(WORD);
 617     if (*lpCmd == '\0' && *(LPWORD)(lpCmd + 1 + sizeof(DWORD)) == MCI_RETURN) {
 618         return *(LPDWORD)(lpCmd + 1);
 619     }
 620     return 0L;
 621 }
 622
 623 /**************************************************************************
 624  *                              MCI_GetMessage                  [internal]
 625  */
 626 static  WORD            MCI_GetMessage(LPCSTR lpCmd)
 627 {
 628     return (WORD)*(LPDWORD)(lpCmd + strlen(lpCmd) + 1);
 629 }
 630
 631 /**************************************************************************
 632  *                              MCI_GetDWord                    [internal]
 633  */
 634 static  BOOL            MCI_GetDWord(LPDWORD data, LPSTR* ptr)
 635 {
 636     DWORD       val;
 637     LPSTR       ret;
 638
 639     val = strtoul(*ptr, &ret, 0);
 640
 641     switch (*ret) {
 642     case '\0':  break;
 643     case ' ':   ret++; break;
 644     default:    return FALSE;
 645     }
 646
 647     *data |= val;
 648     *ptr = ret;
 649     return TRUE;
 650 }
 651
 652 /**************************************************************************
 653  *                              MCI_GetString           [internal]
 654  */
 655 static  DWORD   MCI_GetString(LPSTR* str, LPSTR* args)
 656 {
 657     LPSTR       ptr = *args;
 658
 659     /* see if we have a quoted string */
 660     if (*ptr == '"') {
 661         ptr = strchr(*str = ptr + 1, '"');
 662         if (!ptr) return MCIERR_NO_CLOSING_QUOTE;
 663         /* FIXME: shall we escape \" from string ?? */
 664         if (ptr[-1] == '\\') TRACE("Ooops: un-escaped \"\n");
 665         *ptr++ = '\0'; /* remove trailing " */
 666         if (*ptr != ' ' && *ptr != '\0') return MCIERR_EXTRA_CHARACTERS;
 667         *ptr++ = '\0';
 668     } else {
 669         ptr = strchr(ptr, ' ');
 670
 671         if (ptr) {
 672             *ptr++ = '\0';
 673         } else {
 674             ptr = *args + strlen(*args);
 675         }
 676         *str = *args;
 677     }
 678
 679     *args = ptr;
 680     return 0;
 681 }
 682
 683 #define MCI_DATA_SIZE   16
 684
 685 /**************************************************************************
 686  *                              MCI_ParseOptArgs                [internal]
 687  */
 688 static  DWORD   MCI_ParseOptArgs(LPDWORD data, int _offset, LPCSTR lpCmd,
 689                                  LPSTR args, LPDWORD dwFlags)
 690 {
 691     int         len, offset;
 692     LPCSTR      lmem, str;
 693     DWORD       dwRet, flg, cflg = 0;
 694     WORD        eid;
 695     BOOL        inCst, found;
 696
 697     /* loop on arguments */
 698     while (*args) {
 699         lmem = lpCmd;
 700         found = inCst = FALSE;
 701         offset = _offset;
 702
 703         /* skip any leading white space(s) */
 704         while (*args == ' ') args++;
 705         TRACE("args='%s' offset=%d\n", args, offset);
 706
 707         do { /* loop on options for command table for the requested verb */
 708             str = lmem;
 709             lmem += (len = strlen(lmem)) + 1;
 710             flg = *(LPDWORD)lmem;
 711             eid = *(LPWORD)(lmem + sizeof(DWORD));
 712             lmem += sizeof(DWORD) + sizeof(WORD);
 713 /* EPP      TRACE("\tcmd='%s' inCst=%c eid=%04x\n", str, inCst ? 'Y' : 'N', eid); */
 714
 715             switch (eid) {
 716             case MCI_CONSTANT:
 717                 inCst = TRUE;   cflg = flg;     break;
 718             case MCI_END_CONSTANT:
 719                 /* there may be additional integral values after flag in constant */
 720                 if (inCst && MCI_GetDWord(&(data[offset]), &args)) {
 721                     *dwFlags |= cflg;
 722                 }
 723                 inCst = FALSE;  cflg = 0;
 724                 break;
 725             }
 726
 727             if (strncasecmp(args, str, len) == 0 &&
 728                 (args[len] == 0 || args[len] == ' ')) {
 729                 /* store good values into data[] */
 730                 args += len;
 731                 while (*args == ' ') args++;
 732                 found = TRUE;
 733
 734                 switch (eid) {
 735                 case MCI_COMMAND_HEAD:
 736                 case MCI_RETURN:
 737                 case MCI_END_COMMAND:
 738                 case MCI_END_COMMAND_LIST:
 739                 case MCI_CONSTANT:      /* done above */
 740                 case MCI_END_CONSTANT:  /* done above */
 741                     break;
 742                 case MCI_FLAG:
 743                     *dwFlags |= flg;
 744                     break;
 745                 case MCI_INTEGER:
 746                     if (inCst) {
 747                         data[offset] |= flg;
 748                         *dwFlags |= cflg;
 749                         inCst = FALSE;
 750                     } else {
 751                         *dwFlags |= flg;
 752                         if (!MCI_GetDWord(&(data[offset]), &args)) {
 753                             return MCIERR_BAD_INTEGER;
 754                         }
 755                     }
 756                     break;
 757                 case MCI_RECT:
 758                     /* store rect in data (offset...offset+3) */
 759                     *dwFlags |= flg;
 760                     if (!MCI_GetDWord(&(data[offset+0]), &args) ||
 761                         !MCI_GetDWord(&(data[offset+1]), &args) ||
 762                         !MCI_GetDWord(&(data[offset+2]), &args) ||
 763                         !MCI_GetDWord(&(data[offset+3]), &args)) {
 764                         ERR("Bad rect '%s'\n", args);
 765                         return MCIERR_BAD_INTEGER;
 766                     }
 767                     break;
 768                 case MCI_STRING:
 769                     *dwFlags |= flg;
 770                     if ((dwRet = MCI_GetString((LPSTR*)&data[offset], &args)))
 771                         return dwRet;
 772                     break;
 773                 default:        ERR("oops\n");
 774                 }
 775                 /* exit inside while loop, except if just entered in constant area definition */
 776                 if (!inCst || eid != MCI_CONSTANT) eid = MCI_END_COMMAND;
 777             } else {
 778                 /* have offset incremented if needed */
 779                 switch (eid) {
 780                 case MCI_COMMAND_HEAD:
 781                 case MCI_RETURN:
 782                 case MCI_END_COMMAND:
 783                 case MCI_END_COMMAND_LIST:
 784                 case MCI_CONSTANT:
 785                 case MCI_FLAG:                  break;
 786                 case MCI_INTEGER:               if (!inCst) offset++;   break;
 787                 case MCI_END_CONSTANT:
 788                 case MCI_STRING:                offset++; break;
 789                 case MCI_RECT:                  offset += 4; break;
 790                 default:                        ERR("oops\n");
 791                 }
 792             }
 793         } while (eid != MCI_END_COMMAND);
 794         if (!found) {
 795             WARN("Optarg '%s' not found\n", args);
 796             return MCIERR_UNRECOGNIZED_COMMAND;
 797         }
 798         if (offset == MCI_DATA_SIZE) {
 799             ERR("Internal data[] buffer overflow\n");
 800             return MCIERR_PARSER_INTERNAL;
 801         }
 802     }
 803     return 0;
 804 }
 805
 806 /**************************************************************************
 807  *                              MCI_HandleReturnValues  [internal]
 808  */
 809 static  DWORD   MCI_HandleReturnValues(LPWINE_MM_IDATA iData, DWORD dwRet,
 810                                        LPWINE_MCIDRIVER wmd, LPCSTR lpCmd, LPDWORD data,
 811                                        LPSTR lpstrRet, UINT uRetLen)
 812 {
 813     if (lpstrRet) {
 814         switch (MCI_GetReturnType(lpCmd)) {
 815         case 0: /* nothing to return */
 816             break;
 817         case MCI_INTEGER:
 818             switch (dwRet & 0xFFFF0000ul) {
 819             case 0:
 820             case MCI_INTEGER_RETURNED:
 821                 snprintf(lpstrRet, uRetLen, "%ld", data[1]);
 822                 break;
 823             case MCI_RESOURCE_RETURNED:
 824                 /* return string which ID is HIWORD(data[1]),
 825                  * string is loaded from mmsystem.dll */
 826                 LoadStringA(iData->hWinMM32Instance, HIWORD(data[1]),
 827                             lpstrRet, uRetLen);
 828                 break;
 829             case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER:
 830                 /* return string which ID is HIWORD(data[1]),
 831                  * string is loaded from driver */
 832                 /* FIXME: this is wrong for a 16 bit handle */
 833                 LoadStringA(GetDriverModuleHandle(wmd->hDriver),
 834                             HIWORD(data[1]), lpstrRet, uRetLen);
 835                 break;
 836             case MCI_COLONIZED3_RETURN:
 837                 snprintf(lpstrRet, uRetLen, "%d:%d:%d",
 838                          LOBYTE(LOWORD(data[1])), HIBYTE(LOWORD(data[1])),
 839                          LOBYTE(HIWORD(data[1])));
 840                 break;
 841             case MCI_COLONIZED4_RETURN:
 842                 snprintf(lpstrRet, uRetLen, "%d:%d:%d:%d",
 843                          LOBYTE(LOWORD(data[1])), HIBYTE(LOWORD(data[1])),
 844                          LOBYTE(HIWORD(data[1])), HIBYTE(HIWORD(data[1])));
 845                 break;
 846             default:    ERR("Ooops (%04X)\n", HIWORD(dwRet));
 847             }
 848             break;
 849         case MCI_STRING:
 850             switch (dwRet & 0xFFFF0000ul) {
 851             case 0:
 852                 /* nothing to do data[1] == lpstrRet */
 853                 break;
 854             case MCI_INTEGER_RETURNED:
 855                 data[1] = *(LPDWORD)lpstrRet;
 856                 snprintf(lpstrRet, uRetLen, "%ld", data[1]);
 857                 break;
 858             default:
 859                 WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet));
 860                 break;
 861             }
 862             break;
 863         case MCI_RECT:
 864             if (dwRet & 0xFFFF0000ul)
 865                 WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet));
 866             snprintf(lpstrRet, uRetLen, "%ld %ld %ld %ld",
 867                        data[1], data[2], data[3], data[4]);
 868             break;
 869         default:                ERR("oops\n");
 870         }
 871     }
 872     return LOWORD(dwRet);
 873 }
 874
 875 /**************************************************************************
 876  *                              mciSendStringA          [WINMM.@]
 877  */
 878 DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet,
 879                             UINT uRetLen, HWND hwndCallback)
 880 {
 881     LPSTR               verb, dev, args;
 882     LPWINE_MCIDRIVER    wmd = 0;
 883     DWORD               dwFlags = 0, dwRet = 0;
 884     int                 offset = 0;
 885     DWORD               data[MCI_DATA_SIZE];
 886     LPCSTR              lpCmd = 0;
 887     LPSTR               devAlias = NULL;
 888     LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIData();
 889     BOOL                bAutoOpen = FALSE;
 890
 891     TRACE("('%s', %p, %d, %X)\n", lpstrCommand, lpstrRet, uRetLen, hwndCallback);
 892
 893     /* format is <command> <device> <optargs> */
 894     if (!(verb = HeapAlloc(GetProcessHeap(), 0, strlen(lpstrCommand)+1)))
 895         return MCIERR_OUT_OF_MEMORY;
 896     strcpy( verb, lpstrCommand );
 897
 898     memset(data, 0, sizeof(data));
 899
 900     if (!(args = strchr(verb, ' '))) {
 901         dwRet = MCIERR_MISSING_DEVICE_NAME;
 902         goto errCleanUp;
 903     }
 904     *args++ = '\0';
 905     if ((dwRet = MCI_GetString(&dev, &args))) {
 906         goto errCleanUp;
 907     }
 908
 909     /* case dev == 'new' has to be handled */
 910     if (!strcasecmp(dev, "new")) {
 911         FIXME("'new': NIY as device name\n");
 912         dwRet = MCIERR_MISSING_DEVICE_NAME;
 913         goto errCleanUp;
 914     }
 915
 916     /* otherwise, try to grab devType from open */
 917     if (!strcmp(verb, "open")) {
 918         LPSTR   devType, tmp;
 919
 920         if ((devType = strchr(dev, '!')) != NULL) {
 921             *devType++ = '\0';
 922             tmp = devType; devType = dev; dev = tmp;
 923
 924             dwFlags |= MCI_OPEN_TYPE;
 925             data[2] = (DWORD)devType;
 926             devType = str_dup_upper(devType);
 927             dwFlags |= MCI_OPEN_ELEMENT;
 928             data[3] = (DWORD)dev;
 929         } else if (strchr(dev, '.') == NULL) {
 930             tmp = strchr(dev,' ');
 931             if (tmp) *tmp = '\0';
 932             data[2] = (DWORD)dev;
 933             devType = str_dup_upper(dev);
 934             if (tmp) *tmp = ' ';
 935             dwFlags |= MCI_OPEN_TYPE;
 936         } else {
 937             if ((devType = strstr(args, "type ")) != NULL) {
 938                 devType += 5;
 939                 tmp = strchr(devType, ' ');
 940                 if (tmp) *tmp = '\0';
 941                 devType = str_dup_upper(devType);
 942                 if (tmp) *tmp = ' ';
 943                 /* dwFlags and data[2] will be correctly set in ParseOpt loop */
 944             } else {
 945                 char    buf[32];
 946                 if ((dwRet = MCI_GetDevTypeFromFileName(dev, buf, sizeof(buf))))
 947                     goto errCleanUp;
 948
 949                 devType = str_dup_upper(buf);
 950             }
 951             dwFlags |= MCI_OPEN_ELEMENT;
 952             data[3] = (DWORD)dev;
 953         }
 954         if ((devAlias = strstr(args," alias "))) {
 955             char *tmp2;
 956             devAlias += 7;
 957             if (!(tmp = strchr(devAlias,' '))) tmp = devAlias + strlen(devAlias);
 958             if (tmp) *tmp = '\0';
 959             tmp2 = HeapAlloc(GetProcessHeap(), 0, tmp - devAlias + 1 );
 960             memcpy( tmp2, devAlias, tmp - devAlias );
 961             tmp2[tmp - devAlias] = 0;
 962             data[4] = (DWORD)tmp2;
 963             /* should be done in regular options parsing */
 964             /* dwFlags |= MCI_OPEN_ALIAS; */
 965         }
 966
 967         dwRet = MCI_LoadMciDriver(iData, devType, &wmd);
 968         HeapFree(GetProcessHeap(), 0, devType);
 969         if (dwRet) {
 970             MCI_UnLoadMciDriver(iData, wmd);
 971             goto errCleanUp;
 972         }
 973     } else if (!(wmd = MCI_GetDriver(mciGetDeviceIDA(dev)))) {
 974         /* auto open */
 975         char    buf[128];
 976         sprintf(buf, "open %s wait", dev);
 977
 978         if ((dwRet = mciSendStringA(buf, NULL, 0, 0)) != 0)
 979             goto errCleanUp;
 980
 981         wmd = MCI_GetDriver(mciGetDeviceIDA(dev));
 982         if (!wmd) {
 983             /* FIXME: memory leak, MCI driver is not closed */
 984             dwRet = MCIERR_INVALID_DEVICE_ID;
 985             goto errCleanUp;
 986         }
 987     }
 988
 989     /* get the verb in the different command tables */
 990     if (wmd) {
 991         /* try the device specific command table */
 992         lpCmd = MCI_FindCommand(wmd->uSpecificCmdTable, verb);
 993         if (!lpCmd) {
 994             /* try the type specific command table */
 995             if (wmd->uTypeCmdTable == MCI_COMMAND_TABLE_NOT_LOADED)
 996                 wmd->uTypeCmdTable = MCI_GetCommandTable(iData, wmd->wType);
 997             if (wmd->uTypeCmdTable != MCI_NO_COMMAND_TABLE)
 998                 lpCmd = MCI_FindCommand(wmd->uTypeCmdTable, verb);
 999         }
1000     }
1001     /* try core command table */
1002     if (!lpCmd) lpCmd = MCI_FindCommand(MCI_GetCommandTable(iData, 0), verb);
1003
1004     if (!lpCmd) {
1005         TRACE("Command '%s' not found!\n", verb);
1006         dwRet = MCIERR_UNRECOGNIZED_COMMAND;
1007         goto errCleanUp;
1008     }
1009
1010     /* set up call back */
1011     if (hwndCallback != 0) {
1012         dwFlags |= MCI_NOTIFY;
1013         data[0] = (DWORD)hwndCallback;
1014     }
1015
1016     /* set return information */
1017     switch (MCI_GetReturnType(lpCmd)) {
1018     case 0:             offset = 1;     break;
1019     case MCI_INTEGER:   offset = 2;     break;
1020     case MCI_STRING:    data[1] = (DWORD)lpstrRet; data[2] = uRetLen; offset = 3; break;
1021     case MCI_RECT:      offset = 5;     break;
1022     default:    ERR("oops\n");
1023     }
1024
1025     TRACE("verb='%s' on dev='%s'; offset=%d\n", verb, dev, offset);
1026
1027     if ((dwRet = MCI_ParseOptArgs(data, offset, lpCmd, args, &dwFlags)))
1028         goto errCleanUp;
1029
1030     if (bAutoOpen && (dwFlags & MCI_NOTIFY)) {
1031         dwRet = MCIERR_NOTIFY_ON_AUTO_OPEN;
1032         goto errCleanUp;
1033     }
1034     /* FIXME: the command should get it's own notification window set up and
1035      * ask for device closing while processing the notification mechanism
1036      */
1037     if (lpstrRet && uRetLen) *lpstrRet = '\0';
1038
1039 #define STR_OF(_x) (IsBadReadPtr((char*)_x,1)?"?":(char*)(_x))
1040     TRACE("[%d, %s, %08lx, %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s]\n",
1041           wmd->wDeviceID, MCI_MessageToString(MCI_GetMessage(lpCmd)), dwFlags,
1042           data[0], STR_OF(data[0]), data[1], STR_OF(data[1]),
1043           data[2], STR_OF(data[2]), data[3], STR_OF(data[3]),
1044           data[4], STR_OF(data[4]), data[5], STR_OF(data[5]));
1045 #undef STR_OF
1046
1047     if (strcmp(verb, "open") == 0) {
1048         if ((dwRet = MCI_FinishOpen(wmd, (LPMCI_OPEN_PARMSA)data, dwFlags)))
1049             MCI_UnLoadMciDriver(iData, wmd);
1050         /* FIXME: notification is not properly shared across two opens */
1051     } else {
1052         dwRet = MCI_SendCommand(wmd->wDeviceID, MCI_GetMessage(lpCmd), dwFlags, (DWORD)data, TRUE);
1053     }
1054     TRACE("=> 1/ %lx (%s)\n", dwRet, lpstrRet);
1055     dwRet = MCI_HandleReturnValues(iData, dwRet, wmd, lpCmd, data, lpstrRet, uRetLen);
1056     TRACE("=> 2/ %lx (%s)\n", dwRet, lpstrRet);
1057
1058 errCleanUp:
1059     HeapFree(GetProcessHeap(), 0, verb);
1060     HeapFree(GetProcessHeap(), 0, devAlias);
1061     return dwRet;
1062 }
1063
1064 /**************************************************************************
1065  *                              mciSendStringW                  [WINMM.@]
1066  */
1067 DWORD WINAPI mciSendStringW(LPCWSTR lpwstrCommand, LPSTR lpstrRet,
1068                             UINT uRetLen, HWND hwndCallback)
1069 {
1070     LPSTR       lpstrCommand;
1071     UINT        ret;
1072     INT len;
1073
1074     /* FIXME: is there something to do with lpstrReturnString ? */
1075     len = WideCharToMultiByte( CP_ACP, 0, lpwstrCommand, -1, NULL, 0, NULL, NULL );
1076     lpstrCommand = HeapAlloc( GetProcessHeap(), 0, len );
1077     WideCharToMultiByte( CP_ACP, 0, lpwstrCommand, -1, lpstrCommand, len, NULL, NULL );
1078     ret = mciSendStringA(lpstrCommand, lpstrRet, uRetLen, hwndCallback);
1079     HeapFree(GetProcessHeap(), 0, lpstrCommand);
1080     return ret;
1081 }
1082
1083 /**************************************************************************
1084  *                              mciSendString                   [MMSYSTEM.702]
1085  */
1086 DWORD WINAPI mciSendString16(LPCSTR lpstrCommand, LPSTR lpstrRet,
1087                              UINT16 uRetLen, HWND16 hwndCallback)
1088 {
1089     return mciSendStringA(lpstrCommand, lpstrRet, uRetLen, hwndCallback);
1090 }
1091
1092 /**************************************************************************
1093  *                              mciExecute                      [WINMM.@]
1094  *                              mciExecute                      [MMSYSTEM.712]
1095  */
1096 DWORD WINAPI mciExecute(LPCSTR lpstrCommand)
1097 {
1098     char        strRet[256];
1099     DWORD       ret;
1100
1101     TRACE("(%s)!\n", lpstrCommand);
1102
1103     ret = mciSendStringA(lpstrCommand, strRet, sizeof(strRet), 0);
1104     if (ret != 0) {
1105         if (!mciGetErrorStringA(ret, strRet, sizeof(strRet))) {
1106             sprintf(strRet, "Unknown MCI error (%ld)", ret);
1107         }
1108         MessageBoxA(0, strRet, "Error in mciExecute()", MB_OK);
1109     }
1110     /* FIXME: what shall I return ? */
1111     return 0;
1112 }
1113
1114 /**************************************************************************
1115  *                      mciLoadCommandResource                  [MMSYSTEM.705]
1116  */
1117 UINT16 WINAPI mciLoadCommandResource16(HANDLE16 hInst, LPCSTR resname, UINT16 type)
1118 {
1119     HRSRC               hRsrc = 0;
1120     HGLOBAL             hMem;
1121     UINT16              ret = MCI_NO_COMMAND_TABLE;
1122     LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIData();
1123
1124     TRACE("(%04x, %s, %d)!\n", hInst, resname, type);
1125
1126     /* if file exists "resname.mci", then load resource "resname" from it
1127      * otherwise directly from driver
1128      * We don't support it (who uses this feature ?), but we check anyway
1129      */
1130     if (!type) {
1131         char            buf[128];
1132         OFSTRUCT        ofs;
1133
1134         strcat(strcpy(buf, resname), ".mci");
1135         if (OpenFile(buf, &ofs, OF_EXIST) != HFILE_ERROR) {
1136             FIXME("NIY: command table to be loaded from '%s'\n", ofs.szPathName);
1137         }
1138     }
1139     if (!(hRsrc = FindResourceA(hInst, resname, (LPCSTR)RT_RCDATAA))) {
1140         WARN("No command table found in resource\n");
1141     } else if ((hMem = LoadResource(hInst, hRsrc))) {
1142         ret = MCI_SetCommandTable(iData, hMem, type);
1143     } else {
1144         WARN("Couldn't load resource.\n");
1145     }
1146     TRACE("=> %04x\n", ret);
1147     return ret;
1148 }
1149
1150 /**************************************************************************
1151  *                      mciFreeCommandResource                  [MMSYSTEM.713]
1152  */
1153 BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable)
1154 {
1155     TRACE("(%04x)!\n", uTable);
1156
1157     return MCI_DeleteCommandTable(uTable);
1158 }
1159
1160 /**************************************************************************
1161  *                      mciLoadCommandResource                  [WINMM.@]
1162  *
1163  * Strangely, this function only exists as an UNICODE one.
1164  */
1165 UINT WINAPI mciLoadCommandResource(HINSTANCE hInst, LPCWSTR resNameW, UINT type)
1166 {
1167     HRSRC               hRsrc = 0;
1168     HGLOBAL             hMem;
1169     UINT16              ret = MCI_NO_COMMAND_TABLE;
1170     LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIData();
1171
1172     TRACE("(%04x, %s, %d)!\n", hInst, debugstr_w(resNameW), type);
1173
1174 #if 0
1175     /* if file exists "resname.mci", then load resource "resname" from it
1176      * otherwise directly from driver
1177      * We don't support it (who uses this feature ?), but we check anyway
1178      */
1179     if (!type) {
1180         char            buf[128];
1181         OFSTRUCT        ofs;
1182
1183         strcat(strcpy(buf, resname), ".mci");
1184         if (OpenFile(buf, &ofs, OF_EXIST) != HFILE_ERROR) {
1185             FIXME("NIY: command table to be loaded from '%s'\n", ofs.szPathName);
1186         }
1187     }
1188 #endif
1189     if (!(hRsrc = FindResourceW(hInst, resNameW, (LPCWSTR)RT_RCDATAA))) {
1190         WARN("No command table found in resource\n");
1191     } else if ((hMem = LoadResource(hInst, hRsrc))) {
1192         ret = MCI_SetCommandTable(iData, hMem, type);
1193     } else {
1194         WARN("Couldn't load resource.\n");
1195     }
1196     TRACE("=> %04x\n", ret);
1197     return ret;
1198 }
1199
1200 #if 0
1201     LPSTR       resNameA;
1202     UINT        ret;
1203
1204     TRACE("(%04x, %s, %d)!\n", hinst, debugstr_w(resNameW), type);
1205
1206     resNameA = HEAP_strdupWtoA(GetProcessHeap(), 0, resNameW);
1207     ret = mciLoadCommandResource16(hinst, resNameA, type);
1208     HeapFree(GetProcessHeap(), 0, resNameA);
1209     return ret;
1210 #endif
1211
1212 /**************************************************************************
1213  *                      mciFreeCommandResource                  [WINMM.@]
1214  */
1215 BOOL WINAPI mciFreeCommandResource(UINT uTable)
1216 {
1217     TRACE("(%08x)!\n", uTable);
1218
1219     return MCI_DeleteCommandTable(uTable);
1220 }
1221
1222 /**************************************************************************
1223  *                      MCI_MapMsg16To32A                       [internal]
1224  */
1225 static  MCI_MapType     MCI_MapMsg16To32A(WORD uDevType, WORD wMsg, DWORD* lParam)
1226 {
1227     if (*lParam == 0)
1228         return MCI_MAP_OK;
1229     /* FIXME: to add also (with seg/linear modifications to do):
1230      * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
1231      * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
1232      */
1233     switch (wMsg) {
1234         /* case MCI_CAPTURE */
1235     case MCI_CLOSE:
1236     case MCI_CLOSE_DRIVER:
1237     case MCI_CONFIGURE:
1238     case MCI_COPY:
1239     case MCI_CUE:
1240     case MCI_CUT:
1241     case MCI_DELETE:
1242     case MCI_FREEZE:
1243     case MCI_GETDEVCAPS:
1244         /* case MCI_INDEX: */
1245         /* case MCI_MARK: */
1246         /* case MCI_MONITOR: */
1247     case MCI_PASTE:
1248     case MCI_PAUSE:
1249     case MCI_PLAY:
1250     case MCI_PUT:
1251     case MCI_REALIZE:
1252     case MCI_RECORD:
1253     case MCI_RESUME:
1254     case MCI_SEEK:
1255     case MCI_SET:
1256         /* case MCI_SETTIMECODE:*/
1257         /* case MCI_SIGNAL:*/
1258     case MCI_SPIN:
1259     case MCI_STATUS:            /* FIXME: is wrong for digital video */
1260     case MCI_STEP:
1261     case MCI_STOP:
1262         /* case MCI_UNDO: */
1263     case MCI_UNFREEZE:
1264     case MCI_UPDATE:
1265     case MCI_WHERE:
1266         *lParam = (DWORD)MapSL(*lParam);
1267         return MCI_MAP_OK;
1268     case MCI_WINDOW:
1269         /* in fact, I would also need the dwFlags... to see
1270          * which members of lParam are effectively used
1271          */
1272         *lParam = (DWORD)MapSL(*lParam);
1273         FIXME("Current mapping may be wrong\n");
1274         break;
1275     case MCI_BREAK:
1276         {
1277             LPMCI_BREAK_PARMS           mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
1278             LPMCI_BREAK_PARMS16         mbp16 = MapSL(*lParam);
1279
1280             if (mbp32) {
1281                 mbp32->dwCallback = mbp16->dwCallback;
1282                 mbp32->nVirtKey = mbp16->nVirtKey;
1283                 mbp32->hwndBreak = mbp16->hwndBreak;
1284             } else {
1285                 return MCI_MAP_NOMEM;
1286             }
1287             *lParam = (DWORD)mbp32;
1288         }
1289         return MCI_MAP_OKMEM;
1290     case MCI_ESCAPE:
1291         {
1292             LPMCI_VD_ESCAPE_PARMSA      mvep32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSA));
1293             LPMCI_VD_ESCAPE_PARMS16     mvep16  = MapSL(*lParam);
1294
1295             if (mvep32a) {
1296                 mvep32a->dwCallback       = mvep16->dwCallback;
1297                 mvep32a->lpstrCommand     = MapSL(mvep16->lpstrCommand);
1298             } else {
1299                 return MCI_MAP_NOMEM;
1300             }
1301             *lParam = (DWORD)mvep32a;
1302         }
1303         return MCI_MAP_OKMEM;
1304     case MCI_INFO:
1305         {
1306             LPMCI_INFO_PARMSA   mip32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_INFO_PARMSA));
1307             LPMCI_INFO_PARMS16  mip16  = MapSL(*lParam);
1308
1309             /* FIXME this is wrong if device is of type
1310              * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
1311              */
1312             if (mip32a) {
1313                 mip32a->dwCallback  = mip16->dwCallback;
1314                 mip32a->lpstrReturn = MapSL(mip16->lpstrReturn);
1315                 mip32a->dwRetSize   = mip16->dwRetSize;
1316             } else {
1317                 return MCI_MAP_NOMEM;
1318             }
1319             *lParam = (DWORD)mip32a;
1320         }
1321         return MCI_MAP_OKMEM;
1322     case MCI_OPEN:
1323     case MCI_OPEN_DRIVER:
1324         {
1325             LPMCI_OPEN_PARMSA   mop32a = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSA) + 2 * sizeof(DWORD));
1326             LPMCI_OPEN_PARMS16  mop16  = MapSL(*lParam);
1327
1328             if (mop32a) {
1329                 *(LPMCI_OPEN_PARMS16*)(mop32a) = mop16;
1330                 mop32a = (LPMCI_OPEN_PARMSA)((char*)mop32a + sizeof(LPMCI_OPEN_PARMS16));
1331                 mop32a->dwCallback       = mop16->dwCallback;
1332                 mop32a->wDeviceID        = mop16->wDeviceID;
1333                 mop32a->lpstrDeviceType  = MapSL(mop16->lpstrDeviceType);
1334                 mop32a->lpstrElementName = MapSL(mop16->lpstrElementName);
1335                 mop32a->lpstrAlias       = MapSL(mop16->lpstrAlias);
1336                 /* copy extended information if any...
1337                  * FIXME: this may seg fault if initial structure does not contain them and
1338                  * the reads after msip16 fail under LDT limits...
1339                  * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
1340                  * should not take care of extended parameters, and should be used by MCI_Open
1341                  * to fetch uDevType. When, this is known, the mapping for sending the
1342                  * MCI_OPEN_DRIVER shall be done depending on uDevType.
1343                  */
1344                 memcpy(mop32a + 1, mop16 + 1, 2 * sizeof(DWORD));
1345             } else {
1346                 return MCI_MAP_NOMEM;
1347             }
1348             *lParam = (DWORD)mop32a;
1349         }
1350         return MCI_MAP_OKMEM;
1351     case MCI_SYSINFO:
1352         {
1353             LPMCI_SYSINFO_PARMSA        msip32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SYSINFO_PARMSA));
1354             LPMCI_SYSINFO_PARMS16       msip16  = MapSL(*lParam);
1355
1356             if (msip32a) {
1357                 msip32a->dwCallback       = msip16->dwCallback;
1358                 msip32a->lpstrReturn      = MapSL(msip16->lpstrReturn);
1359                 msip32a->dwRetSize        = msip16->dwRetSize;
1360                 msip32a->dwNumber         = msip16->dwNumber;
1361                 msip32a->wDeviceType      = msip16->wDeviceType;
1362             } else {
1363                 return MCI_MAP_NOMEM;
1364             }
1365             *lParam = (DWORD)msip32a;
1366         }
1367         return MCI_MAP_OKMEM;
1368     case DRV_LOAD:
1369     case DRV_ENABLE:
1370     case DRV_OPEN:
1371     case DRV_CLOSE:
1372     case DRV_DISABLE:
1373     case DRV_FREE:
1374     case DRV_CONFIGURE:
1375     case DRV_QUERYCONFIGURE:
1376     case DRV_INSTALL:
1377     case DRV_REMOVE:
1378     case DRV_EXITSESSION:
1379     case DRV_EXITAPPLICATION:
1380     case DRV_POWER:
1381         FIXME("This is a hack\n");
1382         return MCI_MAP_OK;
1383
1384     default:
1385         WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
1386     }
1387     return MCI_MAP_MSGERROR;
1388 }
1389
1390 /**************************************************************************
1391  *                      MCI_UnMapMsg16To32A                     [internal]
1392  */
1393 static  MCI_MapType     MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg, DWORD lParam)
1394 {
1395     switch (wMsg) {
1396         /* case MCI_CAPTURE */
1397     case MCI_CLOSE:
1398     case MCI_CLOSE_DRIVER:
1399     case MCI_CONFIGURE:
1400     case MCI_COPY:
1401     case MCI_CUE:
1402     case MCI_CUT:
1403     case MCI_DELETE:
1404     case MCI_FREEZE:
1405     case MCI_GETDEVCAPS:
1406         /* case MCI_INDEX: */
1407         /* case MCI_MARK: */
1408         /* case MCI_MONITOR: */
1409     case MCI_PASTE:
1410     case MCI_PAUSE:
1411     case MCI_PLAY:
1412     case MCI_PUT:
1413     case MCI_REALIZE:
1414     case MCI_RECORD:
1415     case MCI_RESUME:
1416     case MCI_SEEK:
1417     case MCI_SET:
1418         /* case MCI_SETTIMECODE:*/
1419         /* case MCI_SIGNAL:*/
1420     case MCI_SPIN:
1421     case MCI_STATUS:
1422     case MCI_STEP:
1423     case MCI_STOP:
1424         /* case MCI_UNDO: */
1425     case MCI_UNFREEZE:
1426     case MCI_UPDATE:
1427     case MCI_WHERE:
1428         return MCI_MAP_OK;
1429
1430     case MCI_WINDOW:
1431         /* FIXME ?? see Map function */
1432         return MCI_MAP_OK;
1433
1434     case MCI_BREAK:
1435     case MCI_ESCAPE:
1436     case MCI_INFO:
1437     case MCI_SYSINFO:
1438         HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
1439         return MCI_MAP_OK;
1440     case MCI_OPEN:
1441     case MCI_OPEN_DRIVER:
1442         if (lParam) {
1443             LPMCI_OPEN_PARMSA   mop32a = (LPMCI_OPEN_PARMSA)lParam;
1444             LPMCI_OPEN_PARMS16  mop16  = *(LPMCI_OPEN_PARMS16*)((char*)mop32a - sizeof(LPMCI_OPEN_PARMS16));
1445
1446             mop16->wDeviceID = mop32a->wDeviceID;
1447             if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
1448                 FIXME("bad free line=%d\n", __LINE__);
1449         }
1450         return MCI_MAP_OK;
1451     case DRV_LOAD:
1452     case DRV_ENABLE:
1453     case DRV_OPEN:
1454     case DRV_CLOSE:
1455     case DRV_DISABLE:
1456     case DRV_FREE:
1457     case DRV_CONFIGURE:
1458     case DRV_QUERYCONFIGURE:
1459     case DRV_INSTALL:
1460     case DRV_REMOVE:
1461     case DRV_EXITSESSION:
1462     case DRV_EXITAPPLICATION:
1463     case DRV_POWER:
1464         FIXME("This is a hack\n");
1465         return MCI_MAP_OK;
1466     default:
1467         FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
1468     }
1469     return MCI_MAP_MSGERROR;
1470 }
1471
1472 /*
1473  * 0000 stop
1474  * 0001 squeeze   signed 4 bytes to 2 bytes     *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2;     S += 4
1475  * 0010 squeeze unsigned 4 bytes to 2 bytes     *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2;     S += 4
1476  * 0100
1477  * 0101
1478  * 0110 zero 4 bytes                            *(DWORD)D = 0                        D += 4;     S += 4
1479  * 0111 copy string                             *(LPSTR*)D = seg dup(*(LPSTR*)S)     D += 4;     S += 4
1480  * 1xxx copy xxx + 1 bytes                      memcpy(D, S, xxx + 1);               D += xxx+1; S += xxx+1
1481  */
1482
1483 /**************************************************************************
1484  *                      MCI_MsgMapper32To16_Create              [internal]
1485  *
1486  * Helper for MCI_MapMsg32ATo16.
1487  * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit
1488  * segmented pointer.
1489  * map contains a list of action to be performed for the mapping (see list
1490  * above)
1491  * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
1492  */
1493 static  MCI_MapType     MCI_MsgMapper32To16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
1494 {
1495     void*       lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 );
1496     LPBYTE      p16, p32;
1497
1498     if (!lp) {
1499         return MCI_MAP_NOMEM;
1500     }
1501     p32 = (LPBYTE)(*ptr);
1502     if (keep) {
1503         *(void**)lp = *ptr;
1504         p16 = (LPBYTE)lp + sizeof(void**);
1505         *ptr = (char*)MapLS(lp) + sizeof(void**);
1506     } else {
1507         p16 = lp;
1508         *ptr = (void*)MapLS(lp);
1509     }
1510
1511     if (map == 0) {
1512         memcpy(p16, p32, size16);
1513     } else {
1514         unsigned        nibble;
1515         unsigned        sz;
1516
1517         while (map & 0xF) {
1518             nibble = map & 0xF;
1519             if (nibble & 0x8) {
1520                 sz = (nibble & 7) + 1;
1521                 memcpy(p16, p32, sz);
1522                 p16 += sz;
1523                 p32 += sz;
1524                 size16 -= sz;   /* DEBUG only */
1525             } else {
1526                 switch (nibble) {
1527                 case 0x1:
1528                     *(LPINT16)p16 = *(LPINT)p32;
1529                     p16 += sizeof(INT16);
1530                     p32 += sizeof(INT);
1531                     size16 -= sizeof(INT16);
1532                     break;
1533                 case 0x2:
1534                     *(LPUINT16)p16 = *(LPUINT)p32;
1535                     p16 += sizeof(UINT16);
1536                     p32 += sizeof(UINT);
1537                     size16 -= sizeof(UINT16);
1538                     break;
1539                 case 0x6:
1540                     *(LPDWORD)p16 = 0;
1541                     p16 += sizeof(DWORD);
1542                     p32 += sizeof(DWORD);
1543                     size16 -= sizeof(DWORD);
1544                     break;
1545                 case 0x7:
1546                     *(SEGPTR *)p16 = MapLS( *(LPSTR *)p32 );
1547                     p16 += sizeof(SEGPTR);
1548                     p32 += sizeof(LPSTR);
1549                     size16 -= sizeof(SEGPTR);
1550                     break;
1551                 default:
1552                     FIXME("Unknown nibble for mapping (%x)\n", nibble);
1553                 }
1554             }
1555             map >>= 4;
1556         }
1557         if (size16 != 0) /* DEBUG only */
1558             FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
1559     }
1560     return MCI_MAP_OKMEM;
1561 }
1562
1563 /**************************************************************************
1564  *                      MCI_MsgMapper32To16_Destroy             [internal]
1565  *
1566  * Helper for MCI_UnMapMsg32ATo16.
1567  */
1568 static  MCI_MapType     MCI_MsgMapper32To16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
1569 {
1570     if (ptr) {
1571         void*           msg16 = MapSL((SEGPTR)ptr);
1572         void*           alloc;
1573         LPBYTE          p32, p16;
1574         unsigned        nibble;
1575
1576         UnMapLS( (SEGPTR)ptr );
1577         if (kept) {
1578             alloc = (char*)msg16 - sizeof(void**);
1579             p32 = *(void**)alloc;
1580             p16 = msg16;
1581
1582             if (map == 0) {
1583                 memcpy(p32, p16, size16);
1584             } else {
1585                 while (map & 0xF) {
1586                     nibble = map & 0xF;
1587                     if (nibble & 0x8) {
1588                         memcpy(p32, p16, (nibble & 7) + 1);
1589                         p16 += (nibble & 7) + 1;
1590                         p32 += (nibble & 7) + 1;
1591                         size16 -= (nibble & 7) + 1;
1592                     } else {
1593                         switch (nibble) {
1594                         case 0x1:
1595                             *(LPINT)p32 = *(LPINT16)p16;
1596                             p16 += sizeof(INT16);
1597                             p32 += sizeof(INT);
1598                             size16 -= sizeof(INT16);
1599                             break;
1600                         case 0x2:
1601                             *(LPUINT)p32 = *(LPUINT16)p16;
1602                             p16 += sizeof(UINT16);
1603                             p32 += sizeof(UINT);
1604                             size16 -= sizeof(UINT16);
1605                             break;
1606                         case 0x6:
1607                             p16 += sizeof(UINT);
1608                             p32 += sizeof(UINT);
1609                             size16 -= sizeof(UINT);
1610                             break;
1611                         case 0x7:
1612                             UnMapLS( *(SEGPTR *)p16 );
1613                             p16 += sizeof(SEGPTR);
1614                             p32 += sizeof(char*);
1615                             size16 -= sizeof(SEGPTR);
1616                             break;
1617                         default:
1618                             FIXME("Unknown nibble for mapping (%x)\n", nibble);
1619                         }
1620                     }
1621                     map >>= 4;
1622                 }
1623                 if (size16 != 0) /* DEBUG only */
1624                     FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
1625             }
1626         } else {
1627             alloc = msg16;
1628         }
1629
1630         HeapFree( GetProcessHeap(), 0, alloc );
1631     }
1632     return MCI_MAP_OK;
1633 }
1634
1635 /**************************************************************************
1636  *                      MCI_MapMsg32ATo16                       [internal]
1637  *
1638  * Map a 32-A bit MCI message to a 16 bit MCI message.
1639  */
1640 static  MCI_MapType     MCI_MapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam)
1641 {
1642     int         size;
1643     BOOLEAN     keep = FALSE;
1644     DWORD       map = 0;
1645
1646     if (*lParam == 0)
1647         return MCI_MAP_OK;
1648
1649     /* FIXME: to add also (with seg/linear modifications to do):
1650      * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
1651      * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
1652      */
1653     switch (wMsg) {
1654     case MCI_BREAK:
1655         size = sizeof(MCI_BREAK_PARMS);
1656         break;
1657         /* case MCI_CAPTURE */
1658     case MCI_CLOSE:
1659     case MCI_CLOSE_DRIVER:
1660     case MCI_CONFIGURE:
1661         size = sizeof(MCI_GENERIC_PARMS);
1662         break;
1663         /* case MCI_COPY: */
1664     case MCI_CUE:
1665         switch (uDevType) {
1666         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS);       break;
1667         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_CUE_PARMS);     break;*/        FIXME("NIY vcr\n");     return MCI_MAP_NOMEM;
1668         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
1669         }
1670         break;
1671         /* case MCI_CUT:*/
1672     case MCI_DELETE:
1673         switch (uDevType) {
1674         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16);  map = 0x0F1111FB;       break;
1675         case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS);   break;
1676         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
1677         }
1678         break;
1679         /* case MCI_ESCAPE: */
1680     case MCI_FREEZE:
1681         switch (uDevType) {
1682         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS);    map = 0x0001111B;       break;
1683         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS);     map = 0x0001111B;       break;
1684         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
1685         }
1686         break;
1687     case MCI_GETDEVCAPS:
1688         keep = TRUE;
1689         size = sizeof(MCI_GETDEVCAPS_PARMS);
1690         break;
1691         /* case MCI_INDEX: */
1692     case MCI_INFO:
1693         {
1694             LPMCI_INFO_PARMSA   mip32a = (LPMCI_INFO_PARMSA)(*lParam);
1695             LPMCI_INFO_PARMS16  mip16;
1696
1697             switch (uDevType) {
1698             case MCI_DEVTYPE_DIGITAL_VIDEO:     size = sizeof(MCI_DGV_INFO_PARMS16);    break;
1699             default:                            size = sizeof(MCI_INFO_PARMS16);        break;
1700             }
1701             mip16 = HeapAlloc( GetProcessHeap(), 0, size);
1702             if (mip16)
1703             {
1704                 mip16->dwCallback  = mip32a->dwCallback;
1705                 mip16->lpstrReturn = MapLS( mip32a->lpstrReturn );
1706                 mip16->dwRetSize   = mip32a->dwRetSize;
1707                 if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) {
1708                     ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSA)mip32a)->dwItem;
1709                 }
1710             } else {
1711                 return MCI_MAP_NOMEM;
1712             }
1713             *lParam = MapLS(mip16);
1714         }
1715         return MCI_MAP_OKMEM;
1716         /* case MCI_MARK: */
1717         /* case MCI_MONITOR: */
1718     case MCI_OPEN:
1719     case MCI_OPEN_DRIVER:
1720         {
1721             LPMCI_OPEN_PARMSA   mop32a = (LPMCI_OPEN_PARMSA)(*lParam);
1722             char* ptr = HeapAlloc( GetProcessHeap(), 0,
1723                                    sizeof(LPMCI_OPEN_PARMSA) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD));
1724             LPMCI_OPEN_PARMS16  mop16;
1725
1726
1727             if (ptr) {
1728                 *(LPMCI_OPEN_PARMSA*)(ptr) = mop32a;
1729                 mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSA));
1730                 mop16->dwCallback       = mop32a->dwCallback;
1731                 mop16->wDeviceID        = mop32a->wDeviceID;
1732                 if (dwFlags & MCI_OPEN_TYPE) {
1733                     if (dwFlags & MCI_OPEN_TYPE_ID) {
1734                         /* dword "transparent" value */
1735                         mop16->lpstrDeviceType = (SEGPTR)mop32a->lpstrDeviceType;
1736                     } else {
1737                         /* string */
1738                         mop16->lpstrDeviceType = MapLS( mop32a->lpstrDeviceType );
1739                     }
1740                 } else {
1741                     /* nuthin' */
1742                     mop16->lpstrDeviceType = 0;
1743                 }
1744                 if (dwFlags & MCI_OPEN_ELEMENT) {
1745                     if (dwFlags & MCI_OPEN_ELEMENT_ID) {
1746                         mop16->lpstrElementName = (SEGPTR)mop32a->lpstrElementName;
1747                     } else {
1748                         mop16->lpstrElementName = MapLS( mop32a->lpstrElementName );
1749                     }
1750                 } else {
1751                     mop16->lpstrElementName = 0;
1752                 }
1753                 if (dwFlags & MCI_OPEN_ALIAS) {
1754                     mop16->lpstrAlias = MapLS( mop32a->lpstrAlias );
1755                 } else {
1756                     mop16->lpstrAlias = 0;
1757                 }
1758                 /* copy extended information if any...
1759                  * FIXME: this may seg fault if initial structure does not contain them and
1760                  * the reads after msip16 fail under LDT limits...
1761                  * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
1762                  * should not take care of extended parameters, and should be used by MCI_Open
1763                  * to fetch uDevType. When, this is known, the mapping for sending the
1764                  * MCI_OPEN_DRIVER shall be done depending on uDevType.
1765                  */
1766                 memcpy(mop16 + 1, mop32a + 1, 2 * sizeof(DWORD));
1767             } else {
1768                 return MCI_MAP_NOMEM;
1769             }
1770             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_PARMSA);
1771         }
1772         return MCI_MAP_OKMEM;
1773         /* case MCI_PASTE:*/
1774     case MCI_PAUSE:
1775         size = sizeof(MCI_GENERIC_PARMS);
1776         break;
1777     case MCI_PLAY:
1778         size = sizeof(MCI_PLAY_PARMS);
1779         break;
1780     case MCI_PUT:
1781         switch (uDevType) {
1782         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       break;
1783         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS);     map = 0x0001111B;       break;
1784         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
1785         }
1786         break;
1787     case MCI_REALIZE:
1788         size = sizeof(MCI_GENERIC_PARMS);
1789         break;
1790     case MCI_RECORD:
1791         switch (uDevType) {
1792         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16);  map = 0x0F1111FB;       break;
1793         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_RECORD_PARMS);  break;*/FIXME("NIY vcr\n");     return MCI_MAP_NOMEM;
1794         default:                        size = sizeof(MCI_RECORD_PARMS);        break;
1795         }
1796         break;
1797     case MCI_RESUME:
1798         size = sizeof(MCI_GENERIC_PARMS);
1799         break;
1800     case MCI_SEEK:
1801         switch (uDevType) {
1802         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SEEK_PARMS);    break;*/FIXME("NIY vcr\n");     return MCI_MAP_NOMEM;
1803         default:                        size = sizeof(MCI_SEEK_PARMS);          break;
1804         }
1805         break;
1806     case MCI_SET:
1807         switch (uDevType) {
1808         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS);       break;
1809         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SET_PARMS);     break;*/FIXME("NIY vcr\n");     return MCI_MAP_NOMEM;
1810         case MCI_DEVTYPE_SEQUENCER:     size = sizeof(MCI_SEQ_SET_PARMS);       break;
1811         /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned,
1812          * so not doing anything should work...
1813          */
1814         case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS);      break;
1815         default:                        size = sizeof(MCI_SET_PARMS);           break;
1816         }
1817         break;
1818     case MCI_SETAUDIO:
1819         switch (uDevType) {
1820         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SETAUDIO_PARMS16);map = 0x0000077FF;      break;
1821         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SETAUDIO_PARMS);        break;*/FIXME("NIY vcr\n");     return MCI_MAP_NOMEM;
1822         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
1823         }
1824         break;
1825         /* case MCI_SETTIMECODE:*/
1826         /* case MCI_SIGNAL:*/
1827     case MCI_SPIN:
1828         size = sizeof(MCI_SET_PARMS);
1829         break;
1830     case MCI_STATUS:
1831         keep = TRUE;
1832         switch (uDevType) {
1833         /* FIXME:
1834          * don't know if buffer for value is the one passed through lpstrDevice
1835          * or is provided by MCI driver.
1836          * Assuming solution 2: provided by MCI driver, so zeroing on entry
1837          */
1838         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16);  map = 0x0B6FF;          break;
1839         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STATUS_PARMS);  break;*/FIXME("NIY vcr\n");     return MCI_MAP_NOMEM;
1840         default:                        size = sizeof(MCI_STATUS_PARMS);        break;
1841         }
1842         break;
1843     case MCI_STEP:
1844         switch (uDevType) {
1845         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS);      break;
1846         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STEP_PARMS);    break;*/FIXME("NIY vcr\n");     return MCI_MAP_NOMEM;
1847         case MCI_DEVTYPE_VIDEODISC:     size = sizeof(MCI_VD_STEP_PARMS);       break;
1848         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
1849         }
1850         break;
1851     case MCI_STOP:
1852         size = sizeof(MCI_SET_PARMS);
1853         break;
1854     case MCI_SYSINFO:
1855         {
1856             LPMCI_SYSINFO_PARMSA  msip32a = (LPMCI_SYSINFO_PARMSA)(*lParam);
1857             LPMCI_SYSINFO_PARMS16 msip16;
1858             char* ptr = HeapAlloc( GetProcessHeap(), 0,
1859                                    sizeof(LPMCI_SYSINFO_PARMSA) + sizeof(MCI_SYSINFO_PARMS16) );
1860
1861             if (ptr) {
1862                 *(LPMCI_SYSINFO_PARMSA*)(ptr) = msip32a;
1863                 msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSA));
1864
1865                 msip16->dwCallback       = msip32a->dwCallback;
1866                 msip16->lpstrReturn      = MapLS( msip32a->lpstrReturn );
1867                 msip16->dwRetSize        = msip32a->dwRetSize;
1868                 msip16->dwNumber         = msip32a->dwNumber;
1869                 msip16->wDeviceType      = msip32a->wDeviceType;
1870             } else {
1871                 return MCI_MAP_NOMEM;
1872             }
1873             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_SYSINFO_PARMSA);
1874         }
1875         return MCI_MAP_OKMEM;
1876         /* case MCI_UNDO: */
1877     case MCI_UNFREEZE:
1878         switch (uDevType) {
1879         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       break;
1880         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       break;
1881         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
1882         }
1883         break;
1884     case MCI_UPDATE:
1885         switch (uDevType) {
1886         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16);  map = 0x000B1111B;      break;
1887         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
1888         }
1889         break;
1890     case MCI_WHERE:
1891         switch (uDevType) {
1892         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       keep = TRUE;    break;
1893         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       keep = TRUE;    break;
1894         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
1895         }
1896         break;
1897     case MCI_WINDOW:
1898         switch (uDevType) {
1899         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16);  if (dwFlags & MCI_DGV_WINDOW_TEXT)  map = 0x7FB;        break;
1900         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB;        break;
1901         default:                        size = sizeof(MCI_GENERIC_PARMS);       break;
1902         }
1903         break;
1904     case DRV_OPEN:
1905         {
1906             LPMCI_OPEN_DRIVER_PARMSA  modp32a = (LPMCI_OPEN_DRIVER_PARMSA)(*lParam);
1907             LPMCI_OPEN_DRIVER_PARMS16 modp16;
1908             char *ptr = HeapAlloc( GetProcessHeap(), 0,
1909                                   sizeof(LPMCI_OPEN_DRIVER_PARMSA) + sizeof(MCI_OPEN_DRIVER_PARMS16));
1910
1911             if (ptr) {
1912                 *(LPMCI_OPEN_DRIVER_PARMSA*)(ptr) = modp32a;
1913                 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSA));
1914                 modp16->wDeviceID = modp32a->wDeviceID;
1915                 modp16->lpstrParams = MapLS( modp32a->lpstrParams );
1916                 /* other fields are gonna be filled by the driver, don't copy them */
1917             } else {
1918                 return MCI_MAP_NOMEM;
1919             }
1920             *lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_DRIVER_PARMSA);
1921         }
1922         return MCI_MAP_OKMEM;
1923     case DRV_LOAD:
1924     case DRV_ENABLE:
1925     case DRV_CLOSE:
1926     case DRV_DISABLE:
1927     case DRV_FREE:
1928     case DRV_CONFIGURE:
1929     case DRV_QUERYCONFIGURE:
1930     case DRV_INSTALL:
1931     case DRV_REMOVE:
1932     case DRV_EXITSESSION:
1933     case DRV_EXITAPPLICATION:
1934     case DRV_POWER:
1935         return MCI_MAP_OK;
1936
1937     default:
1938         WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
1939         return MCI_MAP_MSGERROR;
1940     }
1941     return MCI_MsgMapper32To16_Create((void**)lParam, size, map, keep);
1942 }
1943
1944 /**************************************************************************
1945  *                      MCI_UnMapMsg32ATo16                     [internal]
1946  */
1947 static  MCI_MapType     MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam)
1948 {
1949     int         size = 0;
1950     BOOLEAN     kept = FALSE;   /* there is no need to compute size when kept is FALSE */
1951     DWORD       map = 0;
1952
1953     switch (wMsg) {
1954     case MCI_BREAK:
1955         break;
1956         /* case MCI_CAPTURE */
1957     case MCI_CLOSE:
1958     case MCI_CLOSE_DRIVER:
1959     case MCI_CONFIGURE:
1960         break;
1961         /* case MCI_COPY: */
1962     case MCI_CUE:
1963         break;
1964         /* case MCI_CUT: */
1965     case MCI_DELETE:
1966         break;
1967         /* case MCI_ESCAPE: */
1968     case MCI_FREEZE:
1969         break;
1970     case MCI_GETDEVCAPS:
1971         kept = TRUE;
1972         size = sizeof(MCI_GETDEVCAPS_PARMS);
1973         break;
1974         /* case MCI_INDEX: */
1975     case MCI_INFO:
1976         {
1977             LPMCI_INFO_PARMS16 mip16  = (LPMCI_INFO_PARMS16)MapSL(lParam);
1978             UnMapLS( lParam );
1979             UnMapLS( mip16->lpstrReturn );
1980             HeapFree( GetProcessHeap(), 0, mip16 );
1981         }
1982         return MCI_MAP_OK;
1983         /* case MCI_MARK: */
1984         /* case MCI_MONITOR: */
1985     case MCI_OPEN:
1986     case MCI_OPEN_DRIVER:
1987         if (lParam) {
1988             LPMCI_OPEN_PARMS16  mop16  = (LPMCI_OPEN_PARMS16)MapSL(lParam);
1989             LPMCI_OPEN_PARMSA   mop32a = *(LPMCI_OPEN_PARMSA*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSA));
1990             UnMapLS( lParam );
1991             mop32a->wDeviceID = mop16->wDeviceID;
1992             if ((dwFlags & MCI_OPEN_TYPE) && !(dwFlags & MCI_OPEN_TYPE_ID))
1993                 UnMapLS( mop16->lpstrDeviceType );
1994             if ((dwFlags & MCI_OPEN_ELEMENT) && !(dwFlags & MCI_OPEN_ELEMENT_ID))
1995                 UnMapLS( mop16->lpstrElementName );
1996             if (dwFlags & MCI_OPEN_ALIAS)
1997                 UnMapLS( mop16->lpstrAlias );
1998             HeapFree( GetProcessHeap(), 0, (char*)mop16 - sizeof(LPMCI_OPEN_PARMSA) );
1999         }
2000         return MCI_MAP_OK;
2001         /* case MCI_PASTE:*/
2002     case MCI_PAUSE:
2003         break;
2004     case MCI_PLAY:
2005         break;
2006     case MCI_PUT:
2007         break;
2008     case MCI_REALIZE:
2009         break;
2010     case MCI_RECORD:
2011         break;
2012     case MCI_RESUME:
2013         break;
2014     case MCI_SEEK:
2015         break;
2016     case MCI_SET:
2017         break;
2018     case MCI_SETAUDIO:
2019         switch (uDevType) {
2020         case MCI_DEVTYPE_DIGITAL_VIDEO: map = 0x0000077FF;      break;
2021         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_SETAUDIO_PARMS);        break;*/FIXME("NIY vcr\n");     return MCI_MAP_NOMEM;
2022         }
2023         break;
2024         /* case MCI_SETTIMECODE:*/
2025         /* case MCI_SIGNAL:*/
2026     case MCI_SPIN:
2027         break;
2028     case MCI_STATUS:
2029         kept = TRUE;
2030         switch (uDevType) {
2031         case MCI_DEVTYPE_DIGITAL_VIDEO:
2032         if (lParam) {
2033             LPMCI_DGV_STATUS_PARMS16    mdsp16  = (LPMCI_DGV_STATUS_PARMS16)MapSL(lParam);
2034             LPMCI_DGV_STATUS_PARMSA     mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA));
2035
2036             UnMapLS( lParam );
2037             if (mdsp16) {
2038                 mdsp32a->dwReturn = mdsp16->dwReturn;
2039                 if (dwFlags & MCI_DGV_STATUS_DISKSPACE) {
2040                     TRACE("MCI_STATUS (DGV) lpstrDrive=%08lx\n", mdsp16->lpstrDrive);
2041                     TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive));
2042                     UnMapLS( mdsp16->lpstrDrive );
2043                 }
2044                 HeapFree( GetProcessHeap(), 0, (char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA) );
2045             } else {
2046                 return MCI_MAP_NOMEM;
2047             }
2048         }
2049         return MCI_MAP_OKMEM;
2050         case MCI_DEVTYPE_VCR:           /*size = sizeof(MCI_VCR_STATUS_PARMS);  break;*/FIXME("NIY vcr\n");     return MCI_MAP_NOMEM;
2051         default:                        size = sizeof(MCI_STATUS_PARMS);        break;
2052         }
2053         break;
2054     case MCI_STEP:
2055         break;
2056     case MCI_STOP:
2057         break;
2058     case MCI_SYSINFO:
2059         if (lParam) {
2060             LPMCI_SYSINFO_PARMS16       msip16  = (LPMCI_SYSINFO_PARMS16)MapSL(lParam);
2061             LPMCI_SYSINFO_PARMSA        msip32a = *(LPMCI_SYSINFO_PARMSA*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA));
2062
2063             UnMapLS( lParam );
2064             if (msip16) {
2065                 msip16->dwCallback = msip32a->dwCallback;
2066                 UnMapLS( msip16->lpstrReturn );
2067                 HeapFree( GetProcessHeap(), 0, (char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA) );
2068             } else {
2069                 return MCI_MAP_NOMEM;
2070             }
2071         }
2072         return MCI_MAP_OKMEM;
2073         /* case MCI_UNDO: */
2074     case MCI_UNFREEZE:
2075         break;
2076     case MCI_UPDATE:
2077         break;
2078     case MCI_WHERE:
2079         switch (uDevType) {
2080         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16);    map = 0x0001111B;       kept = TRUE;    break;
2081         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_RECT_PARMS16);   map = 0x0001111B;       kept = TRUE;    break;
2082         default:                        break;
2083         }
2084         break;
2085     case MCI_WINDOW:
2086         switch (uDevType) {
2087         case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16);  if (dwFlags & MCI_DGV_WINDOW_TEXT)  map = 0x7666;       break;
2088         case MCI_DEVTYPE_OVERLAY:       size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666;       break;
2089         default:                        break;
2090         }
2091         /* FIXME: see map function */
2092         break;
2093
2094     case DRV_OPEN:
2095         if (lParam) {
2096             LPMCI_OPEN_DRIVER_PARMS16   modp16  = (LPMCI_OPEN_DRIVER_PARMS16)MapSL(lParam);
2097             LPMCI_OPEN_DRIVER_PARMSA    modp32a = *(LPMCI_OPEN_DRIVER_PARMSA*)((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA));
2098
2099             UnMapLS( lParam );
2100             modp32a->wCustomCommandTable = modp16->wCustomCommandTable;
2101             modp32a->wType = modp16->wType;
2102             UnMapLS( modp16->lpstrParams );
2103             HeapFree( GetProcessHeap(), 0, (char *)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA) );
2104         }
2105         return MCI_MAP_OK;
2106     case DRV_LOAD:
2107     case DRV_ENABLE:
2108     case DRV_CLOSE:
2109     case DRV_DISABLE:
2110     case DRV_FREE:
2111     case DRV_CONFIGURE:
2112     case DRV_QUERYCONFIGURE:
2113     case DRV_INSTALL:
2114     case DRV_REMOVE:
2115     case DRV_EXITSESSION:
2116     case DRV_EXITAPPLICATION:
2117     case DRV_POWER:
2118         FIXME("This is a hack\n");
2119         return MCI_MAP_OK;
2120     default:
2121         FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
2122         return MCI_MAP_MSGERROR;
2123     }
2124     return MCI_MsgMapper32To16_Destroy((void*)lParam, size, map, kept);
2125 }
2126
2127 /**************************************************************************
2128  *                      MCI_SendCommandFrom32                   [internal]
2129  */
2130 DWORD MCI_SendCommandFrom32(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
2131 {
2132     DWORD               dwRet = MCIERR_INVALID_DEVICE_ID;
2133     LPWINE_MCIDRIVER    wmd = MCI_GetDriver(wDevID);
2134
2135     if (wmd) {
2136         if (wmd->bIs32) {
2137             dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
2138         } else {
2139             MCI_MapType res;
2140
2141             switch (res = MCI_MapMsg32ATo16(wmd->wType, wMsg, dwParam1, &dwParam2)) {
2142             case MCI_MAP_MSGERROR:
2143                 TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg));
2144                 dwRet = MCIERR_DRIVER_INTERNAL;
2145                 break;
2146             case MCI_MAP_NOMEM:
2147                 TRACE("Problem mapping msg=%s from 32a to 16\n", MCI_MessageToString(wMsg));
2148                 dwRet = MCIERR_OUT_OF_MEMORY;
2149                 break;
2150             case MCI_MAP_OK:
2151             case MCI_MAP_OKMEM:
2152                 dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
2153                 if (res == MCI_MAP_OKMEM)
2154                     MCI_UnMapMsg32ATo16(wmd->wType, wMsg, dwParam1, dwParam2);
2155                 break;
2156             }
2157         }
2158     }
2159     return dwRet;
2160 }
2161
2162 /**************************************************************************
2163  *                      MCI_SendCommandFrom16                   [internal]
2164  */
2165 DWORD MCI_SendCommandFrom16(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
2166 {
2167     DWORD               dwRet = MCIERR_INVALID_DEVICE_ID;
2168     LPWINE_MCIDRIVER    wmd = MCI_GetDriver(wDevID);
2169
2170     if (wmd) {
2171         dwRet = MCIERR_INVALID_DEVICE_ID;
2172
2173         if (wmd->bIs32) {
2174             MCI_MapType         res;
2175
2176             switch (res = MCI_MapMsg16To32A(wmd->wType, wMsg, &dwParam2)) {
2177             case MCI_MAP_MSGERROR:
2178                 TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg));
2179                 dwRet = MCIERR_DRIVER_INTERNAL;
2180                 break;
2181             case MCI_MAP_NOMEM:
2182                 TRACE("Problem mapping msg=%s from 16 to 32a\n", MCI_MessageToString(wMsg));
2183                 dwRet = MCIERR_OUT_OF_MEMORY;
2184                 break;
2185             case MCI_MAP_OK:
2186             case MCI_MAP_OKMEM:
2187                 dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
2188                 if (res == MCI_MAP_OKMEM)
2189                     MCI_UnMapMsg16To32A(wmd->wType, wMsg, dwParam2);
2190                 break;
2191             }
2192         } else {
2193             dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
2194         }
2195     }
2196     return dwRet;
2197 }
2198
2199 /**************************************************************************
2200  *                      MCI_Open                                [internal]
2201  */
2202 static  DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms)
2203 {
2204     char                        strDevTyp[128];
2205     DWORD                       dwRet;
2206     LPWINE_MCIDRIVER            wmd = NULL;
2207     LPWINE_MM_IDATA             iData = MULTIMEDIA_GetIData();
2208
2209     TRACE("(%08lX, %p)\n", dwParam, lpParms);
2210     if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
2211
2212     /* only two low bytes are generic, the other ones are dev type specific */
2213 #define WINE_MCIDRIVER_SUPP     (0xFFFF0000|MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT| \
2214                          MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID| \
2215                          MCI_NOTIFY|MCI_WAIT)
2216     if ((dwParam & ~WINE_MCIDRIVER_SUPP) != 0) {
2217         FIXME("Unsupported yet dwFlags=%08lX\n", dwParam & ~WINE_MCIDRIVER_SUPP);
2218     }
2219 #undef WINE_MCIDRIVER_SUPP
2220
2221     strDevTyp[0] = 0;
2222
2223     if (dwParam & MCI_OPEN_TYPE) {
2224         if (dwParam & MCI_OPEN_TYPE_ID) {
2225             WORD uDevType = LOWORD((DWORD)lpParms->lpstrDeviceType);
2226
2227             if (uDevType < MCI_DEVTYPE_FIRST ||
2228                 uDevType > MCI_DEVTYPE_LAST ||
2229                 !LoadStringA(iData->hWinMM32Instance, uDevType, strDevTyp, sizeof(strDevTyp))) {
2230                 dwRet = MCIERR_BAD_INTEGER;
2231                 goto errCleanUp;
2232             }
2233         } else {
2234             LPSTR       ptr;
2235             if (lpParms->lpstrDeviceType == NULL) {
2236                 dwRet = MCIERR_NULL_PARAMETER_BLOCK;
2237                 goto errCleanUp;
2238             }
2239             strcpy(strDevTyp, lpParms->lpstrDeviceType);
2240             ptr = strchr(strDevTyp, '!');
2241             if (ptr) {
2242                 /* this behavior is not documented in windows. However, since, in
2243                  * some occasions, MCI_OPEN handling is translated by WinMM into
2244                  * a call to mciSendString("open <type>"); this code shall be correct
2245                  */
2246                 if (dwParam & MCI_OPEN_ELEMENT) {
2247                     ERR("Both MCI_OPEN_ELEMENT(%s) and %s are used\n",
2248                         lpParms->lpstrElementName, strDevTyp);
2249                     dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
2250                     goto errCleanUp;
2251                 }
2252                 dwParam |= MCI_OPEN_ELEMENT;
2253                 *ptr++ = 0;
2254                 /* FIXME: not a good idea to write in user supplied buffer */
2255                 lpParms->lpstrElementName = ptr;
2256             }
2257
2258         }
2259         TRACE("devType='%s' !\n", strDevTyp);
2260     }
2261
2262     if (dwParam & MCI_OPEN_ELEMENT) {
2263         TRACE("lpstrElementName='%s'\n", lpParms->lpstrElementName);
2264
2265         if (dwParam & MCI_OPEN_ELEMENT_ID) {
2266             FIXME("Unsupported yet flag MCI_OPEN_ELEMENT_ID\n");
2267             dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
2268             goto errCleanUp;
2269         }
2270
2271         if (!lpParms->lpstrElementName) {
2272             dwRet = MCIERR_NULL_PARAMETER_BLOCK;
2273             goto errCleanUp;
2274         }
2275
2276         /* type, if given as a parameter, supersedes file extension */
2277         if (!strDevTyp[0] &&
2278             MCI_GetDevTypeFromFileName(lpParms->lpstrElementName,
2279                                        strDevTyp, sizeof(strDevTyp))) {
2280             if (GetDriveTypeA(lpParms->lpstrElementName) != DRIVE_CDROM) {
2281                 dwRet = MCIERR_EXTENSION_NOT_FOUND;
2282                 goto errCleanUp;
2283             }
2284             /* FIXME: this will not work if several CDROM drives are installed on the machine */
2285             strcpy(strDevTyp, "CDAUDIO");
2286         }
2287     }
2288
2289     if (strDevTyp[0] == 0) {
2290         FIXME("Couldn't load driver\n");
2291         dwRet = MCIERR_INVALID_DEVICE_NAME;
2292         goto errCleanUp;
2293     }
2294
2295     if (dwParam & MCI_OPEN_ALIAS) {
2296         TRACE("Alias='%s' !\n", lpParms->lpstrAlias);
2297         if (!lpParms->lpstrAlias) {
2298             dwRet = MCIERR_NULL_PARAMETER_BLOCK;
2299             goto errCleanUp;
2300         }
2301     }
2302
2303     if ((dwRet = MCI_LoadMciDriver(iData, strDevTyp, &wmd))) {
2304         goto errCleanUp;
2305     }
2306
2307     if ((dwRet = MCI_FinishOpen(wmd, lpParms, dwParam))) {
2308         TRACE("Failed to open driver (MCI_OPEN_DRIVER) [%08lx], closing\n", dwRet);
2309         /* FIXME: is dwRet the correct ret code ? */
2310         goto errCleanUp;
2311     }
2312
2313     /* only handled devices fall through */
2314     TRACE("wDevID=%04X wDeviceID=%d dwRet=%ld\n", wmd->wDeviceID, lpParms->wDeviceID, dwRet);
2315
2316     if (dwParam & MCI_NOTIFY)
2317         mciDriverNotify16(lpParms->dwCallback, wmd->wDeviceID, MCI_NOTIFY_SUCCESSFUL);
2318
2319     return 0;
2320 errCleanUp:
2321     if (wmd) MCI_UnLoadMciDriver(iData, wmd);
2322
2323     if (dwParam & MCI_NOTIFY)
2324         mciDriverNotify16(lpParms->dwCallback, 0, MCI_NOTIFY_FAILURE);
2325     return dwRet;
2326 }
2327
2328 /**************************************************************************
2329  *                      MCI_Close                               [internal]
2330  */
2331 static  DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
2332 {
2333     DWORD               dwRet;
2334     LPWINE_MCIDRIVER    wmd;
2335     LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIData();
2336
2337     TRACE("(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms);
2338
2339     if (wDevID == MCI_ALL_DEVICE_ID) {
2340         LPWINE_MCIDRIVER        next;
2341
2342         EnterCriticalSection(&iData->cs);
2343         /* FIXME: shall I notify once after all is done, or for
2344          * each of the open drivers ? if the latest, which notif
2345          * to return when only one fails ?
2346          */
2347         for (wmd = iData->lpMciDrvs; wmd; ) {
2348             next = wmd->lpNext;
2349             MCI_Close(wmd->wDeviceID, dwParam, lpParms);
2350             wmd = next;
2351         }
2352         LeaveCriticalSection(&iData->cs);
2353         return 0;
2354     }
2355
2356     if (!(wmd = MCI_GetDriver(wDevID))) {
2357         return MCIERR_INVALID_DEVICE_ID;
2358     }
2359
2360     dwRet = MCI_SendCommandFrom32(wDevID, MCI_CLOSE_DRIVER, dwParam, (DWORD)lpParms);
2361
2362     MCI_UnLoadMciDriver(iData, wmd);
2363
2364     if (dwParam & MCI_NOTIFY)
2365         mciDriverNotify16(lpParms->dwCallback, wDevID,
2366                           (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
2367
2368     return dwRet;
2369 }
2370
2371 /**************************************************************************
2372  *                      MCI_WriteString                         [internal]
2373  */
2374 DWORD   MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr)
2375 {
2376     DWORD       ret = 0;
2377
2378     if (lpSrcStr) {
2379         if (dstSize <= strlen(lpSrcStr)) {
2380             lstrcpynA(lpDstStr, lpSrcStr, dstSize - 1);
2381             ret = MCIERR_PARAM_OVERFLOW;
2382         } else {
2383             strcpy(lpDstStr, lpSrcStr);
2384         }
2385     } else {
2386         *lpDstStr = 0;
2387     }
2388     return ret;
2389 }
2390
2391 /**************************************************************************
2392  *                      MCI_Sysinfo                             [internal]
2393  */
2394 static  DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParms)
2395 {
2396     DWORD               ret = MCIERR_INVALID_DEVICE_ID;
2397     LPWINE_MCIDRIVER    wmd;
2398     LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIData();
2399
2400     if (lpParms == NULL)                        return MCIERR_NULL_PARAMETER_BLOCK;
2401
2402     TRACE("(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n",
2403           uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType);
2404
2405     switch (dwFlags & ~MCI_SYSINFO_OPEN) {
2406     case MCI_SYSINFO_QUANTITY:
2407         {
2408             DWORD       cnt = 0;
2409
2410             if (lpParms->wDeviceType < MCI_DEVTYPE_FIRST ||
2411                 lpParms->wDeviceType > MCI_DEVTYPE_LAST) {
2412                 if (dwFlags & MCI_SYSINFO_OPEN) {
2413                     TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
2414                     EnterCriticalSection(&iData->cs);
2415                     for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
2416                         cnt++;
2417                     }
2418                     LeaveCriticalSection(&iData->cs);
2419                 } else {
2420                     TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
2421                     cnt = MCI_InstalledCount;
2422                 }
2423             } else {
2424                 if (dwFlags & MCI_SYSINFO_OPEN) {
2425                     TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n",
2426                           lpParms->wDeviceType);
2427                     EnterCriticalSection(&iData->cs);
2428                     for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
2429                         if (wmd->wType == lpParms->wDeviceType)
2430                             cnt++;
2431                     }
2432                     LeaveCriticalSection(&iData->cs);
2433                 } else {
2434                     TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n",
2435                           lpParms->wDeviceType);
2436                     FIXME("Don't know how to get # of MCI devices of a given type\n");
2437                     cnt = 1;
2438                 }
2439             }
2440             *(DWORD*)lpParms->lpstrReturn = cnt;
2441         }
2442         TRACE("(%ld) => '%ld'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn);
2443         ret = MCI_INTEGER_RETURNED;
2444         break;
2445     case MCI_SYSINFO_INSTALLNAME:
2446         TRACE("MCI_SYSINFO_INSTALLNAME \n");
2447         if ((wmd = MCI_GetDriver(uDevID))) {
2448             ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize,
2449                                   wmd->lpstrDeviceType);
2450         } else {
2451             *lpParms->lpstrReturn = 0;
2452             ret = MCIERR_INVALID_DEVICE_ID;
2453         }
2454         TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
2455         break;
2456     case MCI_SYSINFO_NAME:
2457         TRACE("MCI_SYSINFO_NAME\n");
2458         if (dwFlags & MCI_SYSINFO_OPEN) {
2459             FIXME("Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n");
2460             ret = MCIERR_UNRECOGNIZED_COMMAND;
2461         } else if (lpParms->dwNumber > MCI_InstalledCount) {
2462             ret = MCIERR_OUTOFRANGE;
2463         } else {
2464             DWORD       count = lpParms->dwNumber;
2465             LPSTR       ptr = MCI_lpInstallNames;
2466
2467             while (--count > 0) ptr += strlen(ptr) + 1;
2468             ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, ptr);
2469         }
2470         TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
2471         break;
2472     default:
2473         TRACE("Unsupported flag value=%08lx\n", dwFlags);
2474         ret = MCIERR_UNRECOGNIZED_COMMAND;
2475     }
2476     return ret;
2477 }
2478
2479 /**************************************************************************
2480  *                      MCI_Break                               [internal]
2481  */
2482 static  DWORD MCI_Break(UINT wDevID, DWORD dwFlags, LPMCI_BREAK_PARMS lpParms)
2483 {
2484     DWORD       dwRet = 0;
2485
2486     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
2487
2488     if (dwFlags & MCI_NOTIFY)
2489         mciDriverNotify16(lpParms->dwCallback, wDevID,
2490                           (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
2491
2492     return dwRet;
2493 }
2494
2495 /**************************************************************************
2496  *                      MCI_SendCommand                         [internal]
2497  */
2498 DWORD   MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1,
2499                         DWORD dwParam2, BOOL bFrom32)
2500 {
2501     DWORD               dwRet = MCIERR_UNRECOGNIZED_COMMAND;
2502
2503     switch (wMsg) {
2504     case MCI_OPEN:
2505         if (bFrom32) {
2506             dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
2507         } else {
2508             switch (MCI_MapMsg16To32A(0, wMsg, &dwParam2)) {
2509             case MCI_MAP_OK:
2510             case MCI_MAP_OKMEM:
2511                 dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
2512                 MCI_UnMapMsg16To32A(0, wMsg, dwParam2);
2513                 break;
2514             default: break; /* so that gcc does not bark */
2515             }
2516         }
2517         break;
2518     case MCI_CLOSE:
2519         if (bFrom32) {
2520             dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
2521         } else {
2522             switch (MCI_MapMsg16To32A(0, wMsg, &dwParam2)) {
2523             case MCI_MAP_OK:
2524             case MCI_MAP_OKMEM:
2525                 dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
2526                 MCI_UnMapMsg16To32A(0, wMsg, dwParam2);
2527                 break;
2528             default: break; /* so that gcc does not bark */
2529             }
2530         }
2531         break;
2532     case MCI_SYSINFO:
2533         if (bFrom32) {
2534             dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2);
2535         } else {
2536             switch (MCI_MapMsg16To32A(0, wMsg, &dwParam2)) {
2537             case MCI_MAP_OK:
2538             case MCI_MAP_OKMEM:
2539                 dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2);
2540                 MCI_UnMapMsg16To32A(0, wMsg, dwParam2);
2541                 break;
2542             default: break; /* so that gcc doesnot  bark */
2543             }
2544         }
2545         break;
2546     case MCI_BREAK:
2547         if (bFrom32) {
2548             dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2);
2549         } else {
2550             switch (MCI_MapMsg16To32A(0, wMsg, &dwParam2)) {
2551             case MCI_MAP_OK:
2552             case MCI_MAP_OKMEM:
2553                 dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2);
2554                 MCI_UnMapMsg16To32A(0, wMsg, dwParam2);
2555                 break;
2556             default: break; /* so that gcc does not bark */
2557             }
2558         }
2559         break;
2560     case MCI_SOUND:
2561         /* FIXME: it seems that MCI_SOUND needs the same handling as MCI_BREAK
2562          * but I couldn't get any doc on this MCI message
2563          */
2564         break;
2565     default:
2566         if (wDevID == MCI_ALL_DEVICE_ID) {
2567             FIXME("unhandled MCI_ALL_DEVICE_ID\n");
2568             dwRet = MCIERR_CANNOT_USE_ALL;
2569         } else {
2570             dwRet = (bFrom32) ?
2571                 MCI_SendCommandFrom32(wDevID, wMsg, dwParam1, dwParam2) :
2572                 MCI_SendCommandFrom16(wDevID, wMsg, dwParam1, dwParam2);
2573         }
2574         break;
2575     }
2576     return dwRet;
2577 }
2578
2579 /**************************************************************************
2580  *                              MCI_CleanUp                     [internal]
2581  *
2582  * Some MCI commands need to be cleaned-up (when not called from
2583  * mciSendString), because MCI drivers return extra information for string
2584  * transformation. This function gets rid of them.
2585  */
2586 LRESULT         MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2, BOOL bIs32)
2587 {
2588     if (LOWORD(dwRet))
2589         return LOWORD(dwRet);
2590
2591     switch (wMsg) {
2592     case MCI_GETDEVCAPS:
2593         switch (dwRet & 0xFFFF0000ul) {
2594         case 0:
2595         case MCI_COLONIZED3_RETURN:
2596         case MCI_COLONIZED4_RETURN:
2597         case MCI_INTEGER_RETURNED:
2598             /* nothing to do */
2599             break;
2600         case MCI_RESOURCE_RETURNED:
2601         case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER:
2602             {
2603                 LPMCI_GETDEVCAPS_PARMS  lmgp;
2604
2605                 lmgp = (LPMCI_GETDEVCAPS_PARMS)(bIs32 ? (void*)dwParam2 : MapSL(dwParam2));
2606                 TRACE("Changing %08lx to %08lx\n", lmgp->dwReturn, (DWORD)LOWORD(lmgp->dwReturn));
2607                 lmgp->dwReturn = LOWORD(lmgp->dwReturn);
2608             }
2609             break;
2610         default:
2611             FIXME("Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2612                   HIWORD(dwRet), MCI_MessageToString(wMsg));
2613         }
2614         break;
2615     case MCI_STATUS:
2616         switch (dwRet & 0xFFFF0000ul) {
2617         case 0:
2618         case MCI_COLONIZED3_RETURN:
2619         case MCI_COLONIZED4_RETURN:
2620         case MCI_INTEGER_RETURNED:
2621             /* nothing to do */
2622             break;
2623         case MCI_RESOURCE_RETURNED:
2624         case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER:
2625             {
2626                 LPMCI_STATUS_PARMS      lsp;
2627
2628                 lsp = (LPMCI_STATUS_PARMS)(bIs32 ? (void*)dwParam2 : MapSL(dwParam2));
2629                 TRACE("Changing %08lx to %08lx\n", lsp->dwReturn, (DWORD)LOWORD(lsp->dwReturn));
2630                 lsp->dwReturn = LOWORD(lsp->dwReturn);
2631             }
2632             break;
2633         default:
2634             FIXME("Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2635                   HIWORD(dwRet), MCI_MessageToString(wMsg));
2636         }
2637         break;
2638     case MCI_SYSINFO:
2639         switch (dwRet & 0xFFFF0000ul) {
2640         case 0:
2641         case MCI_INTEGER_RETURNED:
2642             /* nothing to do */
2643             break;
2644         default:
2645             FIXME("Unsupported value for hiword (%04x)\n", HIWORD(dwRet));
2646         }
2647         break;
2648     default:
2649         if (HIWORD(dwRet)) {
2650             FIXME("Got non null hiword for dwRet=0x%08lx for command %s\n",
2651                   dwRet, MCI_MessageToString(wMsg));
2652         }
2653         break;
2654     }
2655     return LOWORD(dwRet);
2656 }
2657
2658 /**************************************************************************
2659  *                      MULTIMEDIA_MciInit                      [internal]
2660  *
2661  * Initializes the MCI internal variables.
2662  *
2663  */
2664 BOOL MULTIMEDIA_MciInit(void)
2665 {
2666     LPSTR       ptr1, ptr2;
2667     HKEY        hWineConf;
2668     HKEY        hkey;
2669     DWORD       err;
2670     DWORD       type;
2671     DWORD       count = 2048;
2672
2673     MCI_InstalledCount = 0;
2674     ptr1 = MCI_lpInstallNames = HeapAlloc(GetProcessHeap(), 0, count);
2675
2676     if (!MCI_lpInstallNames)
2677         return FALSE;
2678
2679     /* FIXME: should do also some registry diving here ? */
2680     if (!(err = RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config", &hWineConf)) &&
2681         !(err = RegOpenKeyA(hWineConf, "options", &hkey))) {
2682         err = RegQueryValueExA(hkey, "mci", 0, &type, MCI_lpInstallNames, &count);
2683         RegCloseKey(hkey);
2684
2685     }
2686     if (!err) {
2687         TRACE("Wine => '%s' \n", ptr1);
2688         while ((ptr2 = strchr(ptr1, ':')) != 0) {
2689             *ptr2++ = 0;
2690             TRACE("---> '%s' \n", ptr1);
2691             MCI_InstalledCount++;
2692             ptr1 = ptr2;
2693         }
2694         MCI_InstalledCount++;
2695         TRACE("---> '%s' \n", ptr1);
2696         ptr1 += strlen(ptr1) + 1;
2697     } else {
2698         GetPrivateProfileStringA("mci", NULL, "", MCI_lpInstallNames, count, "SYSTEM.INI");
2699         while (strlen(ptr1) > 0) {
2700             TRACE("---> '%s' \n", ptr1);
2701             ptr1 += strlen(ptr1) + 1;
2702             MCI_InstalledCount++;
2703         }
2704     }
2705     RegCloseKey(hWineConf);
2706     return TRUE;
2707 }
2708