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