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
41 #include "wine/port.h"
60 #include "wine/debug.h"
61 #include "wine/unicode.h"
63 WINE_DEFAULT_DEBUG_CHANNEL(mci
);
65 /* First MCI valid device ID (0 means error) */
66 #define MCI_MAGIC 0x0001
69 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};
70 static const WCHAR wszNull
[] = {0};
71 static const WCHAR wszAll
[] = {'A','L','L',0};
72 static const WCHAR wszMci
[] = {'M','C','I',0};
73 static const WCHAR wszOpen
[] = {'o','p','e','n',0};
74 static const WCHAR wszSystemIni
[] = {'s','y','s','t','e','m','.','i','n','i',0};
76 static WINE_MCIDRIVER
*MciDrivers
;
78 static UINT WINAPI
MCI_DefYieldProc(MCIDEVICEID wDevID
, DWORD data
);
79 static UINT
MCI_SetCommandTable(HGLOBAL hMem
, UINT uDevType
);
81 /* dup a string and uppercase it */
82 static inline LPWSTR
str_dup_upper( LPCWSTR str
)
84 INT len
= (strlenW(str
) + 1) * sizeof(WCHAR
);
85 LPWSTR p
= HeapAlloc( GetProcessHeap(), 0, len
);
88 memcpy( p
, str
, len
);
94 /**************************************************************************
95 * MCI_GetDriver [internal]
97 static LPWINE_MCIDRIVER
MCI_GetDriver(UINT wDevID
)
99 LPWINE_MCIDRIVER wmd
= 0;
101 EnterCriticalSection(&WINMM_cs
);
102 for (wmd
= MciDrivers
; wmd
; wmd
= wmd
->lpNext
) {
103 if (wmd
->wDeviceID
== wDevID
)
106 LeaveCriticalSection(&WINMM_cs
);
110 /**************************************************************************
111 * MCI_GetDriverFromString [internal]
113 static UINT
MCI_GetDriverFromString(LPCWSTR lpstrName
)
115 LPWINE_MCIDRIVER wmd
;
121 if (!strcmpiW(lpstrName
, wszAll
))
122 return MCI_ALL_DEVICE_ID
;
124 EnterCriticalSection(&WINMM_cs
);
125 for (wmd
= MciDrivers
; wmd
; wmd
= wmd
->lpNext
) {
126 if (wmd
->lpstrAlias
&& strcmpiW(wmd
->lpstrAlias
, lpstrName
) == 0) {
127 ret
= wmd
->wDeviceID
;
131 LeaveCriticalSection(&WINMM_cs
);
136 /**************************************************************************
137 * MCI_MessageToString [internal]
139 static const char* MCI_MessageToString(UINT wMsg
)
141 #define CASE(s) case (s): return #s
151 CASE(DRV_QUERYCONFIGURE
);
154 CASE(DRV_EXITSESSION
);
155 CASE(DRV_EXITAPPLICATION
);
159 CASE(MCI_CLOSE_DRIVER
);
168 CASE(MCI_GETDEVCAPS
);
172 CASE(MCI_OPEN_DRIVER
);
191 /* constants for digital video */
205 return wine_dbg_sprintf("MCI_<<%04X>>", wMsg
);
209 static LPWSTR
MCI_strdupAtoW( LPCSTR str
)
214 if (!str
) return NULL
;
215 len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
216 ret
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
217 if (ret
) MultiByteToWideChar( CP_ACP
, 0, str
, -1, ret
, len
);
221 static int MCI_MapMsgAtoW(UINT msg
, DWORD_PTR dwParam1
, DWORD_PTR
*dwParam2
)
223 if (msg
< DRV_RESERVED
) return 0;
258 { /* MCI_ANIM_OPEN_PARMS is the largest known MCI_OPEN_PARMS
259 * structure, larger than MCI_WAVE_OPEN_PARMS */
260 MCI_ANIM_OPEN_PARMSA
*mci_openA
= (MCI_ANIM_OPEN_PARMSA
*)*dwParam2
;
261 MCI_ANIM_OPEN_PARMSW
*mci_openW
;
264 ptr
= HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD_PTR
) + sizeof(*mci_openW
));
267 *ptr
++ = *dwParam2
; /* save the previous pointer */
268 *dwParam2
= (DWORD_PTR
)ptr
;
269 mci_openW
= (MCI_ANIM_OPEN_PARMSW
*)ptr
;
271 if (dwParam1
& MCI_NOTIFY
)
272 mci_openW
->dwCallback
= mci_openA
->dwCallback
;
274 if (dwParam1
& MCI_OPEN_TYPE
)
276 if (dwParam1
& MCI_OPEN_TYPE_ID
)
277 mci_openW
->lpstrDeviceType
= (LPCWSTR
)mci_openA
->lpstrDeviceType
;
279 mci_openW
->lpstrDeviceType
= MCI_strdupAtoW(mci_openA
->lpstrDeviceType
);
281 if (dwParam1
& MCI_OPEN_ELEMENT
)
283 if (dwParam1
& MCI_OPEN_ELEMENT_ID
)
284 mci_openW
->lpstrElementName
= (LPCWSTR
)mci_openA
->lpstrElementName
;
286 mci_openW
->lpstrElementName
= MCI_strdupAtoW(mci_openA
->lpstrElementName
);
288 if (dwParam1
& MCI_OPEN_ALIAS
)
289 mci_openW
->lpstrAlias
= MCI_strdupAtoW(mci_openA
->lpstrAlias
);
290 /* We don't know how many DWORD follow, as
291 * the structure depends on the device. */
292 if (HIWORD(dwParam1
))
293 memcpy(&mci_openW
->dwStyle
, &mci_openA
->dwStyle
, sizeof(MCI_ANIM_OPEN_PARMSW
) - sizeof(MCI_OPEN_PARMSW
));
298 if (dwParam1
& MCI_ANIM_WINDOW_TEXT
)
300 MCI_ANIM_WINDOW_PARMSA
*mci_windowA
= (MCI_ANIM_WINDOW_PARMSA
*)*dwParam2
;
301 MCI_ANIM_WINDOW_PARMSW
*mci_windowW
;
303 mci_windowW
= HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_windowW
));
304 if (!mci_windowW
) return -1;
306 *dwParam2
= (DWORD_PTR
)mci_windowW
;
308 mci_windowW
->lpstrText
= MCI_strdupAtoW(mci_windowA
->lpstrText
);
310 if (dwParam1
& MCI_NOTIFY
)
311 mci_windowW
->dwCallback
= mci_windowA
->dwCallback
;
312 if (dwParam1
& MCI_ANIM_WINDOW_HWND
)
313 mci_windowW
->hWnd
= mci_windowA
->hWnd
;
314 if (dwParam1
& MCI_ANIM_WINDOW_STATE
)
315 mci_windowW
->nCmdShow
= mci_windowA
->nCmdShow
;
322 if (dwParam1
& (MCI_SYSINFO_INSTALLNAME
| MCI_SYSINFO_NAME
))
324 MCI_SYSINFO_PARMSA
*mci_sysinfoA
= (MCI_SYSINFO_PARMSA
*)*dwParam2
;
325 MCI_SYSINFO_PARMSW
*mci_sysinfoW
;
328 ptr
= HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_sysinfoW
) + sizeof(DWORD_PTR
));
331 *ptr
++ = *dwParam2
; /* save the previous pointer */
332 *dwParam2
= (DWORD_PTR
)ptr
;
333 mci_sysinfoW
= (MCI_SYSINFO_PARMSW
*)ptr
;
335 if (dwParam1
& MCI_NOTIFY
)
336 mci_sysinfoW
->dwCallback
= mci_sysinfoA
->dwCallback
;
338 /* Size is measured in numbers of characters, despite what MSDN says. */
339 mci_sysinfoW
->dwRetSize
= mci_sysinfoA
->dwRetSize
;
340 mci_sysinfoW
->lpstrReturn
= HeapAlloc(GetProcessHeap(), 0, mci_sysinfoW
->dwRetSize
* sizeof(WCHAR
));
341 mci_sysinfoW
->dwNumber
= mci_sysinfoA
->dwNumber
;
342 mci_sysinfoW
->wDeviceType
= mci_sysinfoA
->wDeviceType
;
348 MCI_DGV_INFO_PARMSA
*mci_infoA
= (MCI_DGV_INFO_PARMSA
*)*dwParam2
;
349 MCI_DGV_INFO_PARMSW
*mci_infoW
;
352 ptr
= HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_infoW
) + sizeof(DWORD_PTR
));
355 *ptr
++ = *dwParam2
; /* save the previous pointer */
356 *dwParam2
= (DWORD_PTR
)ptr
;
357 mci_infoW
= (MCI_DGV_INFO_PARMSW
*)ptr
;
359 if (dwParam1
& MCI_NOTIFY
)
360 mci_infoW
->dwCallback
= mci_infoA
->dwCallback
;
362 /* Size is measured in numbers of characters. */
363 mci_infoW
->dwRetSize
= mci_infoA
->dwRetSize
;
364 mci_infoW
->lpstrReturn
= HeapAlloc(GetProcessHeap(), 0, mci_infoW
->dwRetSize
* sizeof(WCHAR
));
365 if (dwParam1
& MCI_DGV_INFO_ITEM
)
366 mci_infoW
->dwItem
= mci_infoA
->dwItem
;
373 { /* All these commands have the same layout: callback + string + optional rect */
374 MCI_OVLY_LOAD_PARMSA
*mci_loadA
= (MCI_OVLY_LOAD_PARMSA
*)*dwParam2
;
375 MCI_OVLY_LOAD_PARMSW
*mci_loadW
;
377 mci_loadW
= HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_loadW
));
378 if (!mci_loadW
) return -1;
380 *dwParam2
= (DWORD_PTR
)mci_loadW
;
381 if (dwParam1
& MCI_NOTIFY
)
382 mci_loadW
->dwCallback
= mci_loadA
->dwCallback
;
383 mci_loadW
->lpfilename
= MCI_strdupAtoW(mci_loadA
->lpfilename
);
384 if ((MCI_SAVE
== msg
&& dwParam1
& MCI_DGV_RECT
) ||
385 (MCI_LOAD
== msg
&& dwParam1
& MCI_OVLY_RECT
) ||
386 (MCI_CAPTURE
== msg
&& dwParam1
& MCI_DGV_CAPTURE_AT
) ||
387 (MCI_RESTORE
== msg
&& dwParam1
& MCI_DGV_RESTORE_AT
))
388 mci_loadW
->rc
= mci_loadA
->rc
;
393 { /* All these commands have the same layout: callback + string */
394 MCI_VD_ESCAPE_PARMSA
*mci_vd_escapeA
= (MCI_VD_ESCAPE_PARMSA
*)*dwParam2
;
395 MCI_VD_ESCAPE_PARMSW
*mci_vd_escapeW
;
397 mci_vd_escapeW
= HeapAlloc(GetProcessHeap(), 0, sizeof(*mci_vd_escapeW
));
398 if (!mci_vd_escapeW
) return -1;
400 *dwParam2
= (DWORD_PTR
)mci_vd_escapeW
;
401 if (dwParam1
& MCI_NOTIFY
)
402 mci_vd_escapeW
->dwCallback
= mci_vd_escapeA
->dwCallback
;
403 mci_vd_escapeW
->lpstrCommand
= MCI_strdupAtoW(mci_vd_escapeA
->lpstrCommand
);
408 if (!(dwParam1
& (MCI_DGV_SETVIDEO_QUALITY
| MCI_DGV_SETVIDEO_ALG
409 | MCI_DGV_SETAUDIO_QUALITY
| MCI_DGV_SETAUDIO_ALG
)))
411 /* fall through to default */
416 FIXME("Message %s needs translation\n", MCI_MessageToString(msg
));
417 return 0; /* pass through untouched */
421 static void MCI_UnmapMsgAtoW(UINT msg
, DWORD_PTR dwParam1
, DWORD_PTR dwParam2
,
428 DWORD_PTR
*ptr
= (DWORD_PTR
*)dwParam2
- 1;
429 MCI_OPEN_PARMSA
*mci_openA
= (MCI_OPEN_PARMSA
*)*ptr
;
430 MCI_OPEN_PARMSW
*mci_openW
= (MCI_OPEN_PARMSW
*)dwParam2
;
432 mci_openA
->wDeviceID
= mci_openW
->wDeviceID
;
434 if (dwParam1
& MCI_OPEN_TYPE
)
436 if (!(dwParam1
& MCI_OPEN_TYPE_ID
))
437 HeapFree(GetProcessHeap(), 0, (LPWSTR
)mci_openW
->lpstrDeviceType
);
439 if (dwParam1
& MCI_OPEN_ELEMENT
)
441 if (!(dwParam1
& MCI_OPEN_ELEMENT_ID
))
442 HeapFree(GetProcessHeap(), 0, (LPWSTR
)mci_openW
->lpstrElementName
);
444 if (dwParam1
& MCI_OPEN_ALIAS
)
445 HeapFree(GetProcessHeap(), 0, (LPWSTR
)mci_openW
->lpstrAlias
);
446 HeapFree(GetProcessHeap(), 0, ptr
);
450 if (dwParam1
& MCI_ANIM_WINDOW_TEXT
)
452 MCI_ANIM_WINDOW_PARMSW
*mci_windowW
= (MCI_ANIM_WINDOW_PARMSW
*)dwParam2
;
454 HeapFree(GetProcessHeap(), 0, (void*)mci_windowW
->lpstrText
);
455 HeapFree(GetProcessHeap(), 0, mci_windowW
);
460 if (dwParam1
& (MCI_SYSINFO_INSTALLNAME
| MCI_SYSINFO_NAME
))
462 DWORD_PTR
*ptr
= (DWORD_PTR
*)dwParam2
- 1;
463 MCI_SYSINFO_PARMSA
*mci_sysinfoA
= (MCI_SYSINFO_PARMSA
*)*ptr
;
464 MCI_SYSINFO_PARMSW
*mci_sysinfoW
= (MCI_SYSINFO_PARMSW
*)dwParam2
;
468 WideCharToMultiByte(CP_ACP
, 0,
469 mci_sysinfoW
->lpstrReturn
, -1,
470 mci_sysinfoA
->lpstrReturn
, mci_sysinfoA
->dwRetSize
,
474 HeapFree(GetProcessHeap(), 0, mci_sysinfoW
->lpstrReturn
);
475 HeapFree(GetProcessHeap(), 0, ptr
);
480 DWORD_PTR
*ptr
= (DWORD_PTR
*)dwParam2
- 1;
481 MCI_INFO_PARMSA
*mci_infoA
= (MCI_INFO_PARMSA
*)*ptr
;
482 MCI_INFO_PARMSW
*mci_infoW
= (MCI_INFO_PARMSW
*)dwParam2
;
486 WideCharToMultiByte(CP_ACP
, 0,
487 mci_infoW
->lpstrReturn
, -1,
488 mci_infoA
->lpstrReturn
, mci_infoA
->dwRetSize
,
492 HeapFree(GetProcessHeap(), 0, mci_infoW
->lpstrReturn
);
493 HeapFree(GetProcessHeap(), 0, ptr
);
500 { /* All these commands have the same layout: callback + string + optional rect */
501 MCI_OVLY_LOAD_PARMSW
*mci_loadW
= (MCI_OVLY_LOAD_PARMSW
*)dwParam2
;
503 HeapFree(GetProcessHeap(), 0, (void*)mci_loadW
->lpfilename
);
504 HeapFree(GetProcessHeap(), 0, mci_loadW
);
509 { /* All these commands have the same layout: callback + string */
510 MCI_VD_ESCAPE_PARMSW
*mci_vd_escapeW
= (MCI_VD_ESCAPE_PARMSW
*)dwParam2
;
512 HeapFree(GetProcessHeap(), 0, (void*)mci_vd_escapeW
->lpstrCommand
);
513 HeapFree(GetProcessHeap(), 0, mci_vd_escapeW
);
518 FIXME("Message %s needs unmapping\n", MCI_MessageToString(msg
));
523 /**************************************************************************
524 * MCI_GetDevTypeFromFileName [internal]
526 static DWORD
MCI_GetDevTypeFromFileName(LPCWSTR fileName
, LPWSTR buf
, UINT len
)
530 static const WCHAR keyW
[] = {'S','O','F','T','W','A','R','E','\\','M','i','c','r','o','s','o','f','t','\\',
531 'W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
532 'M','C','I',' ','E','x','t','e','n','s','i','o','n','s',0};
533 if ((tmp
= strrchrW(fileName
, '.'))) {
534 if (RegOpenKeyExW( HKEY_LOCAL_MACHINE
, keyW
,
535 0, KEY_QUERY_VALUE
, &hKey
) == ERROR_SUCCESS
) {
537 LONG lRet
= RegQueryValueExW( hKey
, tmp
+ 1, 0, 0, (void*)buf
, &dwLen
);
539 if (lRet
== ERROR_SUCCESS
) return 0;
541 TRACE("No ...\\MCI Extensions entry for %s found.\n", debugstr_w(tmp
));
543 return MCIERR_EXTENSION_NOT_FOUND
;
546 /**************************************************************************
547 * MCI_GetDevTypeFromResource [internal]
549 static UINT
MCI_GetDevTypeFromResource(LPCWSTR lpstrName
)
553 for (uDevType
= MCI_DEVTYPE_FIRST
; uDevType
<= MCI_DEVTYPE_LAST
; uDevType
++) {
554 if (LoadStringW(hWinMM32Instance
, uDevType
, buf
, sizeof(buf
) / sizeof(WCHAR
))) {
555 /* FIXME: ignore digits suffix */
556 if (!strcmpiW(buf
, lpstrName
))
563 #define MAX_MCICMDTABLE 20
564 #define MCI_COMMAND_TABLE_NOT_LOADED 0xFFFE
566 typedef struct tagWINE_MCICMDTABLE
{
570 UINT nVerbs
; /* number of verbs in command table */
571 LPCWSTR
* aVerbs
; /* array of verbs to speed up the verb look up process */
572 } WINE_MCICMDTABLE
, *LPWINE_MCICMDTABLE
;
574 static WINE_MCICMDTABLE S_MciCmdTable
[MAX_MCICMDTABLE
];
576 /**************************************************************************
577 * MCI_IsCommandTableValid [internal]
579 static BOOL
MCI_IsCommandTableValid(UINT uTbl
)
588 TRACE("Dumping cmdTbl=%d [lpTable=%p devType=%d]\n",
589 uTbl
, S_MciCmdTable
[uTbl
].lpTable
, S_MciCmdTable
[uTbl
].uDevType
);
591 if (uTbl
>= MAX_MCICMDTABLE
|| !S_MciCmdTable
[uTbl
].lpTable
)
594 lmem
= S_MciCmdTable
[uTbl
].lpTable
;
597 lmem
+= (strlenW(str
) + 1) * sizeof(WCHAR
);
598 flg
= *(const DWORD
*)lmem
;
599 eid
= *(const WORD
*)(lmem
+ sizeof(DWORD
));
600 lmem
+= sizeof(DWORD
) + sizeof(WORD
);
602 /* TRACE("cmd=%s %08lx %04x\n", debugstr_w(str), flg, eid); */
604 case MCI_COMMAND_HEAD
: if (!*str
|| !flg
) return FALSE
; idx
= 0; break; /* check unicity of str in table */
605 case MCI_STRING
: if (inCst
) return FALSE
; break;
606 case MCI_HWND
: /* Occurs inside MCI_CONSTANT as in "window handle default" */
609 case MCI_INTEGER
: if (!*str
) return FALSE
; break;
610 case MCI_END_COMMAND
: if (*str
|| flg
|| idx
== 0) return FALSE
; idx
= 0; break;
611 case MCI_RETURN
: if (*str
|| idx
!= 1) return FALSE
; break;
612 case MCI_FLAG
: if (!*str
) return FALSE
; break;
613 case MCI_END_COMMAND_LIST
: if (*str
|| flg
) return FALSE
; idx
= 0; break;
614 case MCI_RECT
: if (!*str
|| inCst
) return FALSE
; break;
615 case MCI_CONSTANT
: if (inCst
) return FALSE
; inCst
= TRUE
; break;
616 case MCI_END_CONSTANT
: if (*str
|| flg
|| !inCst
) return FALSE
; inCst
= FALSE
; break;
617 default: return FALSE
;
619 } while (eid
!= MCI_END_COMMAND_LIST
);
623 /**************************************************************************
624 * MCI_DumpCommandTable [internal]
626 static BOOL
MCI_DumpCommandTable(UINT uTbl
)
632 if (!MCI_IsCommandTableValid(uTbl
)) {
633 ERR("Ooops: %d is not valid\n", uTbl
);
637 lmem
= S_MciCmdTable
[uTbl
].lpTable
;
642 lmem
+= (strlenW(str
) + 1) * sizeof(WCHAR
);
643 /* flg = *(const DWORD*)lmem; */
644 eid
= *(const WORD
*)(lmem
+ sizeof(DWORD
));
645 /* TRACE("cmd=%s %08lx %04x\n", debugstr_w(str), flg, eid); */
646 lmem
+= sizeof(DWORD
) + sizeof(WORD
);
647 } while (eid
!= MCI_END_COMMAND
&& eid
!= MCI_END_COMMAND_LIST
);
648 /* EPP TRACE(" => end of command%s\n", (eid == MCI_END_COMMAND_LIST) ? " list" : ""); */
649 } while (eid
!= MCI_END_COMMAND_LIST
);
654 /**************************************************************************
655 * MCI_GetCommandTable [internal]
657 static UINT
MCI_GetCommandTable(UINT uDevType
)
663 /* first look up existing for existing devType */
664 for (uTbl
= 0; uTbl
< MAX_MCICMDTABLE
; uTbl
++) {
665 if (S_MciCmdTable
[uTbl
].lpTable
&& S_MciCmdTable
[uTbl
].uDevType
== uDevType
)
669 /* well try to load id */
670 if (uDevType
>= MCI_DEVTYPE_FIRST
&& uDevType
<= MCI_DEVTYPE_LAST
) {
671 if (LoadStringW(hWinMM32Instance
, uDevType
, buf
, sizeof(buf
) / sizeof(WCHAR
))) {
674 } else if (uDevType
== 0) {
675 static const WCHAR wszCore
[] = {'C','O','R','E',0};
678 uTbl
= MCI_NO_COMMAND_TABLE
;
680 HRSRC hRsrc
= FindResourceW(hWinMM32Instance
, str
, (LPCWSTR
)RT_RCDATA
);
683 if (hRsrc
) hMem
= LoadResource(hWinMM32Instance
, hRsrc
);
685 uTbl
= MCI_SetCommandTable(hMem
, uDevType
);
687 WARN("No command table found in resource %p[%s]\n",
688 hWinMM32Instance
, debugstr_w(str
));
691 TRACE("=> %d\n", uTbl
);
695 /**************************************************************************
696 * MCI_SetCommandTable [internal]
698 static UINT
MCI_SetCommandTable(HGLOBAL hMem
, UINT uDevType
)
701 static BOOL bInitDone
= FALSE
;
704 * The CORE command table must be loaded first, so that MCI_GetCommandTable()
705 * can be called with 0 as a uDevType to retrieve it.
710 MCI_GetCommandTable(0);
712 TRACE("(%p, %u)\n", hMem
, uDevType
);
713 for (uTbl
= 0; uTbl
< MAX_MCICMDTABLE
; uTbl
++) {
714 if (!S_MciCmdTable
[uTbl
].lpTable
) {
720 S_MciCmdTable
[uTbl
].uDevType
= uDevType
;
721 S_MciCmdTable
[uTbl
].lpTable
= LockResource(hMem
);
722 S_MciCmdTable
[uTbl
].hMem
= hMem
;
725 MCI_DumpCommandTable(uTbl
);
728 /* create the verbs table */
729 /* get # of entries */
730 lmem
= S_MciCmdTable
[uTbl
].lpTable
;
734 lmem
+= (strlenW(str
) + 1) * sizeof(WCHAR
);
735 eid
= *(const WORD
*)(lmem
+ sizeof(DWORD
));
736 lmem
+= sizeof(DWORD
) + sizeof(WORD
);
737 if (eid
== MCI_COMMAND_HEAD
)
739 } while (eid
!= MCI_END_COMMAND_LIST
);
741 S_MciCmdTable
[uTbl
].aVerbs
= HeapAlloc(GetProcessHeap(), 0, count
* sizeof(LPCWSTR
));
742 S_MciCmdTable
[uTbl
].nVerbs
= count
;
744 lmem
= S_MciCmdTable
[uTbl
].lpTable
;
748 lmem
+= (strlenW(str
) + 1) * sizeof(WCHAR
);
749 eid
= *(const WORD
*)(lmem
+ sizeof(DWORD
));
750 lmem
+= sizeof(DWORD
) + sizeof(WORD
);
751 if (eid
== MCI_COMMAND_HEAD
)
752 S_MciCmdTable
[uTbl
].aVerbs
[count
++] = str
;
753 } while (eid
!= MCI_END_COMMAND_LIST
);
754 /* assert(count == S_MciCmdTable[uTbl].nVerbs); */
759 return MCI_NO_COMMAND_TABLE
;
762 /**************************************************************************
763 * MCI_UnLoadMciDriver [internal]
765 static BOOL
MCI_UnLoadMciDriver(LPWINE_MCIDRIVER wmd
)
767 LPWINE_MCIDRIVER
* tmp
;
772 CloseDriver(wmd
->hDriver
, 0, 0);
774 if (wmd
->dwPrivate
!= 0)
775 WARN("Unloading mci driver with non nul dwPrivate field\n");
777 EnterCriticalSection(&WINMM_cs
);
778 for (tmp
= &MciDrivers
; *tmp
; tmp
= &(*tmp
)->lpNext
) {
784 LeaveCriticalSection(&WINMM_cs
);
786 HeapFree(GetProcessHeap(), 0, wmd
->lpstrDeviceType
);
787 HeapFree(GetProcessHeap(), 0, wmd
->lpstrAlias
);
789 HeapFree(GetProcessHeap(), 0, wmd
);
793 /**************************************************************************
794 * MCI_OpenMciDriver [internal]
796 static BOOL
MCI_OpenMciDriver(LPWINE_MCIDRIVER wmd
, LPCWSTR drvTyp
, DWORD_PTR lp
)
800 if (!DRIVER_GetLibName(drvTyp
, wszMci
, libName
, sizeof(libName
)))
803 /* First load driver */
804 wmd
->hDriver
= (HDRVR
)DRIVER_TryOpenDriver32(libName
, lp
);
805 return wmd
->hDriver
!= NULL
;
808 /**************************************************************************
809 * MCI_LoadMciDriver [internal]
811 static DWORD
MCI_LoadMciDriver(LPCWSTR _strDevTyp
, LPWINE_MCIDRIVER
* lpwmd
)
813 LPWSTR strDevTyp
= str_dup_upper(_strDevTyp
);
814 LPWINE_MCIDRIVER wmd
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*wmd
));
815 MCI_OPEN_DRIVER_PARMSW modp
;
818 if (!wmd
|| !strDevTyp
) {
819 dwRet
= MCIERR_OUT_OF_MEMORY
;
823 wmd
->lpfnYieldProc
= MCI_DefYieldProc
;
824 wmd
->dwYieldData
= VK_CANCEL
;
825 wmd
->CreatorThread
= GetCurrentThreadId();
827 EnterCriticalSection(&WINMM_cs
);
828 /* wmd must be inserted in list before sending opening the driver, because it
829 * may want to lookup at wDevID
831 wmd
->lpNext
= MciDrivers
;
834 for (modp
.wDeviceID
= MCI_MAGIC
;
835 MCI_GetDriver(modp
.wDeviceID
) != 0;
838 wmd
->wDeviceID
= modp
.wDeviceID
;
840 LeaveCriticalSection(&WINMM_cs
);
842 TRACE("wDevID=%04X\n", modp
.wDeviceID
);
844 modp
.lpstrParams
= NULL
;
846 if (!MCI_OpenMciDriver(wmd
, strDevTyp
, (DWORD_PTR
)&modp
)) {
847 /* silence warning if all is used... some bogus program use commands like
850 if (strcmpiW(strDevTyp
, wszAll
) == 0) {
851 dwRet
= MCIERR_CANNOT_USE_ALL
;
853 FIXME("Couldn't load driver for type %s.\n",
854 debugstr_w(strDevTyp
));
855 dwRet
= MCIERR_DEVICE_NOT_INSTALLED
;
860 /* FIXME: should also check that module's description is of the form
861 * MODULENAME:[MCI] comment
864 /* some drivers will return 0x0000FFFF, some others 0xFFFFFFFF */
865 wmd
->uSpecificCmdTable
= LOWORD(modp
.wCustomCommandTable
);
866 wmd
->uTypeCmdTable
= MCI_COMMAND_TABLE_NOT_LOADED
;
868 TRACE("Loaded driver %p (%s), type is %d, cmdTable=%08x\n",
869 wmd
->hDriver
, debugstr_w(strDevTyp
), modp
.wType
, modp
.wCustomCommandTable
);
871 wmd
->lpstrDeviceType
= strDevTyp
;
872 wmd
->wType
= modp
.wType
;
874 TRACE("mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
875 modp
.wDeviceID
, modp
.wType
, modp
.wDeviceID
);
879 MCI_UnLoadMciDriver(wmd
);
880 HeapFree(GetProcessHeap(), 0, strDevTyp
);
885 /**************************************************************************
886 * MCI_SendCommandFrom32 [internal]
888 static DWORD
MCI_SendCommandFrom32(MCIDEVICEID wDevID
, UINT16 wMsg
, DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
890 DWORD dwRet
= MCIERR_INVALID_DEVICE_ID
;
891 LPWINE_MCIDRIVER wmd
= MCI_GetDriver(wDevID
);
894 dwRet
= SendDriverMessage(wmd
->hDriver
, wMsg
, dwParam1
, dwParam2
);
899 /**************************************************************************
900 * MCI_FinishOpen [internal]
902 * Three modes of operation:
903 * 1 open foo.ext ... -> OPEN_ELEMENT with lpstrElementName=foo.ext
904 * open sequencer!foo.ext same with lpstrElementName=foo.ext
905 * 2 open new type waveaudio -> OPEN_ELEMENT with empty ("") lpstrElementName
906 * 3 open sequencer -> OPEN_ELEMENT unset, and
907 * capability sequencer (auto-open) likewise
909 static DWORD
MCI_FinishOpen(LPWINE_MCIDRIVER wmd
, LPMCI_OPEN_PARMSW lpParms
,
912 LPCWSTR alias
= NULL
;
913 /* Open always defines an alias for further reference */
914 if (dwParam
& MCI_OPEN_ALIAS
) { /* open ... alias */
915 alias
= lpParms
->lpstrAlias
;
916 if (MCI_GetDriverFromString(alias
))
917 return MCIERR_DUPLICATE_ALIAS
;
919 if ((dwParam
& MCI_OPEN_ELEMENT
) /* open file.wav */
920 && !(dwParam
& MCI_OPEN_ELEMENT_ID
))
921 alias
= lpParms
->lpstrElementName
;
922 else if (dwParam
& MCI_OPEN_TYPE
) /* open cdaudio */
923 alias
= wmd
->lpstrDeviceType
;
924 if (alias
&& MCI_GetDriverFromString(alias
))
925 return MCIERR_DEVICE_OPEN
;
928 wmd
->lpstrAlias
= HeapAlloc(GetProcessHeap(), 0, (strlenW(alias
)+1) * sizeof(WCHAR
));
929 if (!wmd
->lpstrAlias
) return MCIERR_OUT_OF_MEMORY
;
930 strcpyW( wmd
->lpstrAlias
, alias
);
931 /* In most cases, natives adds MCI_OPEN_ALIAS to the flags passed to the driver.
932 * Don't. The drivers don't care about the winmm alias. */
934 lpParms
->wDeviceID
= wmd
->wDeviceID
;
936 return MCI_SendCommandFrom32(wmd
->wDeviceID
, MCI_OPEN_DRIVER
, dwParam
,
940 /**************************************************************************
941 * MCI_FindCommand [internal]
943 static LPCWSTR
MCI_FindCommand(UINT uTbl
, LPCWSTR verb
)
947 if (uTbl
>= MAX_MCICMDTABLE
|| !S_MciCmdTable
[uTbl
].lpTable
)
950 /* another improvement would be to have the aVerbs array sorted,
951 * so that we could use a dichotomic search on it, rather than this dumb
954 for (idx
= 0; idx
< S_MciCmdTable
[uTbl
].nVerbs
; idx
++) {
955 if (strcmpiW(S_MciCmdTable
[uTbl
].aVerbs
[idx
], verb
) == 0)
956 return S_MciCmdTable
[uTbl
].aVerbs
[idx
];
962 /**************************************************************************
963 * MCI_GetReturnType [internal]
965 static DWORD
MCI_GetReturnType(LPCWSTR lpCmd
)
967 lpCmd
= (LPCWSTR
)((const BYTE
*)(lpCmd
+ strlenW(lpCmd
) + 1) + sizeof(DWORD
) + sizeof(WORD
));
968 if (*lpCmd
== '\0' && *(const WORD
*)((const BYTE
*)(lpCmd
+ 1) + sizeof(DWORD
)) == MCI_RETURN
) {
969 return *(const DWORD
*)(lpCmd
+ 1);
974 /**************************************************************************
975 * MCI_GetMessage [internal]
977 static WORD
MCI_GetMessage(LPCWSTR lpCmd
)
979 return (WORD
)*(const DWORD
*)(lpCmd
+ strlenW(lpCmd
) + 1);
982 /**************************************************************************
983 * MCI_GetDWord [internal]
985 * Accept 0 -1 255 255:0 255:255:255:255 :::1 1::: 2::3 ::4: 12345678
986 * Refuse -1:0 0:-1 :: 256:0 1:256 0::::1
988 static BOOL
MCI_GetDWord(DWORD
* data
, LPWSTR
* ptr
)
991 DWORD total
= 0, shift
= 0;
992 BOOL sign
= FALSE
, digits
= FALSE
;
994 while (*ret
== ' ' || *ret
== '\t') ret
++;
1001 while ('0' <= *ret
&& *ret
<= '9') {
1002 val
= *ret
++ - '0' + 10 * val
;
1008 case ' ': ret
++; break;
1009 default: return FALSE
;
1011 if ((val
>= 256) || (shift
>= 24)) return FALSE
;
1012 total
|= val
<< shift
;
1018 if (!digits
) return FALSE
;
1019 if (shift
&& (val
>= 256 || sign
)) return FALSE
;
1020 total
|= val
<< shift
;
1021 *data
= sign
? -total
: total
;
1027 /**************************************************************************
1028 * MCI_GetString [internal]
1030 static DWORD
MCI_GetString(LPWSTR
* str
, LPWSTR
* args
)
1034 /* see if we have a quoted string */
1036 ptr
= strchrW(*str
= ptr
+ 1, '"');
1037 if (!ptr
) return MCIERR_NO_CLOSING_QUOTE
;
1038 /* FIXME: shall we escape \" from string ?? */
1039 if (ptr
[-1] == '\\') TRACE("Ooops: un-escaped \"\n");
1040 *ptr
++ = '\0'; /* remove trailing " */
1041 if (*ptr
!= ' ' && *ptr
!= '\0') return MCIERR_EXTRA_CHARACTERS
;
1043 ptr
= strchrW(ptr
, ' ');
1048 ptr
= *args
+ strlenW(*args
);
1057 #define MCI_DATA_SIZE 16
1059 /**************************************************************************
1060 * MCI_ParseOptArgs [internal]
1062 static DWORD
MCI_ParseOptArgs(DWORD
* data
, int _offset
, LPCWSTR lpCmd
,
1063 LPWSTR args
, LPDWORD dwFlags
)
1068 DWORD dwRet
, flg
, cflg
= 0;
1072 /* loop on arguments */
1074 lmem
= (const char*)lpCmd
;
1075 found
= inCst
= FALSE
;
1078 /* skip any leading white space(s) */
1079 while (*args
== ' ') args
++;
1080 TRACE("args=%s\n", debugstr_w(args
));
1082 do { /* loop on options for command table for the requested verb */
1083 str
= (LPCWSTR
)lmem
;
1084 lmem
+= ((len
= strlenW(str
)) + 1) * sizeof(WCHAR
);
1085 flg
= *(const DWORD
*)lmem
;
1086 eid
= *(const WORD
*)(lmem
+ sizeof(DWORD
));
1087 lmem
+= sizeof(DWORD
) + sizeof(WORD
);
1088 /* TRACE("\tcmd=%s inCst=%c eid=%04x\n", debugstr_w(str), inCst ? 'Y' : 'N', eid); */
1092 inCst
= TRUE
; cflg
= flg
; break;
1093 case MCI_END_CONSTANT
:
1094 /* there may be additional integral values after flag in constant */
1095 if (inCst
&& MCI_GetDWord(&(data
[offset
]), &args
)) {
1098 inCst
= FALSE
; cflg
= 0;
1101 if (offset
!= _offset
) {
1102 ERR("MCI_RETURN not in first position\n");
1103 return MCIERR_PARSER_INTERNAL
;
1107 if (strncmpiW(args
, str
, len
) == 0 &&
1108 ((eid
== MCI_STRING
&& len
== 0) || args
[len
] == 0 || args
[len
] == ' ')) {
1109 /* store good values into data[] */
1111 while (*args
== ' ') args
++;
1115 case MCI_COMMAND_HEAD
:
1117 case MCI_END_COMMAND
:
1118 case MCI_END_COMMAND_LIST
:
1119 case MCI_CONSTANT
: /* done above */
1120 case MCI_END_CONSTANT
: /* done above */
1124 TRACE("flag=%08x\n", flg
);
1131 data
[offset
] |= flg
;
1134 TRACE("flag=%08x constant=%08x\n", cflg
, flg
);
1137 if (!MCI_GetDWord(&(data
[offset
]), &args
)) {
1138 return MCIERR_BAD_INTEGER
;
1140 TRACE("flag=%08x int=%d\n", flg
, data
[offset
]);
1144 /* store rect in data (offset..offset+3) */
1146 if (!MCI_GetDWord(&(data
[offset
+0]), &args
) ||
1147 !MCI_GetDWord(&(data
[offset
+1]), &args
) ||
1148 !MCI_GetDWord(&(data
[offset
+2]), &args
) ||
1149 !MCI_GetDWord(&(data
[offset
+3]), &args
)) {
1150 return MCIERR_BAD_INTEGER
;
1152 TRACE("flag=%08x for rectangle\n", flg
);
1156 if ((dwRet
= MCI_GetString((LPWSTR
*)&data
[offset
], &args
)))
1158 TRACE("flag=%08x string=%s\n", flg
, debugstr_w(*(LPWSTR
*)&data
[offset
]));
1160 default: ERR("oops\n");
1162 /* exit inside while loop, except if just entered in constant area definition */
1163 if (!inCst
|| eid
!= MCI_CONSTANT
) eid
= MCI_END_COMMAND
;
1165 /* have offset incremented if needed */
1167 case MCI_COMMAND_HEAD
:
1169 case MCI_END_COMMAND
:
1170 case MCI_END_COMMAND_LIST
:
1172 case MCI_FLAG
: break;
1175 case MCI_HDC
: if (!inCst
) offset
+= sizeof(HANDLE
)/sizeof(DWORD
); break;
1176 case MCI_INTEGER
: if (!inCst
) offset
++; break;
1177 case MCI_END_CONSTANT
: offset
++; break;
1178 case MCI_STRING
: offset
+= sizeof(LPWSTR
)/sizeof(DWORD
); break;
1179 case MCI_RECT
: offset
+= 4; break;
1180 default: ERR("oops\n");
1183 } while (eid
!= MCI_END_COMMAND
);
1185 WARN("Optarg %s not found\n", debugstr_w(args
));
1186 return MCIERR_UNRECOGNIZED_COMMAND
;
1188 if (offset
== MCI_DATA_SIZE
) {
1189 ERR("Internal data[] buffer overflow\n");
1190 return MCIERR_PARSER_INTERNAL
;
1196 /**************************************************************************
1197 * MCI_HandleReturnValues [internal]
1199 static DWORD
MCI_HandleReturnValues(DWORD dwRet
, LPWINE_MCIDRIVER wmd
, DWORD retType
,
1200 MCI_GENERIC_PARMS
*params
, LPWSTR lpstrRet
, UINT uRetLen
)
1202 static const WCHAR fmt_d
[] = {'%','d',0};
1203 static const WCHAR fmt_d4
[] = {'%','d',' ','%','d',' ','%','d',' ','%','d',0};
1204 static const WCHAR wszCol3
[] = {'%','0','2','d',':','%','0','2','d',':','%','0','2','d',0};
1205 static const WCHAR wszCol4
[] = {'%','0','2','d',':','%','0','2','d',':','%','0','2','d',':','%','0','2','d',0};
1209 case 0: /* nothing to return */
1213 DWORD data
= *(DWORD
*)(params
+ 1);
1214 switch (dwRet
& 0xFFFF0000ul
) {
1216 case MCI_INTEGER_RETURNED
:
1217 snprintfW(lpstrRet
, uRetLen
, fmt_d
, data
);
1219 case MCI_RESOURCE_RETURNED
:
1220 /* return string which ID is HIWORD(data),
1221 * string is loaded from mmsystem.dll */
1222 LoadStringW(hWinMM32Instance
, HIWORD(data
), lpstrRet
, uRetLen
);
1224 case MCI_RESOURCE_RETURNED
|MCI_RESOURCE_DRIVER
:
1225 /* return string which ID is HIWORD(data),
1226 * string is loaded from driver */
1227 /* FIXME: this is wrong for a 16 bit handle */
1228 LoadStringW(GetDriverModuleHandle(wmd
->hDriver
),
1229 HIWORD(data
), lpstrRet
, uRetLen
);
1231 case MCI_COLONIZED3_RETURN
:
1232 snprintfW(lpstrRet
, uRetLen
, wszCol3
,
1233 LOBYTE(LOWORD(data
)), HIBYTE(LOWORD(data
)),
1234 LOBYTE(HIWORD(data
)));
1236 case MCI_COLONIZED4_RETURN
:
1237 snprintfW(lpstrRet
, uRetLen
, wszCol4
,
1238 LOBYTE(LOWORD(data
)), HIBYTE(LOWORD(data
)),
1239 LOBYTE(HIWORD(data
)), HIBYTE(HIWORD(data
)));
1241 default: ERR("Ooops (%04X)\n", HIWORD(dwRet
));
1245 #ifdef MCI_INTEGER64
1248 static const WCHAR fmt_ld
[] = {'%','l','d',0};
1249 DWORD_PTR data
= *(DWORD_PTR
*)(params
+ 1);
1250 switch (dwRet
& 0xFFFF0000ul
) {
1252 case MCI_INTEGER_RETURNED
:
1253 snprintfW(lpstrRet
, uRetLen
, fmt_ld
, data
);
1255 case MCI_RESOURCE_RETURNED
:
1256 /* return string which ID is HIWORD(data),
1257 * string is loaded from mmsystem.dll */
1258 LoadStringW(hWinMM32Instance
, HIWORD(data
), lpstrRet
, uRetLen
);
1260 case MCI_RESOURCE_RETURNED
|MCI_RESOURCE_DRIVER
:
1261 /* return string which ID is HIWORD(data),
1262 * string is loaded from driver */
1263 /* FIXME: this is wrong for a 16 bit handle */
1264 LoadStringW(GetDriverModuleHandle(wmd
->hDriver
),
1265 HIWORD(data
), lpstrRet
, uRetLen
);
1267 case MCI_COLONIZED3_RETURN
:
1268 snprintfW(lpstrRet
, uRetLen
, wszCol3
,
1269 LOBYTE(LOWORD(data
)), HIBYTE(LOWORD(data
)),
1270 LOBYTE(HIWORD(data
)));
1272 case MCI_COLONIZED4_RETURN
:
1273 snprintfW(lpstrRet
, uRetLen
, wszCol4
,
1274 LOBYTE(LOWORD(data
)), HIBYTE(LOWORD(data
)),
1275 LOBYTE(HIWORD(data
)), HIBYTE(HIWORD(data
)));
1277 default: ERR("Ooops (%04X)\n", HIWORD(dwRet
));
1283 switch (dwRet
& 0xFFFF0000ul
) {
1285 /* nothing to do data[0] == lpstrRet */
1287 case MCI_INTEGER_RETURNED
:
1289 DWORD
*data
= (DWORD
*)(params
+ 1);
1290 *data
= *(LPDWORD
)lpstrRet
;
1291 snprintfW(lpstrRet
, uRetLen
, fmt_d
, *data
);
1295 WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet
));
1301 DWORD
*data
= (DWORD
*)(params
+ 1);
1302 if (dwRet
& 0xFFFF0000ul
)
1303 WARN("Oooch. MCI_STRING and HIWORD(dwRet)=%04x\n", HIWORD(dwRet
));
1304 snprintfW(lpstrRet
, uRetLen
, fmt_d4
, data
[0], data
[1], data
[2], data
[3]);
1307 default: ERR("oops\n");
1310 return LOWORD(dwRet
);
1313 /**************************************************************************
1314 * mciSendStringW [WINMM.@]
1316 DWORD WINAPI
mciSendStringW(LPCWSTR lpstrCommand
, LPWSTR lpstrRet
,
1317 UINT uRetLen
, HWND hwndCallback
)
1319 LPWSTR verb
, dev
, args
;
1320 LPWINE_MCIDRIVER wmd
= 0;
1321 MCIDEVICEID uDevID
, auto_open
= 0;
1322 DWORD dwFlags
= 0, dwRet
= 0;
1327 static const WCHAR wszNew
[] = {'n','e','w',0};
1328 static const WCHAR wszSAliasS
[] = {' ','a','l','i','a','s',' ',0};
1329 static const WCHAR wszTypeS
[] = {'t','y','p','e',' ',0};
1332 MCI_GENERIC_PARMS generic
;
1333 MCI_OPEN_PARMSW open
;
1334 MCI_SOUND_PARMSW sound
;
1335 MCI_SYSINFO_PARMSW sysinfo
;
1336 DWORD dw
[MCI_DATA_SIZE
];
1339 TRACE("(%s, %p, %d, %p)\n",
1340 debugstr_w(lpstrCommand
), lpstrRet
, uRetLen
, hwndCallback
);
1341 if (lpstrRet
&& uRetLen
) *lpstrRet
= '\0';
1343 /* format is <command> <device> <optargs> */
1344 if (!(verb
= HeapAlloc(GetProcessHeap(), 0, (strlenW(lpstrCommand
)+1) * sizeof(WCHAR
))))
1345 return MCIERR_OUT_OF_MEMORY
;
1346 strcpyW( verb
, lpstrCommand
);
1349 memset(&data
, 0, sizeof(data
));
1351 if (!(args
= strchrW(verb
, ' '))) {
1352 dwRet
= MCIERR_MISSING_DEVICE_NAME
;
1356 if ((dwRet
= MCI_GetString(&dev
, &args
))) {
1359 uDevID
= strcmpiW(dev
, wszAll
) ? 0 : MCI_ALL_DEVICE_ID
;
1361 /* Determine devType from open */
1362 if (!strcmpW(verb
, wszOpen
)) {
1363 LPWSTR devType
, tmp
;
1366 /* case dev == 'new' has to be handled */
1367 if (!strcmpW(dev
, wszNew
)) {
1369 if ((devType
= strstrW(args
, wszTypeS
)) != NULL
) {
1371 tmp
= strchrW(devType
, ' ');
1372 if (tmp
) *tmp
= '\0';
1373 devType
= str_dup_upper(devType
);
1374 if (tmp
) *tmp
= ' ';
1375 /* dwFlags and data[2] will be correctly set in ParseOpt loop */
1377 WARN("open new requires device type\n");
1378 dwRet
= MCIERR_MISSING_DEVICE_NAME
;
1381 dwFlags
|= MCI_OPEN_ELEMENT
;
1382 data
.open
.lpstrElementName
= &wszNull
[0];
1383 } else if ((devType
= strchrW(dev
, '!')) != NULL
) {
1385 tmp
= devType
; devType
= dev
; dev
= tmp
;
1387 dwFlags
|= MCI_OPEN_TYPE
;
1388 data
.open
.lpstrDeviceType
= devType
;
1389 devType
= str_dup_upper(devType
);
1390 dwFlags
|= MCI_OPEN_ELEMENT
;
1391 data
.open
.lpstrElementName
= dev
;
1392 } else if (DRIVER_GetLibName(dev
, wszMci
, buf
, sizeof(buf
))) {
1393 /* this is the name of a mci driver's type */
1394 tmp
= strchrW(dev
, ' ');
1395 if (tmp
) *tmp
= '\0';
1396 data
.open
.lpstrDeviceType
= dev
;
1397 devType
= str_dup_upper(dev
);
1398 if (tmp
) *tmp
= ' ';
1399 dwFlags
|= MCI_OPEN_TYPE
;
1401 if ((devType
= strstrW(args
, wszTypeS
)) != NULL
) {
1403 tmp
= strchrW(devType
, ' ');
1404 if (tmp
) *tmp
= '\0';
1405 devType
= str_dup_upper(devType
);
1406 if (tmp
) *tmp
= ' ';
1407 /* dwFlags and lpstrDeviceType will be correctly set in ParseOpt loop */
1409 if ((dwRet
= MCI_GetDevTypeFromFileName(dev
, buf
, sizeof(buf
))))
1412 devType
= str_dup_upper(buf
);
1414 dwFlags
|= MCI_OPEN_ELEMENT
;
1415 data
.open
.lpstrElementName
= dev
;
1417 if (MCI_ALL_DEVICE_ID
== uDevID
) {
1418 dwRet
= MCIERR_CANNOT_USE_ALL
;
1421 if (!strstrW(args
, wszSAliasS
) && !dev
) {
1422 dwRet
= MCIERR_NEW_REQUIRES_ALIAS
;
1426 dwRet
= MCI_LoadMciDriver(devType
, &wmd
);
1427 if (dwRet
== MCIERR_DEVICE_NOT_INSTALLED
)
1428 dwRet
= MCIERR_INVALID_DEVICE_NAME
;
1429 HeapFree(GetProcessHeap(), 0, devType
);
1432 } else if ((MCI_ALL_DEVICE_ID
!= uDevID
) && !(wmd
= MCI_GetDriver(mciGetDeviceIDW(dev
)))
1433 && (lpCmd
= MCI_FindCommand(MCI_GetCommandTable(0), verb
))) {
1434 /* auto-open uses the core command table */
1435 switch (MCI_GetMessage(lpCmd
)) {
1436 case MCI_SOUND
: /* command does not use a device name */
1439 case MCI_CLOSE
: /* don't auto-open for close */
1440 case MCI_BREAK
: /* no auto-open for system commands */
1441 dwRet
= MCIERR_INVALID_DEVICE_NAME
;
1446 static const WCHAR wszOpenWait
[] = {'o','p','e','n',' ','%','s',' ','w','a','i','t',0};
1447 WCHAR buf
[138], retbuf
[6];
1448 snprintfW(buf
, sizeof(buf
)/sizeof(WCHAR
), wszOpenWait
, dev
);
1449 /* open via mciSendString handles quoting, dev!file syntax and alias creation */
1450 if ((dwRet
= mciSendStringW(buf
, retbuf
, sizeof(retbuf
)/sizeof(WCHAR
), 0)) != 0)
1452 auto_open
= strtoulW(retbuf
, NULL
, 10);
1453 TRACE("auto-opened %u for %s\n", auto_open
, debugstr_w(dev
));
1455 /* FIXME: test for notify flag (how to preparse?) before opening */
1456 wmd
= MCI_GetDriver(auto_open
);
1458 ERR("No auto-open device %u\n", auto_open
);
1459 dwRet
= MCIERR_INVALID_DEVICE_ID
;
1466 /* get the verb in the different command tables */
1468 /* try the device specific command table */
1469 lpCmd
= MCI_FindCommand(wmd
->uSpecificCmdTable
, verb
);
1471 /* try the type specific command table */
1472 if (wmd
->uTypeCmdTable
== MCI_COMMAND_TABLE_NOT_LOADED
)
1473 wmd
->uTypeCmdTable
= MCI_GetCommandTable(wmd
->wType
);
1474 if (wmd
->uTypeCmdTable
!= MCI_NO_COMMAND_TABLE
)
1475 lpCmd
= MCI_FindCommand(wmd
->uTypeCmdTable
, verb
);
1478 /* try core command table */
1479 if (!lpCmd
) lpCmd
= MCI_FindCommand(MCI_GetCommandTable(0), verb
);
1482 TRACE("Command %s not found!\n", debugstr_w(verb
));
1483 dwRet
= MCIERR_UNRECOGNIZED_COMMAND
;
1486 wMsg
= MCI_GetMessage(lpCmd
);
1488 /* set return information */
1489 offset
= sizeof(data
.generic
);
1490 switch (retType
= MCI_GetReturnType(lpCmd
)) {
1494 offset
+= sizeof(DWORD
);
1497 data
.sysinfo
.lpstrReturn
= lpstrRet
;
1498 data
.sysinfo
.dwRetSize
= uRetLen
;
1499 offset
= FIELD_OFFSET( MCI_SYSINFO_PARMSW
, dwNumber
);
1502 offset
+= 4 * sizeof(DWORD
);
1504 #ifdef MCI_INTEGER64
1506 offset
+= sizeof(DWORD_PTR
);
1513 TRACE("verb=%s on dev=%s; offset=%d\n",
1514 debugstr_w(verb
), debugstr_w(dev
), offset
);
1516 if ((dwRet
= MCI_ParseOptArgs(data
.dw
, offset
/ sizeof(DWORD
), lpCmd
, args
, &dwFlags
)))
1519 /* set up call back */
1521 if (dwFlags
& MCI_NOTIFY
) {
1522 dwRet
= MCIERR_NOTIFY_ON_AUTO_OPEN
;
1525 /* FIXME: the command should get its own notification window set up and
1526 * ask for device closing while processing the notification mechanism.
1527 * hwndCallback = ...
1528 * dwFlags |= MCI_NOTIFY;
1529 * In the meantime special-case all commands but PLAY and RECORD below. */
1531 if (dwFlags
& MCI_NOTIFY
) {
1532 data
.generic
.dwCallback
= (DWORD_PTR
)hwndCallback
;
1537 if (strcmpW(verb
, wszOpen
)) {
1538 FIXME("Cannot open with command %s\n", debugstr_w(verb
));
1539 dwRet
= MCIERR_INTERNAL
;
1545 /* Requirements on dev depend on the flags:
1546 * alias with INSTALLNAME, name like "digitalvideo"
1547 * with QUANTITY and NAME. */
1549 data
.sysinfo
.wDeviceType
= MCI_ALL_DEVICE_ID
;
1550 if (uDevID
!= MCI_ALL_DEVICE_ID
) {
1551 if (dwFlags
& MCI_SYSINFO_INSTALLNAME
)
1552 wmd
= MCI_GetDriver(mciGetDeviceIDW(dev
));
1553 else if (!(data
.sysinfo
.wDeviceType
= MCI_GetDevTypeFromResource(dev
))) {
1554 dwRet
= MCIERR_DEVICE_TYPE_REQUIRED
;
1561 /* FIXME: name is optional, "sound" is a valid command.
1562 * FIXME: Parse "sound notify" as flag, not as name. */
1563 data
.sound
.lpstrSoundName
= dev
;
1564 dwFlags
|= MCI_SOUND_NAME
;
1568 TRACE("[%d, %s, %08x, %08x %08x %08x %08x %08x %08x %08x %08x %08x %08x]\n",
1569 wmd
? wmd
->wDeviceID
: uDevID
, MCI_MessageToString(wMsg
), dwFlags
,
1570 data
.dw
[0], data
.dw
[1], data
.dw
[2], data
.dw
[3], data
.dw
[4],
1571 data
.dw
[5], data
.dw
[6], data
.dw
[7], data
.dw
[8], data
.dw
[9]);
1573 if (wMsg
== MCI_OPEN
) {
1574 if ((dwRet
= MCI_FinishOpen(wmd
, &data
.open
, dwFlags
)))
1576 /* FIXME: notification is not properly shared across two opens */
1578 dwRet
= MCI_SendCommand(wmd
? wmd
->wDeviceID
: uDevID
, wMsg
, dwFlags
, (DWORD_PTR
)&data
);
1580 TRACE("=> 1/ %x (%s)\n", dwRet
, debugstr_w(lpstrRet
));
1581 if (!LOWORD(dwRet
)) {
1582 dwRet
= MCI_HandleReturnValues(dwRet
, wmd
, retType
, &data
.generic
, lpstrRet
, uRetLen
);
1583 TRACE("=> 2/ %x (%s)\n", dwRet
, debugstr_w(lpstrRet
));
1588 /* PLAY and RECORD are the only known non-immediate commands */
1589 if (LOWORD(dwRet
) || !(wMsg
== MCI_PLAY
|| wMsg
== MCI_RECORD
))
1590 MCI_SendCommand(auto_open
, MCI_CLOSE
, 0, 0);
1592 FIXME("leaking auto-open device %u\n", auto_open
);
1594 if (wMsg
== MCI_OPEN
&& LOWORD(dwRet
) && wmd
)
1595 MCI_UnLoadMciDriver(wmd
);
1596 HeapFree(GetProcessHeap(), 0, verb
);
1600 /**************************************************************************
1601 * mciSendStringA [WINMM.@]
1603 DWORD WINAPI
mciSendStringA(LPCSTR lpstrCommand
, LPSTR lpstrRet
,
1604 UINT uRetLen
, HWND hwndCallback
)
1606 LPWSTR lpwstrCommand
;
1607 LPWSTR lpwstrRet
= NULL
;
1611 /* FIXME: is there something to do with lpstrReturnString ? */
1612 len
= MultiByteToWideChar( CP_ACP
, 0, lpstrCommand
, -1, NULL
, 0 );
1613 lpwstrCommand
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
1614 MultiByteToWideChar( CP_ACP
, 0, lpstrCommand
, -1, lpwstrCommand
, len
);
1617 if (uRetLen
) *lpstrRet
= '\0'; /* NT-w2k3 use memset(lpstrRet, 0, uRetLen); */
1618 lpwstrRet
= HeapAlloc(GetProcessHeap(), 0, uRetLen
* sizeof(WCHAR
));
1620 HeapFree( GetProcessHeap(), 0, lpwstrCommand
);
1621 return MCIERR_OUT_OF_MEMORY
;
1624 ret
= mciSendStringW(lpwstrCommand
, lpwstrRet
, uRetLen
, hwndCallback
);
1625 if (!ret
&& lpwstrRet
)
1626 WideCharToMultiByte( CP_ACP
, 0, lpwstrRet
, -1, lpstrRet
, uRetLen
, NULL
, NULL
);
1627 HeapFree(GetProcessHeap(), 0, lpwstrCommand
);
1628 HeapFree(GetProcessHeap(), 0, lpwstrRet
);
1632 /**************************************************************************
1633 * mciExecute [WINMM.@]
1635 BOOL WINAPI
mciExecute(LPCSTR lpstrCommand
)
1640 TRACE("(%s)!\n", lpstrCommand
);
1642 ret
= mciSendStringA(lpstrCommand
, strRet
, sizeof(strRet
), 0);
1644 if (!mciGetErrorStringA(ret
, strRet
, sizeof(strRet
))) {
1645 sprintf(strRet
, "Unknown MCI error (%d)", ret
);
1647 MessageBoxA(0, strRet
, "Error in mciExecute()", MB_OK
);
1649 /* FIXME: what shall I return ? */
1653 /**************************************************************************
1654 * mciLoadCommandResource [WINMM.@]
1656 * Strangely, this function only exists as a UNICODE one.
1658 UINT WINAPI
mciLoadCommandResource(HINSTANCE hInst
, LPCWSTR resNameW
, UINT type
)
1660 UINT ret
= MCI_NO_COMMAND_TABLE
;
1664 TRACE("(%p, %s, %d)!\n", hInst
, debugstr_w(resNameW
), type
);
1666 /* if a file named "resname.mci" exits, then load resource "resname" from it
1667 * otherwise directly from driver
1668 * We don't support it (who uses this feature ?), but we check anyway
1672 /* FIXME: we should put this back into order, but I never found a program
1673 * actually using this feature, so we may not need it
1678 strcat(strcpy(buf
, resname
), ".mci");
1679 if (OpenFile(buf
, &ofs
, OF_EXIST
) != HFILE_ERROR
) {
1680 FIXME("NIY: command table to be loaded from '%s'\n", ofs
.szPathName
);
1684 if ((hRsrc
= FindResourceW(hInst
, resNameW
, (LPWSTR
)RT_RCDATA
)) &&
1685 (hMem
= LoadResource(hInst
, hRsrc
))) {
1686 ret
= MCI_SetCommandTable(hMem
, type
);
1689 else WARN("No command table found in module for %s\n", debugstr_w(resNameW
));
1691 TRACE("=> %04x\n", ret
);
1695 /**************************************************************************
1696 * mciFreeCommandResource [WINMM.@]
1698 BOOL WINAPI
mciFreeCommandResource(UINT uTable
)
1700 TRACE("(%08x)!\n", uTable
);
1702 if (uTable
>= MAX_MCICMDTABLE
|| !S_MciCmdTable
[uTable
].lpTable
)
1705 FreeResource(S_MciCmdTable
[uTable
].hMem
);
1706 S_MciCmdTable
[uTable
].hMem
= NULL
;
1707 S_MciCmdTable
[uTable
].lpTable
= NULL
;
1708 HeapFree(GetProcessHeap(), 0, S_MciCmdTable
[uTable
].aVerbs
);
1709 S_MciCmdTable
[uTable
].aVerbs
= 0;
1710 S_MciCmdTable
[uTable
].nVerbs
= 0;
1714 /**************************************************************************
1715 * MCI_Open [internal]
1717 static DWORD
MCI_Open(DWORD dwParam
, LPMCI_OPEN_PARMSW lpParms
)
1719 WCHAR strDevTyp
[128];
1721 LPWINE_MCIDRIVER wmd
= NULL
;
1723 TRACE("(%08X, %p)\n", dwParam
, lpParms
);
1724 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
1726 /* only two low bytes are generic, the other ones are dev type specific */
1727 #define WINE_MCIDRIVER_SUPP (0xFFFF0000|MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT| \
1728 MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID| \
1729 MCI_NOTIFY|MCI_WAIT)
1730 if ((dwParam
& ~WINE_MCIDRIVER_SUPP
) != 0)
1731 FIXME("Unsupported yet dwFlags=%08X\n", dwParam
& ~WINE_MCIDRIVER_SUPP
);
1732 #undef WINE_MCIDRIVER_SUPP
1736 if (dwParam
& MCI_OPEN_TYPE
) {
1737 if (dwParam
& MCI_OPEN_TYPE_ID
) {
1738 WORD uDevType
= LOWORD(lpParms
->lpstrDeviceType
);
1740 if (uDevType
< MCI_DEVTYPE_FIRST
||
1741 uDevType
> MCI_DEVTYPE_LAST
||
1742 !LoadStringW(hWinMM32Instance
, uDevType
,
1743 strDevTyp
, sizeof(strDevTyp
) / sizeof(WCHAR
))) {
1744 dwRet
= MCIERR_BAD_INTEGER
;
1749 if (lpParms
->lpstrDeviceType
== NULL
) {
1750 dwRet
= MCIERR_NULL_PARAMETER_BLOCK
;
1753 strcpyW(strDevTyp
, lpParms
->lpstrDeviceType
);
1754 ptr
= strchrW(strDevTyp
, '!');
1756 /* this behavior is not documented in windows. However, since, in
1757 * some occasions, MCI_OPEN handling is translated by WinMM into
1758 * a call to mciSendString("open <type>"); this code shall be correct
1760 if (dwParam
& MCI_OPEN_ELEMENT
) {
1761 ERR("Both MCI_OPEN_ELEMENT(%s) and %s are used\n",
1762 debugstr_w(lpParms
->lpstrElementName
),
1763 debugstr_w(strDevTyp
));
1764 dwRet
= MCIERR_UNRECOGNIZED_KEYWORD
;
1767 dwParam
|= MCI_OPEN_ELEMENT
;
1769 /* FIXME: not a good idea to write in user supplied buffer */
1770 lpParms
->lpstrElementName
= ptr
;
1774 TRACE("devType=%s !\n", debugstr_w(strDevTyp
));
1777 if (dwParam
& MCI_OPEN_ELEMENT
) {
1778 TRACE("lpstrElementName=%s\n", debugstr_w(lpParms
->lpstrElementName
));
1780 if (dwParam
& MCI_OPEN_ELEMENT_ID
) {
1781 FIXME("Unsupported yet flag MCI_OPEN_ELEMENT_ID\n");
1782 dwRet
= MCIERR_UNRECOGNIZED_KEYWORD
;
1786 if (!lpParms
->lpstrElementName
) {
1787 dwRet
= MCIERR_NULL_PARAMETER_BLOCK
;
1791 /* type, if given as a parameter, supersedes file extension */
1792 if (!strDevTyp
[0] &&
1793 MCI_GetDevTypeFromFileName(lpParms
->lpstrElementName
,
1794 strDevTyp
, sizeof(strDevTyp
))) {
1795 static const WCHAR wszCdAudio
[] = {'C','D','A','U','D','I','O',0};
1796 if (GetDriveTypeW(lpParms
->lpstrElementName
) != DRIVE_CDROM
) {
1797 dwRet
= MCIERR_EXTENSION_NOT_FOUND
;
1800 /* FIXME: this will not work if several CDROM drives are installed on the machine */
1801 strcpyW(strDevTyp
, wszCdAudio
);
1805 if (strDevTyp
[0] == 0) {
1806 FIXME("Couldn't load driver\n");
1807 dwRet
= MCIERR_INVALID_DEVICE_NAME
;
1811 if (dwParam
& MCI_OPEN_ALIAS
) {
1812 TRACE("Alias=%s !\n", debugstr_w(lpParms
->lpstrAlias
));
1813 if (!lpParms
->lpstrAlias
) {
1814 dwRet
= MCIERR_NULL_PARAMETER_BLOCK
;
1819 if ((dwRet
= MCI_LoadMciDriver(strDevTyp
, &wmd
))) {
1823 if ((dwRet
= MCI_FinishOpen(wmd
, lpParms
, dwParam
))) {
1824 TRACE("Failed to open driver (MCI_OPEN_DRIVER) [%08x], closing\n", dwRet
);
1825 /* FIXME: is dwRet the correct ret code ? */
1829 /* only handled devices fall through */
1830 TRACE("wDevID=%04X wDeviceID=%d dwRet=%d\n", wmd
->wDeviceID
, lpParms
->wDeviceID
, dwRet
);
1834 if (wmd
) MCI_UnLoadMciDriver(wmd
);
1838 /**************************************************************************
1839 * MCI_Close [internal]
1841 static DWORD
MCI_Close(UINT wDevID
, DWORD dwParam
, LPMCI_GENERIC_PARMS lpParms
)
1844 LPWINE_MCIDRIVER wmd
;
1846 TRACE("(%04x, %08X, %p)\n", wDevID
, dwParam
, lpParms
);
1848 /* Every device must handle MCI_NOTIFY on its own. */
1849 if ((UINT16
)wDevID
== (UINT16
)MCI_ALL_DEVICE_ID
) {
1850 while (MciDrivers
) {
1851 /* Retrieve the device ID under lock, but send the message without,
1852 * the driver might be calling some winmm functions from another
1853 * thread before being fully stopped.
1855 EnterCriticalSection(&WINMM_cs
);
1858 LeaveCriticalSection(&WINMM_cs
);
1861 wDevID
= MciDrivers
->wDeviceID
;
1862 LeaveCriticalSection(&WINMM_cs
);
1863 MCI_Close(wDevID
, dwParam
, lpParms
);
1868 if (!(wmd
= MCI_GetDriver(wDevID
))) {
1869 return MCIERR_INVALID_DEVICE_ID
;
1872 dwRet
= MCI_SendCommandFrom32(wDevID
, MCI_CLOSE_DRIVER
, dwParam
, (DWORD_PTR
)lpParms
);
1874 MCI_UnLoadMciDriver(wmd
);
1879 /**************************************************************************
1880 * MCI_WriteString [internal]
1882 static DWORD
MCI_WriteString(LPWSTR lpDstStr
, DWORD dstSize
, LPCWSTR lpSrcStr
)
1887 if (dstSize
<= strlenW(lpSrcStr
)) {
1888 ret
= MCIERR_PARAM_OVERFLOW
;
1890 strcpyW(lpDstStr
, lpSrcStr
);
1898 /**************************************************************************
1899 * MCI_Sysinfo [internal]
1901 static DWORD
MCI_SysInfo(UINT uDevID
, DWORD dwFlags
, LPMCI_SYSINFO_PARMSW lpParms
)
1903 DWORD ret
= MCIERR_INVALID_DEVICE_ID
, cnt
= 0;
1904 WCHAR buf
[2048], *s
, *p
;
1905 LPWINE_MCIDRIVER wmd
;
1908 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
1909 if (lpParms
->lpstrReturn
== NULL
) return MCIERR_PARAM_OVERFLOW
;
1911 TRACE("(%08x, %08X, %p[num=%d, wDevTyp=%u])\n",
1912 uDevID
, dwFlags
, lpParms
, lpParms
->dwNumber
, lpParms
->wDeviceType
);
1913 if ((WORD
)MCI_ALL_DEVICE_ID
== LOWORD(uDevID
))
1914 uDevID
= MCI_ALL_DEVICE_ID
; /* Be compatible with Win9x */
1916 switch (dwFlags
& ~(MCI_SYSINFO_OPEN
|MCI_NOTIFY
|MCI_WAIT
)) {
1917 case MCI_SYSINFO_QUANTITY
:
1918 if (lpParms
->dwRetSize
< sizeof(DWORD
))
1919 return MCIERR_PARAM_OVERFLOW
;
1920 /* Win9x returns 0 for 0 < uDevID < (UINT16)MCI_ALL_DEVICE_ID */
1921 if (uDevID
== MCI_ALL_DEVICE_ID
) {
1922 /* wDeviceType == MCI_ALL_DEVICE_ID is not recognized. */
1923 if (dwFlags
& MCI_SYSINFO_OPEN
) {
1924 TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
1925 EnterCriticalSection(&WINMM_cs
);
1926 for (wmd
= MciDrivers
; wmd
; wmd
= wmd
->lpNext
) {
1929 LeaveCriticalSection(&WINMM_cs
);
1931 TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
1932 if (RegOpenKeyExW( HKEY_LOCAL_MACHINE
, wszHklmMci
,
1933 0, KEY_QUERY_VALUE
, &hKey
) == ERROR_SUCCESS
) {
1934 RegQueryInfoKeyW( hKey
, 0, 0, 0, &cnt
, 0, 0, 0, 0, 0, 0, 0);
1935 RegCloseKey( hKey
);
1937 if (GetPrivateProfileStringW(wszMci
, 0, wszNull
, buf
, sizeof(buf
) / sizeof(buf
[0]), wszSystemIni
))
1938 for (s
= buf
; *s
; s
+= strlenW(s
) + 1) cnt
++;
1941 if (dwFlags
& MCI_SYSINFO_OPEN
) {
1942 TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %d\n", lpParms
->wDeviceType
);
1943 EnterCriticalSection(&WINMM_cs
);
1944 for (wmd
= MciDrivers
; wmd
; wmd
= wmd
->lpNext
) {
1945 if (wmd
->wType
== lpParms
->wDeviceType
) cnt
++;
1947 LeaveCriticalSection(&WINMM_cs
);
1949 TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %d\n", lpParms
->wDeviceType
);
1950 FIXME("Don't know how to get # of MCI devices of a given type\n");
1951 /* name = LoadStringW(hWinMM32Instance, LOWORD(lpParms->wDeviceType))
1952 * then lookup registry and/or system.ini for name, ignoring digits suffix */
1953 switch (LOWORD(lpParms
->wDeviceType
)) {
1954 case MCI_DEVTYPE_CD_AUDIO
:
1955 case MCI_DEVTYPE_WAVEFORM_AUDIO
:
1956 case MCI_DEVTYPE_SEQUENCER
:
1959 default: /* "digitalvideo" gets 0 because it's not in the registry */
1964 *(DWORD
*)lpParms
->lpstrReturn
= cnt
;
1965 TRACE("(%d) => '%d'\n", lpParms
->dwNumber
, *(DWORD
*)lpParms
->lpstrReturn
);
1966 ret
= MCI_INTEGER_RETURNED
;
1967 /* return ret; Only Win9x sends a notification in this case. */
1969 case MCI_SYSINFO_INSTALLNAME
:
1970 TRACE("MCI_SYSINFO_INSTALLNAME\n");
1971 if ((wmd
= MCI_GetDriver(uDevID
))) {
1972 ret
= MCI_WriteString(lpParms
->lpstrReturn
, lpParms
->dwRetSize
,
1973 wmd
->lpstrDeviceType
);
1975 ret
= (uDevID
== MCI_ALL_DEVICE_ID
)
1976 ? MCIERR_CANNOT_USE_ALL
: MCIERR_INVALID_DEVICE_NAME
;
1978 TRACE("(%d) => %s\n", lpParms
->dwNumber
, debugstr_w(lpParms
->lpstrReturn
));
1980 case MCI_SYSINFO_NAME
:
1982 if (dwFlags
& MCI_SYSINFO_OPEN
) {
1983 /* Win9x returns 0 for 0 < uDevID < (UINT16)MCI_ALL_DEVICE_ID */
1984 TRACE("MCI_SYSINFO_NAME: nth alias of type %d\n",
1985 uDevID
== MCI_ALL_DEVICE_ID
? MCI_ALL_DEVICE_ID
: lpParms
->wDeviceType
);
1986 EnterCriticalSection(&WINMM_cs
);
1987 for (wmd
= MciDrivers
; wmd
; wmd
= wmd
->lpNext
) {
1988 /* wDeviceType == MCI_ALL_DEVICE_ID is not recognized. */
1989 if (uDevID
== MCI_ALL_DEVICE_ID
||
1990 lpParms
->wDeviceType
== wmd
->wType
) {
1992 if (cnt
== lpParms
->dwNumber
) {
1993 s
= wmd
->lpstrAlias
;
1998 LeaveCriticalSection(&WINMM_cs
);
1999 ret
= s
? MCI_WriteString(lpParms
->lpstrReturn
, lpParms
->dwRetSize
, s
) : MCIERR_OUTOFRANGE
;
2000 } else if (MCI_ALL_DEVICE_ID
== uDevID
) {
2001 TRACE("MCI_SYSINFO_NAME: device #%d\n", lpParms
->dwNumber
);
2002 if (RegOpenKeyExW( HKEY_LOCAL_MACHINE
, wszHklmMci
, 0,
2003 KEY_QUERY_VALUE
, &hKey
) == ERROR_SUCCESS
) {
2004 if (RegQueryInfoKeyW( hKey
, 0, 0, 0, &cnt
,
2005 0, 0, 0, 0, 0, 0, 0) == ERROR_SUCCESS
&&
2006 lpParms
->dwNumber
<= cnt
) {
2007 DWORD bufLen
= sizeof(buf
)/sizeof(buf
[0]);
2008 if (RegEnumKeyExW(hKey
, lpParms
->dwNumber
- 1,
2009 buf
, &bufLen
, 0, 0, 0, 0) == ERROR_SUCCESS
)
2012 RegCloseKey( hKey
);
2015 if (GetPrivateProfileStringW(wszMci
, 0, wszNull
, buf
, sizeof(buf
) / sizeof(buf
[0]), wszSystemIni
)) {
2016 for (p
= buf
; *p
; p
+= strlenW(p
) + 1, cnt
++) {
2017 TRACE("%d: %s\n", cnt
, debugstr_w(p
));
2018 if (cnt
== lpParms
->dwNumber
- 1) {
2025 ret
= s
? MCI_WriteString(lpParms
->lpstrReturn
, lpParms
->dwRetSize
, s
) : MCIERR_OUTOFRANGE
;
2027 FIXME("MCI_SYSINFO_NAME: nth device of type %d\n", lpParms
->wDeviceType
);
2028 /* Cheating: what is asked for is the nth device from the registry. */
2029 if (1 != lpParms
->dwNumber
|| /* Handle only one of each kind. */
2030 lpParms
->wDeviceType
< MCI_DEVTYPE_FIRST
|| lpParms
->wDeviceType
> MCI_DEVTYPE_LAST
)
2031 ret
= MCIERR_OUTOFRANGE
;
2033 LoadStringW(hWinMM32Instance
, LOWORD(lpParms
->wDeviceType
),
2034 lpParms
->lpstrReturn
, lpParms
->dwRetSize
);
2038 TRACE("(%d) => %s\n", lpParms
->dwNumber
, debugstr_w(lpParms
->lpstrReturn
));
2041 TRACE("Unsupported flag value=%08x\n", dwFlags
);
2042 ret
= MCIERR_UNRECOGNIZED_KEYWORD
;
2044 if ((dwFlags
& MCI_NOTIFY
) && HRESULT_CODE(ret
)==0)
2045 mciDriverNotify((HWND
)lpParms
->dwCallback
, uDevID
, MCI_NOTIFY_SUCCESSFUL
);
2049 /**************************************************************************
2050 * MCI_Break [internal]
2052 static DWORD
MCI_Break(UINT wDevID
, DWORD dwFlags
, LPMCI_BREAK_PARMS lpParms
)
2056 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
2057 FIXME("(%04x) vkey %04X stub\n", dwFlags
, lpParms
->nVirtKey
);
2059 if (MMSYSERR_NOERROR
==dwRet
&& (dwFlags
& MCI_NOTIFY
))
2060 mciDriverNotify((HWND
)lpParms
->dwCallback
, wDevID
, MCI_NOTIFY_SUCCESSFUL
);
2064 /**************************************************************************
2065 * MCI_Sound [internal]
2067 static DWORD
MCI_Sound(UINT wDevID
, DWORD dwFlags
, LPMCI_SOUND_PARMSW lpParms
)
2071 if (dwFlags
& MCI_SOUND_NAME
) {
2072 if (lpParms
== NULL
) return MCIERR_NULL_PARAMETER_BLOCK
;
2073 else dwRet
= PlaySoundW(lpParms
->lpstrSoundName
, NULL
,
2074 SND_ALIAS
| (dwFlags
& MCI_WAIT
? SND_SYNC
: SND_ASYNC
))
2075 ? 0 : MCIERR_HARDWARE
;
2076 } else dwRet
= PlaySoundW((LPCWSTR
)SND_ALIAS_SYSTEMDEFAULT
, NULL
,
2077 SND_ALIAS_ID
| (dwFlags
& MCI_WAIT
? SND_SYNC
: SND_ASYNC
))
2078 ? 0 : MCIERR_HARDWARE
;
2080 if (!dwRet
&& lpParms
&& (dwFlags
& MCI_NOTIFY
))
2081 mciDriverNotify((HWND
)lpParms
->dwCallback
, wDevID
, MCI_NOTIFY_SUCCESSFUL
);
2085 /**************************************************************************
2086 * MCI_SendCommand [internal]
2088 DWORD
MCI_SendCommand(UINT wDevID
, UINT16 wMsg
, DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
2090 DWORD dwRet
= MCIERR_UNRECOGNIZED_COMMAND
;
2094 dwRet
= MCI_Open(dwParam1
, (LPMCI_OPEN_PARMSW
)dwParam2
);
2097 dwRet
= MCI_Close(wDevID
, dwParam1
, (LPMCI_GENERIC_PARMS
)dwParam2
);
2100 dwRet
= MCI_SysInfo(wDevID
, dwParam1
, (LPMCI_SYSINFO_PARMSW
)dwParam2
);
2103 dwRet
= MCI_Break(wDevID
, dwParam1
, (LPMCI_BREAK_PARMS
)dwParam2
);
2106 dwRet
= MCI_Sound(wDevID
, dwParam1
, (LPMCI_SOUND_PARMSW
)dwParam2
);
2109 if ((UINT16
)wDevID
== (UINT16
)MCI_ALL_DEVICE_ID
) {
2110 FIXME("unhandled MCI_ALL_DEVICE_ID\n");
2111 dwRet
= MCIERR_CANNOT_USE_ALL
;
2113 dwRet
= MCI_SendCommandFrom32(wDevID
, wMsg
, dwParam1
, dwParam2
);
2120 /**************************************************************************
2121 * MCI_CleanUp [internal]
2123 * Some MCI commands need to be cleaned-up (when not called from
2124 * mciSendString), because MCI drivers return extra information for string
2125 * transformation. This function gets rid of them.
2127 static LRESULT
MCI_CleanUp(LRESULT dwRet
, UINT wMsg
, DWORD_PTR dwParam2
)
2130 return LOWORD(dwRet
);
2133 case MCI_GETDEVCAPS
:
2134 switch (dwRet
& 0xFFFF0000ul
) {
2136 case MCI_COLONIZED3_RETURN
:
2137 case MCI_COLONIZED4_RETURN
:
2138 case MCI_INTEGER_RETURNED
:
2141 case MCI_RESOURCE_RETURNED
:
2142 case MCI_RESOURCE_RETURNED
|MCI_RESOURCE_DRIVER
:
2144 LPMCI_GETDEVCAPS_PARMS lmgp
;
2146 lmgp
= (LPMCI_GETDEVCAPS_PARMS
)dwParam2
;
2147 TRACE("Changing %08x to %08x\n", lmgp
->dwReturn
, LOWORD(lmgp
->dwReturn
));
2148 lmgp
->dwReturn
= LOWORD(lmgp
->dwReturn
);
2152 FIXME("Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2153 HIWORD(dwRet
), MCI_MessageToString(wMsg
));
2157 switch (dwRet
& 0xFFFF0000ul
) {
2159 case MCI_COLONIZED3_RETURN
:
2160 case MCI_COLONIZED4_RETURN
:
2161 case MCI_INTEGER_RETURNED
:
2164 case MCI_RESOURCE_RETURNED
:
2165 case MCI_RESOURCE_RETURNED
|MCI_RESOURCE_DRIVER
:
2167 LPMCI_STATUS_PARMS lsp
;
2169 lsp
= (LPMCI_STATUS_PARMS
)dwParam2
;
2170 TRACE("Changing %08lx to %08x\n", lsp
->dwReturn
, LOWORD(lsp
->dwReturn
));
2171 lsp
->dwReturn
= LOWORD(lsp
->dwReturn
);
2175 FIXME("Unsupported value for hiword (%04x) returned by DriverProc(%s)\n",
2176 HIWORD(dwRet
), MCI_MessageToString(wMsg
));
2180 switch (dwRet
& 0xFFFF0000ul
) {
2182 case MCI_INTEGER_RETURNED
:
2186 FIXME("Unsupported value for hiword (%04x)\n", HIWORD(dwRet
));
2190 if (HIWORD(dwRet
)) {
2191 FIXME("Got non null hiword for dwRet=0x%08lx for command %s\n",
2192 dwRet
, MCI_MessageToString(wMsg
));
2196 return LOWORD(dwRet
);
2199 /**************************************************************************
2200 * mciGetErrorStringW [WINMM.@]
2202 BOOL WINAPI
mciGetErrorStringW(MCIERROR wError
, LPWSTR lpstrBuffer
, UINT uLength
)
2206 if (lpstrBuffer
!= NULL
&& uLength
> 0 &&
2207 wError
>= MCIERR_BASE
&& wError
<= MCIERR_CUSTOM_DRIVER_BASE
) {
2209 if (LoadStringW(hWinMM32Instance
, wError
, lpstrBuffer
, uLength
) > 0) {
2216 /**************************************************************************
2217 * mciGetErrorStringA [WINMM.@]
2219 BOOL WINAPI
mciGetErrorStringA(MCIERROR dwError
, LPSTR lpstrBuffer
, UINT uLength
)
2223 if (lpstrBuffer
!= NULL
&& uLength
> 0 &&
2224 dwError
>= MCIERR_BASE
&& dwError
<= MCIERR_CUSTOM_DRIVER_BASE
) {
2226 if (LoadStringA(hWinMM32Instance
, dwError
, lpstrBuffer
, uLength
) > 0) {
2233 /**************************************************************************
2234 * mciDriverNotify [WINMM.@]
2236 BOOL WINAPI
mciDriverNotify(HWND hWndCallBack
, MCIDEVICEID wDevID
, UINT wStatus
)
2238 TRACE("(%p, %04x, %04X)\n", hWndCallBack
, wDevID
, wStatus
);
2240 return PostMessageW(hWndCallBack
, MM_MCINOTIFY
, wStatus
, wDevID
);
2243 /**************************************************************************
2244 * mciGetDriverData [WINMM.@]
2246 DWORD_PTR WINAPI
mciGetDriverData(MCIDEVICEID uDeviceID
)
2248 LPWINE_MCIDRIVER wmd
;
2250 TRACE("(%04x)\n", uDeviceID
);
2252 wmd
= MCI_GetDriver(uDeviceID
);
2255 WARN("Bad uDeviceID\n");
2259 return wmd
->dwPrivate
;
2262 /**************************************************************************
2263 * mciSetDriverData [WINMM.@]
2265 BOOL WINAPI
mciSetDriverData(MCIDEVICEID uDeviceID
, DWORD_PTR data
)
2267 LPWINE_MCIDRIVER wmd
;
2269 TRACE("(%04x, %08lx)\n", uDeviceID
, data
);
2271 wmd
= MCI_GetDriver(uDeviceID
);
2274 WARN("Bad uDeviceID\n");
2278 wmd
->dwPrivate
= data
;
2282 /**************************************************************************
2283 * mciSendCommandW [WINMM.@]
2286 DWORD WINAPI
mciSendCommandW(MCIDEVICEID wDevID
, UINT wMsg
, DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
2290 TRACE("(%08x, %s, %08lx, %08lx)\n",
2291 wDevID
, MCI_MessageToString(wMsg
), dwParam1
, dwParam2
);
2293 dwRet
= MCI_SendCommand(wDevID
, wMsg
, dwParam1
, dwParam2
);
2294 dwRet
= MCI_CleanUp(dwRet
, wMsg
, dwParam2
);
2295 TRACE("=> %08x\n", dwRet
);
2299 /**************************************************************************
2300 * mciSendCommandA [WINMM.@]
2302 DWORD WINAPI
mciSendCommandA(MCIDEVICEID wDevID
, UINT wMsg
, DWORD_PTR dwParam1
, DWORD_PTR dwParam2
)
2307 TRACE("(%08x, %s, %08lx, %08lx)\n",
2308 wDevID
, MCI_MessageToString(wMsg
), dwParam1
, dwParam2
);
2310 mapped
= MCI_MapMsgAtoW(wMsg
, dwParam1
, &dwParam2
);
2313 FIXME("message %04x mapping failed\n", wMsg
);
2314 return MCIERR_OUT_OF_MEMORY
;
2316 ret
= mciSendCommandW(wDevID
, wMsg
, dwParam1
, dwParam2
);
2318 MCI_UnmapMsgAtoW(wMsg
, dwParam1
, dwParam2
, ret
);
2322 /**************************************************************************
2323 * mciGetDeviceIDA [WINMM.@]
2325 UINT WINAPI
mciGetDeviceIDA(LPCSTR lpstrName
)
2327 LPWSTR w
= MCI_strdupAtoW(lpstrName
);
2328 UINT ret
= MCIERR_OUT_OF_MEMORY
;
2332 ret
= mciGetDeviceIDW(w
);
2333 HeapFree(GetProcessHeap(), 0, w
);
2338 /**************************************************************************
2339 * mciGetDeviceIDW [WINMM.@]
2341 UINT WINAPI
mciGetDeviceIDW(LPCWSTR lpwstrName
)
2343 return MCI_GetDriverFromString(lpwstrName
);
2346 /**************************************************************************
2347 * MCI_DefYieldProc [internal]
2349 static UINT WINAPI
MCI_DefYieldProc(MCIDEVICEID wDevID
, DWORD data
)
2354 TRACE("(0x%04x, 0x%08x)\n", wDevID
, data
);
2356 if ((HIWORD(data
) != 0 && HWND_16(GetActiveWindow()) != HIWORD(data
)) ||
2357 (GetAsyncKeyState(LOWORD(data
)) & 1) == 0) {
2358 PeekMessageW(&msg
, 0, 0, 0, PM_REMOVE
| PM_QS_SENDMESSAGE
);
2361 msg
.hwnd
= HWND_32(HIWORD(data
));
2362 while (!PeekMessageW(&msg
, msg
.hwnd
, WM_KEYFIRST
, WM_KEYLAST
, PM_REMOVE
));
2368 /**************************************************************************
2369 * mciSetYieldProc [WINMM.@]
2371 BOOL WINAPI
mciSetYieldProc(MCIDEVICEID uDeviceID
, YIELDPROC fpYieldProc
, DWORD dwYieldData
)
2373 LPWINE_MCIDRIVER wmd
;
2375 TRACE("(%u, %p, %08x)\n", uDeviceID
, fpYieldProc
, dwYieldData
);
2377 if (!(wmd
= MCI_GetDriver(uDeviceID
))) {
2378 WARN("Bad uDeviceID\n");
2382 wmd
->lpfnYieldProc
= fpYieldProc
;
2383 wmd
->dwYieldData
= dwYieldData
;
2388 /**************************************************************************
2389 * mciGetDeviceIDFromElementIDA [WINMM.@]
2391 UINT WINAPI
mciGetDeviceIDFromElementIDA(DWORD dwElementID
, LPCSTR lpstrType
)
2393 LPWSTR w
= MCI_strdupAtoW(lpstrType
);
2398 ret
= mciGetDeviceIDFromElementIDW(dwElementID
, w
);
2399 HeapFree(GetProcessHeap(), 0, w
);
2404 /**************************************************************************
2405 * mciGetDeviceIDFromElementIDW [WINMM.@]
2407 UINT WINAPI
mciGetDeviceIDFromElementIDW(DWORD dwElementID
, LPCWSTR lpstrType
)
2409 /* FIXME: that's rather strange, there is no
2410 * mciGetDeviceIDFromElementID32A in winmm.spec
2412 FIXME("(%u, %s) stub\n", dwElementID
, debugstr_w(lpstrType
));
2416 /**************************************************************************
2417 * mciGetYieldProc [WINMM.@]
2419 YIELDPROC WINAPI
mciGetYieldProc(MCIDEVICEID uDeviceID
, DWORD
* lpdwYieldData
)
2421 LPWINE_MCIDRIVER wmd
;
2423 TRACE("(%u, %p)\n", uDeviceID
, lpdwYieldData
);
2425 if (!(wmd
= MCI_GetDriver(uDeviceID
))) {
2426 WARN("Bad uDeviceID\n");
2429 if (!wmd
->lpfnYieldProc
) {
2430 WARN("No proc set\n");
2433 if (lpdwYieldData
) *lpdwYieldData
= wmd
->dwYieldData
;
2434 return wmd
->lpfnYieldProc
;
2437 /**************************************************************************
2438 * mciGetCreatorTask [WINMM.@]
2440 HTASK WINAPI
mciGetCreatorTask(MCIDEVICEID uDeviceID
)
2442 LPWINE_MCIDRIVER wmd
;
2445 if ((wmd
= MCI_GetDriver(uDeviceID
))) ret
= (HTASK
)(DWORD_PTR
)wmd
->CreatorThread
;
2447 TRACE("(%u) => %p\n", uDeviceID
, ret
);
2451 /**************************************************************************
2452 * mciDriverYield [WINMM.@]
2454 UINT WINAPI
mciDriverYield(MCIDEVICEID uDeviceID
)
2456 LPWINE_MCIDRIVER wmd
;
2459 TRACE("(%04x)\n", uDeviceID
);
2461 if (!(wmd
= MCI_GetDriver(uDeviceID
)) || !wmd
->lpfnYieldProc
) {
2463 PeekMessageW(&msg
, 0, 0, 0, PM_REMOVE
| PM_QS_SENDMESSAGE
);
2465 ret
= wmd
->lpfnYieldProc(uDeviceID
, wmd
->dwYieldData
);