1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
4 * MCI internal functions
6 * Copyright 1998/1999 Eric Pouech
18 #include "selectors.h"
20 #include "wine/winbase16.h"
21 #include "debugtools.h"
24 DEFAULT_DEBUG_CHANNEL(mci
);
26 static int MCI_InstalledCount
;
27 static LPSTR MCI_lpInstallNames
= NULL
;
29 /* First MCI valid device ID (0 means error) */
30 #define MCI_MAGIC 0x0001
32 /**************************************************************************
33 * MCI_GetDriver [internal]
35 LPWINE_MCIDRIVER
MCI_GetDriver(UINT16 wDevID
)
37 LPWINE_MCIDRIVER wmd
= 0;
38 LPWINE_MM_IDATA iData
= MULTIMEDIA_GetIData();
40 EnterCriticalSection(&iData
->cs
);
41 for (wmd
= iData
->lpMciDrvs
; wmd
; wmd
= wmd
->lpNext
) {
42 if (wmd
->wDeviceID
== wDevID
)
45 LeaveCriticalSection(&iData
->cs
);
49 /**************************************************************************
50 * MCI_GetDriverFromString [internal]
52 UINT
MCI_GetDriverFromString(LPCSTR lpstrName
)
55 LPWINE_MM_IDATA iData
= MULTIMEDIA_GetIData();
61 if (!lstrcmpiA(lpstrName
, "ALL"))
62 return MCI_ALL_DEVICE_ID
;
64 EnterCriticalSection(&iData
->cs
);
65 for (wmd
= iData
->lpMciDrvs
; wmd
; wmd
= wmd
->lpNext
) {
66 if (wmd
->lpstrElementName
&& strcmp(wmd
->lpstrElementName
, lpstrName
) == 0) {
71 if (wmd
->lpstrDeviceType
&& strcmp(wmd
->lpstrDeviceType
, lpstrName
) == 0) {
76 if (wmd
->lpstrAlias
&& strcmp(wmd
->lpstrAlias
, lpstrName
) == 0) {
81 LeaveCriticalSection(&iData
->cs
);
86 /**************************************************************************
87 * MCI_MessageToString [internal]
89 const char* MCI_MessageToString(UINT16 wMsg
)
91 static char buffer
[100];
93 #define CASE(s) case (s): return #s
98 CASE(MCI_CLOSE_DRIVER
);
107 CASE(MCI_GETDEVCAPS
);
111 CASE(MCI_OPEN_DRIVER
);
129 /* constants for digital video */
143 sprintf(buffer
, "MCI_<<%04X>>", wMsg
);
148 /**************************************************************************
149 * MCI_GetDevTypeFromFileName [internal]
151 static DWORD
MCI_GetDevTypeFromFileName(LPCSTR fileName
, LPSTR buf
, UINT len
)
155 if ((tmp
= strrchr(fileName
, '.'))) {
156 GetProfileStringA("mci extensions", tmp
+ 1, "*", buf
, len
);
157 if (strcmp(buf
, "*") != 0) {
160 TRACE("No [mci extensions] entry for '%s' found.\n", tmp
);
162 return MCIERR_EXTENSION_NOT_FOUND
;
165 #define MAX_MCICMDTABLE 20
166 #define MCI_COMMAND_TABLE_NOT_LOADED 0xFFFE
168 typedef struct tagWINE_MCICMDTABLE
{
172 UINT nVerbs
; /* number of verbs in command table */
173 LPCSTR
* aVerbs
; /* array of verbs to speed up the verb look up process */
174 } WINE_MCICMDTABLE
, *LPWINE_MCICMDTABLE
;
175 WINE_MCICMDTABLE S_MciCmdTable
[MAX_MCICMDTABLE
];
177 /**************************************************************************
178 * MCI_IsCommandTableValid [internal]
180 static BOOL
MCI_IsCommandTableValid(UINT uTbl
)
188 TRACE("Dumping cmdTbl=%d [hMem=%08x devType=%d]\n",
189 uTbl
, S_MciCmdTable
[uTbl
].hMem
, S_MciCmdTable
[uTbl
].uDevType
);
191 if (uTbl
>= MAX_MCICMDTABLE
|| !S_MciCmdTable
[uTbl
].hMem
|| !S_MciCmdTable
[uTbl
].lpTable
)
194 lmem
= S_MciCmdTable
[uTbl
].lpTable
;
198 lmem
+= strlen(lmem
) + 1;
199 flg
= *(LPDWORD
)lmem
;
200 eid
= *(LPWORD
)(lmem
+ sizeof(DWORD
));
201 lmem
+= sizeof(DWORD
) + sizeof(WORD
);
203 /* EPP TRACE("cmd='%s' %08lx %04x\n", str, flg, eid); */
205 case MCI_COMMAND_HEAD
: if (!*str
|| !flg
) return FALSE
; idx
= 0; break; /* check unicity of str in table */
206 case MCI_STRING
: if (inCst
) return FALSE
; break;
207 case MCI_INTEGER
: if (!*str
) return FALSE
; break;
208 case MCI_END_COMMAND
: if (*str
|| flg
|| idx
== 0) return FALSE
; idx
= 0; break;
209 case MCI_RETURN
: if (*str
|| idx
!= 1) return FALSE
; break;
210 case MCI_FLAG
: if (!*str
) return FALSE
; break;
211 case MCI_END_COMMAND_LIST
: if (*str
|| flg
) return FALSE
; idx
= 0; break;
212 case MCI_RECT
: if (!*str
|| inCst
) return FALSE
; break;
213 case MCI_CONSTANT
: if (inCst
) return FALSE
; inCst
= TRUE
; break;
214 case MCI_END_CONSTANT
: if (*str
|| flg
|| !inCst
) return FALSE
; inCst
= FALSE
; break;
215 default: return FALSE
;
217 } while (eid
!= MCI_END_COMMAND_LIST
);
218 } while (eid
!= MCI_END_COMMAND_LIST
);
222 /**************************************************************************
223 * MCI_DumpCommandTable [internal]
225 static BOOL
MCI_DumpCommandTable(UINT uTbl
)
232 if (!MCI_IsCommandTableValid(uTbl
)) {
233 ERR("Ooops: %d is not valid\n", uTbl
);
237 lmem
= S_MciCmdTable
[uTbl
].lpTable
;
241 lmem
+= strlen(lmem
) + 1;
242 flg
= *(LPDWORD
)lmem
;
243 eid
= *(LPWORD
)(lmem
+ sizeof(DWORD
));
244 TRACE("cmd='%s' %08lx %04x\n", str
, flg
, eid
);
245 lmem
+= sizeof(DWORD
) + sizeof(WORD
);
246 } while (eid
!= MCI_END_COMMAND
&& eid
!= MCI_END_COMMAND_LIST
);
247 TRACE(" => end of command%s\n", (eid
== MCI_END_COMMAND_LIST
) ? " list" : "");
248 } while (eid
!= MCI_END_COMMAND_LIST
);
252 static UINT
MCI_SetCommandTable(LPWINE_MM_IDATA iData
, HANDLE hMem
, UINT uDevType
);
254 /**************************************************************************
255 * MCI_GetCommandTable [internal]
257 static UINT
MCI_GetCommandTable(LPWINE_MM_IDATA iData
, UINT uDevType
)
263 /* first look up existing for existing devType */
264 for (uTbl
= 0; uTbl
< MAX_MCICMDTABLE
; uTbl
++) {
265 if (S_MciCmdTable
[uTbl
].hMem
&& S_MciCmdTable
[uTbl
].uDevType
== uDevType
)
269 /* well try to load id */
270 if (uDevType
>= MCI_DEVTYPE_FIRST
&& uDevType
<= MCI_DEVTYPE_LAST
) {
271 if (LoadStringA(iData
->hWinMM32Instance
, uDevType
, buf
, sizeof(buf
))) {
274 } else if (uDevType
== 0) {
277 uTbl
= MCI_NO_COMMAND_TABLE
;
279 HRSRC hRsrc
= FindResourceA(iData
->hWinMM32Instance
, str
, (LPCSTR
)RT_RCDATAA
);
282 if (hRsrc
) hMem
= LoadResource(iData
->hWinMM32Instance
, hRsrc
);
284 uTbl
= MCI_SetCommandTable(iData
, hMem
, uDevType
);
286 WARN("No command table found in resource %04x[%s]\n",
287 iData
->hWinMM32Instance
, str
);
290 TRACE("=> %d\n", uTbl
);
294 /**************************************************************************
295 * MCI_SetCommandTable [internal]
297 static UINT
MCI_SetCommandTable(LPWINE_MM_IDATA iData
, HANDLE hMem
,
301 static BOOL bInitDone
= FALSE
;
304 * The CORE command table must be loaded first, so that MCI_GetCommandTable()
305 * can be called with 0 as a uDevType to retrieve it.
310 for (uTbl
= 0; uTbl
< MAX_MCICMDTABLE
; uTbl
++) {
311 S_MciCmdTable
[uTbl
].hMem
= 0;
313 MCI_GetCommandTable(iData
, 0);
316 for (uTbl
= 0; uTbl
< MAX_MCICMDTABLE
; uTbl
++) {
317 if (S_MciCmdTable
[uTbl
].hMem
== 0) {
322 S_MciCmdTable
[uTbl
].hMem
= hMem
;
323 S_MciCmdTable
[uTbl
].uDevType
= uDevType
;
324 S_MciCmdTable
[uTbl
].lpTable
= LockResource(hMem
);
327 MCI_DumpCommandTable(uTbl
);
330 /* create the verbs table */
331 /* get # of entries */
332 lmem
= S_MciCmdTable
[uTbl
].lpTable
;
335 lmem
+= strlen(lmem
) + 1;
336 eid
= *(LPWORD
)(lmem
+ sizeof(DWORD
));
337 lmem
+= sizeof(DWORD
) + sizeof(WORD
);
338 if (eid
== MCI_COMMAND_HEAD
)
340 } while (eid
!= MCI_END_COMMAND_LIST
);
342 S_MciCmdTable
[uTbl
].aVerbs
= HeapAlloc(GetProcessHeap(), 0, count
* sizeof(LPCSTR
));
343 S_MciCmdTable
[uTbl
].nVerbs
= count
;
345 lmem
= S_MciCmdTable
[uTbl
].lpTable
;
349 lmem
+= strlen(lmem
) + 1;
350 eid
= *(LPWORD
)(lmem
+ sizeof(DWORD
));
351 lmem
+= sizeof(DWORD
) + sizeof(WORD
);
352 if (eid
== MCI_COMMAND_HEAD
)
353 S_MciCmdTable
[uTbl
].aVerbs
[count
++] = str
;
354 } while (eid
!= MCI_END_COMMAND_LIST
);
355 /* assert(count == S_MciCmdTable[uTbl].nVerbs); */
360 return MCI_NO_COMMAND_TABLE
;
363 /**************************************************************************
364 * MCI_DeleteCommandTable [internal]
366 static BOOL
MCI_DeleteCommandTable(UINT uTbl
)
368 if (uTbl
>= MAX_MCICMDTABLE
|| !S_MciCmdTable
[uTbl
].hMem
)
371 FreeResource16(S_MciCmdTable
[uTbl
].hMem
);
372 S_MciCmdTable
[uTbl
].hMem
= 0;
373 if (S_MciCmdTable
[uTbl
].aVerbs
) {
374 HeapFree(GetProcessHeap(), 0, S_MciCmdTable
[uTbl
].aVerbs
);
375 S_MciCmdTable
[uTbl
].aVerbs
= 0;
380 /**************************************************************************
381 * MCI_UnLoadMciDriver [internal]
383 static BOOL
MCI_UnLoadMciDriver(LPWINE_MM_IDATA iData
, LPWINE_MCIDRIVER wmd
)
385 LPWINE_MCIDRIVER
* tmp
;
391 CloseDriver(wmd
->hDrv
, 0, 0);
393 if (wmd
->dwPrivate
!= 0)
394 WARN("Unloading mci driver with non nul dwPrivate field\n");
396 EnterCriticalSection(&iData
->cs
);
397 for (tmp
= &iData
->lpMciDrvs
; *tmp
; tmp
= &(*tmp
)->lpNext
) {
403 LeaveCriticalSection(&iData
->cs
);
405 HeapFree(GetProcessHeap(), 0, wmd
->lpstrDeviceType
);
406 HeapFree(GetProcessHeap(), 0, wmd
->lpstrAlias
);
407 HeapFree(GetProcessHeap(), 0, wmd
->lpstrElementName
);
409 HeapFree(GetProcessHeap(), 0, wmd
);
413 /**************************************************************************
414 * MCI_LoadMciDriver [internal]
416 static DWORD
MCI_LoadMciDriver(LPWINE_MM_IDATA iData
, LPCSTR _strDevTyp
,
417 LPWINE_MCIDRIVER
* lpwmd
)
419 LPSTR strDevTyp
= CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, _strDevTyp
));
420 LPWINE_MCIDRIVER wmd
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*wmd
));
421 MCI_OPEN_DRIVER_PARMSA modp
;
425 if (!wmd
|| !strDevTyp
) {
426 dwRet
= MCIERR_OUT_OF_MEMORY
;
430 wmd
->lpfnYieldProc
= MCI_DefYieldProc
;
431 wmd
->dwYieldData
= VK_CANCEL
;
432 wmd
->hCreatorTask
= GetCurrentTask();
434 EnterCriticalSection(&iData
->cs
);
435 /* wmd must be inserted in list before sending opening the driver, coz' it
436 * may want to lookup at wDevID
438 wmd
->lpNext
= iData
->lpMciDrvs
;
439 iData
->lpMciDrvs
= wmd
;
441 for (modp
.wDeviceID
= MCI_MAGIC
;
442 MCI_GetDriver(modp
.wDeviceID
) != 0;
445 wmd
->wDeviceID
= modp
.wDeviceID
;
447 LeaveCriticalSection(&iData
->cs
);
449 TRACE("wDevID=%04X \n", modp
.wDeviceID
);
451 modp
.lpstrParams
= NULL
;
453 hDrv
= OpenDriverA(strDevTyp
, "mci", (LPARAM
)&modp
);
456 FIXME("Couldn't load driver for type %s.\n"
457 "If you don't have a windows installation accessible from Wine,\n"
458 "you perhaps forgot to create a [mci] section in system.ini\n",
460 dwRet
= MCIERR_DEVICE_NOT_INSTALLED
;
464 /* FIXME: should also check that module's description is of the form
465 * MODULENAME:[MCI] comment
469 /* some drivers will return 0x0000FFFF, some others 0xFFFFFFFF */
470 wmd
->uSpecificCmdTable
= LOWORD(modp
.wCustomCommandTable
);
471 wmd
->uTypeCmdTable
= MCI_COMMAND_TABLE_NOT_LOADED
;
473 TRACE("Loaded driver %x (%s), type is %d, cmdTable=%08x\n",
474 hDrv
, strDevTyp
, modp
.wType
, modp
.wCustomCommandTable
);
476 wmd
->lpstrDeviceType
= strDevTyp
;
477 wmd
->wType
= modp
.wType
;
479 TRACE("mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
480 modp
.wDeviceID
, modp
.wType
, modp
.wDeviceID
);
484 MCI_UnLoadMciDriver(iData
, wmd
);
485 HeapFree(GetProcessHeap(), 0, strDevTyp
);
490 /**************************************************************************
491 * MCI_FinishOpen [internal]
493 static DWORD
MCI_FinishOpen(LPWINE_MCIDRIVER wmd
, LPMCI_OPEN_PARMSA lpParms
,
496 if (dwParam
& MCI_OPEN_ELEMENT
)
497 wmd
->lpstrElementName
= HEAP_strdupA(GetProcessHeap(), 0,
498 lpParms
->lpstrElementName
);
500 if (dwParam
& MCI_OPEN_ALIAS
)
501 wmd
->lpstrAlias
= HEAP_strdupA(GetProcessHeap(), 0, lpParms
->lpstrAlias
);
503 lpParms
->wDeviceID
= wmd
->wDeviceID
;
505 return MCI_SendCommandFrom32(wmd
->wDeviceID
, MCI_OPEN_DRIVER
, dwParam
,
509 /**************************************************************************
510 * MCI_FindCommand [internal]
512 static LPCSTR
MCI_FindCommand(UINT uTbl
, LPCSTR verb
)
516 if (uTbl
>= MAX_MCICMDTABLE
|| S_MciCmdTable
[uTbl
].hMem
== 0)
519 /* another improvement would be to have the aVerbs array sorted,
520 * so that we could use a dichotomic search on it, rather than this dumb
523 for (idx
= 0; idx
< S_MciCmdTable
[uTbl
].nVerbs
; idx
++) {
524 if (strcmp(S_MciCmdTable
[uTbl
].aVerbs
[idx
], verb
) == 0)
525 return S_MciCmdTable
[uTbl
].aVerbs
[idx
];
531 /**************************************************************************
532 * MCI_GetReturnType [internal]
534 static DWORD
MCI_GetReturnType(LPCSTR lpCmd
)
536 lpCmd
+= strlen(lpCmd
) + 1 + sizeof(DWORD
) + sizeof(WORD
);
537 if (*lpCmd
== '\0' && *(LPWORD
)(lpCmd
+ 1 + sizeof(DWORD
)) == MCI_RETURN
) {
538 return *(LPDWORD
)(lpCmd
+ 1);
543 /**************************************************************************
544 * MCI_GetMessage [internal]
546 static WORD
MCI_GetMessage(LPCSTR lpCmd
)
548 return (WORD
)*(LPDWORD
)(lpCmd
+ strlen(lpCmd
) + 1);
551 /**************************************************************************
552 * MCI_GetDWord [internal]
554 static BOOL
MCI_GetDWord(LPDWORD data
, LPSTR
* ptr
)
559 val
= strtoul(*ptr
, &ret
, 0);
563 case ' ': ret
++; break;
564 default: return FALSE
;
572 /**************************************************************************
573 * MCI_GetString [internal]
575 static DWORD
MCI_GetString(LPSTR
* str
, LPSTR
* args
)
579 /* see if we have a quoted string */
581 ptr
= strchr(*str
= ptr
+ 1, '"');
582 if (!ptr
) return MCIERR_NO_CLOSING_QUOTE
;
583 /* FIXME: shall we escape \" from string ?? */
584 if (ptr
[-1] == '\\') TRACE("Ooops: un-escaped \"\n");
585 *ptr
++ = '\0'; /* remove trailing " */
586 if (*ptr
!= ' ' && *ptr
!= '\0') return MCIERR_EXTRA_CHARACTERS
;
589 ptr
= strchr(ptr
, ' ');
594 ptr
= *args
+ strlen(*args
);
603 #define MCI_DATA_SIZE 16
605 /**************************************************************************
606 * MCI_ParseOptArgs [internal]
608 static DWORD
MCI_ParseOptArgs(LPDWORD data
, int _offset
, LPCSTR lpCmd
,
609 LPSTR args
, LPDWORD dwFlags
)
613 DWORD dwRet
, flg
, cflg
= 0;
617 /* loop on arguments */
620 found
= inCst
= FALSE
;
622 TRACE("args='%s' offset=%d\n", args
, offset
);
624 do { /* loop on options for command table for the requested verb */
626 lmem
+= (len
= strlen(lmem
)) + 1;
627 flg
= *(LPDWORD
)lmem
;
628 eid
= *(LPWORD
)(lmem
+ sizeof(DWORD
));
629 lmem
+= sizeof(DWORD
) + sizeof(WORD
);
630 /* EPP TRACE("\tcmd='%s' inCst=%s\n", str, inCst ? "Y" : "N"); */
634 inCst
= TRUE
; cflg
= flg
; break;
635 case MCI_END_CONSTANT
:
636 /* there may be additional integral values after flag in constant */
637 if (inCst
&& MCI_GetDWord(&(data
[offset
]), &args
)) {
640 inCst
= FALSE
; cflg
= 0;
644 if (strncasecmp(args
, str
, len
) == 0 &&
645 (args
[len
] == 0 || args
[len
] == ' ')) {
646 /* store good values into data[] */
648 if (*args
== ' ') args
++;
652 case MCI_COMMAND_HEAD
:
654 case MCI_END_COMMAND
:
655 case MCI_END_COMMAND_LIST
:
656 case MCI_CONSTANT
: /* done above */
657 case MCI_END_CONSTANT
: /* done above */
669 if (!MCI_GetDWord(&(data
[offset
]), &args
)) {
670 return MCIERR_BAD_INTEGER
;
675 /* store rect in data (offset...offset+3) */
677 if (!MCI_GetDWord(&(data
[offset
+0]), &args
) ||
678 !MCI_GetDWord(&(data
[offset
+1]), &args
) ||
679 !MCI_GetDWord(&(data
[offset
+2]), &args
) ||
680 !MCI_GetDWord(&(data
[offset
+3]), &args
)) {
681 ERR("Bad rect '%s'\n", args
);
682 return MCIERR_BAD_INTEGER
;
687 if ((dwRet
= MCI_GetString((LPSTR
*)&data
[offset
], &args
)))
690 default: ERR("oops");
692 /* exit inside while loop */
693 eid
= MCI_END_COMMAND
;
695 /* have offset incremented if needed */
697 case MCI_COMMAND_HEAD
:
699 case MCI_END_COMMAND
:
700 case MCI_END_COMMAND_LIST
:
702 case MCI_FLAG
: break;
703 case MCI_INTEGER
: if (!inCst
) offset
++; break;
704 case MCI_END_CONSTANT
:
705 case MCI_STRING
: offset
++; break;
706 case MCI_RECT
: offset
+= 4; break;
707 default: ERR("oops");
710 } while (eid
!= MCI_END_COMMAND
);
712 TRACE("Optarg '%s' not found\n", args
);
713 return MCIERR_UNRECOGNIZED_COMMAND
;
715 if (offset
== MCI_DATA_SIZE
) {
716 ERR("Internal data[] buffer overflow\n");
717 return MCIERR_PARSER_INTERNAL
;
723 /**************************************************************************
724 * MCI_HandleReturnValues [internal]
726 static DWORD
MCI_HandleReturnValues(LPWINE_MM_IDATA iData
, DWORD dwRet
,
727 LPWINE_MCIDRIVER wmd
, LPCSTR lpCmd
, LPDWORD data
,
728 LPSTR lpstrRet
, UINT uRetLen
)
731 switch (MCI_GetReturnType(lpCmd
)) {
732 case 0: /* nothing to return */
735 switch (dwRet
& 0xFFFF0000ul
) {
737 case MCI_INTEGER_RETURNED
:
738 wsnprintfA(lpstrRet
, uRetLen
, "%ld", data
[1]);
740 case MCI_RESOURCE_RETURNED
:
741 /* return string which ID is HIWORD(data[1]),
742 * string is loaded from mmsystem.dll */
743 LoadStringA(iData
->hWinMM32Instance
, HIWORD(data
[1]),
746 case MCI_RESOURCE_RETURNED
|MCI_RESOURCE_DRIVER
:
747 /* return string which ID is HIWORD(data[1]),
748 * string is loaded from driver */
749 LoadStringA(wmd
->hDrv
, HIWORD(data
[1]), lpstrRet
, uRetLen
);
751 case MCI_COLONIZED3_RETURN
:
752 wsnprintfA(lpstrRet
, uRetLen
, "%d:%d:%d",
753 LOBYTE(LOWORD(data
[1])), HIBYTE(LOWORD(data
[1])),
754 LOBYTE(HIWORD(data
[1])));
756 case MCI_COLONIZED4_RETURN
:
757 wsnprintfA(lpstrRet
, uRetLen
, "%d:%d:%d:%d",
758 LOBYTE(LOWORD(data
[1])), HIBYTE(LOWORD(data
[1])),
759 LOBYTE(HIWORD(data
[1])), HIBYTE(HIWORD(data
[1])));
761 default: ERR("Ooops (%04X)\n", HIWORD(dwRet
));
765 switch (dwRet
& 0xFFFF0000ul
) {
767 /* nothing to do data[1] == lpstrRet */
769 case MCI_INTEGER_RETURNED
:
770 data
[1] = *(LPDWORD
)lpstrRet
;
771 wsnprintfA(lpstrRet
, uRetLen
, "%ld", data
[1]);
774 WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet
));
779 if (dwRet
& 0xFFFF0000ul
)
780 WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet
));
781 wsnprintfA(lpstrRet
, uRetLen
, "%ld %ld %ld %ld",
782 data
[1], data
[2], data
[3], data
[4]);
784 default: ERR("oops\n");
787 return LOWORD(dwRet
);
790 /**************************************************************************
791 * mciSendStringA [MMSYSTEM.702][WINMM.51]
793 DWORD WINAPI
mciSendStringA(LPCSTR lpstrCommand
, LPSTR lpstrRet
,
794 UINT uRetLen
, HWND hwndCallback
)
796 LPSTR verb
, dev
, args
;
797 LPWINE_MCIDRIVER wmd
= 0;
798 DWORD dwFlags
= 0, dwRet
= 0;
800 DWORD data
[MCI_DATA_SIZE
];
802 LPWINE_MM_IDATA iData
= MULTIMEDIA_GetIData();
803 BOOL bAutoOpen
= FALSE
;
805 TRACE("('%s', %p, %d, %X)\n", lpstrCommand
, lpstrRet
, uRetLen
, hwndCallback
);
807 /* format is <command> <device> <optargs> */
808 if (!(verb
= HEAP_strdupA(GetProcessHeap(), 0, lpstrCommand
)))
809 return MCIERR_OUT_OF_MEMORY
;
811 memset(data
, 0, sizeof(data
));
813 if (!(args
= strchr(verb
, ' '))) {
814 dwRet
= MCIERR_MISSING_DEVICE_NAME
;
818 if ((dwRet
= MCI_GetString(&dev
, &args
))) {
822 /* case dev == 'new' has to be handled */
823 if (!strcasecmp(dev
, "new")) {
824 FIXME("'new': NIY as device name\n");
825 dwRet
= MCIERR_MISSING_DEVICE_NAME
;
829 /* otherwise, try to grab devType from open */
830 if (!strcmp(verb
, "open")) {
833 if ((devType
= strchr(dev
, '!')) != NULL
) {
835 tmp
= devType
; devType
= dev
; dev
= tmp
;
837 dwFlags
|= MCI_OPEN_TYPE
;
838 data
[2] = (DWORD
)devType
;
839 devType
= CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, devType
));
840 } else if (strchr(dev
, '.') == NULL
) {
841 tmp
= strchr(dev
,' ');
842 if (tmp
) *tmp
= '\0';
843 data
[2] = (DWORD
)dev
;
844 devType
= CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, dev
));
846 dwFlags
|= MCI_OPEN_TYPE
;
848 if ((devType
= strstr(args
, "type ")) != NULL
) {
850 tmp
= strchr(devType
, ' ');
851 if (tmp
) *tmp
= '\0';
852 devType
= CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, devType
));
854 /* dwFlags and data[2] will be correctly set in ParseOpt loop */
857 if ((dwRet
= MCI_GetDevTypeFromFileName(dev
, buf
, sizeof(buf
))))
860 devType
= CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, buf
));
862 dwFlags
|= MCI_OPEN_ELEMENT
;
863 data
[3] = (DWORD
)dev
;
865 dwRet
= MCI_LoadMciDriver(iData
, devType
, &wmd
);
866 HeapFree(GetProcessHeap(), 0, devType
);
868 MCI_UnLoadMciDriver(iData
, wmd
);
871 } else if (!(wmd
= MCI_GetDriver(mciGetDeviceIDA(dev
)))) {
874 sprintf(buf
, "open %s wait", dev
);
876 if ((dwRet
= mciSendStringA(buf
, NULL
, 0, 0)) != 0)
879 wmd
= MCI_GetDriver(mciGetDeviceIDA(dev
));
881 /* FIXME: memory leak, MCI driver is not closed */
882 dwRet
= MCIERR_INVALID_DEVICE_ID
;
887 /* get the verb in the different command tables */
888 /* try the device specific command table */
889 if (wmd
) lpCmd
= MCI_FindCommand(wmd
->uSpecificCmdTable
, verb
);
890 /* try the type specific command table */
892 if (wmd
&& wmd
->uTypeCmdTable
== MCI_COMMAND_TABLE_NOT_LOADED
)
893 wmd
->uTypeCmdTable
= MCI_GetCommandTable(iData
, wmd
->wType
);
894 if (wmd
&& wmd
->uTypeCmdTable
!= MCI_NO_COMMAND_TABLE
)
895 lpCmd
= MCI_FindCommand(wmd
->uTypeCmdTable
, verb
);
897 /* try core command table */
898 if (!lpCmd
) lpCmd
= MCI_FindCommand(MCI_GetCommandTable(iData
, 0), verb
);
901 TRACE("Command '%s' not found!\n", verb
);
902 dwRet
= MCIERR_UNRECOGNIZED_COMMAND
;
906 /* set up call back */
907 if (hwndCallback
!= 0) {
908 dwFlags
|= MCI_NOTIFY
;
909 data
[0] = (DWORD
)hwndCallback
;
912 /* set return information */
913 switch (MCI_GetReturnType(lpCmd
)) {
914 case 0: offset
= 1; break;
915 case MCI_INTEGER
: offset
= 2; break;
916 case MCI_STRING
: data
[1] = (DWORD
)lpstrRet
; data
[2] = uRetLen
; offset
= 3; break;
917 case MCI_RECT
: offset
= 5; break;
918 default: ERR("oops\n");
921 TRACE("verb='%s' on dev='%s'; offset=%d\n", verb
, dev
, offset
);
923 if ((dwRet
= MCI_ParseOptArgs(data
, offset
, lpCmd
, args
, &dwFlags
)))
926 if (bAutoOpen
&& (dwFlags
& MCI_NOTIFY
)) {
927 dwRet
= MCIERR_NOTIFY_ON_AUTO_OPEN
;
930 /* FIXME: the command should get it's own notification window set up and
931 * ask for device closing while processing the notification mechanism
933 if (lpstrRet
&& uRetLen
) *lpstrRet
= '\0';
935 #define STR_OF(_x) (IsBadReadPtr((char*)_x,1)?"?":(char*)(_x))
936 TRACE("[%d, %s, %08lx, %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s %08lx/%s]\n",
937 wmd
->wDeviceID
, MCI_MessageToString(MCI_GetMessage(lpCmd
)), dwFlags
,
938 data
[0], STR_OF(data
[0]), data
[1], STR_OF(data
[1]),
939 data
[2], STR_OF(data
[2]), data
[3], STR_OF(data
[3]),
940 data
[4], STR_OF(data
[4]), data
[5], STR_OF(data
[5]));
943 if (strcmp(verb
, "open") == 0) {
944 if ((dwRet
= MCI_FinishOpen(wmd
, (LPMCI_OPEN_PARMSA
)data
, dwFlags
)))
945 MCI_UnLoadMciDriver(iData
, wmd
);
946 /* FIXME: notification is not properly shared across two opens */
948 dwRet
= MCI_SendCommand(wmd
->wDeviceID
, MCI_GetMessage(lpCmd
), dwFlags
, (DWORD
)data
, TRUE
);
950 TRACE("=> 1/ %lx (%s)\n", dwRet
, lpstrRet
);
951 if (dwRet
) goto errCleanUp
;
953 dwRet
= MCI_HandleReturnValues(iData
, dwRet
, wmd
, lpCmd
, data
, lpstrRet
, uRetLen
);
954 TRACE("=> 2/ %lx (%s)\n", dwRet
, lpstrRet
);
957 HeapFree(GetProcessHeap(), 0, verb
);
961 /**************************************************************************
962 * mciSendStringW [WINMM.52]
964 DWORD WINAPI
mciSendStringW(LPCWSTR lpwstrCommand
, LPSTR lpstrRet
,
965 UINT uRetLen
, HWND hwndCallback
)
970 /* FIXME: is there something to do with lpstrReturnString ? */
971 lpstrCommand
= HEAP_strdupWtoA(GetProcessHeap(), 0, lpwstrCommand
);
972 ret
= mciSendStringA(lpstrCommand
, lpstrRet
, uRetLen
, hwndCallback
);
973 HeapFree(GetProcessHeap(), 0, lpstrCommand
);
977 /**************************************************************************
978 * mciSendString16 [MMSYSTEM.702]
980 DWORD WINAPI
mciSendString16(LPCSTR lpstrCommand
, LPSTR lpstrRet
,
981 UINT16 uRetLen
, HWND16 hwndCallback
)
983 return mciSendStringA(lpstrCommand
, lpstrRet
, uRetLen
, hwndCallback
);
986 /**************************************************************************
987 * mciExecute [WINMM.38]
989 DWORD WINAPI
mciExecute(LPCSTR lpstrCommand
)
994 TRACE("(%s)!\n", lpstrCommand
);
996 ret
= mciSendString16(lpstrCommand
, strRet
, sizeof(strRet
), 0);
998 if (!mciGetErrorStringA(ret
, strRet
, sizeof(strRet
))) {
999 sprintf(strRet
, "Unknown MCI error (%ld)", ret
);
1001 MessageBoxA(0, strRet
, "Error in mciExecute()", MB_OK
);
1003 /* FIXME: what shall I return ? */
1007 /**************************************************************************
1008 * mciLoadCommandResource [MMSYSTEM.705]
1010 UINT16 WINAPI
mciLoadCommandResource16(HANDLE16 hInst
, LPCSTR resname
, UINT16 type
)
1014 UINT16 ret
= MCI_NO_COMMAND_TABLE
;
1015 LPWINE_MM_IDATA iData
= MULTIMEDIA_GetIData();
1017 TRACE("(%04x, %s, %d)!\n", hInst
, resname
, type
);
1019 /* if file exists "resname.mci", then load resource "resname" from it
1020 * otherwise directly from driver
1021 * We don't support it (who uses this feature ?), but we check anyway
1027 strcat(strcpy(buf
, resname
), ".mci");
1028 if (OpenFile(buf
, &ofs
, OF_EXIST
) != HFILE_ERROR
) {
1029 FIXME("NIY: command table to be loaded from '%s'\n", ofs
.szPathName
);
1032 if (!(hRsrc
= FindResourceA(hInst
, resname
, (LPCSTR
)RT_RCDATAA
))) {
1033 WARN("No command table found in resource\n");
1034 } else if ((hMem
= LoadResource(hInst
, hRsrc
))) {
1035 ret
= MCI_SetCommandTable(iData
, hMem
, type
);
1037 WARN("Couldn't load resource.\n");
1039 TRACE("=> %04x\n", ret
);
1043 /**************************************************************************
1044 * mciFreeCommandResource [MMSYSTEM.713]
1046 BOOL16 WINAPI
mciFreeCommandResource16(UINT16 uTable
)
1048 TRACE("(%04x)!\n", uTable
);
1050 return MCI_DeleteCommandTable(uTable
);
1053 /**************************************************************************
1054 * mciLoadCommandResource [WINMM.48]
1056 * Strangely, this function only exists as an UNICODE one.
1058 UINT WINAPI
mciLoadCommandResource(HINSTANCE hinst
, LPCWSTR resNameW
, UINT type
)
1063 TRACE("(%04x, %s, %d)!\n", hinst
, debugstr_w(resNameW
), type
);
1065 resNameA
= HEAP_strdupWtoA(GetProcessHeap(), 0, resNameW
);
1066 ret
= mciLoadCommandResource16(hinst
, resNameA
, type
);
1067 HeapFree(GetProcessHeap(), 0, resNameA
);
1071 /**************************************************************************
1072 * mciFreeCommandResource [WINMM.39]
1074 BOOL WINAPI
mciFreeCommandResource(UINT uTable
)
1076 TRACE("(%08x)!\n", uTable
);
1078 return mciFreeCommandResource16(uTable
);
1082 MCI_MAP_NOMEM
, /* ko, memory problem */
1083 MCI_MAP_MSGERROR
, /* ko, unknown message */
1084 MCI_MAP_OK
, /* ok, no memory allocated. to be sent to the proc. */
1085 MCI_MAP_OKMEM
, /* ok, some memory allocated, need to call UnMapMsg. to be sent to the proc. */
1086 MCI_MAP_PASS
/* not handled (no memory allocated) to be sent to the driver */
1089 /**************************************************************************
1090 * MCI_MapMsg16To32A [internal]
1092 static MCI_MapType
MCI_MapMsg16To32A(WORD uDevType
, WORD wMsg
, DWORD
* lParam
)
1096 /* FIXME: to add also (with seg/linear modifications to do):
1097 * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
1098 * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
1101 /* case MCI_CAPTURE */
1103 case MCI_CLOSE_DRIVER
:
1104 /* case MCI_CONFIGURE:*/
1110 case MCI_GETDEVCAPS
:
1111 /* case MCI_INDEX: */
1112 /* case MCI_MARK: */
1113 /* case MCI_MONITOR: */
1123 /* case MCI_SETTIMECODE:*/
1124 /* case MCI_SIGNAL:*/
1126 case MCI_STATUS
: /* FIXME: is wrong for digital video */
1129 /* case MCI_UNDO: */
1133 *lParam
= (DWORD
)PTR_SEG_TO_LIN(*lParam
);
1136 /* in fact, I would also need the dwFlags... to see
1137 * which members of lParam are effectively used
1139 *lParam
= (DWORD
)PTR_SEG_TO_LIN(*lParam
);
1140 FIXME("Current mapping may be wrong\n");
1144 LPMCI_BREAK_PARMS mbp32
= HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS
));
1145 LPMCI_BREAK_PARMS16 mbp16
= PTR_SEG_TO_LIN(*lParam
);
1148 mbp32
->dwCallback
= mbp16
->dwCallback
;
1149 mbp32
->nVirtKey
= mbp16
->nVirtKey
;
1150 mbp32
->hwndBreak
= mbp16
->hwndBreak
;
1152 return MCI_MAP_NOMEM
;
1154 *lParam
= (DWORD
)mbp32
;
1156 return MCI_MAP_OKMEM
;
1159 LPMCI_VD_ESCAPE_PARMSA mvep32a
= HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSA
));
1160 LPMCI_VD_ESCAPE_PARMS16 mvep16
= PTR_SEG_TO_LIN(*lParam
);
1163 mvep32a
->dwCallback
= mvep16
->dwCallback
;
1164 mvep32a
->lpstrCommand
= PTR_SEG_TO_LIN(mvep16
->lpstrCommand
);
1166 return MCI_MAP_NOMEM
;
1168 *lParam
= (DWORD
)mvep32a
;
1170 return MCI_MAP_OKMEM
;
1173 LPMCI_INFO_PARMSA mip32a
= HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_INFO_PARMSA
));
1174 LPMCI_INFO_PARMS16 mip16
= PTR_SEG_TO_LIN(*lParam
);
1176 /* FIXME this is wrong if device is of type
1177 * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
1180 mip32a
->dwCallback
= mip16
->dwCallback
;
1181 mip32a
->lpstrReturn
= PTR_SEG_TO_LIN(mip16
->lpstrReturn
);
1182 mip32a
->dwRetSize
= mip16
->dwRetSize
;
1184 return MCI_MAP_NOMEM
;
1186 *lParam
= (DWORD
)mip32a
;
1188 return MCI_MAP_OKMEM
;
1190 case MCI_OPEN_DRIVER
:
1192 LPMCI_OPEN_PARMSA mop32a
= HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16
) + sizeof(MCI_OPEN_PARMSA
) + 2 * sizeof(DWORD
));
1193 LPMCI_OPEN_PARMS16 mop16
= PTR_SEG_TO_LIN(*lParam
);
1196 *(LPMCI_OPEN_PARMS16
*)(mop32a
) = mop16
;
1197 mop32a
= (LPMCI_OPEN_PARMSA
)((char*)mop32a
+ sizeof(LPMCI_OPEN_PARMS16
));
1198 mop32a
->dwCallback
= mop16
->dwCallback
;
1199 mop32a
->wDeviceID
= mop16
->wDeviceID
;
1200 mop32a
->lpstrDeviceType
= PTR_SEG_TO_LIN(mop16
->lpstrDeviceType
);
1201 mop32a
->lpstrElementName
= PTR_SEG_TO_LIN(mop16
->lpstrElementName
);
1202 mop32a
->lpstrAlias
= PTR_SEG_TO_LIN(mop16
->lpstrAlias
);
1203 /* copy extended information if any...
1204 * FIXME: this may seg fault if initial structure does not contain them and
1205 * the reads after msip16 fail under LDT limits...
1206 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
1207 * should not take care of extended parameters, and should be used by MCI_Open
1208 * to fetch uDevType. When, this is known, the mapping for sending the
1209 * MCI_OPEN_DRIVER shall be done depending on uDevType.
1211 memcpy(mop32a
+ 1, mop16
+ 1, 2 * sizeof(DWORD
));
1213 return MCI_MAP_NOMEM
;
1215 *lParam
= (DWORD
)mop32a
;
1217 return MCI_MAP_OKMEM
;
1220 LPMCI_SYSINFO_PARMSA msip32a
= HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SYSINFO_PARMSA
));
1221 LPMCI_SYSINFO_PARMS16 msip16
= PTR_SEG_TO_LIN(*lParam
);
1224 msip32a
->dwCallback
= msip16
->dwCallback
;
1225 msip32a
->lpstrReturn
= PTR_SEG_TO_LIN(msip16
->lpstrReturn
);
1226 msip32a
->dwRetSize
= msip16
->dwRetSize
;
1227 msip32a
->dwNumber
= msip16
->dwNumber
;
1228 msip32a
->wDeviceType
= msip16
->wDeviceType
;
1230 return MCI_MAP_NOMEM
;
1232 *lParam
= (DWORD
)msip32a
;
1234 return MCI_MAP_OKMEM
;
1242 case DRV_QUERYCONFIGURE
:
1245 case DRV_EXITSESSION
:
1246 case DRV_EXITAPPLICATION
:
1248 FIXME("This is a hack\n");
1252 WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg
));
1254 return MCI_MAP_MSGERROR
;
1257 /**************************************************************************
1258 * MCI_UnMapMsg16To32A [internal]
1260 static MCI_MapType
MCI_UnMapMsg16To32A(WORD uDevType
, WORD wMsg
, DWORD lParam
)
1263 /* case MCI_CAPTURE */
1265 case MCI_CLOSE_DRIVER
:
1266 /* case MCI_CONFIGURE:*/
1272 case MCI_GETDEVCAPS
:
1273 /* case MCI_INDEX: */
1274 /* case MCI_MARK: */
1275 /* case MCI_MONITOR: */
1285 /* case MCI_SETTIMECODE:*/
1286 /* case MCI_SIGNAL:*/
1291 /* case MCI_UNDO: */
1298 /* FIXME ?? see Map function */
1305 HeapFree(GetProcessHeap(), 0, (LPVOID
)lParam
);
1308 case MCI_OPEN_DRIVER
:
1310 LPMCI_OPEN_PARMSA mop32a
= (LPMCI_OPEN_PARMSA
)lParam
;
1311 LPMCI_OPEN_PARMS16 mop16
= *(LPMCI_OPEN_PARMS16
*)((char*)mop32a
- sizeof(LPMCI_OPEN_PARMS16
));
1313 mop16
->wDeviceID
= mop32a
->wDeviceID
;
1314 if (!HeapFree(GetProcessHeap(), 0, (LPVOID
)(lParam
- sizeof(LPMCI_OPEN_PARMS16
))))
1315 FIXME("bad free line=%d\n", __LINE__
);
1325 case DRV_QUERYCONFIGURE
:
1328 case DRV_EXITSESSION
:
1329 case DRV_EXITAPPLICATION
:
1331 FIXME("This is a hack\n");
1334 FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg
));
1336 return MCI_MAP_MSGERROR
;
1341 * 0001 squeeze signed 4 bytes to 2 bytes *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2; S += 4
1342 * 0010 squeeze unsigned 4 bytes to 2 bytes *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2; S += 4
1345 * 0110 zero 4 bytes *(DWORD)D = 0 D += 4; S += 4
1346 * 0111 copy string *(LPSTR*)D = seg dup(*(LPSTR*)S) D += 4; S += 4
1347 * 1xxx copy xxx + 1 bytes memcpy(D, S, xxx + 1); D += xxx+1; S += xxx+1
1350 /**************************************************************************
1351 * MCI_MsgMapper32To16_Create [internal]
1353 * Helper for MCI_MapMsg32ATo16.
1354 * Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit
1355 * segmented pointer.
1356 * map contains a list of action to be performed for the mapping (see list
1358 * if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
1360 static MCI_MapType
MCI_MsgMapper32To16_Create(void** ptr
, int size16
, DWORD map
, BOOLEAN keep
)
1362 void* lp
= SEGPTR_ALLOC((keep
? sizeof(void**) : 0) + size16
);
1366 return MCI_MAP_NOMEM
;
1368 p32
= (LPBYTE
)(*ptr
);
1371 p16
= (LPBYTE
)lp
+ sizeof(void**);
1372 *ptr
= (char*)SEGPTR_GET(lp
) + sizeof(void**);
1375 *ptr
= (void*)SEGPTR_GET(lp
);
1379 memcpy(p16
, p32
, size16
);
1387 sz
= (nibble
& 7) + 1;
1388 memcpy(p16
, p32
, sz
);
1391 size16
-= sz
; /* DEBUG only */
1394 case 0x1: *( LPINT16
)p16
= ( INT16
)*( LPINT16
)p32
; p16
+= 2; p32
+= 4; size16
-= 2; break;
1395 case 0x2: *(LPUINT16
)p16
= (UINT16
)*(LPUINT16
)p32
; p16
+= 2; p32
+= 4; size16
-= 2; break;
1396 case 0x6: *(LPDWORD
)p16
= 0; p16
+= 4; p32
+= 4; size16
-= 4; break;
1397 case 0x7: *(LPDWORD
)p16
= SEGPTR_GET(SEGPTR_STRDUP(*(LPSTR
*)p32
));p16
+= 4; p32
+= 4; size16
-= 4; break;
1398 default: FIXME("Unknown nibble for mapping (%x)\n", nibble
);
1403 if (size16
!= 0) /* DEBUG only */
1404 FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
1406 return MCI_MAP_OKMEM
;
1409 /**************************************************************************
1410 * MCI_MsgMapper32To16_Destroy [internal]
1412 * Helper for MCI_UnMapMsg32ATo16.
1414 static MCI_MapType
MCI_MsgMapper32To16_Destroy(void* ptr
, int size16
, DWORD map
, BOOLEAN kept
)
1417 void* msg16
= PTR_SEG_TO_LIN(ptr
);
1423 alloc
= (char*)msg16
- sizeof(void**);
1424 p32
= *(void**)alloc
;
1428 memcpy(p32
, p16
, size16
);
1433 memcpy(p32
, p16
, (nibble
& 7) + 1);
1434 p16
+= (nibble
& 7) + 1;
1435 p32
+= (nibble
& 7) + 1;
1436 size16
-= (nibble
& 7) + 1;
1439 case 0x1: *( LPINT
)p32
= *( LPINT16
)p16
; p16
+= 2; p32
+= 4; size16
-= 2; break;
1440 case 0x2: *(LPUINT
)p32
= *(LPUINT16
)p16
; p16
+= 2; p32
+= 4; size16
-= 2; break;
1441 case 0x6: p16
+= 4; p32
+= 4; size16
-= 4; break;
1442 case 0x7: strcpy(*(LPSTR
*)p32
, PTR_SEG_TO_LIN(*(DWORD
*)p16
));
1443 if (!SEGPTR_FREE(PTR_SEG_TO_LIN(*(DWORD
*)p16
))) {
1444 FIXME("bad free line=%d\n", __LINE__
);
1446 p16
+= 4; p32
+= 4; size16
-= 4; break;
1447 default: FIXME("Unknown nibble for mapping (%x)\n", nibble
);
1452 if (size16
!= 0) /* DEBUG only */
1453 FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
1459 if (!SEGPTR_FREE(alloc
)) {
1460 FIXME("bad free line=%d\n", __LINE__
);
1466 /**************************************************************************
1467 * MCI_MapMsg32ATo16 [internal]
1469 * Map a 32-A bit MCI message to a 16 bit MCI message.
1471 static MCI_MapType
MCI_MapMsg32ATo16(WORD uDevType
, WORD wMsg
, DWORD dwFlags
, DWORD
* lParam
)
1474 BOOLEAN keep
= FALSE
;
1480 /* FIXME: to add also (with seg/linear modifications to do):
1481 * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
1482 * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
1486 size
= sizeof(MCI_BREAK_PARMS
);
1488 /* case MCI_CAPTURE */
1490 case MCI_CLOSE_DRIVER
:
1491 size
= sizeof(MCI_GENERIC_PARMS
);
1493 /* case MCI_CONFIGURE:*/
1494 /* case MCI_COPY: */
1497 case MCI_DEVTYPE_DIGITAL_VIDEO
: size
= sizeof(MCI_DGV_CUE_PARMS
); break;
1498 case MCI_DEVTYPE_VCR
: /*size = sizeof(MCI_VCR_CUE_PARMS); break;*/ FIXME("NIY vcr\n"); return MCI_MAP_NOMEM
;
1499 default: size
= sizeof(MCI_GENERIC_PARMS
); break;
1505 case MCI_DEVTYPE_DIGITAL_VIDEO
: size
= sizeof(MCI_DGV_DELETE_PARMS16
); map
= 0x0F1111FB; break;
1506 case MCI_DEVTYPE_WAVEFORM_AUDIO
:size
= sizeof(MCI_WAVE_DELETE_PARMS
); break;
1507 default: size
= sizeof(MCI_GENERIC_PARMS
); break;
1510 /* case MCI_ESCAPE: */
1513 case MCI_DEVTYPE_DIGITAL_VIDEO
: size
= sizeof(MCI_DGV_FREEZE_PARMS
); map
= 0x0001111B; break;
1514 case MCI_DEVTYPE_OVERLAY
: size
= sizeof(MCI_OVLY_RECT_PARMS
); map
= 0x0001111B; break;
1515 default: size
= sizeof(MCI_GENERIC_PARMS
); break;
1518 case MCI_GETDEVCAPS
:
1520 size
= sizeof(MCI_GETDEVCAPS_PARMS
);
1522 /* case MCI_INDEX: */
1525 LPMCI_INFO_PARMSA mip32a
= (LPMCI_INFO_PARMSA
)(*lParam
);
1527 LPMCI_INFO_PARMS16 mip16
;
1530 case MCI_DEVTYPE_DIGITAL_VIDEO
: size
= sizeof(MCI_DGV_INFO_PARMS16
); break;
1531 default: size
= sizeof(MCI_INFO_PARMS16
); break;
1533 ptr
= SEGPTR_ALLOC(sizeof(LPMCI_INFO_PARMSA
) + size
);
1536 *(LPMCI_INFO_PARMSA
*)ptr
= mip32a
;
1537 mip16
= (LPMCI_INFO_PARMS16
)(ptr
+ sizeof(LPMCI_INFO_PARMSA
));
1538 mip16
->dwCallback
= mip32a
->dwCallback
;
1539 mip16
->lpstrReturn
= (LPSTR
)SEGPTR_GET(SEGPTR_ALLOC(mip32a
->dwRetSize
));
1540 mip16
->dwRetSize
= mip32a
->dwRetSize
;
1541 if (uDevType
== MCI_DEVTYPE_DIGITAL_VIDEO
) {
1542 ((LPMCI_DGV_INFO_PARMS16
)mip16
)->dwItem
= ((LPMCI_DGV_INFO_PARMSA
)mip32a
)->dwItem
;
1545 return MCI_MAP_NOMEM
;
1547 *lParam
= (LPARAM
)SEGPTR_GET(ptr
) + sizeof(LPMCI_INFO_PARMSA
);
1549 return MCI_MAP_OKMEM
;
1550 /* case MCI_MARK: */
1551 /* case MCI_MONITOR: */
1553 case MCI_OPEN_DRIVER
:
1555 LPMCI_OPEN_PARMSA mop32a
= (LPMCI_OPEN_PARMSA
)(*lParam
);
1556 char* ptr
= SEGPTR_ALLOC(sizeof(LPMCI_OPEN_PARMSA
) + sizeof(MCI_OPEN_PARMS16
) + 2 * sizeof(DWORD
));
1557 LPMCI_OPEN_PARMS16 mop16
;
1561 *(LPMCI_OPEN_PARMSA
*)(ptr
) = mop32a
;
1562 mop16
= (LPMCI_OPEN_PARMS16
)(ptr
+ sizeof(LPMCI_OPEN_PARMSA
));
1563 mop16
->dwCallback
= mop32a
->dwCallback
;
1564 mop16
->wDeviceID
= mop32a
->wDeviceID
;
1565 if (dwFlags
& MCI_OPEN_TYPE
) {
1566 if (dwFlags
& MCI_OPEN_TYPE_ID
) {
1567 /* dword "transparent" value */
1568 mop16
->lpstrDeviceType
= mop32a
->lpstrDeviceType
;
1571 mop16
->lpstrDeviceType
= mop32a
->lpstrDeviceType
? (LPSTR
)SEGPTR_GET(SEGPTR_STRDUP(mop32a
->lpstrDeviceType
)) : 0;
1575 mop16
->lpstrDeviceType
= 0;
1577 if (dwFlags
& MCI_OPEN_ELEMENT
) {
1578 if (dwFlags
& MCI_OPEN_ELEMENT_ID
) {
1579 mop16
->lpstrElementName
= mop32a
->lpstrElementName
;
1581 mop16
->lpstrElementName
= mop32a
->lpstrElementName
? (LPSTR
)SEGPTR_GET(SEGPTR_STRDUP(mop32a
->lpstrElementName
)) : 0;
1584 mop16
->lpstrElementName
= 0;
1586 if (dwFlags
& MCI_OPEN_ALIAS
) {
1587 mop16
->lpstrAlias
= mop32a
->lpstrAlias
? (LPSTR
)SEGPTR_GET(SEGPTR_STRDUP(mop32a
->lpstrAlias
)) : 0;
1589 mop16
->lpstrAlias
= 0;
1591 /* copy extended information if any...
1592 * FIXME: this may seg fault if initial structure does not contain them and
1593 * the reads after msip16 fail under LDT limits...
1594 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
1595 * should not take care of extended parameters, and should be used by MCI_Open
1596 * to fetch uDevType. When, this is known, the mapping for sending the
1597 * MCI_OPEN_DRIVER shall be done depending on uDevType.
1599 memcpy(mop16
+ 1, mop32a
+ 1, 2 * sizeof(DWORD
));
1601 return MCI_MAP_NOMEM
;
1603 *lParam
= (LPARAM
)SEGPTR_GET(ptr
) + sizeof(LPMCI_OPEN_PARMSA
);
1605 return MCI_MAP_OKMEM
;
1606 /* case MCI_PASTE:*/
1608 size
= sizeof(MCI_GENERIC_PARMS
);
1611 size
= sizeof(MCI_PLAY_PARMS
);
1615 case MCI_DEVTYPE_DIGITAL_VIDEO
: size
= sizeof(MCI_DGV_RECT_PARMS16
); map
= 0x0001111B; break;
1616 case MCI_DEVTYPE_OVERLAY
: size
= sizeof(MCI_OVLY_RECT_PARMS
); map
= 0x0001111B; break;
1617 default: size
= sizeof(MCI_GENERIC_PARMS
); break;
1621 size
= sizeof(MCI_GENERIC_PARMS
);
1625 case MCI_DEVTYPE_DIGITAL_VIDEO
: size
= sizeof(MCI_DGV_RECORD_PARMS16
); map
= 0x0F1111FB; break;
1626 case MCI_DEVTYPE_VCR
: /*size = sizeof(MCI_VCR_RECORD_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM
;
1627 default: size
= sizeof(MCI_RECORD_PARMS
); break;
1631 size
= sizeof(MCI_GENERIC_PARMS
);
1635 case MCI_DEVTYPE_VCR
: /*size = sizeof(MCI_VCR_SEEK_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM
;
1636 default: size
= sizeof(MCI_SEEK_PARMS
); break;
1641 case MCI_DEVTYPE_DIGITAL_VIDEO
: size
= sizeof(MCI_DGV_SET_PARMS
); break;
1642 case MCI_DEVTYPE_VCR
: /*size = sizeof(MCI_VCR_SET_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM
;
1643 case MCI_DEVTYPE_SEQUENCER
: size
= sizeof(MCI_SEQ_SET_PARMS
); break;
1644 /* FIXME: normally the 16 and 32 bit structures are byte by byte aligned,
1645 * so not doing anything should work...
1647 case MCI_DEVTYPE_WAVEFORM_AUDIO
:size
= sizeof(MCI_WAVE_SET_PARMS
); break;
1648 default: size
= sizeof(MCI_SET_PARMS
); break;
1651 /* case MCI_SETTIMECODE:*/
1652 /* case MCI_SIGNAL:*/
1654 size
= sizeof(MCI_SET_PARMS
);
1660 * don't know if buffer for value is the one passed thru lpstrDevice
1661 * or is provided by MCI driver.
1662 * Assuming solution 2: provided by MCI driver, so zeroing on entry
1664 case MCI_DEVTYPE_DIGITAL_VIDEO
: size
= sizeof(MCI_DGV_STATUS_PARMS16
); map
= 0x0B6FF; break;
1665 case MCI_DEVTYPE_VCR
: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM
;
1666 default: size
= sizeof(MCI_STATUS_PARMS
); break;
1671 case MCI_DEVTYPE_DIGITAL_VIDEO
: size
= sizeof(MCI_DGV_STEP_PARMS
); break;
1672 case MCI_DEVTYPE_VCR
: /*size = sizeof(MCI_VCR_STEP_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM
;
1673 case MCI_DEVTYPE_VIDEODISC
: size
= sizeof(MCI_VD_STEP_PARMS
); break;
1674 default: size
= sizeof(MCI_GENERIC_PARMS
); break;
1678 size
= sizeof(MCI_SET_PARMS
);
1682 LPMCI_SYSINFO_PARMSA msip32a
= (LPMCI_SYSINFO_PARMSA
)(*lParam
);
1683 char* ptr
= SEGPTR_ALLOC(sizeof(LPMCI_SYSINFO_PARMSA
) + sizeof(MCI_SYSINFO_PARMS16
));
1684 LPMCI_SYSINFO_PARMS16 msip16
;
1687 *(LPMCI_SYSINFO_PARMSA
*)(ptr
) = msip32a
;
1688 msip16
= (LPMCI_SYSINFO_PARMS16
)(ptr
+ sizeof(LPMCI_SYSINFO_PARMSA
));
1690 msip16
->dwCallback
= msip32a
->dwCallback
;
1691 msip16
->lpstrReturn
= (LPSTR
)SEGPTR_GET(SEGPTR_ALLOC(msip32a
->dwRetSize
));
1692 msip16
->dwRetSize
= msip32a
->dwRetSize
;
1693 msip16
->dwNumber
= msip32a
->dwNumber
;
1694 msip16
->wDeviceType
= msip32a
->wDeviceType
;
1696 return MCI_MAP_NOMEM
;
1698 *lParam
= (LPARAM
)SEGPTR_GET(ptr
) + sizeof(LPMCI_SYSINFO_PARMSA
);
1700 return MCI_MAP_OKMEM
;
1701 /* case MCI_UNDO: */
1704 case MCI_DEVTYPE_DIGITAL_VIDEO
: size
= sizeof(MCI_DGV_RECT_PARMS16
); map
= 0x0001111B; break;
1705 case MCI_DEVTYPE_OVERLAY
: size
= sizeof(MCI_OVLY_RECT_PARMS16
); map
= 0x0001111B; break;
1706 default: size
= sizeof(MCI_GENERIC_PARMS
); break;
1711 case MCI_DEVTYPE_DIGITAL_VIDEO
: size
= sizeof(MCI_DGV_UPDATE_PARMS16
); map
= 0x000B1111B; break;
1712 default: size
= sizeof(MCI_GENERIC_PARMS
); break;
1717 case MCI_DEVTYPE_DIGITAL_VIDEO
: size
= sizeof(MCI_DGV_RECT_PARMS16
); map
= 0x0001111B; keep
= TRUE
; break;
1718 case MCI_DEVTYPE_OVERLAY
: size
= sizeof(MCI_OVLY_RECT_PARMS16
); map
= 0x0001111B; keep
= TRUE
; break;
1719 default: size
= sizeof(MCI_GENERIC_PARMS
); break;
1724 case MCI_DEVTYPE_DIGITAL_VIDEO
: size
= sizeof(MCI_DGV_WINDOW_PARMS16
); if (dwFlags
& MCI_DGV_WINDOW_TEXT
) map
= 0x7FB; break;
1725 case MCI_DEVTYPE_OVERLAY
: size
= sizeof(MCI_OVLY_WINDOW_PARMS16
); if (dwFlags
& MCI_OVLY_WINDOW_TEXT
) map
= 0x7FB; break;
1726 default: size
= sizeof(MCI_GENERIC_PARMS
); break;
1736 case DRV_QUERYCONFIGURE
:
1739 case DRV_EXITSESSION
:
1740 case DRV_EXITAPPLICATION
:
1742 return MCI_MAP_PASS
;
1745 WARN("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg
));
1746 return MCI_MAP_MSGERROR
;
1748 return MCI_MsgMapper32To16_Create((void**)lParam
, size
, map
, keep
);
1751 /**************************************************************************
1752 * MCI_UnMapMsg32ATo16 [internal]
1754 static MCI_MapType
MCI_UnMapMsg32ATo16(WORD uDevType
, WORD wMsg
, DWORD dwFlags
, DWORD lParam
)
1757 BOOLEAN kept
= FALSE
; /* there is no need to compute size when kept is FALSE */
1763 /* case MCI_CAPTURE */
1765 case MCI_CLOSE_DRIVER
:
1767 /* case MCI_CONFIGURE:*/
1768 /* case MCI_COPY: */
1774 /* case MCI_ESCAPE: */
1777 case MCI_GETDEVCAPS
:
1779 size
= sizeof(MCI_GETDEVCAPS_PARMS
);
1781 /* case MCI_INDEX: */
1784 LPMCI_INFO_PARMS16 mip16
= (LPMCI_INFO_PARMS16
)PTR_SEG_TO_LIN(lParam
);
1785 LPMCI_INFO_PARMSA mip32a
= *(LPMCI_INFO_PARMSA
*)((char*)mip16
- sizeof(LPMCI_INFO_PARMSA
));
1787 memcpy(mip32a
->lpstrReturn
, PTR_SEG_TO_LIN(mip16
->lpstrReturn
), mip32a
->dwRetSize
);
1789 if (!SEGPTR_FREE(PTR_SEG_TO_LIN(mip16
->lpstrReturn
)))
1790 FIXME("bad free line=%d\n", __LINE__
);
1791 if (!SEGPTR_FREE((char*)mip16
- sizeof(LPMCI_INFO_PARMSA
)))
1792 FIXME("bad free line=%d\n", __LINE__
);
1795 /* case MCI_MARK: */
1796 /* case MCI_MONITOR: */
1798 case MCI_OPEN_DRIVER
:
1800 LPMCI_OPEN_PARMS16 mop16
= (LPMCI_OPEN_PARMS16
)PTR_SEG_TO_LIN(lParam
);
1801 LPMCI_OPEN_PARMSA mop32a
= *(LPMCI_OPEN_PARMSA
*)((char*)mop16
- sizeof(LPMCI_OPEN_PARMSA
));
1803 mop32a
->wDeviceID
= mop16
->wDeviceID
;
1804 if ((dwFlags
& MCI_OPEN_TYPE
) && !
1805 (dwFlags
& MCI_OPEN_TYPE_ID
) &&
1806 !SEGPTR_FREE(PTR_SEG_TO_LIN(mop16
->lpstrDeviceType
)))
1807 FIXME("bad free line=%d\n", __LINE__
);
1808 if ((dwFlags
& MCI_OPEN_ELEMENT
) &&
1809 !(dwFlags
& MCI_OPEN_ELEMENT_ID
) &&
1810 !SEGPTR_FREE(PTR_SEG_TO_LIN(mop16
->lpstrElementName
)))
1811 FIXME("bad free line=%d\n", __LINE__
);
1812 if ((dwFlags
& MCI_OPEN_ALIAS
) &&
1813 !SEGPTR_FREE(PTR_SEG_TO_LIN(mop16
->lpstrAlias
)))
1814 FIXME("bad free line=%d\n", __LINE__
);
1816 if (!SEGPTR_FREE((char*)mop16
- sizeof(LPMCI_OPEN_PARMSA
)))
1817 FIXME("bad free line=%d\n", __LINE__
);
1820 /* case MCI_PASTE:*/
1837 /* case MCI_SETTIMECODE:*/
1838 /* case MCI_SIGNAL:*/
1844 case MCI_DEVTYPE_DIGITAL_VIDEO
:
1846 LPMCI_DGV_STATUS_PARMS16 mdsp16
= (LPMCI_DGV_STATUS_PARMS16
)PTR_SEG_TO_LIN(lParam
);
1847 LPMCI_DGV_STATUS_PARMSA mdsp32a
= *(LPMCI_DGV_STATUS_PARMSA
*)((char*)mdsp16
- sizeof(LPMCI_DGV_STATUS_PARMSA
));
1850 mdsp32a
->dwReturn
= mdsp16
->dwReturn
;
1851 if (dwFlags
& MCI_DGV_STATUS_DISKSPACE
) {
1852 TRACE("MCI_STATUS (DGV) lpstrDrive=%p\n", mdsp16
->lpstrDrive
);
1853 TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR
)PTR_SEG_TO_LIN(mdsp16
->lpstrDrive
));
1855 /* FIXME: see map function */
1856 strcpy(mdsp32a
->lpstrDrive
, (LPSTR
)PTR_SEG_TO_LIN(mdsp16
->lpstrDrive
));
1859 if (!SEGPTR_FREE((char*)mdsp16
- sizeof(LPMCI_DGV_STATUS_PARMSA
)))
1860 FIXME("bad free line=%d\n", __LINE__
);
1862 return MCI_MAP_NOMEM
;
1865 return MCI_MAP_OKMEM
;
1866 case MCI_DEVTYPE_VCR
: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return MCI_MAP_NOMEM
;
1867 default: size
= sizeof(MCI_STATUS_PARMS
); break;
1876 LPMCI_SYSINFO_PARMS16 msip16
= (LPMCI_SYSINFO_PARMS16
)PTR_SEG_TO_LIN(lParam
);
1877 LPMCI_SYSINFO_PARMSA msip32a
= *(LPMCI_SYSINFO_PARMSA
*)((char*)msip16
- sizeof(LPMCI_SYSINFO_PARMSA
));
1880 msip16
->dwCallback
= msip32a
->dwCallback
;
1881 memcpy(msip32a
->lpstrReturn
, PTR_SEG_TO_LIN(msip16
->lpstrReturn
), msip32a
->dwRetSize
);
1882 if (!SEGPTR_FREE(PTR_SEG_TO_LIN(msip16
->lpstrReturn
)))
1883 FIXME("bad free line=%d\n", __LINE__
);
1885 if (!SEGPTR_FREE((char*)msip16
- sizeof(LPMCI_SYSINFO_PARMSA
)))
1886 FIXME("bad free line=%d\n", __LINE__
);
1888 return MCI_MAP_NOMEM
;
1891 return MCI_MAP_OKMEM
;
1892 /* case MCI_UNDO: */
1899 case MCI_DEVTYPE_DIGITAL_VIDEO
: size
= sizeof(MCI_DGV_RECT_PARMS16
); map
= 0x0001111B; kept
= TRUE
; break;
1900 case MCI_DEVTYPE_OVERLAY
: size
= sizeof(MCI_OVLY_RECT_PARMS16
); map
= 0x0001111B; kept
= TRUE
; break;
1906 case MCI_DEVTYPE_DIGITAL_VIDEO
: size
= sizeof(MCI_DGV_WINDOW_PARMS16
); if (dwFlags
& MCI_DGV_WINDOW_TEXT
) map
= 0x7666; break;
1907 case MCI_DEVTYPE_OVERLAY
: size
= sizeof(MCI_OVLY_WINDOW_PARMS16
); if (dwFlags
& MCI_OVLY_WINDOW_TEXT
) map
= 0x7666; break;
1910 /* FIXME: see map function */
1920 case DRV_QUERYCONFIGURE
:
1923 case DRV_EXITSESSION
:
1924 case DRV_EXITAPPLICATION
:
1926 FIXME("This is a hack\n");
1927 return MCI_MAP_PASS
;
1929 FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg
));
1930 return MCI_MAP_MSGERROR
;
1932 return MCI_MsgMapper32To16_Destroy((void*)lParam
, size
, map
, kept
);
1935 /**************************************************************************
1936 * MCI_SendCommandFrom32 [internal]
1938 DWORD
MCI_SendCommandFrom32(UINT wDevID
, UINT16 wMsg
, DWORD dwParam1
, DWORD dwParam2
)
1940 DWORD dwRet
= MCIERR_DEVICE_NOT_INSTALLED
;
1941 LPWINE_MCIDRIVER wmd
= MCI_GetDriver(wDevID
);
1944 dwRet
= MCIERR_INVALID_DEVICE_ID
;
1946 switch (GetDriverFlags(wmd
->hDrv
) & (WINE_GDF_EXIST
|WINE_GDF_16BIT
)) {
1947 case WINE_GDF_EXIST
|WINE_GDF_16BIT
:
1951 switch (res
= MCI_MapMsg32ATo16(wmd
->wType
, wMsg
, dwParam1
, &dwParam2
)) {
1952 case MCI_MAP_MSGERROR
:
1953 TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg
));
1954 dwRet
= MCIERR_DRIVER_INTERNAL
;
1957 TRACE("Problem mapping msg=%s from 32a to 16\n", MCI_MessageToString(wMsg
));
1958 dwRet
= MCIERR_OUT_OF_MEMORY
;
1962 dwRet
= SendDriverMessage16(wmd
->hDrv
, wMsg
, dwParam1
, dwParam2
);
1963 if (res
== MCI_MAP_OKMEM
)
1964 MCI_UnMapMsg32ATo16(wmd
->wType
, wMsg
, dwParam1
, dwParam2
);
1967 dwRet
= SendDriverMessage(wmd
->hDrv
, wMsg
, dwParam1
, dwParam2
);
1972 case WINE_GDF_EXIST
:
1973 dwRet
= SendDriverMessage(wmd
->hDrv
, wMsg
, dwParam1
, dwParam2
);
1976 WARN("Unknown driver %u\n", wmd
->hDrv
);
1977 dwRet
= MCIERR_DRIVER_INTERNAL
;
1983 /**************************************************************************
1984 * MCI_SendCommandFrom16 [internal]
1986 DWORD
MCI_SendCommandFrom16(UINT wDevID
, UINT16 wMsg
, DWORD dwParam1
, DWORD dwParam2
)
1988 DWORD dwRet
= MCIERR_DEVICE_NOT_INSTALLED
;
1989 LPWINE_MCIDRIVER wmd
= MCI_GetDriver(wDevID
);
1992 dwRet
= MCIERR_INVALID_DEVICE_ID
;
1996 switch (GetDriverFlags(wmd
->hDrv
) & (WINE_GDF_EXIST
|WINE_GDF_16BIT
)) {
1997 case WINE_GDF_EXIST
|WINE_GDF_16BIT
:
1998 dwRet
= SendDriverMessage16(wmd
->hDrv
, wMsg
, dwParam1
, dwParam2
);
2000 case WINE_GDF_EXIST
:
2001 switch (res
= MCI_MapMsg16To32A(wmd
->wType
, wMsg
, &dwParam2
)) {
2002 case MCI_MAP_MSGERROR
:
2003 TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg
));
2004 dwRet
= MCIERR_DRIVER_INTERNAL
;
2007 TRACE("Problem mapping msg=%s from 16 to 32a\n", MCI_MessageToString(wMsg
));
2008 dwRet
= MCIERR_OUT_OF_MEMORY
;
2012 dwRet
= SendDriverMessage(wmd
->hDrv
, wMsg
, dwParam1
, dwParam2
);
2013 if (res
== MCI_MAP_OKMEM
)
2014 MCI_UnMapMsg16To32A(wmd
->wType
, wMsg
, dwParam2
);
2017 dwRet
= SendDriverMessage16(wmd
->hDrv
, wMsg
, dwParam1
, dwParam2
);
2022 WARN("Unknown driver %u\n", wmd
->hDrv
);
2023 dwRet
= MCIERR_DRIVER_INTERNAL
;
2029 /**************************************************************************
2030 * MCI_Open [internal]
2032 static DWORD
MCI_Open(DWORD dwParam
, LPMCI_OPEN_PARMSA lpParms
)
2034 char strDevTyp
[128];
2036 LPWINE_MCIDRIVER wmd
= NULL
;
2037 LPWINE_MM_IDATA iData
= MULTIMEDIA_GetIData();
2039 TRACE("(%08lX, %p)\n", dwParam
, lpParms
);
2040 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
2042 /* only two low bytes are generic, the other ones are dev type specific */
2043 #define WINE_MCIDRIVER_SUPP (0xFFFF0000|MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT| \
2044 MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID| \
2045 MCI_NOTIFY|MCI_WAIT)
2046 if ((dwParam
& ~WINE_MCIDRIVER_SUPP
) != 0) {
2047 FIXME("Unsupported yet dwFlags=%08lX\n", dwParam
& ~WINE_MCIDRIVER_SUPP
);
2049 #undef WINE_MCIDRIVER_SUPP
2053 if (dwParam
& MCI_OPEN_TYPE
) {
2054 if (dwParam
& MCI_OPEN_TYPE_ID
) {
2055 WORD uDevType
= LOWORD((DWORD
)lpParms
->lpstrDeviceType
);
2057 if (uDevType
< MCI_DEVTYPE_FIRST
||
2058 uDevType
> MCI_DEVTYPE_LAST
||
2059 !LoadStringA(iData
->hWinMM32Instance
, uDevType
, strDevTyp
, sizeof(strDevTyp
))) {
2060 dwRet
= MCIERR_BAD_INTEGER
;
2065 if (lpParms
->lpstrDeviceType
== NULL
) {
2066 dwRet
= MCIERR_NULL_PARAMETER_BLOCK
;
2069 strcpy(strDevTyp
, lpParms
->lpstrDeviceType
);
2070 ptr
= strchr(strDevTyp
, '!');
2072 /* this behavior is not documented in windows. However, since, in
2073 * some occasions, MCI_OPEN handling is translated by WinMM into
2074 * a call to mciSendString("open <type>"); this code shall be correct
2076 if (dwParam
& MCI_OPEN_ELEMENT
) {
2077 ERR("Both MCI_OPEN_ELEMENT(%s) and %s are used\n",
2078 lpParms
->lpstrElementName
, strDevTyp
);
2079 dwRet
= MCIERR_UNRECOGNIZED_KEYWORD
;
2082 dwParam
|= MCI_OPEN_ELEMENT
;
2084 /* FIXME: not a good idea to write in user supplied buffer */
2085 lpParms
->lpstrElementName
= ptr
;
2089 TRACE("devType='%s' !\n", strDevTyp
);
2092 if (dwParam
& MCI_OPEN_ELEMENT
) {
2093 TRACE("lpstrElementName='%s'\n", lpParms
->lpstrElementName
);
2095 if (dwParam
& MCI_OPEN_ELEMENT_ID
) {
2096 FIXME("Unsupported yet flag MCI_OPEN_ELEMENT_ID\n");
2097 dwRet
= MCIERR_UNRECOGNIZED_KEYWORD
;
2101 if (!lpParms
->lpstrElementName
) {
2102 dwRet
= MCIERR_NULL_PARAMETER_BLOCK
;
2106 /* type, if given as a parameter, supersedes file extension */
2107 if (!strDevTyp
[0] &&
2108 MCI_GetDevTypeFromFileName(lpParms
->lpstrElementName
,
2109 strDevTyp
, sizeof(strDevTyp
))) {
2110 if (GetDriveTypeA(lpParms
->lpstrElementName
) != DRIVE_CDROM
) {
2111 dwRet
= MCIERR_EXTENSION_NOT_FOUND
;
2114 /* FIXME: this will not work if several CDROM drives are installed on the machine */
2115 strcpy(strDevTyp
, "CDAUDIO");
2119 if (strDevTyp
[0] == 0) {
2120 FIXME("Couldn't load driver\n");
2121 dwRet
= MCIERR_INVALID_DEVICE_NAME
;
2125 if (dwParam
& MCI_OPEN_ALIAS
) {
2126 TRACE("Alias='%s' !\n", lpParms
->lpstrAlias
);
2127 if (!lpParms
->lpstrAlias
) {
2128 dwRet
= MCIERR_NULL_PARAMETER_BLOCK
;
2133 if ((dwRet
= MCI_LoadMciDriver(iData
, strDevTyp
, &wmd
))) {
2137 if ((dwRet
= MCI_FinishOpen(wmd
, lpParms
, dwParam
))) {
2138 TRACE("Failed to open driver (MCI_OPEN_DRIVER) [%08lx], closing\n", dwRet
);
2139 /* FIXME: is dwRet the correct ret code ? */
2143 /* only handled devices fall through */
2144 TRACE("wDevID=%04X wDeviceID=%d dwRet=%ld\n", wmd
->wDeviceID
, lpParms
->wDeviceID
, dwRet
);
2146 if (dwParam
& MCI_NOTIFY
)
2147 mciDriverNotify16(lpParms
->dwCallback
, wmd
->wDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
2151 if (wmd
) MCI_UnLoadMciDriver(iData
, wmd
);
2153 if (dwParam
& MCI_NOTIFY
)
2154 mciDriverNotify16(lpParms
->dwCallback
, 0, MCI_NOTIFY_FAILURE
);
2158 /**************************************************************************
2159 * MCI_Close [internal]
2161 static DWORD
MCI_Close(UINT16 wDevID
, DWORD dwParam
, LPMCI_GENERIC_PARMS lpParms
)
2164 LPWINE_MCIDRIVER wmd
;
2165 LPWINE_MM_IDATA iData
= MULTIMEDIA_GetIData();
2167 TRACE("(%04x, %08lX, %p)\n", wDevID
, dwParam
, lpParms
);
2169 if (wDevID
== MCI_ALL_DEVICE_ID
) {
2170 LPWINE_MCIDRIVER next
;
2172 EnterCriticalSection(&iData
->cs
);
2173 /* FIXME: shall I notify once after all is done, or for
2174 * each of the open drivers ? if the latest, which notif
2175 * to return when only one fails ?
2177 for (wmd
= iData
->lpMciDrvs
; wmd
; ) {
2179 MCI_Close(wmd
->wDeviceID
, dwParam
, lpParms
);
2182 LeaveCriticalSection(&iData
->cs
);
2186 if (!(wmd
= MCI_GetDriver(wDevID
))) {
2187 return MCIERR_INVALID_DEVICE_ID
;
2190 dwRet
= MCI_SendCommandFrom32(wDevID
, MCI_CLOSE_DRIVER
, dwParam
, (DWORD
)lpParms
);
2192 MCI_UnLoadMciDriver(iData
, wmd
);
2194 if (dwParam
& MCI_NOTIFY
)
2195 mciDriverNotify16(lpParms
->dwCallback
, wDevID
,
2196 (dwRet
== 0) ? MCI_NOTIFY_SUCCESSFUL
: MCI_NOTIFY_FAILURE
);
2201 /**************************************************************************
2202 * MCI_WriteString [internal]
2204 DWORD
MCI_WriteString(LPSTR lpDstStr
, DWORD dstSize
, LPCSTR lpSrcStr
)
2209 if (dstSize
<= strlen(lpSrcStr
)) {
2210 lstrcpynA(lpDstStr
, lpSrcStr
, dstSize
- 1);
2211 ret
= MCIERR_PARAM_OVERFLOW
;
2213 strcpy(lpDstStr
, lpSrcStr
);
2221 /**************************************************************************
2222 * MCI_Sysinfo [internal]
2224 static DWORD
MCI_SysInfo(UINT uDevID
, DWORD dwFlags
, LPMCI_SYSINFO_PARMSA lpParms
)
2226 DWORD ret
= MCIERR_INVALID_DEVICE_ID
;
2227 LPWINE_MCIDRIVER wmd
;
2228 LPWINE_MM_IDATA iData
= MULTIMEDIA_GetIData();
2230 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
2232 TRACE("(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n",
2233 uDevID
, dwFlags
, (DWORD
)lpParms
, lpParms
->dwNumber
, lpParms
->wDeviceType
);
2235 switch (dwFlags
& ~MCI_SYSINFO_OPEN
) {
2236 case MCI_SYSINFO_QUANTITY
:
2240 if (lpParms
->wDeviceType
< MCI_DEVTYPE_FIRST
||
2241 lpParms
->wDeviceType
> MCI_DEVTYPE_LAST
) {
2242 if (dwFlags
& MCI_SYSINFO_OPEN
) {
2243 TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
2244 EnterCriticalSection(&iData
->cs
);
2245 for (wmd
= iData
->lpMciDrvs
; wmd
; wmd
= wmd
->lpNext
) {
2248 LeaveCriticalSection(&iData
->cs
);
2250 TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
2251 cnt
= MCI_InstalledCount
;
2254 if (dwFlags
& MCI_SYSINFO_OPEN
) {
2255 TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n",
2256 lpParms
->wDeviceType
);
2257 EnterCriticalSection(&iData
->cs
);
2258 for (wmd
= iData
->lpMciDrvs
; wmd
; wmd
= wmd
->lpNext
) {
2259 if (wmd
->wType
== lpParms
->wDeviceType
)
2262 LeaveCriticalSection(&iData
->cs
);
2264 TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n",
2265 lpParms
->wDeviceType
);
2266 FIXME("Don't know how to get # of MCI devices of a given type\n");
2270 *(DWORD
*)lpParms
->lpstrReturn
= cnt
;
2272 TRACE("(%ld) => '%ld'\n", lpParms
->dwNumber
, *(DWORD
*)lpParms
->lpstrReturn
);
2273 ret
= MCI_INTEGER_RETURNED
;
2275 case MCI_SYSINFO_INSTALLNAME
:
2276 TRACE("MCI_SYSINFO_INSTALLNAME \n");
2277 if ((wmd
= MCI_GetDriver(uDevID
))) {
2278 ret
= MCI_WriteString(lpParms
->lpstrReturn
, lpParms
->dwRetSize
,
2279 wmd
->lpstrDeviceType
);
2281 *lpParms
->lpstrReturn
= 0;
2282 ret
= MCIERR_INVALID_DEVICE_ID
;
2284 TRACE("(%ld) => '%s'\n", lpParms
->dwNumber
, lpParms
->lpstrReturn
);
2286 case MCI_SYSINFO_NAME
:
2287 TRACE("MCI_SYSINFO_NAME\n");
2288 if (dwFlags
& MCI_SYSINFO_OPEN
) {
2289 FIXME("Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n");
2290 ret
= MCIERR_UNRECOGNIZED_COMMAND
;
2291 } else if (lpParms
->dwNumber
> MCI_InstalledCount
) {
2292 ret
= MCIERR_OUTOFRANGE
;
2294 DWORD count
= lpParms
->dwNumber
;
2295 LPSTR ptr
= MCI_lpInstallNames
;
2297 while (--count
> 0) ptr
+= strlen(ptr
) + 1;
2298 ret
= MCI_WriteString(lpParms
->lpstrReturn
, lpParms
->dwRetSize
, ptr
);
2300 TRACE("(%ld) => '%s'\n", lpParms
->dwNumber
, lpParms
->lpstrReturn
);
2303 TRACE("Unsupported flag value=%08lx\n", dwFlags
);
2304 ret
= MCIERR_UNRECOGNIZED_COMMAND
;
2309 /**************************************************************************
2310 * MCI_Break [internal]
2312 static DWORD
MCI_Break(UINT wDevID
, DWORD dwFlags
, LPMCI_BREAK_PARMS lpParms
)
2316 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
2318 if (dwFlags
& MCI_NOTIFY
)
2319 mciDriverNotify16(lpParms
->dwCallback
, wDevID
,
2320 (dwRet
== 0) ? MCI_NOTIFY_SUCCESSFUL
: MCI_NOTIFY_FAILURE
);
2325 /**************************************************************************
2326 * MCI_SendCommand [internal]
2328 DWORD
MCI_SendCommand(UINT wDevID
, UINT16 wMsg
, DWORD dwParam1
,
2329 DWORD dwParam2
, BOOL bFrom32
)
2331 DWORD dwRet
= MCIERR_UNRECOGNIZED_COMMAND
;
2336 dwRet
= MCI_Open(dwParam1
, (LPMCI_OPEN_PARMSA
)dwParam2
);
2338 switch (MCI_MapMsg16To32A(0, wMsg
, &dwParam2
)) {
2341 dwRet
= MCI_Open(dwParam1
, (LPMCI_OPEN_PARMSA
)dwParam2
);
2342 MCI_UnMapMsg16To32A(0, wMsg
, dwParam2
);
2344 default: break; /* so that gcc does not bark */
2350 dwRet
= MCI_Close(wDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
2352 switch (MCI_MapMsg16To32A(0, wMsg
, &dwParam2
)) {
2355 dwRet
= MCI_Close(wDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
2356 MCI_UnMapMsg16To32A(0, wMsg
, dwParam2
);
2358 default: break; /* so that gcc does not bark */
2364 dwRet
= MCI_SysInfo(wDevID
, dwParam1
, (LPMCI_SYSINFO_PARMSA
)dwParam2
);
2366 switch (MCI_MapMsg16To32A(0, wMsg
, &dwParam2
)) {
2369 dwRet
= MCI_SysInfo(wDevID
, dwParam1
, (LPMCI_SYSINFO_PARMSA
)dwParam2
);
2370 MCI_UnMapMsg16To32A(0, wMsg
, dwParam2
);
2372 default: break; /* so that gcc doesnot bark */
2378 dwRet
= MCI_Break(wDevID
, dwParam1
, (LPMCI_BREAK_PARMS
)dwParam2
);
2380 switch (MCI_MapMsg16To32A(0, wMsg
, &dwParam2
)) {
2383 dwRet
= MCI_Break(wDevID
, dwParam1
, (LPMCI_BREAK_PARMS
)dwParam2
);
2384 MCI_UnMapMsg16To32A(0, wMsg
, dwParam2
);
2386 default: break; /* so that gcc does not bark */
2391 /* FIXME: it seems that MCI_SOUND needs the same handling as MCI_BREAK
2392 * but I couldn't get any doc on this MCI message
2396 if (wDevID
== MCI_ALL_DEVICE_ID
) {
2397 FIXME("unhandled MCI_ALL_DEVICE_ID\n");
2398 dwRet
= MCIERR_CANNOT_USE_ALL
;
2401 MCI_SendCommandFrom32(wDevID
, wMsg
, dwParam1
, dwParam2
) :
2402 MCI_SendCommandFrom16(wDevID
, wMsg
, dwParam1
, dwParam2
);
2409 /**************************************************************************
2410 * MCI_CleanUp [internal]
2412 * Some MCI commands need to be cleaned-up (when not called from
2413 * mciSendString), because MCI drivers return extra information for string
2414 * transformation. This function gets rid of them.
2416 LRESULT
MCI_CleanUp(LRESULT dwRet
, UINT wMsg
, DWORD dwParam2
, BOOL bIs32
)
2419 return LOWORD(dwRet
);
2422 case MCI_GETDEVCAPS
:
2423 switch (dwRet
& 0xFFFF0000ul
) {
2425 case MCI_COLONIZED3_RETURN
:
2426 case MCI_COLONIZED4_RETURN
:
2427 case MCI_INTEGER_RETURNED
:
2430 case MCI_RESOURCE_RETURNED
:
2431 case MCI_RESOURCE_RETURNED
|MCI_RESOURCE_DRIVER
:
2433 LPMCI_GETDEVCAPS_PARMS lmgp
;
2435 lmgp
= (LPMCI_GETDEVCAPS_PARMS
)(bIs32
? (void*)dwParam2
: PTR_SEG_TO_LIN(dwParam2
));
2436 TRACE("Changing %08lx to %08lx\n", lmgp
->dwReturn
, (DWORD
)LOWORD(lmgp
->dwReturn
));
2437 lmgp
->dwReturn
= LOWORD(lmgp
->dwReturn
);
2441 FIXME("Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2442 HIWORD(dwRet
), MCI_MessageToString(wMsg
));
2446 switch (dwRet
& 0xFFFF0000ul
) {
2448 case MCI_COLONIZED3_RETURN
:
2449 case MCI_COLONIZED4_RETURN
:
2450 case MCI_INTEGER_RETURNED
:
2453 case MCI_RESOURCE_RETURNED
:
2454 case MCI_RESOURCE_RETURNED
|MCI_RESOURCE_DRIVER
:
2456 LPMCI_STATUS_PARMS lsp
;
2458 lsp
= (LPMCI_STATUS_PARMS
)(bIs32
? (void*)dwParam2
: PTR_SEG_TO_LIN(dwParam2
));
2459 TRACE("Changing %08lx to %08lx\n", lsp
->dwReturn
, (DWORD
)LOWORD(lsp
->dwReturn
));
2460 lsp
->dwReturn
= LOWORD(lsp
->dwReturn
);
2464 FIXME("Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2465 HIWORD(dwRet
), MCI_MessageToString(wMsg
));
2469 switch (dwRet
& 0xFFFF0000ul
) {
2471 case MCI_INTEGER_RETURNED
:
2475 FIXME("Unsupported value for hiword (%04x)\n", HIWORD(dwRet
));
2479 if (HIWORD(dwRet
)) {
2480 FIXME("Got non null hiword for dwRet=0x%08lx for command %s\n",
2481 dwRet
, MCI_MessageToString(wMsg
));
2485 return LOWORD(dwRet
);
2488 /**************************************************************************
2489 * MULTIMEDIA_MciInit [internal]
2491 * Initializes the MCI internal variables.
2494 BOOL
MULTIMEDIA_MciInit(void)
2503 MCI_InstalledCount
= 0;
2504 ptr1
= MCI_lpInstallNames
= HeapAlloc(GetProcessHeap(), 0, count
);
2506 if (!MCI_lpInstallNames
)
2509 /* FIXME: should do also some registry diving here ? */
2510 if (!(err
= RegOpenKeyA(HKEY_LOCAL_MACHINE
, "Software\\Wine\\Wine\\Config", &hWineConf
)) &&
2511 !(err
= RegOpenKeyA(hWineConf
, "options", &hkey
))) {
2512 err
= RegQueryValueExA(hkey
, "mci", 0, &type
, MCI_lpInstallNames
, &count
);
2517 TRACE("Wine => '%s' \n", ptr1
);
2518 while ((ptr2
= strchr(ptr1
, ':')) != 0) {
2520 TRACE("---> '%s' \n", ptr1
);
2521 MCI_InstalledCount
++;
2524 MCI_InstalledCount
++;
2525 TRACE("---> '%s' \n", ptr1
);
2526 ptr1
+= strlen(ptr1
) + 1;
2528 GetPrivateProfileStringA("mci", NULL
, "", MCI_lpInstallNames
, count
, "SYSTEM.INI");
2529 while (strlen(ptr1
) > 0) {
2530 TRACE("---> '%s' \n", ptr1
);
2531 ptr1
+= strlen(ptr1
) + 1;
2532 MCI_InstalledCount
++;
2535 RegCloseKey(hWineConf
);