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