1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
4 * MCI internal functions
6 * Copyright 1998/1999 Eric Pouech
19 #include "selectors.h"
21 #include "wine/winbase16.h"
22 #include "debugtools.h"
25 DEFAULT_DEBUG_CHANNEL(mci);
27 static int MCI_InstalledCount;
28 static LPSTR MCI_lpInstallNames = NULL;
30 /* First MCI valid device ID (0 means error) */
31 #define MCI_MAGIC 0x0001
33 /**************************************************************************
34 * MCI_GetDriver [internal]
36 LPWINE_MCIDRIVER MCI_GetDriver(UINT16 wDevID)
38 LPWINE_MCIDRIVER wmd = 0;
39 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
41 EnterCriticalSection(&iData->cs);
42 for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
43 if (wmd->wDeviceID == wDevID)
46 LeaveCriticalSection(&iData->cs);
50 /**************************************************************************
51 * MCI_GetDriverFromString [internal]
53 UINT MCI_GetDriverFromString(LPCSTR lpstrName)
56 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
62 if (!lstrcmpiA(lpstrName, "ALL"))
63 return MCI_ALL_DEVICE_ID;
65 EnterCriticalSection(&iData->cs);
66 for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
67 if (wmd->lpstrElementName && strcmp(wmd->lpstrElementName, lpstrName) == 0) {
72 if (wmd->lpstrDeviceType && strcmp(wmd->lpstrDeviceType, lpstrName) == 0) {
77 if (wmd->lpstrAlias && strcmp(wmd->lpstrAlias, lpstrName) == 0) {
82 LeaveCriticalSection(&iData->cs);
87 /**************************************************************************
88 * MCI_MessageToString [internal]
90 const char* MCI_MessageToString(UINT16 wMsg)
92 static char buffer[100];
94 #define CASE(s) case (s): return #s
99 CASE(MCI_CLOSE_DRIVER);
108 CASE(MCI_GETDEVCAPS);
112 CASE(MCI_OPEN_DRIVER);
130 /* constants for digital video */
144 sprintf(buffer, "MCI_<<%04X>>", wMsg);
149 /**************************************************************************
150 * MCI_GetDevTypeFromFileName [internal]
152 static DWORD MCI_GetDevTypeFromFileName(LPCSTR fileName, LPSTR buf, UINT len)
156 if ((tmp = strrchr(fileName, '.'))) {
157 GetProfileStringA("mci extensions", tmp + 1, "*", buf, len);
158 if (strcmp(buf, "*") != 0) {
161 TRACE("No [mci extensions] entry for '%s' found.\n", tmp);
163 return MCIERR_EXTENSION_NOT_FOUND;
166 #define MAX_MCICMDTABLE 20
167 #define MCI_COMMAND_TABLE_NOT_LOADED 0xFFFE
169 typedef struct tagWINE_MCICMDTABLE {
173 UINT nVerbs; /* number of verbs in command table */
174 LPCSTR* aVerbs; /* array of verbs to speed up the verb look up process */
175 } WINE_MCICMDTABLE, *LPWINE_MCICMDTABLE;
176 WINE_MCICMDTABLE S_MciCmdTable[MAX_MCICMDTABLE];
178 /**************************************************************************
179 * MCI_IsCommandTableValid [internal]
181 static BOOL MCI_IsCommandTableValid(UINT uTbl)
189 TRACE("Dumping cmdTbl=%d [hMem=%08x devType=%d]\n",
190 uTbl, S_MciCmdTable[uTbl].hMem, S_MciCmdTable[uTbl].uDevType);
192 if (uTbl >= MAX_MCICMDTABLE || !S_MciCmdTable[uTbl].hMem || !S_MciCmdTable[uTbl].lpTable)
195 lmem = S_MciCmdTable[uTbl].lpTable;
199 lmem += strlen(lmem) + 1;
200 flg = *(LPDWORD)lmem;
201 eid = *(LPWORD)(lmem + sizeof(DWORD));
202 lmem += sizeof(DWORD) + sizeof(WORD);
204 /* EPP TRACE("cmd='%s' %08lx %04x\n", str, flg, eid); */
206 case MCI_COMMAND_HEAD: if (!*str || !flg) return FALSE; idx = 0; break; /* check unicity of str in table */
207 case MCI_STRING: if (inCst) return FALSE; break;
208 case MCI_INTEGER: if (!*str) return FALSE; break;
209 case MCI_END_COMMAND: if (*str || flg || idx == 0) return FALSE; idx = 0; break;
210 case MCI_RETURN: if (*str || idx != 1) return FALSE; break;
211 case MCI_FLAG: if (!*str) return FALSE; break;
212 case MCI_END_COMMAND_LIST: if (*str || flg) return FALSE; idx = 0; break;
213 case MCI_RECT: if (!*str || inCst) return FALSE; break;
214 case MCI_CONSTANT: if (inCst) return FALSE; inCst = TRUE; break;
215 case MCI_END_CONSTANT: if (*str || flg || !inCst) return FALSE; inCst = FALSE; break;
216 default: return FALSE;
218 } while (eid != MCI_END_COMMAND_LIST);
219 } while (eid != MCI_END_COMMAND_LIST);
223 /**************************************************************************
224 * MCI_DumpCommandTable [internal]
226 static BOOL MCI_DumpCommandTable(UINT uTbl)
233 if (!MCI_IsCommandTableValid(uTbl)) {
234 ERR("Ooops: %d is not valid\n", uTbl);
238 lmem = S_MciCmdTable[uTbl].lpTable;
242 lmem += strlen(lmem) + 1;
243 flg = *(LPDWORD)lmem;
244 eid = *(LPWORD)(lmem + sizeof(DWORD));
245 TRACE("cmd='%s' %08lx %04x\n", str, flg, eid);
246 lmem += sizeof(DWORD) + sizeof(WORD);
247 } while (eid != MCI_END_COMMAND && eid != MCI_END_COMMAND_LIST);
248 TRACE(" => end of command%s\n", (eid == MCI_END_COMMAND_LIST) ? " list" : "");
249 } while (eid != MCI_END_COMMAND_LIST);
253 static UINT MCI_SetCommandTable(LPWINE_MM_IDATA iData, HANDLE hMem, UINT uDevType);
255 /**************************************************************************
256 * MCI_GetCommandTable [internal]
258 static UINT MCI_GetCommandTable(LPWINE_MM_IDATA iData, UINT uDevType)
264 /* first look up existing for existing devType */
265 for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) {
266 if (S_MciCmdTable[uTbl].hMem && S_MciCmdTable[uTbl].uDevType == uDevType)
270 /* well try to load id */
271 if (uDevType >= MCI_DEVTYPE_FIRST && uDevType <= MCI_DEVTYPE_LAST) {
272 if (LoadStringA(iData->hWinMM32Instance, uDevType, buf, sizeof(buf))) {
275 } else if (uDevType == 0) {
278 uTbl = MCI_NO_COMMAND_TABLE;
280 HRSRC hRsrc = FindResourceA(iData->hWinMM32Instance, str, (LPCSTR)RT_RCDATAA);
283 if (hRsrc) hMem = LoadResource(iData->hWinMM32Instance, hRsrc);
285 uTbl = MCI_SetCommandTable(iData, hMem, uDevType);
287 WARN("No command table found in resource %04x[%s]\n",
288 iData->hWinMM32Instance, str);
291 TRACE("=> %d\n", uTbl);
295 /**************************************************************************
296 * MCI_SetCommandTable [internal]
298 static UINT MCI_SetCommandTable(LPWINE_MM_IDATA iData, HANDLE hMem,
302 static BOOL bInitDone = FALSE;
305 * The CORE command table must be loaded first, so that MCI_GetCommandTable()
306 * can be called with 0 as a uDevType to retrieve it.
311 for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) {
312 S_MciCmdTable[uTbl].hMem = 0;
314 MCI_GetCommandTable(iData, 0);
317 for (uTbl = 0; uTbl < MAX_MCICMDTABLE; uTbl++) {
318 if (S_MciCmdTable[uTbl].hMem == 0) {
323 S_MciCmdTable[uTbl].hMem = hMem;
324 S_MciCmdTable[uTbl].uDevType = uDevType;
325 S_MciCmdTable[uTbl].lpTable = LockResource(hMem);
328 MCI_DumpCommandTable(uTbl);
331 /* create the verbs table */
332 /* get # of entries */
333 lmem = S_MciCmdTable[uTbl].lpTable;
336 lmem += strlen(lmem) + 1;
337 eid = *(LPWORD)(lmem + sizeof(DWORD));
338 lmem += sizeof(DWORD) + sizeof(WORD);
339 if (eid == MCI_COMMAND_HEAD)
341 } while (eid != MCI_END_COMMAND_LIST);
343 S_MciCmdTable[uTbl].aVerbs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(LPCSTR));
344 S_MciCmdTable[uTbl].nVerbs = count;
346 lmem = S_MciCmdTable[uTbl].lpTable;
350 lmem += strlen(lmem) + 1;
351 eid = *(LPWORD)(lmem + sizeof(DWORD));
352 lmem += sizeof(DWORD) + sizeof(WORD);
353 if (eid == MCI_COMMAND_HEAD)
354 S_MciCmdTable[uTbl].aVerbs[count++] = str;
355 } while (eid != MCI_END_COMMAND_LIST);
356 /* assert(count == S_MciCmdTable[uTbl].nVerbs); */
361 return MCI_NO_COMMAND_TABLE;
364 /**************************************************************************
365 * MCI_DeleteCommandTable [internal]
367 static BOOL MCI_DeleteCommandTable(UINT uTbl)
369 if (uTbl >= MAX_MCICMDTABLE || !S_MciCmdTable[uTbl].hMem)
372 FreeResource16(S_MciCmdTable[uTbl].hMem);
373 S_MciCmdTable[uTbl].hMem = 0;
374 if (S_MciCmdTable[uTbl].aVerbs) {
375 HeapFree(GetProcessHeap(), 0, S_MciCmdTable[uTbl].aVerbs);
376 S_MciCmdTable[uTbl].aVerbs = 0;
381 /**************************************************************************
382 * MCI_UnLoadMciDriver [internal]
384 static BOOL MCI_UnLoadMciDriver(LPWINE_MM_IDATA iData, LPWINE_MCIDRIVER wmd)
386 LPWINE_MCIDRIVER* tmp;
392 CloseDriver(wmd->hDrv, 0, 0);
394 if (wmd->dwPrivate != 0)
395 WARN("Unloading mci driver with non nul dwPrivate field\n");
397 EnterCriticalSection(&iData->cs);
398 for (tmp = &iData->lpMciDrvs; *tmp; tmp = &(*tmp)->lpNext) {
404 LeaveCriticalSection(&iData->cs);
406 HeapFree(GetProcessHeap(), 0, wmd->lpstrDeviceType);
407 HeapFree(GetProcessHeap(), 0, wmd->lpstrAlias);
408 HeapFree(GetProcessHeap(), 0, wmd->lpstrElementName);
410 HeapFree(GetProcessHeap(), 0, wmd);
414 /**************************************************************************
415 * MCI_LoadMciDriver [internal]
417 static DWORD MCI_LoadMciDriver(LPWINE_MM_IDATA iData, LPCSTR _strDevTyp,
418 LPWINE_MCIDRIVER* lpwmd)
420 LPSTR strDevTyp = CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, _strDevTyp));
421 LPWINE_MCIDRIVER wmd = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wmd));
422 MCI_OPEN_DRIVER_PARMSA modp;
426 if (!wmd || !strDevTyp) {
427 dwRet = MCIERR_OUT_OF_MEMORY;
431 wmd->lpfnYieldProc = MCI_DefYieldProc;
432 wmd->dwYieldData = VK_CANCEL;
433 wmd->hCreatorTask = GetCurrentTask();
435 EnterCriticalSection(&iData->cs);
436 /* wmd must be inserted in list before sending opening the driver, coz' it
437 * may want to lookup at wDevID
439 wmd->lpNext = iData->lpMciDrvs;
440 iData->lpMciDrvs = wmd;
442 for (modp.wDeviceID = MCI_MAGIC;
443 MCI_GetDriver(modp.wDeviceID) != 0;
446 wmd->wDeviceID = modp.wDeviceID;
448 LeaveCriticalSection(&iData->cs);
450 TRACE("wDevID=%04X \n", modp.wDeviceID);
452 modp.lpstrParams = NULL;
454 hDrv = OpenDriverA(strDevTyp, "mci", (LPARAM)&modp);
457 FIXME("Couldn't load driver for type %s.\n"
458 "If you don't have a windows installation accessible from Wine,\n"
459 "you perhaps forgot to create a [mci] section in system.ini\n",
461 dwRet = MCIERR_DEVICE_NOT_INSTALLED;
465 /* FIXME: should also check that module's description is of the form
466 * MODULENAME:[MCI] comment
470 /* some drivers will return 0x0000FFFF, some others 0xFFFFFFFF */
471 wmd->uSpecificCmdTable = LOWORD(modp.wCustomCommandTable);
472 wmd->uTypeCmdTable = MCI_COMMAND_TABLE_NOT_LOADED;
474 TRACE("Loaded driver %x (%s), type is %d, cmdTable=%08x\n",
475 hDrv, strDevTyp, modp.wType, modp.wCustomCommandTable);
477 wmd->lpstrDeviceType = strDevTyp;
478 wmd->wType = modp.wType;
480 TRACE("mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
481 modp.wDeviceID, modp.wType, modp.wDeviceID);
485 MCI_UnLoadMciDriver(iData, wmd);
486 HeapFree(GetProcessHeap(), 0, strDevTyp);
491 /**************************************************************************
492 * MCI_FinishOpen [internal]
494 static DWORD MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSA lpParms,
497 if (dwParam & MCI_OPEN_ELEMENT)
498 wmd->lpstrElementName = HEAP_strdupA(GetProcessHeap(), 0,
499 lpParms->lpstrElementName);
501 if (dwParam & MCI_OPEN_ALIAS)
502 wmd->lpstrAlias = HEAP_strdupA(GetProcessHeap(), 0, lpParms->lpstrAlias);
504 lpParms->wDeviceID = wmd->wDeviceID;
506 return MCI_SendCommandFrom32(wmd->wDeviceID, MCI_OPEN_DRIVER, dwParam,
510 /**************************************************************************
511 * MCI_FindCommand [internal]
513 static LPCSTR MCI_FindCommand(UINT uTbl, LPCSTR verb)
517 if (uTbl >= MAX_MCICMDTABLE || S_MciCmdTable[uTbl].hMem == 0)
520 /* another improvement would be to have the aVerbs array sorted,
521 * so that we could use a dichotomic search on it, rather than this dumb
524 for (idx = 0; idx < S_MciCmdTable[uTbl].nVerbs; idx++) {
525 if (strcmp(S_MciCmdTable[uTbl].aVerbs[idx], verb) == 0)
526 return S_MciCmdTable[uTbl].aVerbs[idx];
532 /**************************************************************************
533 * MCI_GetReturnType [internal]
535 static DWORD MCI_GetReturnType(LPCSTR lpCmd)
537 lpCmd += strlen(lpCmd) + 1 + sizeof(DWORD) + sizeof(WORD);
538 if (*lpCmd == '\0' && *(LPWORD)(lpCmd + 1 + sizeof(DWORD)) == MCI_RETURN) {
539 return *(LPDWORD)(lpCmd + 1);
544 /**************************************************************************
545 * MCI_GetMessage [internal]
547 static WORD MCI_GetMessage(LPCSTR lpCmd)
549 return (WORD)*(LPDWORD)(lpCmd + strlen(lpCmd) + 1);
552 /**************************************************************************
553 * MCI_GetDWord [internal]
555 static BOOL MCI_GetDWord(LPDWORD data, LPSTR* ptr)
560 val = strtoul(*ptr, &ret, 0);
564 case ' ': ret++; break;
565 default: return FALSE;
573 /**************************************************************************
574 * MCI_GetString [internal]
576 static DWORD MCI_GetString(LPSTR* str, LPSTR* args)
580 /* see if we have a quoted string */
582 ptr = strchr(*str = ptr + 1, '"');
583 if (!ptr) return MCIERR_NO_CLOSING_QUOTE;
584 /* FIXME: shall we escape \" from string ?? */
585 if (ptr[-1] == '\\') TRACE("Ooops: un-escaped \"\n");
586 *ptr++ = '\0'; /* remove trailing " */
587 if (*ptr != ' ' && *ptr != '\0') return MCIERR_EXTRA_CHARACTERS;
590 ptr = strchr(ptr, ' ');
595 ptr = *args + strlen(*args);
604 #define MCI_DATA_SIZE 16
606 /**************************************************************************
607 * MCI_ParseOptArgs [internal]
609 static DWORD MCI_ParseOptArgs(LPDWORD data, int _offset, LPCSTR lpCmd,
610 LPSTR args, LPDWORD dwFlags)
614 DWORD dwRet, flg, cflg = 0;
618 /* loop on arguments */
621 found = inCst = FALSE;
623 TRACE("args='%s' offset=%d\n", args, offset);
625 do { /* loop on options for command table for the requested verb */
627 lmem += (len = strlen(lmem)) + 1;
628 flg = *(LPDWORD)lmem;
629 eid = *(LPWORD)(lmem + sizeof(DWORD));
630 lmem += sizeof(DWORD) + sizeof(WORD);
631 /* EPP TRACE("\tcmd='%s' inCst=%s\n", str, inCst ? "Y" : "N"); */
635 inCst = TRUE; cflg = flg; break;
636 case MCI_END_CONSTANT:
637 /* there may be additional integral values after flag in constant */
638 if (inCst && MCI_GetDWord(&(data[offset]), &args)) {
641 inCst = FALSE; cflg = 0;
645 if (strncasecmp(args, str, len) == 0 &&
646 (args[len] == 0 || args[len] == ' ')) {
647 /* store good values into data[] */
649 if (*args == ' ') args++;
653 case MCI_COMMAND_HEAD:
655 case MCI_END_COMMAND:
656 case MCI_END_COMMAND_LIST:
657 case MCI_CONSTANT: /* done above */
658 case MCI_END_CONSTANT: /* done above */
670 if (!MCI_GetDWord(&(data[offset]), &args)) {
671 return MCIERR_BAD_INTEGER;
676 /* store rect in data (offset...offset+3) */
678 if (!MCI_GetDWord(&(data[offset+0]), &args) ||
679 !MCI_GetDWord(&(data[offset+1]), &args) ||
680 !MCI_GetDWord(&(data[offset+2]), &args) ||
681 !MCI_GetDWord(&(data[offset+3]), &args)) {
682 ERR("Bad rect '%s'\n", args);
683 return MCIERR_BAD_INTEGER;
688 if ((dwRet = MCI_GetString((LPSTR*)&data[offset], &args)))
691 default: ERR("oops");
693 /* exit inside while loop */
694 eid = MCI_END_COMMAND;
696 /* have offset incremented if needed */
698 case MCI_COMMAND_HEAD:
700 case MCI_END_COMMAND:
701 case MCI_END_COMMAND_LIST:
703 case MCI_FLAG: break;
704 case MCI_INTEGER: if (!inCst) offset++; break;
705 case MCI_END_CONSTANT:
706 case MCI_STRING: offset++; break;
707 case MCI_RECT: offset += 4; break;
708 default: ERR("oops");
711 } while (eid != MCI_END_COMMAND);
713 TRACE("Optarg '%s' not found\n", args);
714 return MCIERR_UNRECOGNIZED_COMMAND;
716 if (offset == MCI_DATA_SIZE) {
717 ERR("Internal data[] buffer overflow\n");
718 return MCIERR_PARSER_INTERNAL;
724 /**************************************************************************
725 * MCI_HandleReturnValues [internal]
727 static DWORD MCI_HandleReturnValues(LPWINE_MM_IDATA iData, DWORD dwRet,
728 LPWINE_MCIDRIVER wmd, LPCSTR lpCmd, LPDWORD data,
729 LPSTR lpstrRet, UINT uRetLen)
732 switch (MCI_GetReturnType(lpCmd)) {
733 case 0: /* nothing to return */
736 switch (dwRet & 0xFFFF0000ul) {
738 case MCI_INTEGER_RETURNED:
739 wsnprintfA(lpstrRet, uRetLen, "%ld", data[1]);
741 case MCI_RESOURCE_RETURNED:
742 /* return string which ID is HIWORD(data[1]),
743 * string is loaded from mmsystem.dll */
744 LoadStringA(iData->hWinMM32Instance, HIWORD(data[1]),
747 case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER:
748 /* return string which ID is HIWORD(data[1]),
749 * string is loaded from driver */
750 LoadStringA(wmd->hDrv, HIWORD(data[1]), lpstrRet, uRetLen);
752 case MCI_COLONIZED3_RETURN:
753 wsnprintfA(lpstrRet, uRetLen, "%d:%d:%d",
754 LOBYTE(LOWORD(data[1])), HIBYTE(LOWORD(data[1])),
755 LOBYTE(HIWORD(data[1])));
757 case MCI_COLONIZED4_RETURN:
758 wsnprintfA(lpstrRet, uRetLen, "%d:%d:%d:%d",
759 LOBYTE(LOWORD(data[1])), HIBYTE(LOWORD(data[1])),
760 LOBYTE(HIWORD(data[1])), HIBYTE(HIWORD(data[1])));
762 default: ERR("Ooops (%04X)\n", HIWORD(dwRet));
766 switch (dwRet & 0xFFFF0000ul) {
768 /* nothing to do data[1] == lpstrRet */
770 case MCI_INTEGER_RETURNED:
771 data[1] = *(LPDWORD)lpstrRet;
772 wsnprintfA(lpstrRet, uRetLen, "%ld", data[1]);
775 WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet));
780 if (dwRet & 0xFFFF0000ul)
781 WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet));
782 wsnprintfA(lpstrRet, uRetLen, "%ld %ld %ld %ld",
783 data[1], data[2], data[3], data[4]);
785 default: ERR("oops\n");
788 return LOWORD(dwRet);
791 /**************************************************************************
792 * mciSendStringA [MMSYSTEM.702][WINMM.51]
794 DWORD WINAPI mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrRet,
795 UINT uRetLen, HWND hwndCallback)
797 LPSTR verb, dev, args;
798 LPWINE_MCIDRIVER wmd = 0;
799 DWORD dwFlags = 0, dwRet = 0;
801 DWORD data[MCI_DATA_SIZE];
803 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
804 BOOL bAutoOpen = FALSE;
806 TRACE("('%s', %p, %d, %X)\n", lpstrCommand, lpstrRet, uRetLen, hwndCallback);
808 /* format is <command> <device> <optargs> */
809 if (!(verb = HEAP_strdupA(GetProcessHeap(), 0, lpstrCommand)))
810 return MCIERR_OUT_OF_MEMORY;
812 memset(data, 0, sizeof(data));
814 if (!(args = strchr(verb, ' '))) {
815 dwRet = MCIERR_MISSING_DEVICE_NAME;
819 if ((dwRet = MCI_GetString(&dev, &args))) {
823 /* case dev == 'new' has to be handled */
824 if (!strcasecmp(dev, "new")) {
825 FIXME("'new': NIY as device name\n");
826 dwRet = MCIERR_MISSING_DEVICE_NAME;
830 /* otherwise, try to grab devType from open */
831 if (!strcmp(verb, "open")) {
834 if ((devType = strchr(dev, '!')) != NULL) {
836 tmp = devType; devType = dev; dev = tmp;
838 dwFlags |= MCI_OPEN_TYPE;
839 data[2] = (DWORD)devType;
840 devType = CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, devType));
841 } else if (strchr(dev, '.') == NULL) {
842 tmp = strchr(dev,' ');
843 if (tmp) *tmp = '\0';
844 data[2] = (DWORD)dev;
845 devType = CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, dev));
847 dwFlags |= MCI_OPEN_TYPE;
849 if ((devType = strstr(args, "type ")) != NULL) {
851 tmp = strchr(devType, ' ');
852 if (tmp) *tmp = '\0';
853 devType = CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, devType));
855 /* dwFlags and data[2] will be correctly set in ParseOpt loop */
858 if ((dwRet = MCI_GetDevTypeFromFileName(dev, buf, sizeof(buf))))
861 devType = CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, buf));
863 dwFlags |= MCI_OPEN_ELEMENT;
864 data[3] = (DWORD)dev;
866 dwRet = MCI_LoadMciDriver(iData, devType, &wmd);
867 HeapFree(GetProcessHeap(), 0, devType);
869 MCI_UnLoadMciDriver(iData, wmd);
872 } else if (!(wmd = MCI_GetDriver(mciGetDeviceIDA(dev)))) {
875 sprintf(buf, "open %s wait", dev);
877 if ((dwRet = mciSendStringA(buf, NULL, 0, 0)) != 0)
880 wmd = MCI_GetDriver(mciGetDeviceIDA(dev));
882 /* FIXME: memory leak, MCI driver is not closed */
883 dwRet = MCIERR_INVALID_DEVICE_ID;
888 /* get the verb in the different command tables */
889 /* try the device specific command table */
890 if (wmd) lpCmd = MCI_FindCommand(wmd->uSpecificCmdTable, verb);
891 /* try the type specific command table */
893 if (wmd && wmd->uTypeCmdTable == MCI_COMMAND_TABLE_NOT_LOADED)
894 wmd->uTypeCmdTable = MCI_GetCommandTable(iData, wmd->wType);
895 if (wmd && wmd->uTypeCmdTable != MCI_NO_COMMAND_TABLE)
896 lpCmd = MCI_FindCommand(wmd->uTypeCmdTable, verb);
898 /* try core command table */
899 if (!lpCmd) lpCmd = MCI_FindCommand(MCI_GetCommandTable(iData, 0), verb);
902 TRACE("Command '%s' not found!\n", verb);
903 dwRet = MCIERR_UNRECOGNIZED_COMMAND;
907 /* set up call back */
908 if (hwndCallback != 0) {
909 dwFlags |= MCI_NOTIFY;
910 data[0] = (DWORD)hwndCallback;
913 /* set return information */
914 switch (MCI_GetReturnType(lpCmd)) {
915 case 0: offset = 1; break;
916 case MCI_INTEGER: offset = 2; break;
917 case MCI_STRING: data[1] = (DWORD)lpstrRet; data[2] = uRetLen; offset = 3; break;
918 case MCI_RECT: offset = 5; break;
919 default: ERR("oops\n");
922 TRACE("verb='%s' on dev='%s'; offset=%d\n", verb, dev, offset);
924 if ((dwRet = MCI_ParseOptArgs(data, offset, lpCmd, args, &dwFlags)))
927 if (bAutoOpen && (dwFlags & MCI_NOTIFY)) {
928 dwRet = MCIERR_NOTIFY_ON_AUTO_OPEN;
931 /* FIXME: the command should get it's own notification window set up and
932 * ask for device closing while processing the notification mechanism
934 if (lpstrRet && uRetLen) *lpstrRet = '\0';
936 #define STR_OF(_x) (IsBadReadPtr((char*)_x,1)?"?":(char*)(_x))
937 TRACE("[%d, %s, %08lx, %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s]\n",
938 wmd->wDeviceID, MCI_MessageToString(MCI_GetMessage(lpCmd)), dwFlags,
939 data[0], STR_OF(data[0]), data[1], STR_OF(data[1]),
940 data[2], STR_OF(data[2]), data[3], STR_OF(data[3]),
941 data[4], STR_OF(data[4]), data[5], STR_OF(data[5]));
944 if (strcmp(verb, "open") == 0) {
945 if ((dwRet = MCI_FinishOpen(wmd, (LPMCI_OPEN_PARMSA)data, dwFlags)))
946 MCI_UnLoadMciDriver(iData, wmd);
947 /* FIXME: notification is not properly shared across two opens */
949 dwRet = MCI_SendCommand(wmd->wDeviceID, MCI_GetMessage(lpCmd), dwFlags, (DWORD)data, TRUE);
951 TRACE("=> 1/ %lx (%s)\n", dwRet, lpstrRet);
952 if (dwRet) goto errCleanUp;
954 dwRet = MCI_HandleReturnValues(iData, dwRet, wmd, lpCmd, data, lpstrRet, uRetLen);
955 TRACE("=> 2/ %lx (%s)\n", dwRet, lpstrRet);
958 HeapFree(GetProcessHeap(), 0, verb);
962 /**************************************************************************
963 * mciSendStringW [WINMM.52]
965 DWORD WINAPI mciSendStringW(LPCWSTR lpwstrCommand, LPSTR lpstrRet,
966 UINT uRetLen, HWND hwndCallback)
971 /* FIXME: is there something to do with lpstrReturnString ? */
972 lpstrCommand = HEAP_strdupWtoA(GetProcessHeap(), 0, lpwstrCommand);
973 ret = mciSendStringA(lpstrCommand, lpstrRet, uRetLen, hwndCallback);
974 HeapFree(GetProcessHeap(), 0, lpstrCommand);
978 /**************************************************************************
979 * mciSendString16 [MMSYSTEM.702]
981 DWORD WINAPI mciSendString16(LPCSTR lpstrCommand, LPSTR lpstrRet,
982 UINT16 uRetLen, HWND16 hwndCallback)
984 return mciSendStringA(lpstrCommand, lpstrRet, uRetLen, hwndCallback);
987 /**************************************************************************
988 * mciExecute [WINMM.38]
990 DWORD WINAPI mciExecute(LPCSTR lpstrCommand)
995 TRACE("(%s)!\n", lpstrCommand);
997 ret = mciSendString16(lpstrCommand, strRet, sizeof(strRet), 0);
999 if (!mciGetErrorStringA(ret, strRet, sizeof(strRet))) {
1000 sprintf(strRet, "Unknown MCI error (%ld)", ret);
1002 MessageBoxA(0, strRet, "Error in mciExecute()", MB_OK);
1004 /* FIXME: what shall I return ? */
1008 /**************************************************************************
1009 * mciLoadCommandResource [MMSYSTEM.705]
1011 UINT16 WINAPI mciLoadCommandResource16(HANDLE16 hInst, LPCSTR resname, UINT16 type)
1015 UINT16 ret = MCI_NO_COMMAND_TABLE;
1016 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
1018 TRACE("(%04x, %s, %d)!\n", hInst, resname, type);
1020 /* if file exists "resname.mci", then load resource "resname" from it
1021 * otherwise directly from driver
1022 * We don't support it (who uses this feature ?), but we check anyway
1028 strcat(strcpy(buf, resname), ".mci");
1029 if (OpenFile(buf, &ofs, OF_EXIST) != HFILE_ERROR) {
1030 FIXME("NIY: command table to be loaded from '%s'\n", ofs.szPathName);
1033 if (!(hRsrc = FindResourceA(hInst, resname, (LPCSTR)RT_RCDATAA))) {
1034 WARN("No command table found in resource\n");
1035 } else if ((hMem = LoadResource(hInst, hRsrc))) {
1036 ret = MCI_SetCommandTable(iData, hMem, type);
1038 WARN("Couldn't load resource.\n");
1040 TRACE("=> %04x\n", ret);
1044 /**************************************************************************
1045 * mciFreeCommandResource [MMSYSTEM.713]
1047 BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable)
1049 TRACE("(%04x)!\n", uTable);
1051 return MCI_DeleteCommandTable(uTable);
1054 /**************************************************************************
1055 * mciLoadCommandResource [WINMM.48]
1057 * Strangely, this function only exists as an UNICODE one.
1059 UINT WINAPI mciLoadCommandResource(HINSTANCE hinst, LPCWSTR resNameW, UINT type)
1064 TRACE("(%04x, %s, %d)!\n", hinst, debugstr_w(resNameW), type);
1066 resNameA = HEAP_strdupWtoA(GetProcessHeap(), 0, resNameW);
1067 ret = mciLoadCommandResource16(hinst, resNameA, type);
1068 HeapFree(GetProcessHeap(), 0, resNameA);
1072 /**************************************************************************
1073 * mciFreeCommandResource [WINMM.39]
1075 BOOL WINAPI mciFreeCommandResource(UINT uTable)
1077 TRACE("(%08x)!\n", uTable);
1079 return mciFreeCommandResource16(uTable);
1083 MCI_MAP_NOMEM, /* ko, memory problem */
1084 MCI_MAP_MSGERROR, /* ko, unknown message */
1085 MCI_MAP_OK, /* ok, no memory allocated. to be sent to the proc. */
1086 MCI_MAP_OKMEM, /* ok, some memory allocated, need to call UnMapMsg. to be sent to the proc. */
1087 MCI_MAP_PASS /* not handled (no memory allocated) to be sent to the driver */
1090 /**************************************************************************
1091 * MCI_MapMsg16To32A [internal]
1093 static MCI_MapType MCI_MapMsg16To32A(WORD uDevType, WORD wMsg, DWORD* lParam)
1097 /* FIXME: to add also (with seg/linear modifications to do):
1098 * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
1099 * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
1102 /* case MCI_CAPTURE */
1104 case MCI_CLOSE_DRIVER:
1105 /* case MCI_CONFIGURE:*/
1111 case MCI_GETDEVCAPS:
1112 /* case MCI_INDEX: */
1113 /* case MCI_MARK: */
1114 /* case MCI_MONITOR: */
1124 /* case MCI_SETTIMECODE:*/
1125 /* case MCI_SIGNAL:*/
1127 case MCI_STATUS: /* FIXME: is wrong for digital video */
1130 /* case MCI_UNDO: */
1134 *lParam = (DWORD)PTR_SEG_TO_LIN(*lParam);
1137 /* in fact, I would also need the dwFlags... to see
1138 * which members of lParam are effectively used
1140 *lParam = (DWORD)PTR_SEG_TO_LIN(*lParam);
1141 FIXME("Current mapping may be wrong\n");
1145 LPMCI_BREAK_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
1146 LPMCI_BREAK_PARMS16 mbp16 = PTR_SEG_TO_LIN(*lParam);
1149 mbp32->dwCallback = mbp16->dwCallback;
1150 mbp32->nVirtKey = mbp16->nVirtKey;
1151 mbp32->hwndBreak = mbp16->hwndBreak;
1153 return MCI_MAP_NOMEM;
1155 *lParam = (DWORD)mbp32;
1157 return MCI_MAP_OKMEM;
1160 LPMCI_VD_ESCAPE_PARMSA mvep32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSA));
1161 LPMCI_VD_ESCAPE_PARMS16 mvep16 = PTR_SEG_TO_LIN(*lParam);
1164 mvep32a->dwCallback = mvep16->dwCallback;
1165 mvep32a->lpstrCommand = PTR_SEG_TO_LIN(mvep16->lpstrCommand);
1167 return MCI_MAP_NOMEM;
1169 *lParam = (DWORD)mvep32a;
1171 return MCI_MAP_OKMEM;
1174 LPMCI_INFO_PARMSA mip32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_INFO_PARMSA));
1175 LPMCI_INFO_PARMS16 mip16 = PTR_SEG_TO_LIN(*lParam);
1177 /* FIXME this is wrong if device is of type
1178 * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
1181 mip32a->dwCallback = mip16->dwCallback;
1182 mip32a->lpstrReturn = PTR_SEG_TO_LIN(mip16->lpstrReturn);
1183 mip32a->dwRetSize = mip16->dwRetSize;
1185 return MCI_MAP_NOMEM;
1187 *lParam = (DWORD)mip32a;
1189 return MCI_MAP_OKMEM;
1191 case MCI_OPEN_DRIVER:
1193 LPMCI_OPEN_PARMSA mop32a = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSA) + 2 * sizeof(DWORD));
1194 LPMCI_OPEN_PARMS16 mop16 = PTR_SEG_TO_LIN(*lParam);
1197 *(LPMCI_OPEN_PARMS16*)(mop32a) = mop16;
1198 mop32a = (LPMCI_OPEN_PARMSA)((char*)mop32a + sizeof(LPMCI_OPEN_PARMS16));
1199 mop32a->dwCallback = mop16->dwCallback;
1200 mop32a->wDeviceID = mop16->wDeviceID;
1201 mop32a->lpstrDeviceType = PTR_SEG_TO_LIN(mop16->lpstrDeviceType);
1202 mop32a->lpstrElementName = PTR_SEG_TO_LIN(mop16->lpstrElementName);
1203 mop32a->lpstrAlias = PTR_SEG_TO_LIN(mop16->lpstrAlias);
1204 /* copy extended information if any...
1205 * FIXME: this may seg fault if initial structure does not contain them and
1206 * the reads after msip16 fail under LDT limits...
1207 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
1208 * should not take care of extended parameters, and should be used by MCI_Open
1209 * to fetch uDevType. When, this is known, the mapping for sending the
1210 * MCI_OPEN_DRIVER shall be done depending on uDevType.
1212 memcpy(mop32a + 1, mop16 + 1, 2 * sizeof(DWORD));
1214 return MCI_MAP_NOMEM;
1216 *lParam = (DWORD)mop32a;
1218 return MCI_MAP_OKMEM;
1221 LPMCI_SYSINFO_PARMSA msip32a = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SYSINFO_PARMSA));
1222 LPMCI_SYSINFO_PARMS16 msip16 = PTR_SEG_TO_LIN(*lParam);
1225 msip32a->dwCallback = msip16->dwCallback;
1226 msip32a->lpstrReturn = PTR_SEG_TO_LIN(msip16->lpstrReturn);
1227 msip32a->dwRetSize = msip16->dwRetSize;
1228 msip32a->dwNumber = msip16->dwNumber;
1229 msip32a->wDeviceType = msip16->wDeviceType;
1231 return MCI_MAP_NOMEM;
1233 *lParam = (DWORD)msip32a;
1235 return MCI_MAP_OKMEM;
1243 case DRV_QUERYCONFIGURE:
1246 case DRV_EXITSESSION:
1247 case DRV_EXITAPPLICATION:
1249 FIXME("This is a hack\n");
1253 WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
1255 return MCI_MAP_MSGERROR;
1258 /**************************************************************************
1259 * MCI_UnMapMsg16To32A [internal]
1261 static MCI_MapType MCI_UnMapMsg16To32A(WORD uDevType, WORD wMsg, DWORD lParam)
1264 /* case MCI_CAPTURE */
1266 case MCI_CLOSE_DRIVER:
1267 /* case MCI_CONFIGURE:*/
1273 case MCI_GETDEVCAPS:
1274 /* case MCI_INDEX: */
1275 /* case MCI_MARK: */
1276 /* case MCI_MONITOR: */
1286 /* case MCI_SETTIMECODE:*/
1287 /* case MCI_SIGNAL:*/
1292 /* case MCI_UNDO: */
1299 /* FIXME ?? see Map function */
1306 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
1309 case MCI_OPEN_DRIVER:
1311 LPMCI_OPEN_PARMSA mop32a = (LPMCI_OPEN_PARMSA)lParam;
1312 LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32a - sizeof(LPMCI_OPEN_PARMS16));
1314 mop16->wDeviceID = mop32a->wDeviceID;
1315 if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
1316 FIXME("bad free line=%d\n", __LINE__);
1326 case DRV_QUERYCONFIGURE:
1329 case DRV_EXITSESSION:
1330 case DRV_EXITAPPLICATION:
1332 FIXME("This is a hack\n");
1335 FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
1337 return MCI_MAP_MSGERROR;
1342 * 0001 squeeze signed 4 bytes to 2 bytes *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2; S += 4
1343 * 0010 squeeze unsigned 4 bytes to 2 bytes *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2; S += 4
1346 * 0110 zero 4 bytes *(DWORD)D = 0 D += 4; S += 4
1347 * 0111 copy string *(LPSTR*)D = seg dup(*(LPSTR*)S) D += 4; S += 4
1348 * 1xxx copy xxx + 1 bytes memcpy(D, S, xxx + 1); D += xxx+1; S += xxx+1
1351 /**************************************************************************
1352 * MCI_MsgMapper32To16_Create [internal]
1354 * Helper for MCI_MapMsg32ATo16.
1355 * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit
1356 * segmented pointer.
1357 * map contains a list of action to be performed for the mapping (see list
1359 * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
1361 static MCI_MapType MCI_MsgMapper32To16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
1363 void* lp = SEGPTR_ALLOC((keep ? sizeof(void**) : 0) + size16);
1367 return MCI_MAP_NOMEM;
1369 p32 = (LPBYTE)(*ptr);
1372 p16 = (LPBYTE)lp + sizeof(void**);
1373 *ptr = (char*)SEGPTR_GET(lp) + sizeof(void**);
1376 *ptr = (void*)SEGPTR_GET(lp);
1380 memcpy(p16, p32, size16);
1388 sz = (nibble & 7) + 1;
1389 memcpy(p16, p32, sz);
1392 size16 -= sz; /* DEBUG only */
1395 case 0x1: *( LPINT16)p16 = ( INT16)*( LPINT16)p32; p16 += 2; p32 += 4; size16 -= 2; break;
1396 case 0x2: *(LPUINT16)p16 = (UINT16)*(LPUINT16)p32; p16 += 2; p32 += 4; size16 -= 2; break;
1397 case 0x6: *(LPDWORD)p16 = 0; p16 += 4; p32 += 4; size16 -= 4; break;
1398 case 0x7: *(LPDWORD)p16 = SEGPTR_GET(SEGPTR_STRDUP(*(LPSTR*)p32));p16 += 4; p32 += 4; size16 -= 4; break;
1399 default: FIXME("Unknown nibble for mapping (%x)\n", nibble);
1404 if (size16 != 0) /* DEBUG only */
1405 FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
1407 return MCI_MAP_OKMEM;
1410 /**************************************************************************
1411 * MCI_MsgMapper32To16_Destroy [internal]
1413 * Helper for MCI_UnMapMsg32ATo16.
1415 static MCI_MapType MCI_MsgMapper32To16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
1418 void* msg16 = PTR_SEG_TO_LIN(ptr);
1424 alloc = (char*)msg16 - sizeof(void**);
1425 p32 = *(void**)alloc;
1429 memcpy(p32, p16, size16);
1434 memcpy(p32, p16, (nibble & 7) + 1);
1435 p16 += (nibble & 7) + 1;
1436 p32 += (nibble & 7) + 1;
1437 size16 -= (nibble & 7) + 1;
1440 case 0x1: *( LPINT)p32 = *( LPINT16)p16; p16 += 2; p32 += 4; size16 -= 2; break;
1441 case 0x2: *(LPUINT)p32 = *(LPUINT16)p16; p16 += 2; p32 += 4; size16 -= 2; break;
1442 case 0x6: p16 += 4; p32 += 4; size16 -= 4; break;
1443 case 0x7: strcpy(*(LPSTR*)p32, PTR_SEG_TO_LIN(*(DWORD*)p16));
1444 if (!SEGPTR_FREE(PTR_SEG_TO_LIN(*(DWORD*)p16))) {
1445 FIXME("bad free line=%d\n", __LINE__);
1447 p16 += 4; p32 += 4; size16 -= 4; break;
1448 default: FIXME("Unknown nibble for mapping (%x)\n", nibble);
1453 if (size16 != 0) /* DEBUG only */
1454 FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
1460 if (!SEGPTR_FREE(alloc)) {
1461 FIXME("bad free line=%d\n", __LINE__);
1467 /**************************************************************************
1468 * MCI_MapMsg32ATo16 [internal]
1470 * Map a 32-A bit MCI message to a 16 bit MCI message.
1472 static MCI_MapType MCI_MapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam)
1475 BOOLEAN keep = FALSE;
1481 /* FIXME: to add also (with seg/linear modifications to do):
1482 * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
1483 * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
1487 size = sizeof(MCI_BREAK_PARMS);
1489 /* case MCI_CAPTURE */
1491 case MCI_CLOSE_DRIVER:
1492 size = sizeof(MCI_GENERIC_PARMS);
1494 /* case MCI_CONFIGURE:*/
1495 /* case MCI_COPY: */
1498 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS); break;
1499 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_CUE_PARMS); break;*/ FIXME("NIY vcr\n"); return MCI_MAP_NOMEM;
1500 default: size = sizeof(MCI_GENERIC_PARMS); break;
1506 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16); map = 0x0F1111FB; break;
1507 case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS); break;
1508 default: size = sizeof(MCI_GENERIC_PARMS); break;
1511 /* case MCI_ESCAPE: */
1514 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS); map = 0x0001111B; break;
1515 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break;
1516 default: size = sizeof(MCI_GENERIC_PARMS); break;
1519 case MCI_GETDEVCAPS:
1521 size = sizeof(MCI_GETDEVCAPS_PARMS);
1523 /* case MCI_INDEX: */
1526 LPMCI_INFO_PARMSA mip32a = (LPMCI_INFO_PARMSA)(*lParam);
1528 LPMCI_INFO_PARMS16 mip16;
1531 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_INFO_PARMS16); break;
1532 default: size = sizeof(MCI_INFO_PARMS16); break;
1534 ptr = SEGPTR_ALLOC(sizeof(LPMCI_INFO_PARMSA) + size);
1537 *(LPMCI_INFO_PARMSA*)ptr = mip32a;
1538 mip16 = (LPMCI_INFO_PARMS16)(ptr + sizeof(LPMCI_INFO_PARMSA));
1539 mip16->dwCallback = mip32a->dwCallback;
1540 mip16->lpstrReturn = (LPSTR)SEGPTR_GET(SEGPTR_ALLOC(mip32a->dwRetSize));
1541 mip16->dwRetSize = mip32a->dwRetSize;
1542 if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) {
1543 ((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSA)mip32a)->dwItem;
1546 return MCI_MAP_NOMEM;
1548 *lParam = (LPARAM)SEGPTR_GET(ptr) + sizeof(LPMCI_INFO_PARMSA);
1550 return MCI_MAP_OKMEM;
1551 /* case MCI_MARK: */
1552 /* case MCI_MONITOR: */
1554 case MCI_OPEN_DRIVER:
1556 LPMCI_OPEN_PARMSA mop32a = (LPMCI_OPEN_PARMSA)(*lParam);
1557 char* ptr = SEGPTR_ALLOC(sizeof(LPMCI_OPEN_PARMSA) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD));
1558 LPMCI_OPEN_PARMS16 mop16;
1562 *(LPMCI_OPEN_PARMSA*)(ptr) = mop32a;
1563 mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSA));
1564 mop16->dwCallback = mop32a->dwCallback;
1565 mop16->wDeviceID = mop32a->wDeviceID;
1566 if (dwFlags & MCI_OPEN_TYPE) {
1567 if (dwFlags & MCI_OPEN_TYPE_ID) {
1568 /* dword "transparent" value */
1569 mop16->lpstrDeviceType = mop32a->lpstrDeviceType;
1572 mop16->lpstrDeviceType = mop32a->lpstrDeviceType ? (LPSTR)SEGPTR_GET(SEGPTR_STRDUP(mop32a->lpstrDeviceType)) : 0;
1576 mop16->lpstrDeviceType = 0;
1578 if (dwFlags & MCI_OPEN_ELEMENT) {
1579 if (dwFlags & MCI_OPEN_ELEMENT_ID) {
1580 mop16->lpstrElementName = mop32a->lpstrElementName;
1582 mop16->lpstrElementName = mop32a->lpstrElementName ? (LPSTR)SEGPTR_GET(SEGPTR_STRDUP(mop32a->lpstrElementName)) : 0;
1585 mop16->lpstrElementName = 0;
1587 if (dwFlags & MCI_OPEN_ALIAS) {
1588 mop16->lpstrAlias = mop32a->lpstrAlias ? (LPSTR)SEGPTR_GET(SEGPTR_STRDUP(mop32a->lpstrAlias)) : 0;
1590 mop16->lpstrAlias = 0;
1592 /* copy extended information if any...
1593 * FIXME: this may seg fault if initial structure does not contain them and
1594 * the reads after msip16 fail under LDT limits...
1595 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
1596 * should not take care of extended parameters, and should be used by MCI_Open
1597 * to fetch uDevType. When, this is known, the mapping for sending the
1598 * MCI_OPEN_DRIVER shall be done depending on uDevType.
1600 memcpy(mop16 + 1, mop32a + 1, 2 * sizeof(DWORD));
1602 return MCI_MAP_NOMEM;
1604 *lParam = (LPARAM)SEGPTR_GET(ptr) + sizeof(LPMCI_OPEN_PARMSA);
1606 return MCI_MAP_OKMEM;
1607 /* case MCI_PASTE:*/
1609 size = sizeof(MCI_GENERIC_PARMS);
1612 size = sizeof(MCI_PLAY_PARMS);
1616 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break;
1617 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break;
1618 default: size = sizeof(MCI_GENERIC_PARMS); break;
1622 size = sizeof(MCI_GENERIC_PARMS);
1626 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16); map = 0x0F1111FB; break;
1627 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_RECORD_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM;
1628 default: size = sizeof(MCI_RECORD_PARMS); break;
1632 size = sizeof(MCI_GENERIC_PARMS);
1636 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SEEK_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM;
1637 default: size = sizeof(MCI_SEEK_PARMS); break;
1642 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS); break;
1643 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SET_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM;
1644 case MCI_DEVTYPE_SEQUENCER: size = sizeof(MCI_SEQ_SET_PARMS); break;
1645 /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned,
1646 * so not doing anything should work...
1648 case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS); break;
1649 default: size = sizeof(MCI_SET_PARMS); break;
1652 /* case MCI_SETTIMECODE:*/
1653 /* case MCI_SIGNAL:*/
1655 size = sizeof(MCI_SET_PARMS);
1661 * don't know if buffer for value is the one passed thru lpstrDevice
1662 * or is provided by MCI driver.
1663 * Assuming solution 2: provided by MCI driver, so zeroing on entry
1665 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16); map = 0x0B6FF; break;
1666 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM;
1667 default: size = sizeof(MCI_STATUS_PARMS); break;
1672 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS); break;
1673 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STEP_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM;
1674 case MCI_DEVTYPE_VIDEODISC: size = sizeof(MCI_VD_STEP_PARMS); break;
1675 default: size = sizeof(MCI_GENERIC_PARMS); break;
1679 size = sizeof(MCI_SET_PARMS);
1683 LPMCI_SYSINFO_PARMSA msip32a = (LPMCI_SYSINFO_PARMSA)(*lParam);
1684 char* ptr = SEGPTR_ALLOC(sizeof(LPMCI_SYSINFO_PARMSA) + sizeof(MCI_SYSINFO_PARMS16));
1685 LPMCI_SYSINFO_PARMS16 msip16;
1688 *(LPMCI_SYSINFO_PARMSA*)(ptr) = msip32a;
1689 msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSA));
1691 msip16->dwCallback = msip32a->dwCallback;
1692 msip16->lpstrReturn = (LPSTR)SEGPTR_GET(SEGPTR_ALLOC(msip32a->dwRetSize));
1693 msip16->dwRetSize = msip32a->dwRetSize;
1694 msip16->dwNumber = msip32a->dwNumber;
1695 msip16->wDeviceType = msip32a->wDeviceType;
1697 return MCI_MAP_NOMEM;
1699 *lParam = (LPARAM)SEGPTR_GET(ptr) + sizeof(LPMCI_SYSINFO_PARMSA);
1701 return MCI_MAP_OKMEM;
1702 /* case MCI_UNDO: */
1705 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break;
1706 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; break;
1707 default: size = sizeof(MCI_GENERIC_PARMS); break;
1712 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16); map = 0x000B1111B; break;
1713 default: size = sizeof(MCI_GENERIC_PARMS); break;
1718 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break;
1719 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break;
1720 default: size = sizeof(MCI_GENERIC_PARMS); break;
1725 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7FB; break;
1726 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB; break;
1727 default: size = sizeof(MCI_GENERIC_PARMS); break;
1737 case DRV_QUERYCONFIGURE:
1740 case DRV_EXITSESSION:
1741 case DRV_EXITAPPLICATION:
1743 return MCI_MAP_PASS;
1746 WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
1747 return MCI_MAP_MSGERROR;
1749 return MCI_MsgMapper32To16_Create((void**)lParam, size, map, keep);
1752 /**************************************************************************
1753 * MCI_UnMapMsg32ATo16 [internal]
1755 static MCI_MapType MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam)
1758 BOOLEAN kept = FALSE; /* there is no need to compute size when kept is FALSE */
1764 /* case MCI_CAPTURE */
1766 case MCI_CLOSE_DRIVER:
1768 /* case MCI_CONFIGURE:*/
1769 /* case MCI_COPY: */
1775 /* case MCI_ESCAPE: */
1778 case MCI_GETDEVCAPS:
1780 size = sizeof(MCI_GETDEVCAPS_PARMS);
1782 /* case MCI_INDEX: */
1785 LPMCI_INFO_PARMS16 mip16 = (LPMCI_INFO_PARMS16)PTR_SEG_TO_LIN(lParam);
1786 LPMCI_INFO_PARMSA mip32a = *(LPMCI_INFO_PARMSA*)((char*)mip16 - sizeof(LPMCI_INFO_PARMSA));
1788 memcpy(mip32a->lpstrReturn, PTR_SEG_TO_LIN(mip16->lpstrReturn), mip32a->dwRetSize);
1790 if (!SEGPTR_FREE(PTR_SEG_TO_LIN(mip16->lpstrReturn)))
1791 FIXME("bad free line=%d\n", __LINE__);
1792 if (!SEGPTR_FREE((char*)mip16 - sizeof(LPMCI_INFO_PARMSA)))
1793 FIXME("bad free line=%d\n", __LINE__);
1796 /* case MCI_MARK: */
1797 /* case MCI_MONITOR: */
1799 case MCI_OPEN_DRIVER:
1801 LPMCI_OPEN_PARMS16 mop16 = (LPMCI_OPEN_PARMS16)PTR_SEG_TO_LIN(lParam);
1802 LPMCI_OPEN_PARMSA mop32a = *(LPMCI_OPEN_PARMSA*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSA));
1804 mop32a->wDeviceID = mop16->wDeviceID;
1805 if ((dwFlags & MCI_OPEN_TYPE) && !
1806 (dwFlags & MCI_OPEN_TYPE_ID) &&
1807 !SEGPTR_FREE(PTR_SEG_TO_LIN(mop16->lpstrDeviceType)))
1808 FIXME("bad free line=%d\n", __LINE__);
1809 if ((dwFlags & MCI_OPEN_ELEMENT) &&
1810 !(dwFlags & MCI_OPEN_ELEMENT_ID) &&
1811 !SEGPTR_FREE(PTR_SEG_TO_LIN(mop16->lpstrElementName)))
1812 FIXME("bad free line=%d\n", __LINE__);
1813 if ((dwFlags & MCI_OPEN_ALIAS) &&
1814 !SEGPTR_FREE(PTR_SEG_TO_LIN(mop16->lpstrAlias)))
1815 FIXME("bad free line=%d\n", __LINE__);
1817 if (!SEGPTR_FREE((char*)mop16 - sizeof(LPMCI_OPEN_PARMSA)))
1818 FIXME("bad free line=%d\n", __LINE__);
1821 /* case MCI_PASTE:*/
1838 /* case MCI_SETTIMECODE:*/
1839 /* case MCI_SIGNAL:*/
1845 case MCI_DEVTYPE_DIGITAL_VIDEO:
1847 LPMCI_DGV_STATUS_PARMS16 mdsp16 = (LPMCI_DGV_STATUS_PARMS16)PTR_SEG_TO_LIN(lParam);
1848 LPMCI_DGV_STATUS_PARMSA mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA));
1851 mdsp32a->dwReturn = mdsp16->dwReturn;
1852 if (dwFlags & MCI_DGV_STATUS_DISKSPACE) {
1853 TRACE("MCI_STATUS (DGV) lpstrDrive=%p\n", mdsp16->lpstrDrive);
1854 TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)PTR_SEG_TO_LIN(mdsp16->lpstrDrive));
1856 /* FIXME: see map function */
1857 strcpy(mdsp32a->lpstrDrive, (LPSTR)PTR_SEG_TO_LIN(mdsp16->lpstrDrive));
1860 if (!SEGPTR_FREE((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA)))
1861 FIXME("bad free line=%d\n", __LINE__);
1863 return MCI_MAP_NOMEM;
1866 return MCI_MAP_OKMEM;
1867 case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM;
1868 default: size = sizeof(MCI_STATUS_PARMS); break;
1877 LPMCI_SYSINFO_PARMS16 msip16 = (LPMCI_SYSINFO_PARMS16)PTR_SEG_TO_LIN(lParam);
1878 LPMCI_SYSINFO_PARMSA msip32a = *(LPMCI_SYSINFO_PARMSA*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA));
1881 msip16->dwCallback = msip32a->dwCallback;
1882 memcpy(msip32a->lpstrReturn, PTR_SEG_TO_LIN(msip16->lpstrReturn), msip32a->dwRetSize);
1883 if (!SEGPTR_FREE(PTR_SEG_TO_LIN(msip16->lpstrReturn)))
1884 FIXME("bad free line=%d\n", __LINE__);
1886 if (!SEGPTR_FREE((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA)))
1887 FIXME("bad free line=%d\n", __LINE__);
1889 return MCI_MAP_NOMEM;
1892 return MCI_MAP_OKMEM;
1893 /* case MCI_UNDO: */
1900 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break;
1901 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break;
1907 case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7666; break;
1908 case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666; break;
1911 /* FIXME: see map function */
1921 case DRV_QUERYCONFIGURE:
1924 case DRV_EXITSESSION:
1925 case DRV_EXITAPPLICATION:
1927 FIXME("This is a hack\n");
1928 return MCI_MAP_PASS;
1930 FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
1931 return MCI_MAP_MSGERROR;
1933 return MCI_MsgMapper32To16_Destroy((void*)lParam, size, map, kept);
1936 /**************************************************************************
1937 * MCI_SendCommandFrom32 [internal]
1939 DWORD MCI_SendCommandFrom32(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
1941 DWORD dwRet = MCIERR_DEVICE_NOT_INSTALLED;
1942 LPWINE_MCIDRIVER wmd = MCI_GetDriver(wDevID);
1945 dwRet = MCIERR_INVALID_DEVICE_ID;
1947 switch (GetDriverFlags(wmd->hDrv) & (WINE_GDF_EXIST|WINE_GDF_16BIT)) {
1948 case WINE_GDF_EXIST|WINE_GDF_16BIT:
1952 switch (res = MCI_MapMsg32ATo16(wmd->wType, wMsg, dwParam1, &dwParam2)) {
1953 case MCI_MAP_MSGERROR:
1954 TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg));
1955 dwRet = MCIERR_DRIVER_INTERNAL;
1958 TRACE("Problem mapping msg=%s from 32a to 16\n", MCI_MessageToString(wMsg));
1959 dwRet = MCIERR_OUT_OF_MEMORY;
1963 dwRet = SendDriverMessage16(wmd->hDrv, wMsg, dwParam1, dwParam2);
1964 if (res == MCI_MAP_OKMEM)
1965 MCI_UnMapMsg32ATo16(wmd->wType, wMsg, dwParam1, dwParam2);
1968 dwRet = SendDriverMessage(wmd->hDrv, wMsg, dwParam1, dwParam2);
1973 case WINE_GDF_EXIST:
1974 dwRet = SendDriverMessage(wmd->hDrv, wMsg, dwParam1, dwParam2);
1977 WARN("Unknown driver %u\n", wmd->hDrv);
1978 dwRet = MCIERR_DRIVER_INTERNAL;
1984 /**************************************************************************
1985 * MCI_SendCommandFrom16 [internal]
1987 DWORD MCI_SendCommandFrom16(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
1989 DWORD dwRet = MCIERR_DEVICE_NOT_INSTALLED;
1990 LPWINE_MCIDRIVER wmd = MCI_GetDriver(wDevID);
1993 dwRet = MCIERR_INVALID_DEVICE_ID;
1997 switch (GetDriverFlags(wmd->hDrv) & (WINE_GDF_EXIST|WINE_GDF_16BIT)) {
1998 case WINE_GDF_EXIST|WINE_GDF_16BIT:
1999 dwRet = SendDriverMessage16(wmd->hDrv, wMsg, dwParam1, dwParam2);
2001 case WINE_GDF_EXIST:
2002 switch (res = MCI_MapMsg16To32A(wmd->wType, wMsg, &dwParam2)) {
2003 case MCI_MAP_MSGERROR:
2004 TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg));
2005 dwRet = MCIERR_DRIVER_INTERNAL;
2008 TRACE("Problem mapping msg=%s from 16 to 32a\n", MCI_MessageToString(wMsg));
2009 dwRet = MCIERR_OUT_OF_MEMORY;
2013 dwRet = SendDriverMessage(wmd->hDrv, wMsg, dwParam1, dwParam2);
2014 if (res == MCI_MAP_OKMEM)
2015 MCI_UnMapMsg16To32A(wmd->wType, wMsg, dwParam2);
2018 dwRet = SendDriverMessage16(wmd->hDrv, wMsg, dwParam1, dwParam2);
2023 WARN("Unknown driver %u\n", wmd->hDrv);
2024 dwRet = MCIERR_DRIVER_INTERNAL;
2030 /**************************************************************************
2031 * MCI_Open [internal]
2033 static DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms)
2035 char strDevTyp[128];
2037 LPWINE_MCIDRIVER wmd = NULL;
2038 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
2040 TRACE("(%08lX, %p)\n", dwParam, lpParms);
2041 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
2043 /* only two low bytes are generic, the other ones are dev type specific */
2044 #define WINE_MCIDRIVER_SUPP (0xFFFF0000|MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT| \
2045 MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID| \
2046 MCI_NOTIFY|MCI_WAIT)
2047 if ((dwParam & ~WINE_MCIDRIVER_SUPP) != 0) {
2048 FIXME("Unsupported yet dwFlags=%08lX\n", dwParam & ~WINE_MCIDRIVER_SUPP);
2050 #undef WINE_MCIDRIVER_SUPP
2054 if (dwParam & MCI_OPEN_TYPE) {
2055 if (dwParam & MCI_OPEN_TYPE_ID) {
2056 WORD uDevType = LOWORD((DWORD)lpParms->lpstrDeviceType);
2058 if (uDevType < MCI_DEVTYPE_FIRST ||
2059 uDevType > MCI_DEVTYPE_LAST ||
2060 !LoadStringA(iData->hWinMM32Instance, uDevType, strDevTyp, sizeof(strDevTyp))) {
2061 dwRet = MCIERR_BAD_INTEGER;
2066 if (lpParms->lpstrDeviceType == NULL) {
2067 dwRet = MCIERR_NULL_PARAMETER_BLOCK;
2070 strcpy(strDevTyp, lpParms->lpstrDeviceType);
2071 ptr = strchr(strDevTyp, '!');
2073 /* this behavior is not documented in windows. However, since, in
2074 * some occasions, MCI_OPEN handling is translated by WinMM into
2075 * a call to mciSendString("open <type>"); this code shall be correct
2077 if (dwParam & MCI_OPEN_ELEMENT) {
2078 ERR("Both MCI_OPEN_ELEMENT(%s) and %s are used\n",
2079 lpParms->lpstrElementName, strDevTyp);
2080 dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
2083 dwParam |= MCI_OPEN_ELEMENT;
2085 /* FIXME: not a good idea to write in user supplied buffer */
2086 lpParms->lpstrElementName = ptr;
2090 TRACE("devType='%s' !\n", strDevTyp);
2093 if (dwParam & MCI_OPEN_ELEMENT) {
2094 TRACE("lpstrElementName='%s'\n", lpParms->lpstrElementName);
2096 if (dwParam & MCI_OPEN_ELEMENT_ID) {
2097 FIXME("Unsupported yet flag MCI_OPEN_ELEMENT_ID\n");
2098 dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
2102 if (!lpParms->lpstrElementName) {
2103 dwRet = MCIERR_NULL_PARAMETER_BLOCK;
2107 /* type, if given as a parameter, supersedes file extension */
2108 if (!strDevTyp[0] &&
2109 MCI_GetDevTypeFromFileName(lpParms->lpstrElementName,
2110 strDevTyp, sizeof(strDevTyp))) {
2111 if (GetDriveTypeA(lpParms->lpstrElementName) != DRIVE_CDROM) {
2112 dwRet = MCIERR_EXTENSION_NOT_FOUND;
2115 /* FIXME: this will not work if several CDROM drives are installed on the machine */
2116 strcpy(strDevTyp, "CDAUDIO");
2120 if (strDevTyp[0] == 0) {
2121 FIXME("Couldn't load driver\n");
2122 dwRet = MCIERR_INVALID_DEVICE_NAME;
2126 if (dwParam & MCI_OPEN_ALIAS) {
2127 TRACE("Alias='%s' !\n", lpParms->lpstrAlias);
2128 if (!lpParms->lpstrAlias) {
2129 dwRet = MCIERR_NULL_PARAMETER_BLOCK;
2134 if ((dwRet = MCI_LoadMciDriver(iData, strDevTyp, &wmd))) {
2138 if ((dwRet = MCI_FinishOpen(wmd, lpParms, dwParam))) {
2139 TRACE("Failed to open driver (MCI_OPEN_DRIVER) [%08lx], closing\n", dwRet);
2140 /* FIXME: is dwRet the correct ret code ? */
2144 /* only handled devices fall through */
2145 TRACE("wDevID=%04X wDeviceID=%d dwRet=%ld\n", wmd->wDeviceID, lpParms->wDeviceID, dwRet);
2147 if (dwParam & MCI_NOTIFY)
2148 mciDriverNotify16(lpParms->dwCallback, wmd->wDeviceID, MCI_NOTIFY_SUCCESSFUL);
2152 if (wmd) MCI_UnLoadMciDriver(iData, wmd);
2154 if (dwParam & MCI_NOTIFY)
2155 mciDriverNotify16(lpParms->dwCallback, 0, MCI_NOTIFY_FAILURE);
2159 /**************************************************************************
2160 * MCI_Close [internal]
2162 static DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
2165 LPWINE_MCIDRIVER wmd;
2166 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
2168 TRACE("(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms);
2170 if (wDevID == MCI_ALL_DEVICE_ID) {
2171 LPWINE_MCIDRIVER next;
2173 EnterCriticalSection(&iData->cs);
2174 /* FIXME: shall I notify once after all is done, or for
2175 * each of the open drivers ? if the latest, which notif
2176 * to return when only one fails ?
2178 for (wmd = iData->lpMciDrvs; wmd; ) {
2180 MCI_Close(wmd->wDeviceID, dwParam, lpParms);
2183 LeaveCriticalSection(&iData->cs);
2187 if (!(wmd = MCI_GetDriver(wDevID))) {
2188 return MCIERR_INVALID_DEVICE_ID;
2191 dwRet = MCI_SendCommandFrom32(wDevID, MCI_CLOSE_DRIVER, dwParam, (DWORD)lpParms);
2193 MCI_UnLoadMciDriver(iData, wmd);
2195 if (dwParam & MCI_NOTIFY)
2196 mciDriverNotify16(lpParms->dwCallback, wDevID,
2197 (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
2202 /**************************************************************************
2203 * MCI_WriteString [internal]
2205 DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr)
2210 if (dstSize <= strlen(lpSrcStr)) {
2211 lstrcpynA(lpDstStr, lpSrcStr, dstSize - 1);
2212 ret = MCIERR_PARAM_OVERFLOW;
2214 strcpy(lpDstStr, lpSrcStr);
2222 /**************************************************************************
2223 * MCI_Sysinfo [internal]
2225 static DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParms)
2227 DWORD ret = MCIERR_INVALID_DEVICE_ID;
2228 LPWINE_MCIDRIVER wmd;
2229 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
2231 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
2233 TRACE("(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n",
2234 uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType);
2236 switch (dwFlags & ~MCI_SYSINFO_OPEN) {
2237 case MCI_SYSINFO_QUANTITY:
2241 if (lpParms->wDeviceType < MCI_DEVTYPE_FIRST ||
2242 lpParms->wDeviceType > MCI_DEVTYPE_LAST) {
2243 if (dwFlags & MCI_SYSINFO_OPEN) {
2244 TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
2245 EnterCriticalSection(&iData->cs);
2246 for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
2249 LeaveCriticalSection(&iData->cs);
2251 TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
2252 cnt = MCI_InstalledCount;
2255 if (dwFlags & MCI_SYSINFO_OPEN) {
2256 TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n",
2257 lpParms->wDeviceType);
2258 EnterCriticalSection(&iData->cs);
2259 for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
2260 if (wmd->wType == lpParms->wDeviceType)
2263 LeaveCriticalSection(&iData->cs);
2265 TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n",
2266 lpParms->wDeviceType);
2267 FIXME("Don't know how to get # of MCI devices of a given type\n");
2271 *(DWORD*)lpParms->lpstrReturn = cnt;
2273 TRACE("(%ld) => '%ld'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn);
2274 ret = MCI_INTEGER_RETURNED;
2276 case MCI_SYSINFO_INSTALLNAME:
2277 TRACE("MCI_SYSINFO_INSTALLNAME \n");
2278 if ((wmd = MCI_GetDriver(uDevID))) {
2279 ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize,
2280 wmd->lpstrDeviceType);
2282 *lpParms->lpstrReturn = 0;
2283 ret = MCIERR_INVALID_DEVICE_ID;
2285 TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
2287 case MCI_SYSINFO_NAME:
2288 TRACE("MCI_SYSINFO_NAME\n");
2289 if (dwFlags & MCI_SYSINFO_OPEN) {
2290 FIXME("Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n");
2291 ret = MCIERR_UNRECOGNIZED_COMMAND;
2292 } else if (lpParms->dwNumber > MCI_InstalledCount) {
2293 ret = MCIERR_OUTOFRANGE;
2295 DWORD count = lpParms->dwNumber;
2296 LPSTR ptr = MCI_lpInstallNames;
2298 while (--count > 0) ptr += strlen(ptr) + 1;
2299 ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, ptr);
2301 TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
2304 TRACE("Unsupported flag value=%08lx\n", dwFlags);
2305 ret = MCIERR_UNRECOGNIZED_COMMAND;
2310 /**************************************************************************
2311 * MCI_Break [internal]
2313 static DWORD MCI_Break(UINT wDevID, DWORD dwFlags, LPMCI_BREAK_PARMS lpParms)
2317 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
2319 if (dwFlags & MCI_NOTIFY)
2320 mciDriverNotify16(lpParms->dwCallback, wDevID,
2321 (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
2326 /**************************************************************************
2327 * MCI_SendCommand [internal]
2329 DWORD MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1,
2330 DWORD dwParam2, BOOL bFrom32)
2332 DWORD dwRet = MCIERR_UNRECOGNIZED_COMMAND;
2337 dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
2339 switch (MCI_MapMsg16To32A(0, wMsg, &dwParam2)) {
2342 dwRet = MCI_Open(dwParam1, (LPMCI_OPEN_PARMSA)dwParam2);
2343 MCI_UnMapMsg16To32A(0, wMsg, dwParam2);
2345 default: break; /* so that gcc does not bark */
2351 dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
2353 switch (MCI_MapMsg16To32A(0, wMsg, &dwParam2)) {
2356 dwRet = MCI_Close(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
2357 MCI_UnMapMsg16To32A(0, wMsg, dwParam2);
2359 default: break; /* so that gcc does not bark */
2365 dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2);
2367 switch (MCI_MapMsg16To32A(0, wMsg, &dwParam2)) {
2370 dwRet = MCI_SysInfo(wDevID, dwParam1, (LPMCI_SYSINFO_PARMSA)dwParam2);
2371 MCI_UnMapMsg16To32A(0, wMsg, dwParam2);
2373 default: break; /* so that gcc doesnot bark */
2379 dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2);
2381 switch (MCI_MapMsg16To32A(0, wMsg, &dwParam2)) {
2384 dwRet = MCI_Break(wDevID, dwParam1, (LPMCI_BREAK_PARMS)dwParam2);
2385 MCI_UnMapMsg16To32A(0, wMsg, dwParam2);
2387 default: break; /* so that gcc does not bark */
2392 /* FIXME: it seems that MCI_SOUND needs the same handling as MCI_BREAK
2393 * but I couldn't get any doc on this MCI message
2397 if (wDevID == MCI_ALL_DEVICE_ID) {
2398 FIXME("unhandled MCI_ALL_DEVICE_ID\n");
2399 dwRet = MCIERR_CANNOT_USE_ALL;
2402 MCI_SendCommandFrom32(wDevID, wMsg, dwParam1, dwParam2) :
2403 MCI_SendCommandFrom16(wDevID, wMsg, dwParam1, dwParam2);
2410 /**************************************************************************
2411 * MCI_CleanUp [internal]
2413 * Some MCI commands need to be cleaned-up (when not called from
2414 * mciSendString), because MCI drivers return extra information for string
2415 * transformation. This function gets rid of them.
2417 LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2, BOOL bIs32)
2420 return LOWORD(dwRet);
2423 case MCI_GETDEVCAPS:
2424 switch (dwRet & 0xFFFF0000ul) {
2426 case MCI_COLONIZED3_RETURN:
2427 case MCI_COLONIZED4_RETURN:
2428 case MCI_INTEGER_RETURNED:
2431 case MCI_RESOURCE_RETURNED:
2432 case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER:
2434 LPMCI_GETDEVCAPS_PARMS lmgp;
2436 lmgp = (LPMCI_GETDEVCAPS_PARMS)(bIs32 ? (void*)dwParam2 : PTR_SEG_TO_LIN(dwParam2));
2437 TRACE("Changing %08lx to %08lx\n", lmgp->dwReturn, (DWORD)LOWORD(lmgp->dwReturn));
2438 lmgp->dwReturn = LOWORD(lmgp->dwReturn);
2442 FIXME("Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2443 HIWORD(dwRet), MCI_MessageToString(wMsg));
2447 switch (dwRet & 0xFFFF0000ul) {
2449 case MCI_COLONIZED3_RETURN:
2450 case MCI_COLONIZED4_RETURN:
2451 case MCI_INTEGER_RETURNED:
2454 case MCI_RESOURCE_RETURNED:
2455 case MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER:
2457 LPMCI_STATUS_PARMS lsp;
2459 lsp = (LPMCI_STATUS_PARMS)(bIs32 ? (void*)dwParam2 : PTR_SEG_TO_LIN(dwParam2));
2460 TRACE("Changing %08lx to %08lx\n", lsp->dwReturn, (DWORD)LOWORD(lsp->dwReturn));
2461 lsp->dwReturn = LOWORD(lsp->dwReturn);
2465 FIXME("Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2466 HIWORD(dwRet), MCI_MessageToString(wMsg));
2470 switch (dwRet & 0xFFFF0000ul) {
2472 case MCI_INTEGER_RETURNED:
2476 FIXME("Unsupported value for hiword (%04x)\n", HIWORD(dwRet));
2480 if (HIWORD(dwRet)) {
2481 FIXME("Got non null hiword for dwRet=0x%08lx for command %s\n",
2482 dwRet, MCI_MessageToString(wMsg));
2486 return LOWORD(dwRet);
2489 /**************************************************************************
2490 * MULTIMEDIA_MciInit [internal]
2492 * Initializes the MCI internal variables.
2495 BOOL MULTIMEDIA_MciInit(void)
2504 MCI_InstalledCount = 0;
2505 ptr1 = MCI_lpInstallNames = HeapAlloc(GetProcessHeap(), 0, count);
2507 if (!MCI_lpInstallNames)
2510 /* FIXME: should do also some registry diving here ? */
2511 if (!(err = RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config", &hWineConf)) &&
2512 !(err = RegOpenKeyA(hWineConf, "options", &hkey))) {
2513 err = RegQueryValueExA(hkey, "mci", 0, &type, MCI_lpInstallNames, &count);
2518 TRACE("Wine => '%s' \n", ptr1);
2519 while ((ptr2 = strchr(ptr1, ':')) != 0) {
2521 TRACE("---> '%s' \n", ptr1);
2522 MCI_InstalledCount++;
2525 MCI_InstalledCount++;
2526 TRACE("---> '%s' \n", ptr1);
2527 ptr1 += strlen(ptr1) + 1;
2529 GetPrivateProfileStringA("mci", NULL, "", MCI_lpInstallNames, count, "SYSTEM.INI");
2530 while (strlen(ptr1) > 0) {
2531 TRACE("---> '%s' \n", ptr1);
2532 ptr1 += strlen(ptr1) + 1;
2533 MCI_InstalledCount++;
2536 RegCloseKey(hWineConf);