4 * Copyright 1993 Martin Ayotte
5 * 1998-2003,2009 Eric Pouech
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 #define NONAMELESSUNION
27 #define NONAMELESSSTRUCT
35 #include "wine/winuser16.h"
39 #include "wine/debug.h"
41 WINE_DEFAULT_DEBUG_CHANNEL(mmsys
);
43 /**************************************************************************
44 * MCI_MessageToString [internal]
46 static const char* MCI_MessageToString(UINT wMsg
)
48 static char buffer
[100];
50 #define CASE(s) case (s): return #s
60 CASE(DRV_QUERYCONFIGURE
);
63 CASE(DRV_EXITSESSION
);
64 CASE(DRV_EXITAPPLICATION
);
68 CASE(MCI_CLOSE_DRIVER
);
81 CASE(MCI_OPEN_DRIVER
);
100 /* constants for digital video */
114 sprintf(buffer
, "MCI_<<%04X>>", wMsg
);
119 static LPWSTR
MCI_strdupAtoW( LPCSTR str
)
124 if (!str
) return NULL
;
125 len
= MultiByteToWideChar( CP_ACP
, 0, str
, -1, NULL
, 0 );
126 ret
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
127 if (ret
) MultiByteToWideChar( CP_ACP
, 0, str
, -1, ret
, len
);
131 static DWORD
MCI_get_device_type(UINT16 deviceId
)
133 MCI_GETDEVCAPS_PARMS parms
;
136 err
= mciSendCommandW(deviceId
, MCI_GETDEVCAPS
, MCI_GETDEVCAPS_DEVICE_TYPE
| MCI_WAIT
, (DWORD_PTR
)&parms
);
137 if (err
!= MMSYSERR_NOERROR
)
138 return MCI_DEVTYPE_OTHER
;
139 return parms
.dwReturn
;
142 /**************************************************************************
143 * MCI_MapMsg16To32W [internal]
145 static MMSYSTEM_MapType
MCI_MapMsg16To32W(UINT16 wDevID
, WORD wMsg
, DWORD dwFlags
, DWORD_PTR
* lParam
)
148 return MMSYSTEM_MAP_OK
;
149 /* FIXME: to add also (with seg/linear modifications to do):
150 * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
151 * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
154 /* case MCI_CAPTURE */
156 case MCI_CLOSE_DRIVER
:
163 /* case MCI_INDEX: */
165 /* case MCI_MONITOR: */
174 /* case MCI_SETTIMECODE:*/
175 /* case MCI_SIGNAL:*/
181 *lParam
= (DWORD
)MapSL(*lParam
);
182 return MMSYSTEM_MAP_OK
;
188 LPMCI_DGV_RECT_PARMS mdrp32
= HeapAlloc(GetProcessHeap(), 0,
189 sizeof(LPMCI_DGV_RECT_PARMS16
) + sizeof(MCI_DGV_RECT_PARMS
));
190 LPMCI_DGV_RECT_PARMS16 mdrp16
= MapSL(*lParam
);
192 *(LPMCI_DGV_RECT_PARMS16
*)(mdrp32
) = mdrp16
;
193 mdrp32
= (LPMCI_DGV_RECT_PARMS
)((char*)mdrp32
+ sizeof(LPMCI_DGV_RECT_PARMS16
));
194 mdrp32
->dwCallback
= mdrp16
->dwCallback
;
195 mdrp32
->rc
.left
= mdrp16
->rc
.left
;
196 mdrp32
->rc
.top
= mdrp16
->rc
.top
;
197 mdrp32
->rc
.right
= mdrp16
->rc
.right
;
198 mdrp32
->rc
.bottom
= mdrp16
->rc
.bottom
;
200 return MMSYSTEM_MAP_NOMEM
;
202 *lParam
= (DWORD
)mdrp32
;
204 return MMSYSTEM_MAP_OKMEM
;
207 if (MCI_get_device_type(wDevID
) == MCI_DEVTYPE_DIGITAL_VIDEO
) {
208 LPMCI_DGV_STATUS_PARMSW mdsp32w
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
209 sizeof(LPMCI_DGV_STATUS_PARMS16
) + sizeof(MCI_DGV_STATUS_PARMSW
));
210 LPMCI_DGV_STATUS_PARMS16 mdsp16
= MapSL(*lParam
);
212 *(LPMCI_DGV_STATUS_PARMS16
*)(mdsp32w
) = mdsp16
;
213 mdsp32w
= (LPMCI_DGV_STATUS_PARMSW
)((char*)mdsp32w
+ sizeof(LPMCI_DGV_STATUS_PARMS16
));
214 mdsp32w
->dwCallback
= mdsp16
->dwCallback
;
215 mdsp32w
->dwReturn
= mdsp16
->dwReturn
;
216 mdsp32w
->dwItem
= mdsp16
->dwItem
;
217 mdsp32w
->dwTrack
= mdsp16
->dwTrack
;
218 if (dwFlags
& MCI_DGV_STATUS_DISKSPACE
)
219 mdsp32w
->lpstrDrive
= MCI_strdupAtoW(MapSL(mdsp16
->lpstrDrive
));
220 mdsp32w
->dwReference
= mdsp16
->dwReference
;
221 *lParam
= (DWORD
)mdsp32w
;
223 return MMSYSTEM_MAP_NOMEM
;
226 *lParam
= (DWORD
)MapSL(*lParam
);
229 return MMSYSTEM_MAP_OKMEM
;
232 LPMCI_OVLY_WINDOW_PARMSW mowp32w
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(MCI_OVLY_WINDOW_PARMSW
));
233 LPMCI_OVLY_WINDOW_PARMS16 mowp16
= MapSL(*lParam
);
235 mowp32w
->dwCallback
= mowp16
->dwCallback
;
236 mowp32w
->hWnd
= HWND_32(mowp16
->hWnd
);
237 mowp32w
->nCmdShow
= mowp16
->nCmdShow
;
238 if (dwFlags
& (MCI_DGV_WINDOW_TEXT
| MCI_OVLY_WINDOW_TEXT
))
239 mowp32w
->lpstrText
= MCI_strdupAtoW(MapSL(mowp16
->lpstrText
));
241 return MMSYSTEM_MAP_NOMEM
;
243 *lParam
= (DWORD
)mowp32w
;
245 return MMSYSTEM_MAP_OKMEM
;
248 LPMCI_BREAK_PARMS mbp32
= HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS
));
249 LPMCI_BREAK_PARMS16 mbp16
= MapSL(*lParam
);
252 mbp32
->dwCallback
= mbp16
->dwCallback
;
253 mbp32
->nVirtKey
= mbp16
->nVirtKey
;
254 mbp32
->hwndBreak
= HWND_32(mbp16
->hwndBreak
);
256 return MMSYSTEM_MAP_NOMEM
;
258 *lParam
= (DWORD
)mbp32
;
260 return MMSYSTEM_MAP_OKMEM
;
263 LPMCI_VD_ESCAPE_PARMSW mvep32w
= HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSW
));
264 LPMCI_VD_ESCAPE_PARMS16 mvep16
= MapSL(*lParam
);
267 mvep32w
->dwCallback
= mvep16
->dwCallback
;
268 mvep32w
->lpstrCommand
= MCI_strdupAtoW(MapSL(mvep16
->lpstrCommand
));
270 return MMSYSTEM_MAP_NOMEM
;
272 *lParam
= (DWORD
)mvep32w
;
274 return MMSYSTEM_MAP_OKMEM
;
277 LPMCI_INFO_PARMSW mip32w
= HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16
) + sizeof(MCI_INFO_PARMSW
));
278 LPMCI_INFO_PARMS16 mip16
= MapSL(*lParam
);
280 /* FIXME this is wrong if device is of type
281 * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
284 *(LPMCI_INFO_PARMS16
*)(mip32w
) = mip16
;
285 mip32w
= (LPMCI_INFO_PARMSW
)((char*)mip32w
+ sizeof(LPMCI_INFO_PARMS16
));
286 mip32w
->dwCallback
= mip16
->dwCallback
;
287 mip32w
->lpstrReturn
= HeapAlloc(GetProcessHeap(), 0, mip16
->dwRetSize
* sizeof(WCHAR
));
288 mip32w
->dwRetSize
= mip16
->dwRetSize
* sizeof(WCHAR
);
290 return MMSYSTEM_MAP_NOMEM
;
292 *lParam
= (DWORD
)mip32w
;
294 return MMSYSTEM_MAP_OKMEM
;
296 case MCI_OPEN_DRIVER
:
298 LPMCI_OPEN_PARMSW mop32w
= HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16
) + sizeof(MCI_OPEN_PARMSW
) + 2 * sizeof(DWORD
));
299 LPMCI_OPEN_PARMS16 mop16
= MapSL(*lParam
);
302 *(LPMCI_OPEN_PARMS16
*)(mop32w
) = mop16
;
303 mop32w
= (LPMCI_OPEN_PARMSW
)((char*)mop32w
+ sizeof(LPMCI_OPEN_PARMS16
));
304 mop32w
->dwCallback
= mop16
->dwCallback
;
305 mop32w
->wDeviceID
= mop16
->wDeviceID
;
306 if( ( dwFlags
& ( MCI_OPEN_TYPE
| MCI_OPEN_TYPE_ID
)) == MCI_OPEN_TYPE
)
307 mop32w
->lpstrDeviceType
= MCI_strdupAtoW(MapSL(mop16
->lpstrDeviceType
));
309 mop32w
->lpstrDeviceType
= (LPWSTR
) mop16
->lpstrDeviceType
;
310 if( ( dwFlags
& ( MCI_OPEN_ELEMENT
| MCI_OPEN_ELEMENT_ID
)) == MCI_OPEN_ELEMENT
)
311 mop32w
->lpstrElementName
= MCI_strdupAtoW(MapSL(mop16
->lpstrElementName
));
313 mop32w
->lpstrElementName
= (LPWSTR
) mop16
->lpstrElementName
;
314 if( ( dwFlags
& MCI_OPEN_ALIAS
))
315 mop32w
->lpstrAlias
= MCI_strdupAtoW(MapSL(mop16
->lpstrAlias
));
317 mop32w
->lpstrAlias
= (LPWSTR
) mop16
->lpstrAlias
;
318 /* copy extended information if any...
319 * FIXME: this may seg fault if initial structure does not contain them and
320 * the reads after msip16 fail under LDT limits...
321 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
322 * should not take care of extended parameters, and should be used by MCI_Open
323 * to fetch uDevType. When, this is known, the mapping for sending the
324 * MCI_OPEN_DRIVER shall be done depending on uDevType.
326 memcpy(mop32w
+ 1, mop16
+ 1, 2 * sizeof(DWORD
));
328 return MMSYSTEM_MAP_NOMEM
;
330 *lParam
= (DWORD
)mop32w
;
332 return MMSYSTEM_MAP_OKMEM
;
335 MCI_SYSINFO_PARMSW
*msip32w
= HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_OPEN_PARMS16
*) + sizeof(MCI_SYSINFO_PARMSW
));
336 MCI_SYSINFO_PARMS16
*msip16
= MapSL(*lParam
);
339 return MMSYSTEM_MAP_NOMEM
;
341 *(MCI_SYSINFO_PARMS16
**)msip32w
= msip16
;
342 msip32w
= (MCI_SYSINFO_PARMSW
*)((char *)msip32w
+ sizeof(MCI_OPEN_PARMS16
*));
343 msip32w
->dwCallback
= msip16
->dwCallback
;
344 msip32w
->lpstrReturn
= HeapAlloc(GetProcessHeap(), 0, (dwFlags
& MCI_SYSINFO_QUANTITY
) ?
346 msip16
->dwRetSize
* sizeof(WCHAR
));
347 if (!msip32w
->lpstrReturn
)
349 HeapFree(GetProcessHeap(), 0, msip32w
);
350 return MMSYSTEM_MAP_NOMEM
;
352 msip32w
->dwRetSize
= (dwFlags
& MCI_SYSINFO_QUANTITY
) ? sizeof(DWORD
) : msip16
->dwRetSize
;
353 msip32w
->dwNumber
= msip16
->dwNumber
;
354 msip32w
->wDeviceType
= msip16
->wDeviceType
;
356 *lParam
= (DWORD
)msip32w
;
358 return MMSYSTEM_MAP_OKMEM
;
361 LPMCI_SOUND_PARMSW mbp32
= HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMSW
));
362 LPMCI_SOUND_PARMS16 mbp16
= MapSL(*lParam
);
365 mbp32
->dwCallback
= mbp16
->dwCallback
;
366 mbp32
->lpstrSoundName
= MCI_strdupAtoW(MapSL(mbp16
->lpstrSoundName
));
368 return MMSYSTEM_MAP_NOMEM
;
370 *lParam
= (DWORD
)mbp32
;
372 return MMSYSTEM_MAP_OKMEM
;
380 case DRV_QUERYCONFIGURE
:
383 case DRV_EXITSESSION
:
384 case DRV_EXITAPPLICATION
:
386 FIXME("This is a hack\n");
387 return MMSYSTEM_MAP_OK
;
389 FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg
));
391 return MMSYSTEM_MAP_MSGERROR
;
394 /**************************************************************************
395 * MCI_UnMapMsg16To32W [internal]
397 static MMSYSTEM_MapType
MCI_UnMapMsg16To32W(UINT16 wDevID
, WORD wMsg
, DWORD dwFlags
, DWORD_PTR lParam
)
400 /* case MCI_CAPTURE */
402 case MCI_CLOSE_DRIVER
:
409 /* case MCI_INDEX: */
411 /* case MCI_MONITOR: */
420 /* case MCI_SETTIMECODE:*/
421 /* case MCI_SIGNAL:*/
427 return MMSYSTEM_MAP_OK
;
434 LPMCI_DGV_RECT_PARMS mdrp32
= (LPMCI_DGV_RECT_PARMS
)lParam
;
435 char *base
= (char*)lParam
- sizeof(LPMCI_DGV_RECT_PARMS16
);
436 LPMCI_DGV_RECT_PARMS16 mdrp16
= *(LPMCI_DGV_RECT_PARMS16
*)base
;
437 mdrp16
->dwCallback
= mdrp32
->dwCallback
;
438 mdrp16
->rc
.left
= mdrp32
->rc
.left
;
439 mdrp16
->rc
.top
= mdrp32
->rc
.top
;
440 mdrp16
->rc
.right
= mdrp32
->rc
.right
;
441 mdrp16
->rc
.bottom
= mdrp32
->rc
.bottom
;
442 HeapFree(GetProcessHeap(), 0, base
);
444 return MMSYSTEM_MAP_OK
;
446 if (lParam
&& MCI_get_device_type(wDevID
) == MCI_DEVTYPE_DIGITAL_VIDEO
) {
447 LPMCI_DGV_STATUS_PARMSW mdsp32w
= (LPMCI_DGV_STATUS_PARMSW
)lParam
;
448 char *base
= (char*)lParam
- sizeof(LPMCI_DGV_STATUS_PARMS16
);
449 LPMCI_DGV_STATUS_PARMS16 mdsp16
= *(LPMCI_DGV_STATUS_PARMS16
*)base
;
450 mdsp16
->dwCallback
= mdsp32w
->dwCallback
;
451 mdsp16
->dwReturn
= mdsp32w
->dwReturn
;
452 mdsp16
->dwItem
= mdsp32w
->dwItem
;
453 mdsp16
->dwTrack
= mdsp32w
->dwTrack
;
454 mdsp16
->dwReference
= mdsp32w
->dwReference
;
455 HeapFree(GetProcessHeap(), 0, (LPVOID
)mdsp32w
->lpstrDrive
);
456 HeapFree(GetProcessHeap(), 0, base
);
458 return MMSYSTEM_MAP_OK
;
461 LPMCI_OVLY_WINDOW_PARMSW mowp32w
= (LPMCI_OVLY_WINDOW_PARMSW
)lParam
;
462 HeapFree(GetProcessHeap(), 0, (LPVOID
)mowp32w
->lpstrText
);
463 HeapFree(GetProcessHeap(), 0, mowp32w
);
465 return MMSYSTEM_MAP_OK
;
468 HeapFree(GetProcessHeap(), 0, (LPVOID
)lParam
);
469 return MMSYSTEM_MAP_OK
;
472 LPMCI_VD_ESCAPE_PARMSW mvep32W
= (LPMCI_VD_ESCAPE_PARMSW
)lParam
;
473 HeapFree(GetProcessHeap(), 0, (LPVOID
)mvep32W
->lpstrCommand
);
474 HeapFree(GetProcessHeap(), 0, (LPVOID
)lParam
);
476 return MMSYSTEM_MAP_OK
;
479 LPMCI_INFO_PARMSW mip32w
= (LPMCI_INFO_PARMSW
)lParam
;
480 char *base
= (char*)lParam
- sizeof(LPMCI_INFO_PARMS16
);
481 LPMCI_INFO_PARMS16 mip16
= *(LPMCI_INFO_PARMS16
*)base
;
483 WideCharToMultiByte(CP_ACP
, 0,
484 mip32w
->lpstrReturn
, mip32w
->dwRetSize
/ sizeof(WCHAR
),
485 MapSL(mip16
->lpstrReturn
), mip16
->dwRetSize
,
487 HeapFree(GetProcessHeap(), 0, mip32w
->lpstrReturn
);
488 HeapFree(GetProcessHeap(), 0, base
);
490 return MMSYSTEM_MAP_OK
;
493 MCI_SYSINFO_PARMSW
*msip32w
= (MCI_SYSINFO_PARMSW
*)lParam
;
494 char *base
= (char*)lParam
- sizeof(MCI_SYSINFO_PARMS16
*);
495 MCI_SYSINFO_PARMS16
*msip16
= *(MCI_SYSINFO_PARMS16
**)base
;
497 if (dwFlags
& MCI_SYSINFO_QUANTITY
) {
498 DWORD
*quantity
= MapSL(msip16
->lpstrReturn
);
500 *quantity
= *(DWORD
*)msip32w
->lpstrReturn
;
503 WideCharToMultiByte(CP_ACP
, 0,
504 msip32w
->lpstrReturn
, msip32w
->dwRetSize
,
505 MapSL(msip16
->lpstrReturn
), msip16
->dwRetSize
,
509 HeapFree(GetProcessHeap(), 0, msip32w
->lpstrReturn
);
510 HeapFree(GetProcessHeap(), 0, base
);
512 return MMSYSTEM_MAP_OK
;
515 LPMCI_SOUND_PARMSW msp32W
= (LPMCI_SOUND_PARMSW
)lParam
;
516 HeapFree(GetProcessHeap(), 0, (LPVOID
)msp32W
->lpstrSoundName
);
517 HeapFree(GetProcessHeap(), 0, (LPVOID
)lParam
);
519 return MMSYSTEM_MAP_OK
;
521 case MCI_OPEN_DRIVER
:
523 LPMCI_OPEN_PARMSW mop32w
= (LPMCI_OPEN_PARMSW
)lParam
;
524 char *base
= (char*)lParam
- sizeof(LPMCI_OPEN_PARMS16
);
525 LPMCI_OPEN_PARMS16 mop16
= *(LPMCI_OPEN_PARMS16
*)base
;
527 mop16
->wDeviceID
= mop32w
->wDeviceID
;
528 if( ( dwFlags
& ( MCI_OPEN_TYPE
| MCI_OPEN_TYPE_ID
)) == MCI_OPEN_TYPE
)
529 HeapFree(GetProcessHeap(), 0, (LPWSTR
)mop32w
->lpstrDeviceType
);
530 if( ( dwFlags
& ( MCI_OPEN_ELEMENT
| MCI_OPEN_ELEMENT_ID
)) == MCI_OPEN_ELEMENT
)
531 HeapFree(GetProcessHeap(), 0, (LPWSTR
)mop32w
->lpstrElementName
);
532 if( ( dwFlags
& MCI_OPEN_ALIAS
))
533 HeapFree(GetProcessHeap(), 0, (LPWSTR
)mop32w
->lpstrAlias
);
534 if (!HeapFree(GetProcessHeap(), 0, base
))
535 FIXME("bad free line=%d\n", __LINE__
);
537 return MMSYSTEM_MAP_OK
;
545 case DRV_QUERYCONFIGURE
:
548 case DRV_EXITSESSION
:
549 case DRV_EXITAPPLICATION
:
551 FIXME("This is a hack\n");
552 return MMSYSTEM_MAP_OK
;
554 FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg
));
556 return MMSYSTEM_MAP_MSGERROR
;
559 /* ###################################################
561 * ###################################################
564 #include <pshpack1.h>
565 #define MCI_MAX_THUNKS 32
567 static struct mci_thunk
569 BYTE popl_eax
; /* popl %eax (return address) */
570 BYTE pushl_func
; /* pushl $pfn16 (16bit callback function) */
572 BYTE pushl_eax
; /* pushl %eax */
573 BYTE jmp
; /* ljmp MCI_Yield1632 */
580 static CRITICAL_SECTION mci_cs
;
581 static CRITICAL_SECTION_DEBUG mci_critsect_debug
=
584 { &mci_critsect_debug
.ProcessLocksList
, &mci_critsect_debug
.ProcessLocksList
},
585 0, 0, { (DWORD_PTR
)(__FILE__
": mmsystem_mci_cs") }
587 static CRITICAL_SECTION mci_cs
= { &mci_critsect_debug
, -1, 0, 0, 0, 0 };
589 static UINT
MCI_Yield1632(DWORD pfn16
, MCIDEVICEID id
, DWORD yield_data
)
596 PeekMessageW( &msg
, 0, 0, 0, PM_REMOVE
| PM_QS_SENDMESSAGE
);
600 /* 16 bit func, call it */
601 TRACE("Function (16 bit) !\n");
603 args
[2] = (MCIDEVICEID16
)id
;
604 args
[1] = HIWORD(yield_data
);
605 args
[0] = LOWORD(yield_data
);
606 return WOWCallback16Ex(pfn16
, WCB16_PASCAL
, sizeof(args
), args
, NULL
);
609 /******************************************************************
613 static struct mci_thunk
* MCI_AddThunk(MCIDEVICEID id
, YIELDPROC16 pfn16
)
615 struct mci_thunk
* thunk
;
619 MCI_Thunks
= VirtualAlloc(NULL
, MCI_MAX_THUNKS
* sizeof(*MCI_Thunks
), MEM_COMMIT
,
620 PAGE_EXECUTE_READWRITE
);
621 if (!MCI_Thunks
) return NULL
;
622 for (thunk
= MCI_Thunks
; thunk
< &MCI_Thunks
[MCI_MAX_THUNKS
]; thunk
++)
624 thunk
->popl_eax
= 0x58; /* popl %eax */
625 thunk
->pushl_func
= 0x68; /* pushl $pfn16 */
627 thunk
->pushl_eax
= 0x50; /* pushl %eax */
628 thunk
->jmp
= 0xe9; /* jmp MCI_Yield1632 */
629 thunk
->callback
= (char *)MCI_Yield1632
- (char *)(&thunk
->callback
+ 1);
633 for (thunk
= MCI_Thunks
; thunk
< &MCI_Thunks
[MCI_MAX_THUNKS
]; thunk
++)
635 if (thunk
->yield16
== 0)
637 thunk
->yield16
= pfn16
;
642 FIXME("Out of mci-thunks. Bump MCI_MAX_THUNKS\n");
646 /******************************************************************
650 static struct mci_thunk
* MCI_HasThunk(YIELDPROC pfn
)
652 struct mci_thunk
* thunk
;
654 if (!MCI_Thunks
) return NULL
;
655 for (thunk
= MCI_Thunks
; thunk
< &MCI_Thunks
[MCI_MAX_THUNKS
]; thunk
++)
657 if ((YIELDPROC
)thunk
== pfn
) return thunk
;
662 /**************************************************************************
663 * mciSetYieldProc [MMSYSTEM.714]
665 BOOL16 WINAPI
mciSetYieldProc16(UINT16 uDeviceID
, YIELDPROC16 fpYieldProc
, DWORD dwYieldData
)
667 struct mci_thunk
* thunk
;
670 TRACE("(%u, %p, %08x)\n", uDeviceID
, fpYieldProc
, dwYieldData
);
672 if (!(thunk
= MCI_AddThunk(uDeviceID
, fpYieldProc
)))
674 ret
= mciSetYieldProc(uDeviceID
, (YIELDPROC
)thunk
, dwYieldData
);
675 if (!ret
) thunk
->yield16
= NULL
;
679 /**************************************************************************
680 * mciGetYieldProc [MMSYSTEM.716]
682 YIELDPROC16 WINAPI
mciGetYieldProc16(UINT16 uDeviceID
, DWORD
* lpdwYieldData
)
686 struct mci_thunk
* thunk
;
688 TRACE("(%u, %p)\n", uDeviceID
, lpdwYieldData
);
690 yield
= mciGetYieldProc(uDeviceID
, &data
);
691 if (!yield
|| !(thunk
= MCI_HasThunk(yield
))) return NULL
;
693 if (lpdwYieldData
) *lpdwYieldData
= data
;
694 return thunk
->yield16
;
697 /**************************************************************************
698 * mciGetErrorString [MMSYSTEM.706]
700 BOOL16 WINAPI
mciGetErrorString16(DWORD wError
, LPSTR lpstrBuffer
, UINT16 uLength
)
702 return mciGetErrorStringA(wError
, lpstrBuffer
, uLength
);
705 /**************************************************************************
706 * mciDriverNotify [MMSYSTEM.711]
708 BOOL16 WINAPI
mciDriverNotify16(HWND16 hWndCallBack
, UINT16 wDevID
, UINT16 wStatus
)
710 TRACE("(%04X, %04x, %04X)\n", hWndCallBack
, wDevID
, wStatus
);
712 return PostMessageA(HWND_32(hWndCallBack
), MM_MCINOTIFY
, wStatus
, wDevID
);
715 /**************************************************************************
716 * mciGetDriverData [MMSYSTEM.708]
718 DWORD WINAPI
mciGetDriverData16(UINT16 uDeviceID
)
720 return mciGetDriverData(uDeviceID
);
723 /**************************************************************************
724 * mciSetDriverData [MMSYSTEM.707]
726 BOOL16 WINAPI
mciSetDriverData16(UINT16 uDeviceID
, DWORD data
)
728 return mciSetDriverData(uDeviceID
, data
);
731 /**************************************************************************
732 * mciSendCommand [MMSYSTEM.701]
734 DWORD WINAPI
mciSendCommand16(UINT16 wDevID
, UINT16 wMsg
, DWORD dwParam1
, DWORD p2
)
738 DWORD_PTR dwParam2
= p2
;
740 TRACE("(%04X, %s, %08X, %08lX)\n", wDevID
, MCI_MessageToString(wMsg
), dwParam1
, dwParam2
);
751 /* FIXME: this is suboptimal. If MCI driver is a 16bit one, we'll be
752 * doing 16=>32W, then 32W=>16 conversions.
753 * We could directly call the 16bit driver if we had the information.
758 MMSYSTEM_MapType res
;
760 dwRet
= MCIERR_INVALID_DEVICE_ID
;
762 switch (res
= MCI_MapMsg16To32W(wDevID
, wMsg
, dwParam1
, &dwParam2
)) {
763 case MMSYSTEM_MAP_MSGERROR
:
764 TRACE("%s not handled yet\n", MCI_MessageToString(wMsg
));
765 dwRet
= MCIERR_DRIVER_INTERNAL
;
767 case MMSYSTEM_MAP_NOMEM
:
768 TRACE("Problem mapping %s from 16 to 32a\n", MCI_MessageToString(wMsg
));
769 dwRet
= MCIERR_OUT_OF_MEMORY
;
771 case MMSYSTEM_MAP_OK
:
772 case MMSYSTEM_MAP_OKMEM
:
773 dwRet
= mciSendCommandW(wDevID
, wMsg
, dwParam1
, dwParam2
);
774 if (res
== MMSYSTEM_MAP_OKMEM
)
775 MCI_UnMapMsg16To32W(wDevID
, wMsg
, dwParam1
, dwParam2
);
782 if (wDevID
== MCI_ALL_DEVICE_ID
) {
783 FIXME("unhandled MCI_ALL_DEVICE_ID\n");
784 dwRet
= MCIERR_CANNOT_USE_ALL
;
786 dwRet
= SendDriverMessage(hdrv
, wMsg
, dwParam1
, dwParam2
);
790 if (wMsg
== MCI_CLOSE
&& dwRet
== 0 && MCI_Thunks
)
792 /* free yield thunks, if any */
794 for (i
= 0; i
< MCI_MAX_THUNKS
; i
++)
796 if (MCI_Thunks
[i
].id
== wDevID
)
797 MCI_Thunks
[i
].yield16
= NULL
;
803 /**************************************************************************
804 * mciGetDeviceID [MMSYSTEM.703]
806 UINT16 WINAPI
mciGetDeviceID16(LPCSTR lpstrName
)
808 TRACE("(\"%s\")\n", lpstrName
);
810 return mciGetDeviceIDA(lpstrName
);
813 /**************************************************************************
814 * mciGetDeviceIDFromElementID [MMSYSTEM.715]
816 UINT16 WINAPI
mciGetDeviceIDFromElementID16(DWORD dwElementID
, LPCSTR lpstrType
)
818 return mciGetDeviceIDFromElementIDA(dwElementID
, lpstrType
);
821 /**************************************************************************
822 * mciGetCreatorTask [MMSYSTEM.717]
824 HTASK16 WINAPI
mciGetCreatorTask16(UINT16 uDeviceID
)
826 return HTASK_16(mciGetCreatorTask(uDeviceID
));
829 /**************************************************************************
830 * mciDriverYield [MMSYSTEM.710]
832 UINT16 WINAPI
mciDriverYield16(UINT16 uDeviceID
)
834 return mciDriverYield(uDeviceID
);
837 /**************************************************************************
838 * mciSendString [MMSYSTEM.702]
840 DWORD WINAPI
mciSendString16(LPCSTR lpstrCommand
, LPSTR lpstrRet
,
841 UINT16 uRetLen
, HWND16 hwndCallback
)
843 return mciSendStringA(lpstrCommand
, lpstrRet
, uRetLen
, HWND_32(hwndCallback
));
846 /**************************************************************************
847 * mciLoadCommandResource [MMSYSTEM.705]
849 UINT16 WINAPI
mciLoadCommandResource16(HINSTANCE16 hInst
, LPCSTR resname
, UINT16 type
)
851 TRACE("(%04x, %s, %x)!\n", hInst
, resname
, type
);
852 return MCI_NO_COMMAND_TABLE
;
855 /**************************************************************************
856 * mciFreeCommandResource [MMSYSTEM.713]
858 BOOL16 WINAPI
mciFreeCommandResource16(UINT16 uTable
)
860 TRACE("(%04x)!\n", uTable
);
865 /**************************************************************************
866 * mciExecute [MMSYSTEM.712]
868 BOOL16 WINAPI
mciExecute16(LPCSTR lpstrCommand
)
870 return mciExecute(lpstrCommand
);