2 * MCI internal functions
4 * Copyright 1998/1999 Eric Pouech
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 * - implement WINMM (32bit) multitasking and use it in all MCI drivers
23 * instead of the home grown one
24 * - 16bit mmTaskXXX functions are currently broken because the 16
25 * loader does not support binary command lines => provide Wine's
26 * own mmtask.tsk not using binary command line.
27 * - correctly handle the MCI_ALL_DEVICE_ID in functions.
28 * - finish mapping 16 <=> 32 of MCI structures and commands
29 * - implement auto-open feature (ie, when a string command is issued
30 * for a not yet opened device, MCI automatically opens it)
31 * - use a default registry setting to replace the [mci] section in
32 * configuration file (layout of info in registry should be compatible
33 * with all Windows' version - which use different layouts of course)
34 * - implement automatic open
35 * + only works on string interface, on regular devices (don't work on all
37 * - command table handling isn't thread safe
40 /* to be cross checked:
41 * - heapalloc for *sizeof(WCHAR) when needed
42 * - size of string in WCHAR or bytes? (#chars for MCI_INFO, #bytes for MCI_SYSINFO)
46 #include "wine/port.h"
66 #include "wine/debug.h"
67 #include "wine/unicode.h"
69 WINE_DEFAULT_DEBUG_CHANNEL(mci
);
71 WINMM_MapType (*pFnMciMapMsg16To32W
) (WORD
,WORD
,DWORD
,DWORD_PTR
*) = NULL
;
72 WINMM_MapType (*pFnMciUnMapMsg16To32W
)(WORD
,WORD
,DWORD
,DWORD_PTR
) = NULL
;
73 WINMM_MapType (*pFnMciMapMsg32WTo16
) (WORD
,WORD
,DWORD
,DWORD_PTR
*) = NULL
;
74 WINMM_MapType (*pFnMciUnMapMsg32WTo16
)(WORD
,WORD
,DWORD
,DWORD_PTR
) = NULL
;
76 /* First MCI valid device ID (0 means error) */
77 #define MCI_MAGIC 0x0001
80 static const WCHAR wszHklmMci
[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','M','C','I',0};
81 static const WCHAR wszNull
[] = {0};
82 static const WCHAR wszAll
[] = {'A','L','L',0};
83 static const WCHAR wszMci
[] = {'M','C','I',0};
84 static const WCHAR wszOpen
[] = {'o','p','e','n',0};
85 static const WCHAR wszSystemIni
[] = {'s','y','s','t','e','m','.','i','n','i',0};
87 /* dup a string and uppercase it */
88 inline static LPWSTR
str_dup_upper( LPCWSTR str
)
90 INT len
= (strlenW(str
) + 1) * sizeof(WCHAR
);
91 LPWSTR p
= HeapAlloc( GetProcessHeap(), 0, len
);
94 memcpy( p
, str
, len
);
100 /**************************************************************************
101 * MCI_GetDriver [internal]
103 LPWINE_MCIDRIVER
MCI_GetDriver(UINT16 wDevID
)
105 LPWINE_MCIDRIVER wmd
= 0;
107 EnterCriticalSection(&WINMM_IData
.cs
);
108 for (wmd
= WINMM_IData
.lpMciDrvs
; wmd
; wmd
= wmd
->lpNext
) {
109 if (wmd
->wDeviceID
== wDevID
)
112 LeaveCriticalSection(&WINMM_IData
.cs
);
116 /**************************************************************************
117 * MCI_GetDriverFromString [internal]
119 UINT
MCI_GetDriverFromString(LPCWSTR lpstrName
)
121 LPWINE_MCIDRIVER wmd
;
127 if (!strcmpiW(lpstrName
, wszAll
))
128 return MCI_ALL_DEVICE_ID
;
130 EnterCriticalSection(&WINMM_IData
.cs
);
131 for (wmd
= WINMM_IData
.lpMciDrvs
; wmd
; wmd
= wmd
->lpNext
) {
132 if (wmd
->lpstrElementName
&& strcmpW(wmd
->lpstrElementName
, lpstrName
) == 0) {
133 ret
= wmd
->wDeviceID
;
136 if (wmd
->lpstrDeviceType
&& strcmpiW(wmd
->lpstrDeviceType
, lpstrName
) == 0) {
137 ret
= wmd
->wDeviceID
;
140 if (wmd
->lpstrAlias
&& strcmpiW(wmd
->lpstrAlias
, lpstrName
) == 0) {
141 ret
= wmd
->wDeviceID
;
145 LeaveCriticalSection(&WINMM_IData
.cs
);
150 /**************************************************************************
151 * MCI_MessageToString [internal]
153 const char* MCI_MessageToString(UINT wMsg
)
155 static char buffer
[100];
157 #define CASE(s) case (s): return #s
167 CASE(DRV_QUERYCONFIGURE
);
170 CASE(DRV_EXITSESSION
);
171 CASE(DRV_EXITAPPLICATION
);
175 CASE(MCI_CLOSE_DRIVER
);
184 CASE(MCI_GETDEVCAPS
);
188 CASE(MCI_OPEN_DRIVER
);
206 /* constants for digital video */
220 sprintf(buffer
, "MCI_<<%04X>>", wMsg
);
225 LPWSTR
MCI_strdupAtoW( LPCSTR str
)
230 if (!str
) return NULL
;
231 len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
232 ret
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
233 if (ret
) MultiByteToWideChar( CP_ACP
, 0, str
, -1, ret
, len
);
237 LPSTR
MCI_strdupWtoA( LPCWSTR str
)
242 if (!str
) return NULL
;
243 len
= WideCharToMultiByte( CP_ACP
, 0, str
, -1, NULL
, 0, NULL
, NULL
);
244 ret
= HeapAlloc( GetProcessHeap(), 0, len
);
245 if (ret
) WideCharToMultiByte( CP_ACP
, 0, str
, -1, ret
, len
, NULL
, NULL
);
249 static int MCI_MapMsgAtoW(UINT msg
, DWORD_PTR dwParam1
, DWORD_PTR
*dwParam2
)
251 if (msg
< DRV_RESERVED
) return 0;
290 MCI_OPEN_PARMSA
*mci_openA
= (MCI_OPEN_PARMSA
*)*dwParam2
;
291 MCI_OPEN_PARMSW
*mci_openW
;
294 ptr
= HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD_PTR
) + sizeof(*mci_openW
) + 2 * sizeof(DWORD
));
297 *ptr
++ = *dwParam2
; /* save the previous pointer */
298 *dwParam2
= (DWORD_PTR
)ptr
;
299 mci_openW
= (MCI_OPEN_PARMSW
*)ptr
;
301 if (dwParam1
& MCI_NOTIFY
)
302 mci_openW
->dwCallback
= mci_openA
->dwCallback
;
304 if (dwParam1
& MCI_OPEN_TYPE
)
306 if (dwParam1
& MCI_OPEN_TYPE_ID
)
307 mci_openW
->lpstrDeviceType
= (LPCWSTR
)mci_openA
->lpstrDeviceType
;
309 mci_openW
->lpstrDeviceType
= MCI_strdupAtoW(mci_openA
->lpstrDeviceType
);
311 if (dwParam1
& MCI_OPEN_ELEMENT
)
313 if (dwParam1
& MCI_OPEN_ELEMENT_ID
)
314 mci_openW
->lpstrElementName
= (LPCWSTR
)mci_openA
->lpstrElementName
;
316 mci_openW
->lpstrElementName
= MCI_strdupAtoW(mci_openA
->lpstrElementName
);
318 if (dwParam1
& MCI_OPEN_ALIAS
)
319 mci_openW
->lpstrAlias
= MCI_strdupAtoW(mci_openA
->lpstrAlias
);
320 /* FIXME: this is only needed for specific types of MCI devices, and
321 * may cause a segfault if the two DWORD:s don't exist at the end of
324 memcpy(mci_openW
+ 1, mci_openA
+ 1, 2 * sizeof(DWORD
));
329 if (dwParam1
& MCI_ANIM_WINDOW_TEXT
)
331 MCI_ANIM_WINDOW_PARMSA
*mci_windowA
= (MCI_ANIM_WINDOW_PARMSA
*)*dwParam2
;
332 MCI_ANIM_WINDOW_PARMSW
*mci_windowW
;
334 mci_windowW
= HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_windowW
));
335 if (!mci_windowW
) return -1;
337 *dwParam2
= (DWORD_PTR
)mci_windowW
;
339 mci_windowW
->lpstrText
= MCI_strdupAtoW(mci_windowA
->lpstrText
);
341 if (dwParam1
& MCI_NOTIFY
)
342 mci_windowW
->dwCallback
= mci_windowA
->dwCallback
;
343 if (dwParam1
& MCI_ANIM_WINDOW_HWND
)
344 mci_windowW
->hWnd
= mci_windowA
->hWnd
;
345 if (dwParam1
& MCI_ANIM_WINDOW_STATE
)
346 mci_windowW
->nCmdShow
= mci_windowA
->nCmdShow
;
354 MCI_SYSINFO_PARMSA
*mci_sysinfoA
= (MCI_SYSINFO_PARMSA
*)*dwParam2
;
355 MCI_SYSINFO_PARMSW
*mci_sysinfoW
;
358 ptr
= HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_sysinfoW
) + sizeof(DWORD_PTR
));
361 *ptr
++ = *dwParam2
; /* save the previous pointer */
362 *dwParam2
= (DWORD_PTR
)ptr
;
363 mci_sysinfoW
= (MCI_SYSINFO_PARMSW
*)ptr
;
365 if (dwParam1
& MCI_NOTIFY
)
366 mci_sysinfoW
->dwCallback
= mci_sysinfoA
->dwCallback
;
368 mci_sysinfoW
->dwRetSize
= mci_sysinfoA
->dwRetSize
;
369 mci_sysinfoW
->lpstrReturn
= HeapAlloc(GetProcessHeap(), 0, mci_sysinfoW
->dwRetSize
);
370 mci_sysinfoW
->dwNumber
= mci_sysinfoA
->dwNumber
;
371 mci_sysinfoW
->wDeviceType
= mci_sysinfoA
->wDeviceType
;
376 MCI_INFO_PARMSA
*mci_infoA
= (MCI_INFO_PARMSA
*)*dwParam2
;
377 MCI_INFO_PARMSW
*mci_infoW
;
380 ptr
= HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_infoW
) + sizeof(DWORD_PTR
));
383 *ptr
++ = *dwParam2
; /* save the previous pointer */
384 *dwParam2
= (DWORD_PTR
)ptr
;
385 mci_infoW
= (MCI_INFO_PARMSW
*)ptr
;
387 if (dwParam1
& MCI_NOTIFY
)
388 mci_infoW
->dwCallback
= mci_infoA
->dwCallback
;
390 mci_infoW
->dwRetSize
= mci_infoA
->dwRetSize
* sizeof(WCHAR
); /* it's not the same as SYSINFO !!! */
391 mci_infoW
->lpstrReturn
= HeapAlloc(GetProcessHeap(), 0, mci_infoW
->dwRetSize
);
396 MCI_SAVE_PARMSA
*mci_saveA
= (MCI_SAVE_PARMSA
*)*dwParam2
;
397 MCI_SAVE_PARMSW
*mci_saveW
;
399 mci_saveW
= HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_saveW
));
400 if (!mci_saveW
) return -1;
402 *dwParam2
= (DWORD_PTR
)mci_saveW
;
403 if (dwParam1
& MCI_NOTIFY
)
404 mci_saveW
->dwCallback
= mci_saveA
->dwCallback
;
405 mci_saveW
->lpfilename
= MCI_strdupAtoW(mci_saveA
->lpfilename
);
410 MCI_LOAD_PARMSA
*mci_loadA
= (MCI_LOAD_PARMSA
*)*dwParam2
;
411 MCI_LOAD_PARMSW
*mci_loadW
;
413 mci_loadW
= HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_loadW
));
414 if (!mci_loadW
) return -1;
416 *dwParam2
= (DWORD_PTR
)mci_loadW
;
417 if (dwParam1
& MCI_NOTIFY
)
418 mci_loadW
->dwCallback
= mci_loadA
->dwCallback
;
419 mci_loadW
->lpfilename
= MCI_strdupAtoW(mci_loadA
->lpfilename
);
425 MCI_VD_ESCAPE_PARMSA
*mci_vd_escapeA
= (MCI_VD_ESCAPE_PARMSA
*)*dwParam2
;
426 MCI_VD_ESCAPE_PARMSW
*mci_vd_escapeW
;
428 mci_vd_escapeW
= HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_vd_escapeW
));
429 if (!mci_vd_escapeW
) return -1;
431 *dwParam2
= (DWORD_PTR
)mci_vd_escapeW
;
432 if (dwParam1
& MCI_NOTIFY
)
433 mci_vd_escapeW
->dwCallback
= mci_vd_escapeA
->dwCallback
;
434 mci_vd_escapeW
->lpstrCommand
= MCI_strdupAtoW(mci_vd_escapeA
->lpstrCommand
);
438 FIXME("Message %s needs translation\n", MCI_MessageToString(msg
));
443 static DWORD
MCI_UnmapMsgAtoW(UINT msg
, DWORD_PTR dwParam1
, DWORD_PTR dwParam2
,
450 DWORD_PTR
*ptr
= (DWORD_PTR
*)dwParam2
- 1;
451 MCI_OPEN_PARMSA
*mci_openA
= (MCI_OPEN_PARMSA
*)*ptr
;
452 MCI_OPEN_PARMSW
*mci_openW
= (MCI_OPEN_PARMSW
*)(ptr
+ 1);
454 mci_openA
->wDeviceID
= mci_openW
->wDeviceID
;
456 if (dwParam1
& MCI_OPEN_TYPE
)
458 if (!(dwParam1
& MCI_OPEN_TYPE_ID
))
459 HeapFree(GetProcessHeap(), 0, (LPWSTR
)mci_openW
->lpstrDeviceType
);
461 if (dwParam1
& MCI_OPEN_ELEMENT
)
463 if (!(dwParam1
& MCI_OPEN_ELEMENT_ID
))
464 HeapFree(GetProcessHeap(), 0, (LPWSTR
)mci_openW
->lpstrElementName
);
466 if (dwParam1
& MCI_OPEN_ALIAS
)
467 HeapFree(GetProcessHeap(), 0, (LPWSTR
)mci_openW
->lpstrAlias
);
468 HeapFree(GetProcessHeap(), 0, ptr
);
472 if (dwParam1
& MCI_ANIM_WINDOW_TEXT
)
474 MCI_ANIM_WINDOW_PARMSW
*mci_windowW
= (MCI_ANIM_WINDOW_PARMSW
*)dwParam2
;
476 HeapFree(GetProcessHeap(), 0, (void*)mci_windowW
->lpstrText
);
477 HeapFree(GetProcessHeap(), 0, mci_windowW
);
483 DWORD_PTR
*ptr
= (DWORD_PTR
*)dwParam2
- 1;
484 MCI_SYSINFO_PARMSA
*mci_sysinfoA
= (MCI_SYSINFO_PARMSA
*)*ptr
;
485 MCI_SYSINFO_PARMSW
*mci_sysinfoW
= (MCI_SYSINFO_PARMSW
*)(ptr
+ 1);
489 mci_sysinfoA
->dwNumber
= mci_sysinfoW
->dwNumber
;
490 mci_sysinfoA
->wDeviceType
= mci_sysinfoW
->wDeviceType
;
491 if (dwParam1
& MCI_SYSINFO_QUANTITY
)
492 *(DWORD
*)mci_sysinfoA
->lpstrReturn
= *(DWORD
*)mci_sysinfoW
->lpstrReturn
;
494 WideCharToMultiByte(CP_ACP
, 0,
495 mci_sysinfoW
->lpstrReturn
, mci_sysinfoW
->dwRetSize
,
496 mci_sysinfoA
->lpstrReturn
, mci_sysinfoA
->dwRetSize
,
500 HeapFree(GetProcessHeap(), 0, mci_sysinfoW
->lpstrReturn
);
501 HeapFree(GetProcessHeap(), 0, ptr
);
506 DWORD_PTR
*ptr
= (DWORD_PTR
*)dwParam2
- 1;
507 MCI_INFO_PARMSA
*mci_infoA
= (MCI_INFO_PARMSA
*)*ptr
;
508 MCI_INFO_PARMSW
*mci_infoW
= (MCI_INFO_PARMSW
*)(ptr
+ 1);
512 WideCharToMultiByte(CP_ACP
, 0,
513 mci_infoW
->lpstrReturn
, mci_infoW
->dwRetSize
/ sizeof(WCHAR
),
514 mci_infoA
->lpstrReturn
, mci_infoA
->dwRetSize
,
518 HeapFree(GetProcessHeap(), 0, mci_infoW
->lpstrReturn
);
519 HeapFree(GetProcessHeap(), 0, ptr
);
524 MCI_SAVE_PARMSW
*mci_saveW
= (MCI_SAVE_PARMSW
*)dwParam2
;
526 HeapFree(GetProcessHeap(), 0, (void*)mci_saveW
->lpfilename
);
527 HeapFree(GetProcessHeap(), 0, mci_saveW
);
532 MCI_LOAD_PARMSW
*mci_loadW
= (MCI_LOAD_PARMSW
*)dwParam2
;
534 HeapFree(GetProcessHeap(), 0, (void*)mci_loadW
->lpfilename
);
535 HeapFree(GetProcessHeap(), 0, mci_loadW
);
540 MCI_VD_ESCAPE_PARMSW
*mci_vd_escapeW
= (MCI_VD_ESCAPE_PARMSW
*)dwParam2
;
542 HeapFree(GetProcessHeap(), 0, (void*)mci_vd_escapeW
->lpstrCommand
);
543 HeapFree(GetProcessHeap(), 0, mci_vd_escapeW
);
548 FIXME("Message %s needs unmapping\n", MCI_MessageToString(msg
));
555 /**************************************************************************
556 * MCI_GetDevTypeFromFileName [internal]
558 static DWORD
MCI_GetDevTypeFromFileName(LPCWSTR fileName
, LPWSTR buf
, UINT len
)
562 static const WCHAR keyW
[] = {'S','O','F','T','W','A','R','E','\\','M','i','c','r','o','s','o','f','t','\\',
563 'W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
564 'M','C','I',' ','E','x','t','e','n','s','i','o','n','s',0};
565 if ((tmp
= strrchrW(fileName
, '.'))) {
566 if (RegOpenKeyExW( HKEY_LOCAL_MACHINE
, keyW
,
567 0, KEY_QUERY_VALUE
, &hKey
) == ERROR_SUCCESS
) {
569 LONG lRet
= RegQueryValueExW( hKey
, tmp
+ 1, 0, 0, (void*)buf
, &dwLen
);
571 if (lRet
== ERROR_SUCCESS
) return 0;
573 TRACE("No ...\\MCI Extensions entry for %s found.\n", debugstr_w(tmp
));
575 return MCIERR_EXTENSION_NOT_FOUND
;
578 #define MAX_MCICMDTABLE 20
579 #define MCI_COMMAND_TABLE_NOT_LOADED 0xFFFE
581 typedef struct tagWINE_MCICMDTABLE
{
584 UINT nVerbs
; /* number of verbs in command table */
585 LPCWSTR
* aVerbs
; /* array of verbs to speed up the verb look up process */
586 } WINE_MCICMDTABLE
, *LPWINE_MCICMDTABLE
;
588 static WINE_MCICMDTABLE S_MciCmdTable
[MAX_MCICMDTABLE
];
590 /**************************************************************************
591 * MCI_IsCommandTableValid [internal]
593 static BOOL
MCI_IsCommandTableValid(UINT uTbl
)
602 TRACE("Dumping cmdTbl=%d [lpTable=%p devType=%d]\n",
603 uTbl
, S_MciCmdTable
[uTbl
].lpTable
, S_MciCmdTable
[uTbl
].uDevType
);
605 if (uTbl
>= MAX_MCICMDTABLE
|| !S_MciCmdTable
[uTbl
].lpTable
)
608 lmem
= S_MciCmdTable
[uTbl
].lpTable
;
611 lmem
+= (strlenW(str
) + 1) * sizeof(WCHAR
);
612 flg
= *(const DWORD
*)lmem
;
613 eid
= *(const WORD
*)(lmem
+ sizeof(DWORD
));
614 lmem
+= sizeof(DWORD
) + sizeof(WORD
);
616 /* TRACE("cmd=%s %08lx %04x\n", debugstr_w(str), flg, eid); */
618 case MCI_COMMAND_HEAD
: if (!*str
|| !flg
) return FALSE
; idx
= 0; break; /* check unicity of str in table */
619 case MCI_STRING
: if (inCst
) return FALSE
; break;
620 case MCI_INTEGER
: if (!*str
) return FALSE
; break;
621 case MCI_END_COMMAND
: if (*str
|| flg
|| idx
== 0) return FALSE
; idx
= 0; break;
622 case MCI_RETURN
: if (*str
|| idx
!= 1) return FALSE
; break;
623 case MCI_FLAG
: if (!*str
) return FALSE
; break;
624 case MCI_END_COMMAND_LIST
: if (*str
|| flg
) return FALSE
; idx
= 0; break;
625 case MCI_RECT
: if (!*str
|| inCst
) return FALSE
; break;
626 case MCI_CONSTANT
: if (inCst
) return FALSE
; inCst
= TRUE
; break;
627 case MCI_END_CONSTANT
: if (*str
|| flg
|| !inCst
) return FALSE
; inCst
= FALSE
; break;
628 default: return FALSE
;
630 } while (eid
!= MCI_END_COMMAND_LIST
);
634 /**************************************************************************
635 * MCI_DumpCommandTable [internal]
637 static BOOL
MCI_DumpCommandTable(UINT uTbl
)
644 if (!MCI_IsCommandTableValid(uTbl
)) {
645 ERR("Ooops: %d is not valid\n", uTbl
);
649 lmem
= S_MciCmdTable
[uTbl
].lpTable
;
653 lmem
+= (strlenW(str
) + 1) * sizeof(WCHAR
);
654 flg
= *(const DWORD
*)lmem
;
655 eid
= *(const WORD
*)(lmem
+ sizeof(DWORD
));
656 /* TRACE("cmd=%s %08lx %04x\n", debugstr_w(str), flg, eid); */
657 lmem
+= sizeof(DWORD
) + sizeof(WORD
);
658 } while (eid
!= MCI_END_COMMAND
&& eid
!= MCI_END_COMMAND_LIST
);
659 /* EPP TRACE(" => end of command%s\n", (eid == MCI_END_COMMAND_LIST) ? " list" : ""); */
660 } while (eid
!= MCI_END_COMMAND_LIST
);
665 /**************************************************************************
666 * MCI_GetCommandTable [internal]
668 static UINT
MCI_GetCommandTable(UINT uDevType
)
674 /* first look up existing for existing devType */
675 for (uTbl
= 0; uTbl
< MAX_MCICMDTABLE
; uTbl
++) {
676 if (S_MciCmdTable
[uTbl
].lpTable
&& S_MciCmdTable
[uTbl
].uDevType
== uDevType
)
680 /* well try to load id */
681 if (uDevType
>= MCI_DEVTYPE_FIRST
&& uDevType
<= MCI_DEVTYPE_LAST
) {
682 if (LoadStringW(WINMM_IData
.hWinMM32Instance
, uDevType
, buf
, sizeof(buf
) / sizeof(WCHAR
))) {
685 } else if (uDevType
== 0) {
686 static const WCHAR wszCore
[] = {'C','O','R','E',0};
689 uTbl
= MCI_NO_COMMAND_TABLE
;
691 HRSRC hRsrc
= FindResourceW(WINMM_IData
.hWinMM32Instance
, str
, (LPCWSTR
)RT_RCDATA
);
694 if (hRsrc
) hMem
= LoadResource(WINMM_IData
.hWinMM32Instance
, hRsrc
);
696 uTbl
= MCI_SetCommandTable(LockResource(hMem
), uDevType
);
698 WARN("No command table found in resource %p[%s]\n",
699 WINMM_IData
.hWinMM32Instance
, debugstr_w(str
));
702 TRACE("=> %d\n", uTbl
);
706 /**************************************************************************
707 * MCI_SetCommandTable [internal]
709 UINT
MCI_SetCommandTable(void *table
, UINT uDevType
)
712 static BOOL bInitDone
= FALSE
;
715 * The CORE command table must be loaded first, so that MCI_GetCommandTable()
716 * can be called with 0 as a uDevType to retrieve it.
721 MCI_GetCommandTable(0);
723 TRACE("(%p, %u)\n", table
, uDevType
);
724 for (uTbl
= 0; uTbl
< MAX_MCICMDTABLE
; uTbl
++) {
725 if (!S_MciCmdTable
[uTbl
].lpTable
) {
731 S_MciCmdTable
[uTbl
].uDevType
= uDevType
;
732 S_MciCmdTable
[uTbl
].lpTable
= table
;
735 MCI_DumpCommandTable(uTbl
);
738 /* create the verbs table */
739 /* get # of entries */
740 lmem
= S_MciCmdTable
[uTbl
].lpTable
;
744 lmem
+= (strlenW(str
) + 1) * sizeof(WCHAR
);
745 eid
= *(const WORD
*)(lmem
+ sizeof(DWORD
));
746 lmem
+= sizeof(DWORD
) + sizeof(WORD
);
747 if (eid
== MCI_COMMAND_HEAD
)
749 } while (eid
!= MCI_END_COMMAND_LIST
);
751 S_MciCmdTable
[uTbl
].aVerbs
= HeapAlloc(GetProcessHeap(), 0, count
* sizeof(LPCWSTR
));
752 S_MciCmdTable
[uTbl
].nVerbs
= count
;
754 lmem
= S_MciCmdTable
[uTbl
].lpTable
;
758 lmem
+= (strlenW(str
) + 1) * sizeof(WCHAR
);
759 eid
= *(const WORD
*)(lmem
+ sizeof(DWORD
));
760 lmem
+= sizeof(DWORD
) + sizeof(WORD
);
761 if (eid
== MCI_COMMAND_HEAD
)
762 S_MciCmdTable
[uTbl
].aVerbs
[count
++] = str
;
763 } while (eid
!= MCI_END_COMMAND_LIST
);
764 /* assert(count == S_MciCmdTable[uTbl].nVerbs); */
769 return MCI_NO_COMMAND_TABLE
;
772 /**************************************************************************
773 * MCI_DeleteCommandTable [internal]
775 BOOL
MCI_DeleteCommandTable(UINT uTbl
, BOOL
delete)
777 if (uTbl
>= MAX_MCICMDTABLE
|| !S_MciCmdTable
[uTbl
].lpTable
)
780 if (delete) HeapFree(GetProcessHeap(), 0, (void*)S_MciCmdTable
[uTbl
].lpTable
);
781 S_MciCmdTable
[uTbl
].lpTable
= NULL
;
782 HeapFree(GetProcessHeap(), 0, S_MciCmdTable
[uTbl
].aVerbs
);
783 S_MciCmdTable
[uTbl
].aVerbs
= 0;
787 /**************************************************************************
788 * MCI_UnLoadMciDriver [internal]
790 static BOOL
MCI_UnLoadMciDriver(LPWINE_MCIDRIVER wmd
)
792 LPWINE_MCIDRIVER
* tmp
;
797 CloseDriver(wmd
->hDriver
, 0, 0);
799 if (wmd
->dwPrivate
!= 0)
800 WARN("Unloading mci driver with non nul dwPrivate field\n");
802 EnterCriticalSection(&WINMM_IData
.cs
);
803 for (tmp
= &WINMM_IData
.lpMciDrvs
; *tmp
; tmp
= &(*tmp
)->lpNext
) {
809 LeaveCriticalSection(&WINMM_IData
.cs
);
811 HeapFree(GetProcessHeap(), 0, wmd
->lpstrDeviceType
);
812 HeapFree(GetProcessHeap(), 0, wmd
->lpstrAlias
);
813 HeapFree(GetProcessHeap(), 0, wmd
->lpstrElementName
);
815 HeapFree(GetProcessHeap(), 0, wmd
);
819 /**************************************************************************
820 * MCI_OpenMciDriver [internal]
822 static BOOL
MCI_OpenMciDriver(LPWINE_MCIDRIVER wmd
, LPCWSTR drvTyp
, DWORD_PTR lp
)
826 if (!DRIVER_GetLibName(drvTyp
, wszMci
, libName
, sizeof(libName
)))
830 /* First load driver */
831 if ((wmd
->hDriver
= (HDRVR
)DRIVER_TryOpenDriver32(libName
, lp
))) {
833 } else if (WINMM_CheckForMMSystem() && pFnMciMapMsg32WTo16
) {
836 switch (res
= pFnMciMapMsg32WTo16(0, DRV_OPEN
, 0, &lp
)) {
837 case WINMM_MAP_MSGERROR
:
838 TRACE("Not handled yet (DRV_OPEN)\n");
840 case WINMM_MAP_NOMEM
:
841 TRACE("Problem mapping msg=DRV_OPEN from 32W to 16\n");
844 case WINMM_MAP_OKMEM
:
845 if ((wmd
->hDriver
= OpenDriver(drvTyp
, wszMci
, lp
)))
847 if (res
== WINMM_MAP_OKMEM
)
848 pFnMciUnMapMsg32WTo16(0, DRV_OPEN
, 0, lp
);
852 return (wmd
->bIs32
== 0xFFFF) ? FALSE
: TRUE
;
855 /**************************************************************************
856 * MCI_LoadMciDriver [internal]
858 static DWORD
MCI_LoadMciDriver(LPCWSTR _strDevTyp
, LPWINE_MCIDRIVER
* lpwmd
)
860 LPWSTR strDevTyp
= str_dup_upper(_strDevTyp
);
861 LPWINE_MCIDRIVER wmd
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*wmd
));
862 MCI_OPEN_DRIVER_PARMSW modp
;
865 if (!wmd
|| !strDevTyp
) {
866 dwRet
= MCIERR_OUT_OF_MEMORY
;
870 wmd
->lpfnYieldProc
= MCI_DefYieldProc
;
871 wmd
->dwYieldData
= VK_CANCEL
;
872 wmd
->CreatorThread
= GetCurrentThreadId();
874 EnterCriticalSection(&WINMM_IData
.cs
);
875 /* wmd must be inserted in list before sending opening the driver, coz' it
876 * may want to lookup at wDevID
878 wmd
->lpNext
= WINMM_IData
.lpMciDrvs
;
879 WINMM_IData
.lpMciDrvs
= wmd
;
881 for (modp
.wDeviceID
= MCI_MAGIC
;
882 MCI_GetDriver(modp
.wDeviceID
) != 0;
885 wmd
->wDeviceID
= modp
.wDeviceID
;
887 LeaveCriticalSection(&WINMM_IData
.cs
);
889 TRACE("wDevID=%04X\n", modp
.wDeviceID
);
891 modp
.lpstrParams
= NULL
;
893 if (!MCI_OpenMciDriver(wmd
, strDevTyp
, (DWORD_PTR
)&modp
)) {
894 /* silence warning if all is used... some bogus program use commands like
897 if (strcmpiW(strDevTyp
, wszAll
) == 0) {
898 dwRet
= MCIERR_CANNOT_USE_ALL
;
900 FIXME("Couldn't load driver for type %s.\n"
901 "If you don't have a windows installation accessible from Wine,\n"
902 "you perhaps forgot to create a [mci] section in system.ini\n",
903 debugstr_w(strDevTyp
));
904 dwRet
= MCIERR_DEVICE_NOT_INSTALLED
;
909 /* FIXME: should also check that module's description is of the form
910 * MODULENAME:[MCI] comment
913 /* some drivers will return 0x0000FFFF, some others 0xFFFFFFFF */
914 wmd
->uSpecificCmdTable
= LOWORD(modp
.wCustomCommandTable
);
915 wmd
->uTypeCmdTable
= MCI_COMMAND_TABLE_NOT_LOADED
;
917 TRACE("Loaded driver %p (%s), type is %d, cmdTable=%08x\n",
918 wmd
->hDriver
, debugstr_w(strDevTyp
), modp
.wType
, modp
.wCustomCommandTable
);
920 wmd
->lpstrDeviceType
= strDevTyp
;
921 wmd
->wType
= modp
.wType
;
923 TRACE("mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
924 modp
.wDeviceID
, modp
.wType
, modp
.wDeviceID
);
928 MCI_UnLoadMciDriver(wmd
);
929 HeapFree(GetProcessHeap(), 0, strDevTyp
);
934 /**************************************************************************
935 * MCI_FinishOpen [internal]
937 static DWORD
MCI_FinishOpen(LPWINE_MCIDRIVER wmd
, LPMCI_OPEN_PARMSW lpParms
,
940 if (dwParam
& MCI_OPEN_ELEMENT
)
942 wmd
->lpstrElementName
= HeapAlloc(GetProcessHeap(),0,(strlenW(lpParms
->lpstrElementName
)+1) * sizeof(WCHAR
));
943 strcpyW( wmd
->lpstrElementName
, lpParms
->lpstrElementName
);
945 if (dwParam
& MCI_OPEN_ALIAS
)
947 wmd
->lpstrAlias
= HeapAlloc(GetProcessHeap(), 0, (strlenW(lpParms
->lpstrAlias
)+1) * sizeof(WCHAR
));
948 strcpyW( wmd
->lpstrAlias
, lpParms
->lpstrAlias
);
950 lpParms
->wDeviceID
= wmd
->wDeviceID
;
952 return MCI_SendCommandFrom32(wmd
->wDeviceID
, MCI_OPEN_DRIVER
, dwParam
,
956 /**************************************************************************
957 * MCI_FindCommand [internal]
959 static LPCWSTR
MCI_FindCommand(UINT uTbl
, LPCWSTR verb
)
963 if (uTbl
>= MAX_MCICMDTABLE
|| !S_MciCmdTable
[uTbl
].lpTable
)
966 /* another improvement would be to have the aVerbs array sorted,
967 * so that we could use a dichotomic search on it, rather than this dumb
970 for (idx
= 0; idx
< S_MciCmdTable
[uTbl
].nVerbs
; idx
++) {
971 if (strcmpiW(S_MciCmdTable
[uTbl
].aVerbs
[idx
], verb
) == 0)
972 return S_MciCmdTable
[uTbl
].aVerbs
[idx
];
978 /**************************************************************************
979 * MCI_GetReturnType [internal]
981 static DWORD
MCI_GetReturnType(LPCWSTR lpCmd
)
983 lpCmd
= (LPCWSTR
)((const BYTE
*)(lpCmd
+ strlenW(lpCmd
) + 1) + sizeof(DWORD
) + sizeof(WORD
));
984 if (*lpCmd
== '\0' && *(const WORD
*)((const BYTE
*)(lpCmd
+ 1) + sizeof(DWORD
)) == MCI_RETURN
) {
985 return *(const DWORD
*)(lpCmd
+ 1);
990 /**************************************************************************
991 * MCI_GetMessage [internal]
993 static WORD
MCI_GetMessage(LPCWSTR lpCmd
)
995 return (WORD
)*(const DWORD
*)(lpCmd
+ strlenW(lpCmd
) + 1);
998 /**************************************************************************
999 * MCI_GetDWord [internal]
1001 static BOOL
MCI_GetDWord(LPDWORD data
, LPWSTR
* ptr
)
1006 val
= strtoulW(*ptr
, &ret
, 0);
1010 case ' ': ret
++; break;
1011 default: return FALSE
;
1019 /**************************************************************************
1020 * MCI_GetString [internal]
1022 static DWORD
MCI_GetString(LPWSTR
* str
, LPWSTR
* args
)
1026 /* see if we have a quoted string */
1028 ptr
= strchrW(*str
= ptr
+ 1, '"');
1029 if (!ptr
) return MCIERR_NO_CLOSING_QUOTE
;
1030 /* FIXME: shall we escape \" from string ?? */
1031 if (ptr
[-1] == '\\') TRACE("Ooops: un-escaped \"\n");
1032 *ptr
++ = '\0'; /* remove trailing " */
1033 if (*ptr
!= ' ' && *ptr
!= '\0') return MCIERR_EXTRA_CHARACTERS
;
1035 ptr
= strchrW(ptr
, ' ');
1040 ptr
= *args
+ strlenW(*args
);
1049 #define MCI_DATA_SIZE 16
1051 /**************************************************************************
1052 * MCI_ParseOptArgs [internal]
1054 static DWORD
MCI_ParseOptArgs(LPDWORD data
, int _offset
, LPCWSTR lpCmd
,
1055 LPWSTR args
, LPDWORD dwFlags
)
1060 DWORD dwRet
, flg
, cflg
= 0;
1064 /* loop on arguments */
1066 lmem
= (const char*)lpCmd
;
1067 found
= inCst
= FALSE
;
1070 /* skip any leading white space(s) */
1071 while (*args
== ' ') args
++;
1072 TRACE("args=%s offset=%d\n", debugstr_w(args
), offset
);
1074 do { /* loop on options for command table for the requested verb */
1075 str
= (LPCWSTR
)lmem
;
1076 lmem
+= ((len
= strlenW(str
)) + 1) * sizeof(WCHAR
);
1077 flg
= *(const DWORD
*)lmem
;
1078 eid
= *(const WORD
*)(lmem
+ sizeof(DWORD
));
1079 lmem
+= sizeof(DWORD
) + sizeof(WORD
);
1080 /* TRACE("\tcmd=%s inCst=%c eid=%04x\n", debugstr_w(str), inCst ? 'Y' : 'N', eid); */
1084 inCst
= TRUE
; cflg
= flg
; break;
1085 case MCI_END_CONSTANT
:
1086 /* there may be additional integral values after flag in constant */
1087 if (inCst
&& MCI_GetDWord(&(data
[offset
]), &args
)) {
1090 inCst
= FALSE
; cflg
= 0;
1094 if (strncmpiW(args
, str
, len
) == 0 &&
1095 ((eid
== MCI_STRING
&& len
== 0) || args
[len
] == 0 || args
[len
] == ' ')) {
1096 /* store good values into data[] */
1098 while (*args
== ' ') args
++;
1102 case MCI_COMMAND_HEAD
:
1104 case MCI_END_COMMAND
:
1105 case MCI_END_COMMAND_LIST
:
1106 case MCI_CONSTANT
: /* done above */
1107 case MCI_END_CONSTANT
: /* done above */
1114 data
[offset
] |= flg
;
1119 if (!MCI_GetDWord(&(data
[offset
]), &args
)) {
1120 return MCIERR_BAD_INTEGER
;
1125 /* store rect in data (offset...offset+3) */
1127 if (!MCI_GetDWord(&(data
[offset
+0]), &args
) ||
1128 !MCI_GetDWord(&(data
[offset
+1]), &args
) ||
1129 !MCI_GetDWord(&(data
[offset
+2]), &args
) ||
1130 !MCI_GetDWord(&(data
[offset
+3]), &args
)) {
1131 ERR("Bad rect %s\n", debugstr_w(args
));
1132 return MCIERR_BAD_INTEGER
;
1137 if ((dwRet
= MCI_GetString((LPWSTR
*)&data
[offset
], &args
)))
1140 default: ERR("oops\n");
1142 /* exit inside while loop, except if just entered in constant area definition */
1143 if (!inCst
|| eid
!= MCI_CONSTANT
) eid
= MCI_END_COMMAND
;
1145 /* have offset incremented if needed */
1147 case MCI_COMMAND_HEAD
:
1149 case MCI_END_COMMAND
:
1150 case MCI_END_COMMAND_LIST
:
1152 case MCI_FLAG
: break;
1153 case MCI_INTEGER
: if (!inCst
) offset
++; break;
1154 case MCI_END_CONSTANT
:
1155 case MCI_STRING
: offset
++; break;
1156 case MCI_RECT
: offset
+= 4; break;
1157 default: ERR("oops\n");
1160 } while (eid
!= MCI_END_COMMAND
);
1162 WARN("Optarg %s not found\n", debugstr_w(args
));
1163 return MCIERR_UNRECOGNIZED_COMMAND
;
1165 if (offset
== MCI_DATA_SIZE
) {
1166 ERR("Internal data[] buffer overflow\n");
1167 return MCIERR_PARSER_INTERNAL
;
1173 /**************************************************************************
1174 * MCI_HandleReturnValues [internal]
1176 static DWORD
MCI_HandleReturnValues(DWORD dwRet
, LPWINE_MCIDRIVER wmd
, DWORD retType
,
1177 LPDWORD data
, LPWSTR lpstrRet
, UINT uRetLen
)
1179 static const WCHAR wszLd
[] = {'%','l','d',0};
1180 static const WCHAR wszLd4
[] = {'%','l','d',' ','%','l','d',' ','%','l','d',' ','%','l','d',0};
1181 static const WCHAR wszCol3
[] = {'%','d',':','%','d',':','%','d',0};
1182 static const WCHAR wszCol4
[] = {'%','d',':','%','d',':','%','d',':','%','d',0};
1186 case 0: /* nothing to return */
1189 switch (dwRet
& 0xFFFF0000ul
) {
1191 case MCI_INTEGER_RETURNED
:
1192 snprintfW(lpstrRet
, uRetLen
, wszLd
, data
[1]);
1194 case MCI_RESOURCE_RETURNED
:
1195 /* return string which ID is HIWORD(data[1]),
1196 * string is loaded from mmsystem.dll */
1197 LoadStringW(WINMM_IData
.hWinMM32Instance
, HIWORD(data
[1]),
1200 case MCI_RESOURCE_RETURNED
|MCI_RESOURCE_DRIVER
:
1201 /* return string which ID is HIWORD(data[1]),
1202 * string is loaded from driver */
1203 /* FIXME: this is wrong for a 16 bit handle */
1204 LoadStringW(GetDriverModuleHandle(wmd
->hDriver
),
1205 HIWORD(data
[1]), lpstrRet
, uRetLen
);
1207 case MCI_COLONIZED3_RETURN
:
1208 snprintfW(lpstrRet
, uRetLen
, wszCol3
,
1209 LOBYTE(LOWORD(data
[1])), HIBYTE(LOWORD(data
[1])),
1210 LOBYTE(HIWORD(data
[1])));
1212 case MCI_COLONIZED4_RETURN
:
1213 snprintfW(lpstrRet
, uRetLen
, wszCol4
,
1214 LOBYTE(LOWORD(data
[1])), HIBYTE(LOWORD(data
[1])),
1215 LOBYTE(HIWORD(data
[1])), HIBYTE(HIWORD(data
[1])));
1217 default: ERR("Ooops (%04X)\n", HIWORD(dwRet
));
1221 switch (dwRet
& 0xFFFF0000ul
) {
1223 /* nothing to do data[1] == lpstrRet */
1225 case MCI_INTEGER_RETURNED
:
1226 data
[1] = *(LPDWORD
)lpstrRet
;
1227 snprintfW(lpstrRet
, uRetLen
, wszLd
, data
[1]);
1230 WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet
));
1235 if (dwRet
& 0xFFFF0000ul
)
1236 WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet
));
1237 snprintfW(lpstrRet
, uRetLen
, wszLd4
,
1238 data
[1], data
[2], data
[3], data
[4]);
1240 default: ERR("oops\n");
1243 return LOWORD(dwRet
);
1246 /**************************************************************************
1247 * mciSendStringW [WINMM.@]
1249 DWORD WINAPI
mciSendStringW(LPCWSTR lpstrCommand
, LPWSTR lpstrRet
,
1250 UINT uRetLen
, HWND hwndCallback
)
1252 LPWSTR verb
, dev
, args
;
1253 LPWINE_MCIDRIVER wmd
= 0;
1254 DWORD dwFlags
= 0, dwRet
= 0;
1256 DWORD data
[MCI_DATA_SIZE
];
1259 LPWSTR devAlias
= NULL
;
1260 BOOL bAutoOpen
= FALSE
;
1261 static const WCHAR wszNew
[] = {'n','e','w',0};
1262 static const WCHAR wszSAliasS
[] = {' ','a','l','i','a','s',' ',0};
1263 static const WCHAR wszTypeS
[] = {'t','y','p','e',' ',0};
1265 TRACE("(%s, %p, %d, %p)\n",
1266 debugstr_w(lpstrCommand
), lpstrRet
, uRetLen
, hwndCallback
);
1268 /* format is <command> <device> <optargs> */
1269 if (!(verb
= HeapAlloc(GetProcessHeap(), 0, (strlenW(lpstrCommand
)+1) * sizeof(WCHAR
))))
1270 return MCIERR_OUT_OF_MEMORY
;
1271 strcpyW( verb
, lpstrCommand
);
1274 memset(data
, 0, sizeof(data
));
1276 if (!(args
= strchrW(verb
, ' '))) {
1277 dwRet
= MCIERR_MISSING_DEVICE_NAME
;
1281 if ((dwRet
= MCI_GetString(&dev
, &args
))) {
1285 /* Determine devType from open */
1286 if (!strcmpW(verb
, wszOpen
)) {
1287 LPWSTR devType
, tmp
;
1290 /* case dev == 'new' has to be handled */
1291 if (!strcmpW(dev
, wszNew
)) {
1293 if ((devType
= strstrW(args
, wszTypeS
)) != NULL
) {
1295 tmp
= strchrW(devType
, ' ');
1296 if (tmp
) *tmp
= '\0';
1297 devType
= str_dup_upper(devType
);
1298 if (tmp
) *tmp
= ' ';
1299 /* dwFlags and data[2] will be correctly set in ParseOpt loop */
1301 WARN("open new requires device type\n");
1302 dwRet
= MCIERR_MISSING_DEVICE_NAME
;
1305 } else if ((devType
= strchrW(dev
, '!')) != NULL
) {
1307 tmp
= devType
; devType
= dev
; dev
= tmp
;
1309 dwFlags
|= MCI_OPEN_TYPE
;
1310 data
[2] = (DWORD
)devType
;
1311 devType
= str_dup_upper(devType
);
1312 dwFlags
|= MCI_OPEN_ELEMENT
;
1313 data
[3] = (DWORD
)dev
;
1314 } else if (DRIVER_GetLibName(dev
, wszMci
, buf
, sizeof(buf
))) {
1315 /* this is the name of a mci driver's type */
1316 tmp
= strchrW(dev
, ' ');
1317 if (tmp
) *tmp
= '\0';
1318 data
[2] = (DWORD
)dev
;
1319 devType
= str_dup_upper(dev
);
1320 if (tmp
) *tmp
= ' ';
1321 dwFlags
|= MCI_OPEN_TYPE
;
1323 if ((devType
= strstrW(args
, wszTypeS
)) != NULL
) {
1325 tmp
= strchrW(devType
, ' ');
1326 if (tmp
) *tmp
= '\0';
1327 devType
= str_dup_upper(devType
);
1328 if (tmp
) *tmp
= ' ';
1329 /* dwFlags and data[2] will be correctly set in ParseOpt loop */
1331 if ((dwRet
= MCI_GetDevTypeFromFileName(dev
, buf
, sizeof(buf
))))
1334 devType
= str_dup_upper(buf
);
1336 dwFlags
|= MCI_OPEN_ELEMENT
;
1337 data
[3] = (DWORD
)dev
;
1339 if ((devAlias
= strstrW(args
, wszSAliasS
))) {
1342 if (!(tmp
= strchrW(devAlias
,' '))) tmp
= devAlias
+ strlenW(devAlias
);
1343 if (tmp
) *tmp
= '\0';
1344 tmp2
= HeapAlloc(GetProcessHeap(), 0, (tmp
- devAlias
+ 1) * sizeof(WCHAR
) );
1345 memcpy( tmp2
, devAlias
, (tmp
- devAlias
) * sizeof(WCHAR
) );
1346 tmp2
[tmp
- devAlias
] = 0;
1347 data
[4] = (DWORD
)tmp2
;
1348 /* should be done in regular options parsing */
1349 /* dwFlags |= MCI_OPEN_ALIAS; */
1350 } else if (dev
== 0) {
1351 /* "open new" requires alias */
1352 dwRet
= MCIERR_NEW_REQUIRES_ALIAS
;
1356 dwRet
= MCI_LoadMciDriver(devType
, &wmd
);
1357 if (dwRet
== MCIERR_DEVICE_NOT_INSTALLED
)
1358 dwRet
= MCIERR_INVALID_DEVICE_NAME
;
1359 HeapFree(GetProcessHeap(), 0, devType
);
1361 MCI_UnLoadMciDriver(wmd
);
1364 } else if (!(wmd
= MCI_GetDriver(mciGetDeviceIDW(dev
)))) {
1366 static const WCHAR wszOpenWait
[] = {'o','p','e','n',' ','%','s',' ','w','a','i','t',0};
1368 sprintfW(buf
, wszOpenWait
, dev
);
1370 if ((dwRet
= mciSendStringW(buf
, NULL
, 0, 0)) != 0)
1373 wmd
= MCI_GetDriver(mciGetDeviceIDW(dev
));
1375 /* FIXME: memory leak, MCI driver is not closed */
1376 dwRet
= MCIERR_INVALID_DEVICE_ID
;
1381 /* get the verb in the different command tables */
1383 /* try the device specific command table */
1384 lpCmd
= MCI_FindCommand(wmd
->uSpecificCmdTable
, verb
);
1386 /* try the type specific command table */
1387 if (wmd
->uTypeCmdTable
== MCI_COMMAND_TABLE_NOT_LOADED
)
1388 wmd
->uTypeCmdTable
= MCI_GetCommandTable(wmd
->wType
);
1389 if (wmd
->uTypeCmdTable
!= MCI_NO_COMMAND_TABLE
)
1390 lpCmd
= MCI_FindCommand(wmd
->uTypeCmdTable
, verb
);
1393 /* try core command table */
1394 if (!lpCmd
) lpCmd
= MCI_FindCommand(MCI_GetCommandTable(0), verb
);
1397 TRACE("Command %s not found!\n", debugstr_w(verb
));
1398 dwRet
= MCIERR_UNRECOGNIZED_COMMAND
;
1402 /* set up call back */
1403 if (hwndCallback
!= 0) {
1404 dwFlags
|= MCI_NOTIFY
;
1405 data
[0] = (DWORD
)hwndCallback
;
1408 /* set return information */
1409 switch (retType
= MCI_GetReturnType(lpCmd
)) {
1410 case 0: offset
= 1; break;
1411 case MCI_INTEGER
: offset
= 2; break;
1412 case MCI_STRING
: data
[1] = (DWORD
)lpstrRet
; data
[2] = uRetLen
; offset
= 3; break;
1413 case MCI_RECT
: offset
= 5; break;
1414 default: ERR("oops\n");
1417 TRACE("verb=%s on dev=%s; offset=%d\n",
1418 debugstr_w(verb
), debugstr_w(dev
), offset
);
1420 if ((dwRet
= MCI_ParseOptArgs(data
, offset
, lpCmd
, args
, &dwFlags
)))
1423 if (bAutoOpen
&& (dwFlags
& MCI_NOTIFY
)) {
1424 dwRet
= MCIERR_NOTIFY_ON_AUTO_OPEN
;
1427 /* FIXME: the command should get it's own notification window set up and
1428 * ask for device closing while processing the notification mechanism
1430 if (lpstrRet
&& uRetLen
) *lpstrRet
= '\0';
1432 TRACE("[%d, %s, %08x, %08x/%s %08x/%s %08x/%s %08x/%s %08x/%s %08x/%s]\n",
1433 wmd
->wDeviceID
, MCI_MessageToString(MCI_GetMessage(lpCmd
)), dwFlags
,
1434 data
[0], debugstr_w((WCHAR
*)data
[0]), data
[1], debugstr_w((WCHAR
*)data
[1]),
1435 data
[2], debugstr_w((WCHAR
*)data
[2]), data
[3], debugstr_w((WCHAR
*)data
[3]),
1436 data
[4], debugstr_w((WCHAR
*)data
[4]), data
[5], debugstr_w((WCHAR
*)data
[5]));
1438 if (strcmpW(verb
, wszOpen
) == 0) {
1439 if ((dwRet
= MCI_FinishOpen(wmd
, (LPMCI_OPEN_PARMSW
)data
, dwFlags
)))
1440 MCI_UnLoadMciDriver(wmd
);
1441 /* FIXME: notification is not properly shared across two opens */
1443 dwRet
= MCI_SendCommand(wmd
->wDeviceID
, MCI_GetMessage(lpCmd
), dwFlags
, (DWORD
)data
, TRUE
);
1445 TRACE("=> 1/ %x (%s)\n", dwRet
, debugstr_w(lpstrRet
));
1446 dwRet
= MCI_HandleReturnValues(dwRet
, wmd
, retType
, data
, lpstrRet
, uRetLen
);
1447 TRACE("=> 2/ %x (%s)\n", dwRet
, debugstr_w(lpstrRet
));
1450 HeapFree(GetProcessHeap(), 0, verb
);
1451 HeapFree(GetProcessHeap(), 0, devAlias
);
1455 /**************************************************************************
1456 * mciSendStringA [WINMM.@]
1458 DWORD WINAPI
mciSendStringA(LPCSTR lpstrCommand
, LPSTR lpstrRet
,
1459 UINT uRetLen
, HWND hwndCallback
)
1461 LPWSTR lpwstrCommand
;
1462 LPWSTR lpwstrRet
= NULL
;
1466 /* FIXME: is there something to do with lpstrReturnString ? */
1467 len
= MultiByteToWideChar( CP_ACP
, 0, lpstrCommand
, -1, NULL
, 0 );
1468 lpwstrCommand
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
1469 MultiByteToWideChar( CP_ACP
, 0, lpstrCommand
, -1, lpwstrCommand
, len
);
1472 lpwstrRet
= HeapAlloc(GetProcessHeap(), 0, uRetLen
* sizeof(WCHAR
));
1474 WARN("no memory\n");
1475 HeapFree( GetProcessHeap(), 0, lpwstrCommand
);
1476 return MCIERR_OUT_OF_MEMORY
;
1479 ret
= mciSendStringW(lpwstrCommand
, lpwstrRet
, uRetLen
, hwndCallback
);
1481 WideCharToMultiByte( CP_ACP
, 0, lpwstrRet
, -1, lpstrRet
, uRetLen
, NULL
, NULL
);
1482 HeapFree(GetProcessHeap(), 0, lpwstrCommand
);
1483 HeapFree(GetProcessHeap(), 0, lpwstrRet
);
1487 /**************************************************************************
1488 * mciExecute [WINMM.@]
1489 * mciExecute [MMSYSTEM.712]
1491 BOOL WINAPI
mciExecute(LPCSTR lpstrCommand
)
1496 TRACE("(%s)!\n", lpstrCommand
);
1498 ret
= mciSendStringA(lpstrCommand
, strRet
, sizeof(strRet
), 0);
1500 if (!mciGetErrorStringA(ret
, strRet
, sizeof(strRet
))) {
1501 sprintf(strRet
, "Unknown MCI error (%d)", ret
);
1503 MessageBoxA(0, strRet
, "Error in mciExecute()", MB_OK
);
1505 /* FIXME: what shall I return ? */
1509 /**************************************************************************
1510 * mciLoadCommandResource [WINMM.@]
1512 * Strangely, this function only exists as an UNICODE one.
1514 UINT WINAPI
mciLoadCommandResource(HINSTANCE hInst
, LPCWSTR resNameW
, UINT type
)
1518 UINT16 ret
= MCI_NO_COMMAND_TABLE
;
1520 TRACE("(%p, %s, %d)!\n", hInst
, debugstr_w(resNameW
), type
);
1522 /* if a file named "resname.mci" exits, then load resource "resname" from it
1523 * otherwise directly from driver
1524 * We don't support it (who uses this feature ?), but we check anyway
1528 /* FIXME: we should put this back into order, but I never found a program
1529 * actually using this feature, so we may not need it
1534 strcat(strcpy(buf
, resname
), ".mci");
1535 if (OpenFile(buf
, &ofs
, OF_EXIST
) != HFILE_ERROR
) {
1536 FIXME("NIY: command table to be loaded from '%s'\n", ofs
.szPathName
);
1540 if (!(hRsrc
= FindResourceW(hInst
, resNameW
, (LPWSTR
)RT_RCDATA
))) {
1541 WARN("No command table found in resource\n");
1542 } else if ((hMem
= LoadResource(hInst
, hRsrc
))) {
1543 ret
= MCI_SetCommandTable(LockResource(hMem
), type
);
1545 WARN("Couldn't load resource.\n");
1547 TRACE("=> %04x\n", ret
);
1551 /**************************************************************************
1552 * mciFreeCommandResource [WINMM.@]
1554 BOOL WINAPI
mciFreeCommandResource(UINT uTable
)
1556 TRACE("(%08x)!\n", uTable
);
1558 return MCI_DeleteCommandTable(uTable
, FALSE
);
1561 /**************************************************************************
1562 * MCI_SendCommandFrom32 [internal]
1564 DWORD
MCI_SendCommandFrom32(MCIDEVICEID wDevID
, UINT16 wMsg
, DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
1566 DWORD dwRet
= MCIERR_INVALID_DEVICE_ID
;
1567 LPWINE_MCIDRIVER wmd
= MCI_GetDriver(wDevID
);
1571 dwRet
= SendDriverMessage(wmd
->hDriver
, wMsg
, dwParam1
, dwParam2
);
1572 } else if (pFnMciMapMsg32WTo16
) {
1575 switch (res
= pFnMciMapMsg32WTo16(wmd
->wType
, wMsg
, dwParam1
, &dwParam2
)) {
1576 case WINMM_MAP_MSGERROR
:
1577 TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg
));
1578 dwRet
= MCIERR_DRIVER_INTERNAL
;
1580 case WINMM_MAP_NOMEM
:
1581 TRACE("Problem mapping msg=%s from 32a to 16\n", MCI_MessageToString(wMsg
));
1582 dwRet
= MCIERR_OUT_OF_MEMORY
;
1585 case WINMM_MAP_OKMEM
:
1586 dwRet
= SendDriverMessage(wmd
->hDriver
, wMsg
, dwParam1
, dwParam2
);
1587 if (res
== WINMM_MAP_OKMEM
)
1588 pFnMciUnMapMsg32WTo16(wmd
->wType
, wMsg
, dwParam1
, dwParam2
);
1596 /**************************************************************************
1597 * MCI_SendCommandFrom16 [internal]
1599 DWORD
MCI_SendCommandFrom16(MCIDEVICEID wDevID
, UINT16 wMsg
, DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
1601 DWORD dwRet
= MCIERR_INVALID_DEVICE_ID
;
1602 LPWINE_MCIDRIVER wmd
= MCI_GetDriver(wDevID
);
1605 dwRet
= MCIERR_INVALID_DEVICE_ID
;
1607 if (wmd
->bIs32
&& pFnMciMapMsg16To32W
) {
1610 switch (res
= pFnMciMapMsg16To32W(wmd
->wType
, wMsg
, dwParam1
, &dwParam2
)) {
1611 case WINMM_MAP_MSGERROR
:
1612 TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg
));
1613 dwRet
= MCIERR_DRIVER_INTERNAL
;
1615 case WINMM_MAP_NOMEM
:
1616 TRACE("Problem mapping msg=%s from 16 to 32a\n", MCI_MessageToString(wMsg
));
1617 dwRet
= MCIERR_OUT_OF_MEMORY
;
1620 case WINMM_MAP_OKMEM
:
1621 dwRet
= SendDriverMessage(wmd
->hDriver
, wMsg
, dwParam1
, dwParam2
);
1622 if (res
== WINMM_MAP_OKMEM
)
1623 pFnMciUnMapMsg16To32W(wmd
->wType
, wMsg
, dwParam1
, dwParam2
);
1627 dwRet
= SendDriverMessage(wmd
->hDriver
, wMsg
, dwParam1
, dwParam2
);
1633 /**************************************************************************
1634 * MCI_Open [internal]
1636 static DWORD
MCI_Open(DWORD dwParam
, LPMCI_OPEN_PARMSW lpParms
)
1638 WCHAR strDevTyp
[128];
1640 LPWINE_MCIDRIVER wmd
= NULL
;
1642 TRACE("(%08X, %p)\n", dwParam
, lpParms
);
1643 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
1645 /* only two low bytes are generic, the other ones are dev type specific */
1646 #define WINE_MCIDRIVER_SUPP (0xFFFF0000|MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT| \
1647 MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID| \
1648 MCI_NOTIFY|MCI_WAIT)
1649 if ((dwParam
& ~WINE_MCIDRIVER_SUPP
) != 0) {
1650 FIXME("Unsupported yet dwFlags=%08lX\n", dwParam
& ~WINE_MCIDRIVER_SUPP
);
1652 #undef WINE_MCIDRIVER_SUPP
1656 if (dwParam
& MCI_OPEN_TYPE
) {
1657 if (dwParam
& MCI_OPEN_TYPE_ID
) {
1658 WORD uDevType
= LOWORD((DWORD
)lpParms
->lpstrDeviceType
);
1660 if (uDevType
< MCI_DEVTYPE_FIRST
||
1661 uDevType
> MCI_DEVTYPE_LAST
||
1662 !LoadStringW(WINMM_IData
.hWinMM32Instance
, uDevType
,
1663 strDevTyp
, sizeof(strDevTyp
) / sizeof(WCHAR
))) {
1664 dwRet
= MCIERR_BAD_INTEGER
;
1669 if (lpParms
->lpstrDeviceType
== NULL
) {
1670 dwRet
= MCIERR_NULL_PARAMETER_BLOCK
;
1673 strcpyW(strDevTyp
, lpParms
->lpstrDeviceType
);
1674 ptr
= strchrW(strDevTyp
, '!');
1676 /* this behavior is not documented in windows. However, since, in
1677 * some occasions, MCI_OPEN handling is translated by WinMM into
1678 * a call to mciSendString("open <type>"); this code shall be correct
1680 if (dwParam
& MCI_OPEN_ELEMENT
) {
1681 ERR("Both MCI_OPEN_ELEMENT(%s) and %s are used\n",
1682 debugstr_w(lpParms
->lpstrElementName
),
1683 debugstr_w(strDevTyp
));
1684 dwRet
= MCIERR_UNRECOGNIZED_KEYWORD
;
1687 dwParam
|= MCI_OPEN_ELEMENT
;
1689 /* FIXME: not a good idea to write in user supplied buffer */
1690 lpParms
->lpstrElementName
= ptr
;
1694 TRACE("devType=%s !\n", debugstr_w(strDevTyp
));
1697 if (dwParam
& MCI_OPEN_ELEMENT
) {
1698 TRACE("lpstrElementName=%s\n", debugstr_w(lpParms
->lpstrElementName
));
1700 if (dwParam
& MCI_OPEN_ELEMENT_ID
) {
1701 FIXME("Unsupported yet flag MCI_OPEN_ELEMENT_ID\n");
1702 dwRet
= MCIERR_UNRECOGNIZED_KEYWORD
;
1706 if (!lpParms
->lpstrElementName
) {
1707 dwRet
= MCIERR_NULL_PARAMETER_BLOCK
;
1711 /* type, if given as a parameter, supersedes file extension */
1712 if (!strDevTyp
[0] &&
1713 MCI_GetDevTypeFromFileName(lpParms
->lpstrElementName
,
1714 strDevTyp
, sizeof(strDevTyp
))) {
1715 static const WCHAR wszCdAudio
[] = {'C','D','A','U','D','I','O',0};
1716 if (GetDriveTypeW(lpParms
->lpstrElementName
) != DRIVE_CDROM
) {
1717 dwRet
= MCIERR_EXTENSION_NOT_FOUND
;
1720 /* FIXME: this will not work if several CDROM drives are installed on the machine */
1721 strcpyW(strDevTyp
, wszCdAudio
);
1725 if (strDevTyp
[0] == 0) {
1726 FIXME("Couldn't load driver\n");
1727 dwRet
= MCIERR_INVALID_DEVICE_NAME
;
1731 if (dwParam
& MCI_OPEN_ALIAS
) {
1732 TRACE("Alias=%s !\n", debugstr_w(lpParms
->lpstrAlias
));
1733 if (!lpParms
->lpstrAlias
) {
1734 dwRet
= MCIERR_NULL_PARAMETER_BLOCK
;
1739 if ((dwRet
= MCI_LoadMciDriver(strDevTyp
, &wmd
))) {
1743 if ((dwRet
= MCI_FinishOpen(wmd
, lpParms
, dwParam
))) {
1744 TRACE("Failed to open driver (MCI_OPEN_DRIVER) [%08x], closing\n", dwRet
);
1745 /* FIXME: is dwRet the correct ret code ? */
1749 /* only handled devices fall through */
1750 TRACE("wDevID=%04X wDeviceID=%d dwRet=%d\n", wmd
->wDeviceID
, lpParms
->wDeviceID
, dwRet
);
1752 if (dwParam
& MCI_NOTIFY
)
1753 mciDriverNotify((HWND
)lpParms
->dwCallback
, wmd
->wDeviceID
, MCI_NOTIFY_SUCCESSFUL
);
1757 if (wmd
) MCI_UnLoadMciDriver(wmd
);
1759 if (dwParam
& MCI_NOTIFY
)
1760 mciDriverNotify((HWND
)lpParms
->dwCallback
, 0, MCI_NOTIFY_FAILURE
);
1764 /**************************************************************************
1765 * MCI_Close [internal]
1767 static DWORD
MCI_Close(UINT16 wDevID
, DWORD dwParam
, LPMCI_GENERIC_PARMS lpParms
)
1770 LPWINE_MCIDRIVER wmd
;
1772 TRACE("(%04x, %08X, %p)\n", wDevID
, dwParam
, lpParms
);
1774 if (wDevID
== MCI_ALL_DEVICE_ID
) {
1775 LPWINE_MCIDRIVER next
;
1777 EnterCriticalSection(&WINMM_IData
.cs
);
1778 /* FIXME: shall I notify once after all is done, or for
1779 * each of the open drivers ? if the latest, which notif
1780 * to return when only one fails ?
1782 for (wmd
= WINMM_IData
.lpMciDrvs
; wmd
; ) {
1784 MCI_Close(wmd
->wDeviceID
, dwParam
, lpParms
);
1787 LeaveCriticalSection(&WINMM_IData
.cs
);
1791 if (!(wmd
= MCI_GetDriver(wDevID
))) {
1792 return MCIERR_INVALID_DEVICE_ID
;
1795 dwRet
= MCI_SendCommandFrom32(wDevID
, MCI_CLOSE_DRIVER
, dwParam
, (DWORD
)lpParms
);
1797 MCI_UnLoadMciDriver(wmd
);
1799 if (dwParam
& MCI_NOTIFY
)
1800 mciDriverNotify(lpParms
? (HWND
)lpParms
->dwCallback
: 0,
1802 dwRet
? MCI_NOTIFY_FAILURE
: MCI_NOTIFY_SUCCESSFUL
);
1807 /**************************************************************************
1808 * MCI_WriteString [internal]
1810 DWORD
MCI_WriteString(LPWSTR lpDstStr
, DWORD dstSize
, LPCWSTR lpSrcStr
)
1815 dstSize
/= sizeof(WCHAR
);
1816 if (dstSize
<= strlenW(lpSrcStr
)) {
1817 lstrcpynW(lpDstStr
, lpSrcStr
, dstSize
- 1);
1818 ret
= MCIERR_PARAM_OVERFLOW
;
1820 strcpyW(lpDstStr
, lpSrcStr
);
1828 /**************************************************************************
1829 * MCI_Sysinfo [internal]
1831 static DWORD
MCI_SysInfo(UINT uDevID
, DWORD dwFlags
, LPMCI_SYSINFO_PARMSW lpParms
)
1833 DWORD ret
= MCIERR_INVALID_DEVICE_ID
, cnt
= 0;
1834 WCHAR buf
[2048], *s
= buf
, *p
;
1835 LPWINE_MCIDRIVER wmd
;
1838 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
1840 TRACE("(%08x, %08X, %08X[num=%d, wDevTyp=%u])\n",
1841 uDevID
, dwFlags
, (DWORD
)lpParms
, lpParms
->dwNumber
, lpParms
->wDeviceType
);
1843 switch (dwFlags
& ~MCI_SYSINFO_OPEN
) {
1844 case MCI_SYSINFO_QUANTITY
:
1845 if (lpParms
->wDeviceType
< MCI_DEVTYPE_FIRST
|| lpParms
->wDeviceType
> MCI_DEVTYPE_LAST
) {
1846 if (dwFlags
& MCI_SYSINFO_OPEN
) {
1847 TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
1848 EnterCriticalSection(&WINMM_IData
.cs
);
1849 for (wmd
= WINMM_IData
.lpMciDrvs
; wmd
; wmd
= wmd
->lpNext
) {
1852 LeaveCriticalSection(&WINMM_IData
.cs
);
1854 TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
1855 if (RegOpenKeyExW( HKEY_LOCAL_MACHINE
, wszHklmMci
,
1856 0, KEY_QUERY_VALUE
, &hKey
) == ERROR_SUCCESS
) {
1857 RegQueryInfoKeyW( hKey
, 0, 0, 0, &cnt
, 0, 0, 0, 0, 0, 0, 0);
1858 RegCloseKey( hKey
);
1860 if (GetPrivateProfileStringW(wszMci
, 0, wszNull
, buf
, sizeof(buf
) / sizeof(buf
[0]), wszSystemIni
))
1861 for (s
= buf
; *s
; s
+= strlenW(s
) + 1) cnt
++;
1864 if (dwFlags
& MCI_SYSINFO_OPEN
) {
1865 TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n", lpParms
->wDeviceType
);
1866 EnterCriticalSection(&WINMM_IData
.cs
);
1867 for (wmd
= WINMM_IData
.lpMciDrvs
; wmd
; wmd
= wmd
->lpNext
) {
1868 if (wmd
->wType
== lpParms
->wDeviceType
) cnt
++;
1870 LeaveCriticalSection(&WINMM_IData
.cs
);
1872 TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n", lpParms
->wDeviceType
);
1873 FIXME("Don't know how to get # of MCI devices of a given type\n");
1877 *(DWORD
*)lpParms
->lpstrReturn
= cnt
;
1878 TRACE("(%d) => '%d'\n", lpParms
->dwNumber
, *(DWORD
*)lpParms
->lpstrReturn
);
1879 ret
= MCI_INTEGER_RETURNED
;
1881 case MCI_SYSINFO_INSTALLNAME
:
1882 TRACE("MCI_SYSINFO_INSTALLNAME\n");
1883 if ((wmd
= MCI_GetDriver(uDevID
))) {
1884 ret
= MCI_WriteString(lpParms
->lpstrReturn
, lpParms
->dwRetSize
,
1885 wmd
->lpstrDeviceType
);
1887 *lpParms
->lpstrReturn
= 0;
1888 ret
= MCIERR_INVALID_DEVICE_ID
;
1890 TRACE("(%d) => %s\n", lpParms
->dwNumber
, debugstr_w(lpParms
->lpstrReturn
));
1892 case MCI_SYSINFO_NAME
:
1893 TRACE("MCI_SYSINFO_NAME\n");
1894 if (dwFlags
& MCI_SYSINFO_OPEN
) {
1895 FIXME("Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n");
1896 ret
= MCIERR_UNRECOGNIZED_COMMAND
;
1899 if (RegOpenKeyExW( HKEY_LOCAL_MACHINE
, wszHklmMci
, 0,
1900 KEY_QUERY_VALUE
, &hKey
) == ERROR_SUCCESS
) {
1901 if (RegQueryInfoKeyW( hKey
, 0, 0, 0, &cnt
,
1902 0, 0, 0, 0, 0, 0, 0) == ERROR_SUCCESS
&&
1903 lpParms
->dwNumber
<= cnt
) {
1904 DWORD bufLen
= sizeof(buf
);
1905 if (RegEnumKeyExW(hKey
, lpParms
->dwNumber
- 1,
1906 buf
, &bufLen
, 0, 0, 0, 0) == ERROR_SUCCESS
)
1909 RegCloseKey( hKey
);
1912 if (GetPrivateProfileStringW(wszMci
, 0, wszNull
, buf
, sizeof(buf
) / sizeof(buf
[0]), wszSystemIni
)) {
1913 for (p
= buf
; *p
; p
+= strlenW(p
) + 1, cnt
++) {
1914 TRACE("%d: %s\n", cnt
, debugstr_w(p
));
1915 if (cnt
== lpParms
->dwNumber
- 1) {
1922 ret
= s
? MCI_WriteString(lpParms
->lpstrReturn
, lpParms
->dwRetSize
/ sizeof(WCHAR
), s
) : MCIERR_OUTOFRANGE
;
1924 TRACE("(%d) => %s\n", lpParms
->dwNumber
, debugstr_w(lpParms
->lpstrReturn
));
1927 TRACE("Unsupported flag value=%08x\n", dwFlags
);
1928 ret
= MCIERR_UNRECOGNIZED_COMMAND
;
1933 /**************************************************************************
1934 * MCI_Break [internal]
1936 static DWORD
MCI_Break(UINT wDevID
, DWORD dwFlags
, LPMCI_BREAK_PARMS lpParms
)
1940 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
1942 if (dwFlags
& MCI_NOTIFY
)
1943 mciDriverNotify((HWND
)lpParms
->dwCallback
, wDevID
,
1944 (dwRet
== 0) ? MCI_NOTIFY_SUCCESSFUL
: MCI_NOTIFY_FAILURE
);
1949 /**************************************************************************
1950 * MCI_Sound [internal]
1952 static DWORD
MCI_Sound(UINT wDevID
, DWORD dwFlags
, LPMCI_SOUND_PARMSW lpParms
)
1956 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
1958 if (dwFlags
& MCI_SOUND_NAME
)
1959 dwRet
= sndPlaySoundW(lpParms
->lpstrSoundName
, SND_SYNC
) ? MMSYSERR_NOERROR
: MMSYSERR_ERROR
;
1961 dwRet
= MMSYSERR_ERROR
; /* what should be done ??? */
1962 if (dwFlags
& MCI_NOTIFY
)
1963 mciDriverNotify((HWND
)lpParms
->dwCallback
, wDevID
,
1964 (dwRet
== 0) ? MCI_NOTIFY_SUCCESSFUL
: MCI_NOTIFY_FAILURE
);
1969 /**************************************************************************
1970 * MCI_SendCommand [internal]
1972 DWORD
MCI_SendCommand(UINT wDevID
, UINT16 wMsg
, DWORD_PTR dwParam1
,
1973 DWORD_PTR dwParam2
, BOOL bFrom32
)
1975 DWORD dwRet
= MCIERR_UNRECOGNIZED_COMMAND
;
1980 dwRet
= MCI_Open(dwParam1
, (LPMCI_OPEN_PARMSW
)dwParam2
);
1981 } else if (pFnMciMapMsg16To32W
) {
1982 switch (pFnMciMapMsg16To32W(0, wMsg
, dwParam1
, &dwParam2
)) {
1984 case WINMM_MAP_OKMEM
:
1985 dwRet
= MCI_Open(dwParam1
, (LPMCI_OPEN_PARMSW
)dwParam2
);
1986 pFnMciUnMapMsg16To32W(0, wMsg
, dwParam1
, dwParam2
);
1988 default: break; /* so that gcc does not bark */
1994 dwRet
= MCI_Close(wDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
1995 } else if (pFnMciMapMsg16To32W
) {
1996 switch (pFnMciMapMsg16To32W(0, wMsg
, dwParam1
, &dwParam2
)) {
1998 case WINMM_MAP_OKMEM
:
1999 dwRet
= MCI_Close(wDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
2000 pFnMciUnMapMsg16To32W(0, wMsg
, dwParam1
, dwParam2
);
2002 default: break; /* so that gcc does not bark */
2008 dwRet
= MCI_SysInfo(wDevID
, dwParam1
, (LPMCI_SYSINFO_PARMSW
)dwParam2
);
2009 } else if (pFnMciMapMsg16To32W
) {
2010 switch (pFnMciMapMsg16To32W(0, wMsg
, dwParam1
, &dwParam2
)) {
2012 case WINMM_MAP_OKMEM
:
2013 dwRet
= MCI_SysInfo(wDevID
, dwParam1
, (LPMCI_SYSINFO_PARMSW
)dwParam2
);
2014 pFnMciUnMapMsg16To32W(0, wMsg
, dwParam1
, dwParam2
);
2016 default: break; /* so that gcc does not bark */
2022 dwRet
= MCI_Break(wDevID
, dwParam1
, (LPMCI_BREAK_PARMS
)dwParam2
);
2023 } else if (pFnMciMapMsg16To32W
) {
2024 switch (pFnMciMapMsg16To32W(0, wMsg
, dwParam1
, &dwParam2
)) {
2026 case WINMM_MAP_OKMEM
:
2027 dwRet
= MCI_Break(wDevID
, dwParam1
, (LPMCI_BREAK_PARMS
)dwParam2
);
2028 pFnMciUnMapMsg16To32W(0, wMsg
, dwParam1
, dwParam2
);
2030 default: break; /* so that gcc does not bark */
2036 dwRet
= MCI_Sound(wDevID
, dwParam1
, (LPMCI_SOUND_PARMSW
)dwParam2
);
2037 } else if (pFnMciMapMsg16To32W
) {
2038 switch (pFnMciMapMsg16To32W(0, wMsg
, dwParam1
, &dwParam2
)) {
2040 case WINMM_MAP_OKMEM
:
2041 dwRet
= MCI_Sound(wDevID
, dwParam1
, (LPMCI_SOUND_PARMSW
)dwParam2
);
2042 pFnMciUnMapMsg16To32W(0, wMsg
, dwParam1
, dwParam2
);
2044 default: break; /* so that gcc does not bark */
2049 if (wDevID
== MCI_ALL_DEVICE_ID
) {
2050 FIXME("unhandled MCI_ALL_DEVICE_ID\n");
2051 dwRet
= MCIERR_CANNOT_USE_ALL
;
2054 MCI_SendCommandFrom32(wDevID
, wMsg
, dwParam1
, dwParam2
) :
2055 MCI_SendCommandFrom16(wDevID
, wMsg
, dwParam1
, dwParam2
);
2062 /**************************************************************************
2063 * MCI_CleanUp [internal]
2065 * Some MCI commands need to be cleaned-up (when not called from
2066 * mciSendString), because MCI drivers return extra information for string
2067 * transformation. This function gets rid of them.
2069 LRESULT
MCI_CleanUp(LRESULT dwRet
, UINT wMsg
, DWORD dwParam2
)
2072 return LOWORD(dwRet
);
2075 case MCI_GETDEVCAPS
:
2076 switch (dwRet
& 0xFFFF0000ul
) {
2078 case MCI_COLONIZED3_RETURN
:
2079 case MCI_COLONIZED4_RETURN
:
2080 case MCI_INTEGER_RETURNED
:
2083 case MCI_RESOURCE_RETURNED
:
2084 case MCI_RESOURCE_RETURNED
|MCI_RESOURCE_DRIVER
:
2086 LPMCI_GETDEVCAPS_PARMS lmgp
;
2088 lmgp
= (LPMCI_GETDEVCAPS_PARMS
)(void*)dwParam2
;
2089 TRACE("Changing %08x to %08x\n", lmgp
->dwReturn
, LOWORD(lmgp
->dwReturn
));
2090 lmgp
->dwReturn
= LOWORD(lmgp
->dwReturn
);
2094 FIXME("Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2095 HIWORD(dwRet
), MCI_MessageToString(wMsg
));
2099 switch (dwRet
& 0xFFFF0000ul
) {
2101 case MCI_COLONIZED3_RETURN
:
2102 case MCI_COLONIZED4_RETURN
:
2103 case MCI_INTEGER_RETURNED
:
2106 case MCI_RESOURCE_RETURNED
:
2107 case MCI_RESOURCE_RETURNED
|MCI_RESOURCE_DRIVER
:
2109 LPMCI_STATUS_PARMS lsp
;
2111 lsp
= (LPMCI_STATUS_PARMS
)(void*)dwParam2
;
2112 TRACE("Changing %08x to %08x\n", lsp
->dwReturn
, LOWORD(lsp
->dwReturn
));
2113 lsp
->dwReturn
= LOWORD(lsp
->dwReturn
);
2117 FIXME("Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2118 HIWORD(dwRet
), MCI_MessageToString(wMsg
));
2122 switch (dwRet
& 0xFFFF0000ul
) {
2124 case MCI_INTEGER_RETURNED
:
2128 FIXME("Unsupported value for hiword (%04x)\n", HIWORD(dwRet
));
2132 if (HIWORD(dwRet
)) {
2133 FIXME("Got non null hiword for dwRet=0x%08lx for command %s\n",
2134 dwRet
, MCI_MessageToString(wMsg
));
2138 return LOWORD(dwRet
);
2141 /**************************************************************************
2142 * mciGetErrorStringW [WINMM.@]
2144 BOOL WINAPI
mciGetErrorStringW(MCIERROR wError
, LPWSTR lpstrBuffer
, UINT uLength
)
2148 if (lpstrBuffer
!= NULL
&& uLength
> 0 &&
2149 wError
>= MCIERR_BASE
&& wError
<= MCIERR_CUSTOM_DRIVER_BASE
) {
2151 if (LoadStringW(WINMM_IData
.hWinMM32Instance
,
2152 wError
, lpstrBuffer
, uLength
) > 0) {
2159 /**************************************************************************
2160 * mciGetErrorStringA [WINMM.@]
2162 BOOL WINAPI
mciGetErrorStringA(MCIERROR dwError
, LPSTR lpstrBuffer
, UINT uLength
)
2166 if (lpstrBuffer
!= NULL
&& uLength
> 0 &&
2167 dwError
>= MCIERR_BASE
&& dwError
<= MCIERR_CUSTOM_DRIVER_BASE
) {
2169 if (LoadStringA(WINMM_IData
.hWinMM32Instance
,
2170 dwError
, lpstrBuffer
, uLength
) > 0) {
2177 /**************************************************************************
2178 * mciDriverNotify [WINMM.@]
2180 BOOL WINAPI
mciDriverNotify(HWND hWndCallBack
, MCIDEVICEID wDevID
, UINT wStatus
)
2182 TRACE("(%p, %04x, %04X)\n", hWndCallBack
, wDevID
, wStatus
);
2184 return PostMessageW(hWndCallBack
, MM_MCINOTIFY
, wStatus
, wDevID
);
2187 /**************************************************************************
2188 * mciGetDriverData [WINMM.@]
2190 DWORD WINAPI
mciGetDriverData(MCIDEVICEID uDeviceID
)
2192 LPWINE_MCIDRIVER wmd
;
2194 TRACE("(%04x)\n", uDeviceID
);
2196 wmd
= MCI_GetDriver(uDeviceID
);
2199 WARN("Bad uDeviceID\n");
2203 return wmd
->dwPrivate
;
2206 /**************************************************************************
2207 * mciSetDriverData [WINMM.@]
2209 BOOL WINAPI
mciSetDriverData(MCIDEVICEID uDeviceID
, DWORD data
)
2211 LPWINE_MCIDRIVER wmd
;
2213 TRACE("(%04x, %08x)\n", uDeviceID
, data
);
2215 wmd
= MCI_GetDriver(uDeviceID
);
2218 WARN("Bad uDeviceID\n");
2222 wmd
->dwPrivate
= data
;
2226 /**************************************************************************
2227 * mciSendCommandW [WINMM.@]
2230 DWORD WINAPI
mciSendCommandW(MCIDEVICEID wDevID
, UINT wMsg
, DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
2234 TRACE("(%08x, %s, %08lx, %08lx)\n",
2235 wDevID
, MCI_MessageToString(wMsg
), dwParam1
, dwParam2
);
2237 dwRet
= MCI_SendCommand(wDevID
, wMsg
, dwParam1
, dwParam2
, TRUE
);
2238 dwRet
= MCI_CleanUp(dwRet
, wMsg
, dwParam2
);
2239 TRACE("=> %08x\n", dwRet
);
2243 /**************************************************************************
2244 * mciSendCommandA [WINMM.@]
2246 DWORD WINAPI
mciSendCommandA(MCIDEVICEID wDevID
, UINT wMsg
, DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
2251 TRACE("(%08x, %s, %08lx, %08lx)\n",
2252 wDevID
, MCI_MessageToString(wMsg
), dwParam1
, dwParam2
);
2254 mapped
= MCI_MapMsgAtoW(wMsg
, dwParam1
, &dwParam2
);
2257 FIXME("message %04x mapping failed\n", wMsg
);
2258 return MMSYSERR_NOMEM
;
2260 ret
= mciSendCommandW(wDevID
, wMsg
, dwParam1
, dwParam2
);
2262 MCI_UnmapMsgAtoW(wMsg
, dwParam1
, dwParam2
, ret
);
2266 /**************************************************************************
2267 * mciGetDeviceIDA [WINMM.@]
2269 UINT WINAPI
mciGetDeviceIDA(LPCSTR lpstrName
)
2271 LPWSTR w
= MCI_strdupAtoW(lpstrName
);
2272 UINT ret
= MCIERR_OUT_OF_MEMORY
;
2276 ret
= mciGetDeviceIDW(w
);
2277 HeapFree(GetProcessHeap(), 0, w
);
2282 /**************************************************************************
2283 * mciGetDeviceIDW [WINMM.@]
2285 UINT WINAPI
mciGetDeviceIDW(LPCWSTR lpwstrName
)
2287 return MCI_GetDriverFromString(lpwstrName
);
2290 /******************************************************************
2293 * Internal wrapper to call USER.UserYield16 (in fact through a Wine only export from USER32).
2295 static void MyUserYield(void)
2297 HMODULE mod
= GetModuleHandleA( "user32.dll" );
2300 FARPROC proc
= GetProcAddress( mod
, "UserYield16" );
2305 /**************************************************************************
2306 * MCI_DefYieldProc [internal]
2308 UINT WINAPI
MCI_DefYieldProc(MCIDEVICEID wDevID
, DWORD data
)
2312 TRACE("(0x%04x, 0x%08x)\n", wDevID
, data
);
2314 if ((HIWORD(data
) != 0 && HWND_16(GetActiveWindow()) != HIWORD(data
)) ||
2315 (GetAsyncKeyState(LOWORD(data
)) & 1) == 0) {
2321 msg
.hwnd
= HWND_32(HIWORD(data
));
2322 while (!PeekMessageW(&msg
, msg
.hwnd
, WM_KEYFIRST
, WM_KEYLAST
, PM_REMOVE
));
2328 /**************************************************************************
2329 * mciSetYieldProc [WINMM.@]
2331 BOOL WINAPI
mciSetYieldProc(MCIDEVICEID uDeviceID
, YIELDPROC fpYieldProc
, DWORD dwYieldData
)
2333 LPWINE_MCIDRIVER wmd
;
2335 TRACE("(%u, %p, %08x)\n", uDeviceID
, fpYieldProc
, dwYieldData
);
2337 if (!(wmd
= MCI_GetDriver(uDeviceID
))) {
2338 WARN("Bad uDeviceID\n");
2342 wmd
->lpfnYieldProc
= fpYieldProc
;
2343 wmd
->dwYieldData
= dwYieldData
;
2349 /**************************************************************************
2350 * mciGetDeviceIDFromElementIDA [WINMM.@]
2352 UINT WINAPI
mciGetDeviceIDFromElementIDA(DWORD dwElementID
, LPCSTR lpstrType
)
2354 LPWSTR w
= MCI_strdupAtoW(lpstrType
);
2359 ret
= mciGetDeviceIDFromElementIDW(dwElementID
, w
);
2360 HeapFree(GetProcessHeap(), 0, w
);
2365 /**************************************************************************
2366 * mciGetDeviceIDFromElementIDW [WINMM.@]
2368 UINT WINAPI
mciGetDeviceIDFromElementIDW(DWORD dwElementID
, LPCWSTR lpstrType
)
2370 /* FIXME: that's rather strange, there is no
2371 * mciGetDeviceIDFromElementID32A in winmm.spec
2373 FIXME("(%u, %s) stub\n", dwElementID
, debugstr_w(lpstrType
));
2377 /**************************************************************************
2378 * mciGetYieldProc [WINMM.@]
2380 YIELDPROC WINAPI
mciGetYieldProc(MCIDEVICEID uDeviceID
, DWORD
* lpdwYieldData
)
2382 LPWINE_MCIDRIVER wmd
;
2384 TRACE("(%u, %p)\n", uDeviceID
, lpdwYieldData
);
2386 if (!(wmd
= MCI_GetDriver(uDeviceID
))) {
2387 WARN("Bad uDeviceID\n");
2390 if (!wmd
->lpfnYieldProc
) {
2391 WARN("No proc set\n");
2395 WARN("Proc is 32 bit\n");
2398 return wmd
->lpfnYieldProc
;
2401 /**************************************************************************
2402 * mciGetCreatorTask [WINMM.@]
2404 HTASK WINAPI
mciGetCreatorTask(MCIDEVICEID uDeviceID
)
2406 LPWINE_MCIDRIVER wmd
;
2409 if ((wmd
= MCI_GetDriver(uDeviceID
))) ret
= (HTASK
)wmd
->CreatorThread
;
2411 TRACE("(%u) => %p\n", uDeviceID
, ret
);
2415 /**************************************************************************
2416 * mciDriverYield [WINMM.@]
2418 UINT WINAPI
mciDriverYield(MCIDEVICEID uDeviceID
)
2420 LPWINE_MCIDRIVER wmd
;
2423 TRACE("(%04x)\n", uDeviceID
);
2425 if (!(wmd
= MCI_GetDriver(uDeviceID
)) || !wmd
->lpfnYieldProc
|| !wmd
->bIs32
) {
2428 ret
= wmd
->lpfnYieldProc(uDeviceID
, wmd
->dwYieldData
);