| /* |
| * MMSYSTEM functions |
| * |
| * Copyright 1993 Martin Ayotte |
| * 1998-2003,2009 Eric Pouech |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include <stdarg.h> |
| #include <string.h> |
| #include <stdio.h> |
| |
| #define NONAMELESSUNION |
| #define NONAMELESSSTRUCT |
| #include "windef.h" |
| #include "winbase.h" |
| #include "mmsystem.h" |
| #include "winternl.h" |
| #include "wownt32.h" |
| #include "winnls.h" |
| |
| #include "wine/winuser16.h" |
| #include "winemm16.h" |
| #include "digitalv.h" |
| |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(mmsys); |
| |
| /************************************************************************** |
| * MCI_MessageToString [internal] |
| */ |
| static const char* MCI_MessageToString(UINT wMsg) |
| { |
| static char buffer[100]; |
| |
| #define CASE(s) case (s): return #s |
| |
| switch (wMsg) { |
| CASE(DRV_LOAD); |
| CASE(DRV_ENABLE); |
| CASE(DRV_OPEN); |
| CASE(DRV_CLOSE); |
| CASE(DRV_DISABLE); |
| CASE(DRV_FREE); |
| CASE(DRV_CONFIGURE); |
| CASE(DRV_QUERYCONFIGURE); |
| CASE(DRV_INSTALL); |
| CASE(DRV_REMOVE); |
| CASE(DRV_EXITSESSION); |
| CASE(DRV_EXITAPPLICATION); |
| CASE(DRV_POWER); |
| CASE(MCI_BREAK); |
| CASE(MCI_CLOSE); |
| CASE(MCI_CLOSE_DRIVER); |
| CASE(MCI_COPY); |
| CASE(MCI_CUE); |
| CASE(MCI_CUT); |
| CASE(MCI_DELETE); |
| CASE(MCI_ESCAPE); |
| CASE(MCI_FREEZE); |
| CASE(MCI_PAUSE); |
| CASE(MCI_PLAY); |
| CASE(MCI_GETDEVCAPS); |
| CASE(MCI_INFO); |
| CASE(MCI_LOAD); |
| CASE(MCI_OPEN); |
| CASE(MCI_OPEN_DRIVER); |
| CASE(MCI_PASTE); |
| CASE(MCI_PUT); |
| CASE(MCI_REALIZE); |
| CASE(MCI_RECORD); |
| CASE(MCI_RESUME); |
| CASE(MCI_SAVE); |
| CASE(MCI_SEEK); |
| CASE(MCI_SET); |
| CASE(MCI_SOUND); |
| CASE(MCI_SPIN); |
| CASE(MCI_STATUS); |
| CASE(MCI_STEP); |
| CASE(MCI_STOP); |
| CASE(MCI_SYSINFO); |
| CASE(MCI_UNFREEZE); |
| CASE(MCI_UPDATE); |
| CASE(MCI_WHERE); |
| CASE(MCI_WINDOW); |
| /* constants for digital video */ |
| CASE(MCI_CAPTURE); |
| CASE(MCI_MONITOR); |
| CASE(MCI_RESERVE); |
| CASE(MCI_SETAUDIO); |
| CASE(MCI_SIGNAL); |
| CASE(MCI_SETVIDEO); |
| CASE(MCI_QUALITY); |
| CASE(MCI_LIST); |
| CASE(MCI_UNDO); |
| CASE(MCI_CONFIGURE); |
| CASE(MCI_RESTORE); |
| #undef CASE |
| default: |
| sprintf(buffer, "MCI_<<%04X>>", wMsg); |
| return buffer; |
| } |
| } |
| |
| static LPWSTR MCI_strdupAtoW( LPCSTR str ) |
| { |
| LPWSTR ret; |
| INT len; |
| |
| if (!str) return NULL; |
| len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 ); |
| ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ); |
| if (ret) MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len ); |
| return ret; |
| } |
| |
| /************************************************************************** |
| * MCI_MapMsg16To32W [internal] |
| */ |
| static MMSYSTEM_MapType MCI_MapMsg16To32W(WORD wMsg, DWORD dwFlags, DWORD_PTR* lParam) |
| { |
| if (*lParam == 0) |
| return MMSYSTEM_MAP_OK; |
| /* FIXME: to add also (with seg/linear modifications to do): |
| * MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE |
| * MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO |
| */ |
| switch (wMsg) { |
| /* case MCI_CAPTURE */ |
| case MCI_CLOSE: |
| case MCI_CLOSE_DRIVER: |
| case MCI_CONFIGURE: |
| case MCI_COPY: |
| case MCI_CUE: |
| case MCI_CUT: |
| case MCI_DELETE: |
| case MCI_GETDEVCAPS: |
| /* case MCI_INDEX: */ |
| /* case MCI_MARK: */ |
| /* case MCI_MONITOR: */ |
| case MCI_PASTE: |
| case MCI_PAUSE: |
| case MCI_PLAY: |
| case MCI_REALIZE: |
| case MCI_RECORD: |
| case MCI_RESUME: |
| case MCI_SEEK: |
| case MCI_SET: |
| /* case MCI_SETTIMECODE:*/ |
| /* case MCI_SIGNAL:*/ |
| case MCI_SPIN: |
| case MCI_STEP: |
| case MCI_STOP: |
| /* case MCI_UNDO: */ |
| case MCI_UPDATE: |
| *lParam = (DWORD)MapSL(*lParam); |
| return MMSYSTEM_MAP_OK; |
| case MCI_WHERE: |
| case MCI_FREEZE: |
| case MCI_UNFREEZE: |
| case MCI_PUT: |
| { |
| LPMCI_DGV_RECT_PARMS mdrp32 = HeapAlloc(GetProcessHeap(), 0, |
| sizeof(LPMCI_DGV_RECT_PARMS16) + sizeof(MCI_DGV_RECT_PARMS)); |
| LPMCI_DGV_RECT_PARMS16 mdrp16 = MapSL(*lParam); |
| if (mdrp32) { |
| *(LPMCI_DGV_RECT_PARMS16*)(mdrp32) = mdrp16; |
| mdrp32 = (LPMCI_DGV_RECT_PARMS)((char*)mdrp32 + sizeof(LPMCI_DGV_RECT_PARMS16)); |
| mdrp32->dwCallback = mdrp16->dwCallback; |
| mdrp32->rc.left = mdrp16->rc.left; |
| mdrp32->rc.top = mdrp16->rc.top; |
| mdrp32->rc.right = mdrp16->rc.right; |
| mdrp32->rc.bottom = mdrp16->rc.bottom; |
| } else { |
| return MMSYSTEM_MAP_NOMEM; |
| } |
| *lParam = (DWORD)mdrp32; |
| } |
| return MMSYSTEM_MAP_OKMEM; |
| case MCI_STATUS: |
| { |
| if (dwFlags & (MCI_DGV_STATUS_REFERENCE | MCI_DGV_STATUS_DISKSPACE)) { |
| LPMCI_DGV_STATUS_PARMSW mdsp32w = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, |
| sizeof(LPMCI_DGV_STATUS_PARMS16) + sizeof(MCI_DGV_STATUS_PARMSW)); |
| LPMCI_DGV_STATUS_PARMS16 mdsp16 = MapSL(*lParam); |
| if (mdsp32w) { |
| *(LPMCI_DGV_STATUS_PARMS16*)(mdsp32w) = mdsp16; |
| mdsp32w = (LPMCI_DGV_STATUS_PARMSW)((char*)mdsp32w + sizeof(LPMCI_DGV_STATUS_PARMS16)); |
| mdsp32w->dwCallback = mdsp16->dwCallback; |
| mdsp32w->dwReturn = mdsp16->dwReturn; |
| mdsp32w->dwItem = mdsp16->dwItem; |
| mdsp32w->dwTrack = mdsp16->dwTrack; |
| if (dwFlags & MCI_DGV_STATUS_DISKSPACE) |
| mdsp32w->lpstrDrive = MCI_strdupAtoW(MapSL(mdsp16->lpstrDrive)); |
| if (dwFlags & MCI_DGV_STATUS_REFERENCE) |
| mdsp32w->dwReference = mdsp16->dwReference; |
| *lParam = (DWORD)mdsp32w; |
| } else { |
| return MMSYSTEM_MAP_NOMEM; |
| } |
| } else { |
| *lParam = (DWORD)MapSL(*lParam); |
| return MMSYSTEM_MAP_OK; |
| } |
| } |
| return MMSYSTEM_MAP_OKMEM; |
| case MCI_WINDOW: |
| { |
| LPMCI_OVLY_WINDOW_PARMSW mowp32w = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MCI_OVLY_WINDOW_PARMSW)); |
| LPMCI_OVLY_WINDOW_PARMS16 mowp16 = MapSL(*lParam); |
| if (mowp32w) { |
| mowp32w->dwCallback = mowp16->dwCallback; |
| mowp32w->hWnd = HWND_32(mowp16->hWnd); |
| mowp32w->nCmdShow = mowp16->nCmdShow; |
| if (dwFlags & (MCI_DGV_WINDOW_TEXT | MCI_OVLY_WINDOW_TEXT)) |
| mowp32w->lpstrText = MCI_strdupAtoW(MapSL(mowp16->lpstrText)); |
| } else { |
| return MMSYSTEM_MAP_NOMEM; |
| } |
| *lParam = (DWORD)mowp32w; |
| } |
| return MMSYSTEM_MAP_OKMEM; |
| case MCI_BREAK: |
| { |
| LPMCI_BREAK_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS)); |
| LPMCI_BREAK_PARMS16 mbp16 = MapSL(*lParam); |
| |
| if (mbp32) { |
| mbp32->dwCallback = mbp16->dwCallback; |
| mbp32->nVirtKey = mbp16->nVirtKey; |
| mbp32->hwndBreak = HWND_32(mbp16->hwndBreak); |
| } else { |
| return MMSYSTEM_MAP_NOMEM; |
| } |
| *lParam = (DWORD)mbp32; |
| } |
| return MMSYSTEM_MAP_OKMEM; |
| case MCI_ESCAPE: |
| { |
| LPMCI_VD_ESCAPE_PARMSW mvep32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSW)); |
| LPMCI_VD_ESCAPE_PARMS16 mvep16 = MapSL(*lParam); |
| |
| if (mvep32w) { |
| mvep32w->dwCallback = mvep16->dwCallback; |
| mvep32w->lpstrCommand = MCI_strdupAtoW(MapSL(mvep16->lpstrCommand)); |
| } else { |
| return MMSYSTEM_MAP_NOMEM; |
| } |
| *lParam = (DWORD)mvep32w; |
| } |
| return MMSYSTEM_MAP_OKMEM; |
| case MCI_INFO: |
| { |
| LPMCI_DGV_INFO_PARMSW mip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_DGV_INFO_PARMS16) + sizeof(MCI_DGV_INFO_PARMSW)); |
| LPMCI_DGV_INFO_PARMS16 mip16 = MapSL(*lParam); |
| |
| if (mip32w) { |
| *(LPMCI_DGV_INFO_PARMS16*)(mip32w) = mip16; |
| mip32w = (LPMCI_DGV_INFO_PARMSW)((char*)mip32w + sizeof(LPMCI_DGV_INFO_PARMS16)); |
| mip32w->dwCallback = mip16->dwCallback; |
| mip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mip16->dwRetSize * sizeof(WCHAR)); |
| mip32w->dwRetSize = mip16->dwRetSize; |
| if (dwFlags & MCI_DGV_INFO_ITEM) |
| mip32w->dwItem = mip16->dwItem; |
| } else { |
| return MMSYSTEM_MAP_NOMEM; |
| } |
| *lParam = (DWORD)mip32w; |
| } |
| return MMSYSTEM_MAP_OKMEM; |
| case MCI_OPEN: |
| case MCI_OPEN_DRIVER: |
| { |
| LPMCI_OPEN_PARMSW mop32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_ANIM_OPEN_PARMSW)); |
| LPMCI_OPEN_PARMS16 mop16 = MapSL(*lParam); |
| |
| if (mop32w) { |
| *(LPMCI_OPEN_PARMS16*)(mop32w) = mop16; |
| mop32w = (LPMCI_OPEN_PARMSW)((char*)mop32w + sizeof(LPMCI_OPEN_PARMS16)); |
| mop32w->dwCallback = mop16->dwCallback; |
| mop32w->wDeviceID = mop16->wDeviceID; |
| if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE) |
| mop32w->lpstrDeviceType = MCI_strdupAtoW(MapSL(mop16->lpstrDeviceType)); |
| else |
| mop32w->lpstrDeviceType = (LPWSTR) mop16->lpstrDeviceType; |
| if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT) |
| mop32w->lpstrElementName = MCI_strdupAtoW(MapSL(mop16->lpstrElementName)); |
| else |
| mop32w->lpstrElementName = (LPWSTR) mop16->lpstrElementName; |
| if( ( dwFlags & MCI_OPEN_ALIAS)) |
| mop32w->lpstrAlias = MCI_strdupAtoW(MapSL(mop16->lpstrAlias)); |
| else |
| mop32w->lpstrAlias = (LPWSTR) mop16->lpstrAlias; |
| /* copy extended information if any... |
| * FIXME: this may seg fault if initial structure does not contain them and |
| * the reads after msip16 fail under LDT limits... |
| * NOTE: this should be split in two. First pass, while calling MCI_OPEN, and |
| * should not take care of extended parameters, and should be used by MCI_Open |
| * to fetch uDevType. When, this is known, the mapping for sending the |
| * MCI_OPEN_DRIVER shall be done depending on uDevType. |
| */ |
| if (HIWORD(dwFlags)) |
| memcpy(mop32w + 1, mop16 + 1, sizeof(MCI_ANIM_OPEN_PARMS16) - sizeof(MCI_OPEN_PARMS16)); |
| } else { |
| return MMSYSTEM_MAP_NOMEM; |
| } |
| *lParam = (DWORD)mop32w; |
| } |
| return MMSYSTEM_MAP_OKMEM; |
| case MCI_SYSINFO: |
| { |
| MCI_SYSINFO_PARMSW *msip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_OPEN_PARMS16 *) + sizeof(MCI_SYSINFO_PARMSW)); |
| MCI_SYSINFO_PARMS16 *msip16 = MapSL(*lParam); |
| |
| if (!msip32w) |
| return MMSYSTEM_MAP_NOMEM; |
| |
| *(MCI_SYSINFO_PARMS16 **)msip32w = msip16; |
| msip32w = (MCI_SYSINFO_PARMSW *)((char *)msip32w + sizeof(MCI_OPEN_PARMS16 *)); |
| msip32w->dwCallback = msip16->dwCallback; |
| msip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, (dwFlags & MCI_SYSINFO_QUANTITY) ? |
| sizeof(DWORD) : |
| msip16->dwRetSize * sizeof(WCHAR)); |
| if (!msip32w->lpstrReturn) |
| { |
| HeapFree(GetProcessHeap(), 0, msip32w); |
| return MMSYSTEM_MAP_NOMEM; |
| } |
| msip32w->dwRetSize = (dwFlags & MCI_SYSINFO_QUANTITY) ? sizeof(DWORD) : msip16->dwRetSize; |
| msip32w->dwNumber = msip16->dwNumber; |
| msip32w->wDeviceType = msip16->wDeviceType; |
| |
| *lParam = (DWORD)msip32w; |
| } |
| return MMSYSTEM_MAP_OKMEM; |
| case MCI_SOUND: |
| { |
| LPMCI_SOUND_PARMSW mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMSW)); |
| LPMCI_SOUND_PARMS16 mbp16 = MapSL(*lParam); |
| |
| if (mbp32) { |
| mbp32->dwCallback = mbp16->dwCallback; |
| mbp32->lpstrSoundName = MCI_strdupAtoW(MapSL(mbp16->lpstrSoundName)); |
| } else { |
| return MMSYSTEM_MAP_NOMEM; |
| } |
| *lParam = (DWORD)mbp32; |
| } |
| return MMSYSTEM_MAP_OKMEM; |
| case DRV_LOAD: |
| case DRV_ENABLE: |
| case DRV_OPEN: |
| case DRV_CLOSE: |
| case DRV_DISABLE: |
| case DRV_FREE: |
| case DRV_CONFIGURE: |
| case DRV_QUERYCONFIGURE: |
| case DRV_INSTALL: |
| case DRV_REMOVE: |
| case DRV_EXITSESSION: |
| case DRV_EXITAPPLICATION: |
| case DRV_POWER: |
| FIXME("This is a hack\n"); |
| return MMSYSTEM_MAP_OK; |
| default: |
| FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg)); |
| } |
| return MMSYSTEM_MAP_MSGERROR; |
| } |
| |
| /************************************************************************** |
| * MCI_UnMapMsg16To32W [internal] |
| */ |
| static void MCI_UnMapMsg16To32W(WORD wMsg, DWORD dwFlags, DWORD_PTR lParam, DWORD result) |
| { |
| switch (wMsg) { |
| case MCI_WHERE: |
| case MCI_FREEZE: |
| case MCI_UNFREEZE: |
| case MCI_PUT: |
| if (lParam) { |
| LPMCI_DGV_RECT_PARMS mdrp32 = (LPMCI_DGV_RECT_PARMS)lParam; |
| char *base = (char*)lParam - sizeof(LPMCI_DGV_RECT_PARMS16); |
| LPMCI_DGV_RECT_PARMS16 mdrp16 = *(LPMCI_DGV_RECT_PARMS16*)base; |
| mdrp16->rc.left = mdrp32->rc.left; |
| mdrp16->rc.top = mdrp32->rc.top; |
| mdrp16->rc.right = mdrp32->rc.right; |
| mdrp16->rc.bottom = mdrp32->rc.bottom; |
| HeapFree(GetProcessHeap(), 0, base); |
| } |
| break; |
| case MCI_STATUS: |
| if (lParam) { |
| LPMCI_DGV_STATUS_PARMSW mdsp32w = (LPMCI_DGV_STATUS_PARMSW)lParam; |
| char *base = (char*)lParam - sizeof(LPMCI_DGV_STATUS_PARMS16); |
| LPMCI_DGV_STATUS_PARMS16 mdsp16 = *(LPMCI_DGV_STATUS_PARMS16*)base; |
| mdsp16->dwReturn = mdsp32w->dwReturn; |
| HeapFree(GetProcessHeap(), 0, (LPVOID)mdsp32w->lpstrDrive); |
| HeapFree(GetProcessHeap(), 0, base); |
| } |
| break; |
| case MCI_WINDOW: |
| if (lParam) { |
| LPMCI_OVLY_WINDOW_PARMSW mowp32w = (LPMCI_OVLY_WINDOW_PARMSW)lParam; |
| HeapFree(GetProcessHeap(), 0, (LPVOID)mowp32w->lpstrText); |
| HeapFree(GetProcessHeap(), 0, mowp32w); |
| } |
| break; |
| case MCI_BREAK: |
| HeapFree(GetProcessHeap(), 0, (LPVOID)lParam); |
| break; |
| case MCI_ESCAPE: |
| if (lParam) { |
| LPMCI_VD_ESCAPE_PARMSW mvep32W = (LPMCI_VD_ESCAPE_PARMSW)lParam; |
| HeapFree(GetProcessHeap(), 0, (LPVOID)mvep32W->lpstrCommand); |
| HeapFree(GetProcessHeap(), 0, (LPVOID)lParam); |
| } |
| break; |
| case MCI_INFO: |
| if (lParam) { |
| LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)lParam; |
| char *base = (char*)lParam - sizeof(LPMCI_INFO_PARMS16); |
| LPMCI_INFO_PARMS16 mip16 = *(LPMCI_INFO_PARMS16*)base; |
| |
| if (result == MMSYSERR_NOERROR) |
| WideCharToMultiByte(CP_ACP, 0, |
| mip32w->lpstrReturn, mip32w->dwRetSize, |
| MapSL(mip16->lpstrReturn), mip16->dwRetSize, |
| NULL, NULL); |
| mip16->dwRetSize = mip32w->dwRetSize; /* never update prior to NT? */ |
| HeapFree(GetProcessHeap(), 0, mip32w->lpstrReturn); |
| HeapFree(GetProcessHeap(), 0, base); |
| } |
| break; |
| case MCI_SYSINFO: |
| if (lParam) { |
| MCI_SYSINFO_PARMSW *msip32w = (MCI_SYSINFO_PARMSW *)lParam; |
| char *base = (char*)lParam - sizeof(MCI_SYSINFO_PARMS16 *); |
| MCI_SYSINFO_PARMS16 *msip16 = *(MCI_SYSINFO_PARMS16 **)base; |
| |
| if (dwFlags & MCI_SYSINFO_QUANTITY) { |
| DWORD *quantity = MapSL(msip16->lpstrReturn); |
| |
| *quantity = *(DWORD *)msip32w->lpstrReturn; |
| } |
| else if (result == MMSYSERR_NOERROR) { |
| WideCharToMultiByte(CP_ACP, 0, |
| msip32w->lpstrReturn, msip32w->dwRetSize, |
| MapSL(msip16->lpstrReturn), msip16->dwRetSize, |
| NULL, NULL); |
| } |
| |
| HeapFree(GetProcessHeap(), 0, msip32w->lpstrReturn); |
| HeapFree(GetProcessHeap(), 0, base); |
| } |
| break; |
| case MCI_SOUND: |
| if (lParam) { |
| LPMCI_SOUND_PARMSW msp32W = (LPMCI_SOUND_PARMSW)lParam; |
| HeapFree(GetProcessHeap(), 0, (LPVOID)msp32W->lpstrSoundName); |
| HeapFree(GetProcessHeap(), 0, (LPVOID)lParam); |
| } |
| break; |
| case MCI_OPEN: |
| case MCI_OPEN_DRIVER: |
| if (lParam) { |
| LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)lParam; |
| char *base = (char*)lParam - sizeof(LPMCI_OPEN_PARMS16); |
| LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)base; |
| |
| mop16->wDeviceID = mop32w->wDeviceID; |
| if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE) |
| HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrDeviceType); |
| if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT) |
| HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrElementName); |
| if( ( dwFlags & MCI_OPEN_ALIAS)) |
| HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrAlias); |
| HeapFree(GetProcessHeap(), 0, base); |
| } |
| break; |
| default: |
| FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg)); |
| } |
| } |
| |
| /* ################################################### |
| * # MCI # |
| * ################################################### |
| */ |
| |
| #include <pshpack1.h> |
| #define MCI_MAX_THUNKS 32 |
| |
| static struct mci_thunk |
| { |
| BYTE popl_eax; /* popl %eax (return address) */ |
| BYTE pushl_func; /* pushl $pfn16 (16bit callback function) */ |
| YIELDPROC16 yield16; |
| BYTE pushl_eax; /* pushl %eax */ |
| BYTE jmp; /* ljmp MCI_Yield1632 */ |
| DWORD callback; |
| MCIDEVICEID id; |
| } *MCI_Thunks; |
| |
| #include <poppack.h> |
| |
| static CRITICAL_SECTION mci_cs; |
| static CRITICAL_SECTION_DEBUG mci_critsect_debug = |
| { |
| 0, 0, &mci_cs, |
| { &mci_critsect_debug.ProcessLocksList, &mci_critsect_debug.ProcessLocksList }, |
| 0, 0, { (DWORD_PTR)(__FILE__ ": mmsystem_mci_cs") } |
| }; |
| static CRITICAL_SECTION mci_cs = { &mci_critsect_debug, -1, 0, 0, 0, 0 }; |
| |
| static UINT MCI_Yield1632(DWORD pfn16, MCIDEVICEID id, DWORD yield_data) |
| { |
| WORD args[8]; |
| |
| if (!pfn16) |
| { |
| MSG msg; |
| PeekMessageW( &msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE ); |
| return 0; |
| } |
| |
| /* 16 bit func, call it */ |
| TRACE("Function (16 bit) !\n"); |
| |
| args[2] = (MCIDEVICEID16)id; |
| args[1] = HIWORD(yield_data); |
| args[0] = LOWORD(yield_data); |
| return WOWCallback16Ex(pfn16, WCB16_PASCAL, sizeof(args), args, NULL); |
| } |
| |
| /****************************************************************** |
| * MCI_AddThunk |
| * |
| */ |
| static struct mci_thunk* MCI_AddThunk(MCIDEVICEID id, YIELDPROC16 pfn16) |
| { |
| struct mci_thunk* thunk; |
| |
| if (!MCI_Thunks) |
| { |
| MCI_Thunks = VirtualAlloc(NULL, MCI_MAX_THUNKS * sizeof(*MCI_Thunks), MEM_COMMIT, |
| PAGE_EXECUTE_READWRITE); |
| if (!MCI_Thunks) return NULL; |
| for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++) |
| { |
| thunk->popl_eax = 0x58; /* popl %eax */ |
| thunk->pushl_func = 0x68; /* pushl $pfn16 */ |
| thunk->yield16 = 0; |
| thunk->pushl_eax = 0x50; /* pushl %eax */ |
| thunk->jmp = 0xe9; /* jmp MCI_Yield1632 */ |
| thunk->callback = (char *)MCI_Yield1632 - (char *)(&thunk->callback + 1); |
| thunk->id = 0; |
| } |
| } |
| for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++) |
| { |
| if (thunk->yield16 == 0) |
| { |
| thunk->yield16 = pfn16; |
| thunk->id = id; |
| return thunk; |
| } |
| } |
| FIXME("Out of mci-thunks. Bump MCI_MAX_THUNKS\n"); |
| return NULL; |
| } |
| |
| /****************************************************************** |
| * MCI_HasThunk |
| * |
| */ |
| static struct mci_thunk* MCI_HasThunk(YIELDPROC pfn) |
| { |
| struct mci_thunk* thunk; |
| |
| if (!MCI_Thunks) return NULL; |
| for (thunk = MCI_Thunks; thunk < &MCI_Thunks[MCI_MAX_THUNKS]; thunk++) |
| { |
| if ((YIELDPROC)thunk == pfn) return thunk; |
| } |
| return NULL; |
| } |
| |
| /************************************************************************** |
| * mciSetYieldProc [MMSYSTEM.714] |
| */ |
| BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD dwYieldData) |
| { |
| struct mci_thunk* thunk; |
| BOOL ret; |
| |
| TRACE("(%u, %p, %08x)\n", uDeviceID, fpYieldProc, dwYieldData); |
| |
| if (!(thunk = MCI_AddThunk(uDeviceID, fpYieldProc))) |
| return FALSE; |
| ret = mciSetYieldProc(uDeviceID, (YIELDPROC)thunk, dwYieldData); |
| if (!ret) thunk->yield16 = NULL; |
| return ret; |
| } |
| |
| /************************************************************************** |
| * mciGetYieldProc [MMSYSTEM.716] |
| */ |
| YIELDPROC16 WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData) |
| { |
| YIELDPROC yield; |
| DWORD data; |
| struct mci_thunk* thunk; |
| |
| TRACE("(%u, %p)\n", uDeviceID, lpdwYieldData); |
| |
| yield = mciGetYieldProc(uDeviceID, &data); |
| if (!yield || !(thunk = MCI_HasThunk(yield))) return NULL; |
| |
| if (lpdwYieldData) *lpdwYieldData = data; |
| return thunk->yield16; |
| } |
| |
| /************************************************************************** |
| * mciGetErrorString [MMSYSTEM.706] |
| */ |
| BOOL16 WINAPI mciGetErrorString16(DWORD wError, LPSTR lpstrBuffer, UINT16 uLength) |
| { |
| return mciGetErrorStringA(wError, lpstrBuffer, uLength); |
| } |
| |
| /************************************************************************** |
| * mciDriverNotify [MMSYSTEM.711] |
| */ |
| BOOL16 WINAPI mciDriverNotify16(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus) |
| { |
| TRACE("(%04X, %04x, %04X)\n", hWndCallBack, wDevID, wStatus); |
| |
| return PostMessageA(HWND_32(hWndCallBack), MM_MCINOTIFY, wStatus, wDevID); |
| } |
| |
| /************************************************************************** |
| * mciGetDriverData [MMSYSTEM.708] |
| */ |
| DWORD WINAPI mciGetDriverData16(UINT16 uDeviceID) |
| { |
| return mciGetDriverData(uDeviceID); |
| } |
| |
| /************************************************************************** |
| * mciSetDriverData [MMSYSTEM.707] |
| */ |
| BOOL16 WINAPI mciSetDriverData16(UINT16 uDeviceID, DWORD data) |
| { |
| return mciSetDriverData(uDeviceID, data); |
| } |
| |
| /************************************************************************** |
| * mciSendCommand [MMSYSTEM.701] |
| */ |
| DWORD WINAPI mciSendCommand16(UINT16 wDevID, UINT16 wMsg, DWORD dwParam1, DWORD p2) |
| { |
| DWORD dwRet; |
| BOOL to32; |
| DWORD_PTR dwParam2 = p2; |
| |
| TRACE("(%04X, %s, %08X, %08lX)\n", wDevID, MCI_MessageToString(wMsg), dwParam1, dwParam2); |
| |
| switch (wMsg) { |
| case MCI_CLOSE: |
| case MCI_OPEN: |
| case MCI_SYSINFO: |
| case MCI_BREAK: |
| case MCI_SOUND: |
| to32 = TRUE; |
| break; |
| default: |
| /* FIXME: this is suboptimal. If MCI driver is a 16bit one, we'll be |
| * doing 16=>32W, then 32W=>16 conversions. |
| * We could directly call the 16bit driver if we had the information. |
| */ |
| to32 = TRUE; |
| } |
| if (to32) { |
| MMSYSTEM_MapType res; |
| |
| dwRet = MCIERR_INVALID_DEVICE_ID; |
| |
| switch (res = MCI_MapMsg16To32W(wMsg, dwParam1, &dwParam2)) { |
| case MMSYSTEM_MAP_MSGERROR: |
| dwRet = MCIERR_DRIVER_INTERNAL; |
| break; |
| case MMSYSTEM_MAP_NOMEM: |
| TRACE("Problem mapping %s from 16 to 32\n", MCI_MessageToString(wMsg)); |
| dwRet = MCIERR_OUT_OF_MEMORY; |
| break; |
| case MMSYSTEM_MAP_OK: |
| case MMSYSTEM_MAP_OKMEM: |
| dwRet = mciSendCommandW(wDevID, wMsg, dwParam1, dwParam2); |
| if (res == MMSYSTEM_MAP_OKMEM) |
| MCI_UnMapMsg16To32W(wMsg, dwParam1, dwParam2, dwRet); |
| break; |
| } |
| } |
| else |
| { |
| #if 0 |
| if (wDevID == MCI_ALL_DEVICE_ID) { |
| FIXME("unhandled MCI_ALL_DEVICE_ID\n"); |
| dwRet = MCIERR_CANNOT_USE_ALL; |
| } else { |
| dwRet = SendDriverMessage(hdrv, wMsg, dwParam1, dwParam2); |
| } |
| #endif |
| } |
| if (wMsg == MCI_CLOSE && dwRet == 0 && MCI_Thunks) |
| { |
| /* free yield thunks, if any */ |
| unsigned i; |
| for (i = 0; i < MCI_MAX_THUNKS; i++) |
| { |
| if (MCI_Thunks[i].id == wDevID) |
| MCI_Thunks[i].yield16 = NULL; |
| } |
| } |
| return dwRet; |
| } |
| |
| /************************************************************************** |
| * mciGetDeviceID [MMSYSTEM.703] |
| */ |
| UINT16 WINAPI mciGetDeviceID16(LPCSTR lpstrName) |
| { |
| TRACE("(\"%s\")\n", lpstrName); |
| |
| return mciGetDeviceIDA(lpstrName); |
| } |
| |
| /************************************************************************** |
| * mciGetDeviceIDFromElementID [MMSYSTEM.715] |
| */ |
| UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD dwElementID, LPCSTR lpstrType) |
| { |
| return mciGetDeviceIDFromElementIDA(dwElementID, lpstrType); |
| } |
| |
| /************************************************************************** |
| * mciGetCreatorTask [MMSYSTEM.717] |
| */ |
| HTASK16 WINAPI mciGetCreatorTask16(UINT16 uDeviceID) |
| { |
| return HTASK_16(mciGetCreatorTask(uDeviceID)); |
| } |
| |
| /************************************************************************** |
| * mciDriverYield [MMSYSTEM.710] |
| */ |
| UINT16 WINAPI mciDriverYield16(UINT16 uDeviceID) |
| { |
| return mciDriverYield(uDeviceID); |
| } |
| |
| /************************************************************************** |
| * mciSendString [MMSYSTEM.702] |
| */ |
| DWORD WINAPI mciSendString16(LPCSTR lpstrCommand, LPSTR lpstrRet, |
| UINT16 uRetLen, HWND16 hwndCallback) |
| { |
| return mciSendStringA(lpstrCommand, lpstrRet, uRetLen, HWND_32(hwndCallback)); |
| } |
| |
| /************************************************************************** |
| * mciLoadCommandResource [MMSYSTEM.705] |
| */ |
| UINT16 WINAPI mciLoadCommandResource16(HINSTANCE16 hInst, LPCSTR resname, UINT16 type) |
| { |
| TRACE("(%04x, %s, %x)!\n", hInst, resname, type); |
| return MCI_NO_COMMAND_TABLE; |
| } |
| |
| /************************************************************************** |
| * mciFreeCommandResource [MMSYSTEM.713] |
| */ |
| BOOL16 WINAPI mciFreeCommandResource16(UINT16 uTable) |
| { |
| TRACE("(%04x)!\n", uTable); |
| |
| return FALSE; |
| } |
| |
| /************************************************************************** |
| * mciExecute [MMSYSTEM.712] |
| */ |
| BOOL16 WINAPI mciExecute16(LPCSTR lpstrCommand) |
| { |
| return mciExecute(lpstrCommand); |
| } |
