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 /**************************************************************************
132 * MCI_MapMsg16To32W [internal]
134 static MMSYSTEM_MapType MCI_MapMsg16To32W(WORD wMsg, DWORD dwFlags, DWORD_PTR* lParam)
137 return MMSYSTEM_MAP_OK;
138 /* FIXME: to add also (with seg/linear modifications to do):
139 * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
140 * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
143 /* case MCI_CAPTURE */
145 case MCI_CLOSE_DRIVER:
153 /* case MCI_INDEX: */
155 /* case MCI_MONITOR: */
165 /* case MCI_SETTIMECODE:*/
166 /* case MCI_SIGNAL:*/
168 case MCI_STATUS: /* FIXME: is wrong for digital video */
175 *lParam = (DWORD)MapSL(*lParam);
176 return MMSYSTEM_MAP_OK;
178 /* in fact, I would also need the dwFlags... to see
179 * which members of lParam are effectively used
181 *lParam = (DWORD)MapSL(*lParam);
182 FIXME("Current mapping may be wrong\n");
186 LPMCI_BREAK_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
187 LPMCI_BREAK_PARMS16 mbp16 = MapSL(*lParam);
190 mbp32->dwCallback = mbp16->dwCallback;
191 mbp32->nVirtKey = mbp16->nVirtKey;
192 mbp32->hwndBreak = HWND_32(mbp16->hwndBreak);
194 return MMSYSTEM_MAP_NOMEM;
196 *lParam = (DWORD)mbp32;
198 return MMSYSTEM_MAP_OKMEM;
201 LPMCI_VD_ESCAPE_PARMSW mvep32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSW));
202 LPMCI_VD_ESCAPE_PARMS16 mvep16 = MapSL(*lParam);
205 mvep32w->dwCallback = mvep16->dwCallback;
206 mvep32w->lpstrCommand = MCI_strdupAtoW(MapSL(mvep16->lpstrCommand));
208 return MMSYSTEM_MAP_NOMEM;
210 *lParam = (DWORD)mvep32w;
212 return MMSYSTEM_MAP_OKMEM;
215 LPMCI_INFO_PARMSW mip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_INFO_PARMSW));
216 LPMCI_INFO_PARMS16 mip16 = MapSL(*lParam);
218 /* FIXME this is wrong if device is of type
219 * MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
222 *(LPMCI_INFO_PARMS16*)(mip32w) = mip16;
223 mip32w = (LPMCI_INFO_PARMSW)((char*)mip32w + sizeof(LPMCI_INFO_PARMS16));
224 mip32w->dwCallback = mip16->dwCallback;
225 mip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mip16->dwRetSize * sizeof(WCHAR));
226 mip32w->dwRetSize = mip16->dwRetSize * sizeof(WCHAR);
228 return MMSYSTEM_MAP_NOMEM;
230 *lParam = (DWORD)mip32w;
232 return MMSYSTEM_MAP_OKMEM;
234 case MCI_OPEN_DRIVER:
236 LPMCI_OPEN_PARMSW mop32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSW) + 2 * sizeof(DWORD));
237 LPMCI_OPEN_PARMS16 mop16 = MapSL(*lParam);
240 *(LPMCI_OPEN_PARMS16*)(mop32w) = mop16;
241 mop32w = (LPMCI_OPEN_PARMSW)((char*)mop32w + sizeof(LPMCI_OPEN_PARMS16));
242 mop32w->dwCallback = mop16->dwCallback;
243 mop32w->wDeviceID = mop16->wDeviceID;
244 if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
245 mop32w->lpstrDeviceType = MCI_strdupAtoW(MapSL(mop16->lpstrDeviceType));
247 mop32w->lpstrDeviceType = (LPWSTR) mop16->lpstrDeviceType;
248 if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
249 mop32w->lpstrElementName = MCI_strdupAtoW(MapSL(mop16->lpstrElementName));
251 mop32w->lpstrElementName = (LPWSTR) mop16->lpstrElementName;
252 if( ( dwFlags & MCI_OPEN_ALIAS))
253 mop32w->lpstrAlias = MCI_strdupAtoW(MapSL(mop16->lpstrAlias));
255 mop32w->lpstrAlias = (LPWSTR) mop16->lpstrAlias;
256 /* copy extended information if any...
257 * FIXME: this may seg fault if initial structure does not contain them and
258 * the reads after msip16 fail under LDT limits...
259 * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
260 * should not take care of extended parameters, and should be used by MCI_Open
261 * to fetch uDevType. When, this is known, the mapping for sending the
262 * MCI_OPEN_DRIVER shall be done depending on uDevType.
264 memcpy(mop32w + 1, mop16 + 1, 2 * sizeof(DWORD));
266 return MMSYSTEM_MAP_NOMEM;
268 *lParam = (DWORD)mop32w;
270 return MMSYSTEM_MAP_OKMEM;
273 LPMCI_SYSINFO_PARMSW msip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_SYSINFO_PARMSW));
274 LPMCI_SYSINFO_PARMS16 msip16 = MapSL(*lParam);
277 *(LPMCI_SYSINFO_PARMS16*)(msip32w) = msip16;
278 msip32w = (LPMCI_SYSINFO_PARMSW)((char*)msip32w + sizeof(LPMCI_OPEN_PARMS16));
279 msip32w->dwCallback = msip16->dwCallback;
280 msip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, msip16->dwRetSize * sizeof(WCHAR));
281 msip32w->dwRetSize = msip16->dwRetSize;
282 msip32w->dwNumber = msip16->dwNumber;
283 msip32w->wDeviceType = msip16->wDeviceType;
285 return MMSYSTEM_MAP_NOMEM;
287 *lParam = (DWORD)msip32w;
289 return MMSYSTEM_MAP_OKMEM;
292 LPMCI_SOUND_PARMSW mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMSW));
293 LPMCI_SOUND_PARMS16 mbp16 = MapSL(*lParam);
296 mbp32->dwCallback = mbp16->dwCallback;
297 mbp32->lpstrSoundName = MCI_strdupAtoW(MapSL(mbp16->lpstrSoundName));
299 return MMSYSTEM_MAP_NOMEM;
301 *lParam = (DWORD)mbp32;
303 return MMSYSTEM_MAP_OKMEM;
311 case DRV_QUERYCONFIGURE:
314 case DRV_EXITSESSION:
315 case DRV_EXITAPPLICATION:
317 FIXME("This is a hack\n");
318 return MMSYSTEM_MAP_OK;
320 FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
322 return MMSYSTEM_MAP_MSGERROR;
325 /**************************************************************************
326 * MCI_UnMapMsg16To32W [internal]
328 static MMSYSTEM_MapType MCI_UnMapMsg16To32W(WORD wMsg, DWORD dwFlags, DWORD_PTR lParam)
331 /* case MCI_CAPTURE */
333 case MCI_CLOSE_DRIVER:
341 /* case MCI_INDEX: */
343 /* case MCI_MONITOR: */
353 /* case MCI_SETTIMECODE:*/
354 /* case MCI_SIGNAL:*/
363 return MMSYSTEM_MAP_OK;
366 /* FIXME ?? see Map function */
367 return MMSYSTEM_MAP_OK;
370 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
371 return MMSYSTEM_MAP_OK;
374 LPMCI_VD_ESCAPE_PARMSW mvep32W = (LPMCI_VD_ESCAPE_PARMSW)lParam;
375 HeapFree(GetProcessHeap(), 0, (LPVOID)mvep32W->lpstrCommand);
376 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
378 return MMSYSTEM_MAP_OK;
381 LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)lParam;
382 LPMCI_INFO_PARMS16 mip16 = *(LPMCI_INFO_PARMS16*)((char*)mip32w - sizeof(LPMCI_INFO_PARMS16));
384 WideCharToMultiByte(CP_ACP, 0,
385 mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR),
386 MapSL(mip16->lpstrReturn), mip16->dwRetSize,
388 HeapFree(GetProcessHeap(), 0, mip32w->lpstrReturn);
389 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
391 return MMSYSTEM_MAP_OK;
394 LPMCI_SYSINFO_PARMSW msip32w = (LPMCI_SYSINFO_PARMSW)lParam;
395 LPMCI_SYSINFO_PARMS16 msip16 = *(LPMCI_SYSINFO_PARMS16*)((char*)msip32w - sizeof(LPMCI_SYSINFO_PARMS16));
397 WideCharToMultiByte(CP_ACP, 0,
398 msip32w->lpstrReturn, msip32w->dwRetSize,
399 MapSL(msip16->lpstrReturn), msip16->dwRetSize,
401 HeapFree(GetProcessHeap(), 0, msip32w->lpstrReturn);
402 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
404 return MMSYSTEM_MAP_OK;
407 LPMCI_SOUND_PARMSW msp32W = (LPMCI_SOUND_PARMSW)lParam;
408 HeapFree(GetProcessHeap(), 0, (LPVOID)msp32W->lpstrSoundName);
409 HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
411 return MMSYSTEM_MAP_OK;
413 case MCI_OPEN_DRIVER:
415 LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)lParam;
416 LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32w - sizeof(LPMCI_OPEN_PARMS16));
418 mop16->wDeviceID = mop32w->wDeviceID;
419 if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
420 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrDeviceType);
421 if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
422 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrElementName);
423 if( ( dwFlags & MCI_OPEN_ALIAS))
424 HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrAlias);
425 if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
426 FIXME("bad free line=%d\n", __LINE__);
428 return MMSYSTEM_MAP_OK;
436 case DRV_QUERYCONFIGURE:
439 case DRV_EXITSESSION:
440 case DRV_EXITAPPLICATION:
442 FIXME("This is a hack\n");
443 return MMSYSTEM_MAP_OK;
445 FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
447 return MMSYSTEM_MAP_MSGERROR;
450 /* ###################################################
452 * ###################################################
455 #include <pshpack1.h>
456 #define MCI_MAX_THUNKS 32
458 static struct mci_thunk
460 BYTE popl_eax; /* popl %eax (return address) */
461 BYTE pushl_func; /* pushl $pfn16 (16bit callback function) */
463 BYTE pushl_eax; /* pushl %eax */
464 BYTE jmp; /* ljmp MCI_Yield1632 */
471 static CRITICAL_SECTION mci_cs;
472 static CRITICAL_SECTION_DEBUG mci_critsect_debug =
475 { &mci_critsect_debug.ProcessLocksList, &mci_critsect_debug.ProcessLocksList },
476 0, 0, { (DWORD_PTR)(__FILE__ ": mmsystem_mci_cs") }
478 static CRITICAL_SECTION mci_cs = { &mci_critsect_debug, -1, 0, 0, 0, 0 };
480 static UINT MCI_Yield1632(DWORD pfn16, MCIDEVICEID id, DWORD yield_data)
487 PeekMessageW( &msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE );
491 /* 16 bit func, call it */
492 TRACE("Function (16 bit) !\n");
494 args[2] = (MCIDEVICEID16)id;
495 args[1] = HIWORD(yield_data);
496 args[0] = LOWORD(yield_data);
497 return WOWCallback16Ex(pfn16, WCB16_PASCAL, sizeof(args), args, NULL);
500 /******************************************************************
504 static struct mci_thunk* MCI_AddThunk(MCIDEVICEID id, YIELDPROC16 pfn16)
506 struct mci_thunk* thunk;
510 MCI_Thunks = VirtualAlloc(NULL, MCI_MAX_THUNKS * sizeof(*MCI_Thunks), MEM_COMMIT,
511 PAGE_EXECUTE_READWRITE);
512 if (!MCI_Thunks) return NULL;
513 for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
515 thunk->popl_eax = 0x58; /* popl %eax */
516 thunk->pushl_func = 0x68; /* pushl $pfn16 */
518 thunk->pushl_eax = 0x50; /* pushl %eax */
519 thunk->jmp = 0xe9; /* jmp MCI_Yield1632 */
520 thunk->callback = (char *)MCI_Yield1632 - (char *)(&thunk->callback + 1);
524 for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
526 if (thunk->yield16 == 0)
528 thunk->yield16 = pfn16;
533 FIXME("Out of mci-thunks. Bump MCI_MAX_THUNKS\n");
537 /******************************************************************
541 static struct mci_thunk* MCI_HasThunk(YIELDPROC pfn)
543 struct mci_thunk* thunk;
545 if (!MCI_Thunks) return NULL;
546 for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++)
548 if ((YIELDPROC)thunk == pfn) return thunk;
553 /**************************************************************************
554 * mciSetYieldProc [MMSYSTEM.714]
556 BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD dwYieldData)
558 struct mci_thunk* thunk;
561 TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData);
563 if (!(thunk = MCI_AddThunk(uDeviceID, fpYieldProc)))
565 ret = mciSetYieldProc(uDeviceID, (YIELDPROC)thunk, dwYieldData);
566 if (!ret) thunk->yield16 = NULL;
570 /**************************************************************************
571 * mciGetYieldProc [MMSYSTEM.716]
573 YIELDPROC16 WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData)
577 struct mci_thunk* thunk;
579 TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData);
581 yield = mciGetYieldProc(uDeviceID, &data);
582 if (!yield || !(thunk = MCI_HasThunk(yield))) return NULL;
584 if (lpdwYieldData) *lpdwYieldData = data;
585 return thunk->yield16;
588 /**************************************************************************
589 * mciGetErrorString [MMSYSTEM.706]
591 BOOL16 WINAPI mciGetErrorString16(DWORD wError, LPSTR lpstrBuffer, UINT16 uLength)
593 return mciGetErrorStringA(wError, lpstrBuffer, uLength);
596 /**************************************************************************
597 * mciDriverNotify [MMSYSTEM.711]
599 BOOL16 WINAPI mciDriverNotify16(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus)
601 TRACE("(%04X, %04x, %04X)\n", hWndCallBack, wDevID, wStatus);
603 return PostMessageA(HWND_32(hWndCallBack), MM_MCINOTIFY, wStatus, wDevID);
606 /**************************************************************************
607 * mciGetDriverData [MMSYSTEM.708]
609 DWORD WINAPI mciGetDriverData16(UINT16 uDeviceID)
611 return mciGetDriverData(uDeviceID);
614 /**************************************************************************
615 * mciSetDriverData [MMSYSTEM.707]
617 BOOL16 WINAPI mciSetDriverData16(UINT16 uDeviceID, DWORD data)
619 return mciSetDriverData(uDeviceID, data);
622 /**************************************************************************
623 * mciSendCommand [MMSYSTEM.701]
625 DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD p2)
629 DWORD_PTR dwParam2 = p2;
631 TRACE("(%04X, %s, %08X, %08lX)\n", wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2);
642 /* FIXME: this is suboptimal. If MCI driver is a 16bit one, we'll be
643 * doing 16=>32W, then 32W=>16 conversions.
644 * We could directly call the 16bit driver if we had the information.
649 MMSYSTEM_MapType res;
651 dwRet = MCIERR_INVALID_DEVICE_ID;
653 switch (res = MCI_MapMsg16To32W(wMsg, dwParam1, &dwParam2)) {
654 case MMSYSTEM_MAP_MSGERROR:
655 TRACE("%s not handled yet\n", MCI_MessageToString(wMsg));
656 dwRet = MCIERR_DRIVER_INTERNAL;
658 case MMSYSTEM_MAP_NOMEM:
659 TRACE("Problem mapping %s from 16 to 32a\n", MCI_MessageToString(wMsg));
660 dwRet = MCIERR_OUT_OF_MEMORY;
662 case MMSYSTEM_MAP_OK:
663 case MMSYSTEM_MAP_OKMEM:
664 dwRet = mciSendCommandW(wDevID, wMsg, dwParam1, dwParam2);
665 if (res == MMSYSTEM_MAP_OKMEM)
666 MCI_UnMapMsg16To32W(wMsg, dwParam1, dwParam2);
673 if (wDevID == MCI_ALL_DEVICE_ID) {
674 FIXME("unhandled MCI_ALL_DEVICE_ID\n");
675 dwRet = MCIERR_CANNOT_USE_ALL;
677 dwRet = SendDriverMessage(hdrv, wMsg, dwParam1, dwParam2);
681 if (wMsg == MCI_CLOSE && dwRet == 0 && MCI_Thunks)
683 /* free yield thunks, if any */
685 for (i = 0; i < MCI_MAX_THUNKS; i++)
687 if (MCI_Thunks[i].id == wDevID)
688 MCI_Thunks[i].yield16 = NULL;
694 /**************************************************************************
695 * mciGetDeviceID [MMSYSTEM.703]
697 UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName)
699 TRACE("(\"%s\")\n", lpstrName);
701 return mciGetDeviceIDA(lpstrName);
704 /**************************************************************************
705 * mciGetDeviceIDFromElementID [MMSYSTEM.715]
707 UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType)
709 return mciGetDeviceIDFromElementIDA(dwElementID, lpstrType);
712 /**************************************************************************
713 * mciGetCreatorTask [MMSYSTEM.717]
715 HTASK16 WINAPI mciGetCreatorTask16(UINT16 uDeviceID)
717 return HTASK_16(mciGetCreatorTask(uDeviceID));
720 /**************************************************************************
721 * mciDriverYield [MMSYSTEM.710]
723 UINT16 WINAPI mciDriverYield16(UINT16 uDeviceID)
725 return mciDriverYield(uDeviceID);
728 /**************************************************************************
729 * mciSendString [MMSYSTEM.702]
731 DWORD WINAPI mciSendString16(LPCSTR lpstrCommand, LPSTR lpstrRet,
732 UINT16 uRetLen, HWND16 hwndCallback)
734 return mciSendStringA(lpstrCommand, lpstrRet, uRetLen, HWND_32(hwndCallback));
737 /**************************************************************************
738 * mciLoadCommandResource [MMSYSTEM.705]
740 UINT16 WINAPI mciLoadCommandResource16(HINSTANCE16 hInst, LPCSTR resname, UINT16 type)
742 TRACE("(%04x, %s, %x)!\n", hInst, resname, type);
743 return MCI_NO_COMMAND_TABLE;
746 /**************************************************************************
747 * mciFreeCommandResource [MMSYSTEM.713]
749 BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable)
751 TRACE("(%04x)!\n", uTable);
756 /**************************************************************************
757 * mciExecute [MMSYSTEM.712]
759 BOOL16 WINAPI mciExecute16(LPCSTR lpstrCommand)
761 return mciExecute(lpstrCommand);