Sweden-Number/dlls/winmm/message16.c

3536 lines
113 KiB
C
Raw Normal View History

/*
* MMSYSTEM MCI and low level mapping functions
*
* Copyright 1999 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 <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <assert.h>
#include "wine/winbase16.h"
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "winver.h"
#include "wownt32.h"
#include "winemm16.h"
#include "digitalv.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(winmm);
/**************************************************************************
* MMDRV_Callback [internal]
*/
2006-11-08 22:24:36 +01:00
static void MMDRV_Callback(LPWINE_MLD mld, HDRVR hDev, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
TRACE("CB (*%08lx)(%p %08x %08lx %08lx %08lx\n",
mld->dwCallback, hDev, uMsg, mld->dwClientInstance, dwParam1, dwParam2);
if (!mld->bFrom32 && (mld->dwFlags & DCB_TYPEMASK) == DCB_FUNCTION)
{
WORD args[8];
/* 16 bit func, call it */
TRACE("Function (16 bit) !\n");
args[7] = HDRVR_16(hDev);
args[6] = uMsg;
args[5] = HIWORD(mld->dwClientInstance);
args[4] = LOWORD(mld->dwClientInstance);
args[3] = HIWORD(dwParam1);
args[2] = LOWORD(dwParam1);
args[1] = HIWORD(dwParam2);
args[0] = LOWORD(dwParam2);
WOWCallback16Ex( mld->dwCallback, WCB16_PASCAL, sizeof(args), args, NULL );
} else {
DriverCallback(mld->dwCallback, mld->dwFlags, hDev, uMsg,
mld->dwClientInstance, dwParam1, dwParam2);
}
}
/* =================================
* A U X M A P P E R S
* ================================= */
/**************************************************************************
* MMDRV_Aux_Map16To32W [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_Aux_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
* MMDRV_Aux_UnMap16To32W [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_Aux_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
* MMDRV_Aux_Map32WTo16 [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_Aux_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
* MMDRV_Aux_UnMap32WTo16 [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_Aux_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{
#if 0
case AUXDM_GETDEVCAPS:
lpCaps->wMid = ac16.wMid;
lpCaps->wPid = ac16.wPid;
lpCaps->vDriverVersion = ac16.vDriverVersion;
strcpy(lpCaps->szPname, ac16.szPname);
lpCaps->wTechnology = ac16.wTechnology;
lpCaps->dwSupport = ac16.dwSupport;
#endif
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
* MMDRV_Aux_Callback [internal]
*/
2006-11-08 22:24:36 +01:00
static void CALLBACK MMDRV_Aux_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
FIXME("NIY\n");
MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
}
/* =================================
* M I X E R M A P P E R S
* ================================= */
/**************************************************************************
* xMMDRV_Mixer_Map16To32W [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_Mixer_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
* MMDRV_Mixer_UnMap16To32W [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_Mixer_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{
#if 0
MIXERCAPSA micA;
UINT ret = mixerGetDevCapsA(devid, &micA, sizeof(micA));
if (ret == MMSYSERR_NOERROR) {
mixcaps->wMid = micA.wMid;
mixcaps->wPid = micA.wPid;
mixcaps->vDriverVersion = micA.vDriverVersion;
strcpy(mixcaps->szPname, micA.szPname);
mixcaps->fdwSupport = micA.fdwSupport;
mixcaps->cDestinations = micA.cDestinations;
}
return ret;
#endif
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
* MMDRV_Mixer_Map32WTo16 [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_Mixer_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
* MMDRV_Mixer_UnMap32WTo16 [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_Mixer_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
* MMDRV_Mixer_Callback [internal]
*/
2006-11-08 22:24:36 +01:00
static void CALLBACK MMDRV_Mixer_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
FIXME("NIY\n");
MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
}
/* =================================
* M I D I I N M A P P E R S
* ================================= */
/**************************************************************************
* MMDRV_MidiIn_Map16To32W [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_MidiIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
* MMDRV_MidiIn_UnMap16To32W [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_MidiIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
* MMDRV_MidiIn_Map32WTo16 [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_MidiIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
* MMDRV_MidiIn_UnMap32WTo16 [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_MidiIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
* MMDRV_MidiIn_Callback [internal]
*/
2006-11-08 22:24:36 +01:00
static void CALLBACK MMDRV_MidiIn_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
switch (uMsg) {
case MIM_OPEN:
case MIM_CLOSE:
/* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
case MIM_DATA:
case MIM_MOREDATA:
case MIM_ERROR:
2006-10-15 17:05:01 +02:00
/* dwParam1 & dwParam2 are data, nothing to do */
break;
case MIM_LONGDATA:
case MIM_LONGERROR:
/* dwParam1 points to a MidiHdr, work to be done !!! */
if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
/* initial map is: 32 => 16 */
LPMIDIHDR mh16 = MapSL(dwParam1);
LPMIDIHDR mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR));
dwParam1 = (DWORD)mh32;
mh32->dwFlags = mh16->dwFlags;
mh32->dwBytesRecorded = mh16->dwBytesRecorded;
if (mh32->reserved >= sizeof(MIDIHDR))
mh32->dwOffset = mh16->dwOffset;
} else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
/* initial map is: 16 => 32 */
LPMIDIHDR mh32 = (LPMIDIHDR)(dwParam1);
SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
LPMIDIHDR mh16 = MapSL(segmh16);
dwParam1 = (DWORD)segmh16;
mh16->dwFlags = mh32->dwFlags;
mh16->dwBytesRecorded = mh32->dwBytesRecorded;
if (mh16->reserved >= sizeof(MIDIHDR))
mh16->dwOffset = mh32->dwOffset;
}
/* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
break;
/* case MOM_POSITIONCB: */
default:
ERR("Unknown msg %u\n", uMsg);
}
MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
}
/* =================================
* M I D I O U T M A P P E R S
* ================================= */
/**************************************************************************
* MMDRV_MidiOut_Map16To32W [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_MidiOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
switch (wMsg) {
case MODM_GETNUMDEVS:
case MODM_DATA:
case MODM_RESET:
case MODM_SETVOLUME:
ret = WINMM_MAP_OK;
break;
case MODM_OPEN:
case MODM_CLOSE:
case MODM_GETVOLUME:
FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
break;
case MODM_GETDEVCAPS:
{
LPMIDIOUTCAPSW moc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPS16) + sizeof(MIDIOUTCAPSW));
LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1);
if (moc32) {
*(LPMIDIOUTCAPS16*)moc32 = moc16;
moc32 = (LPMIDIOUTCAPSW)((LPSTR)moc32 + sizeof(LPMIDIOUTCAPS16));
*lpParam1 = (DWORD)moc32;
*lpParam2 = sizeof(MIDIOUTCAPSW);
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
}
break;
case MODM_PREPARE:
{
LPMIDIHDR mh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMIDIHDR) + sizeof(MIDIHDR));
LPMIDIHDR mh16 = MapSL(*lpParam1);
if (mh32) {
*(LPMIDIHDR*)mh32 = (LPMIDIHDR)*lpParam1;
mh32 = (LPMIDIHDR)((LPSTR)mh32 + sizeof(LPMIDIHDR));
mh32->lpData = MapSL((SEGPTR)mh16->lpData);
mh32->dwBufferLength = mh16->dwBufferLength;
mh32->dwBytesRecorded = mh16->dwBytesRecorded;
mh32->dwUser = mh16->dwUser;
mh32->dwFlags = mh16->dwFlags;
/* FIXME: nothing on mh32->lpNext */
/* could link the mh32->lpNext at this level for memory house keeping */
mh32->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? ((LPMIDIHDR)mh16)->dwOffset : 0;
mh16->lpNext = mh32; /* for reuse in unprepare and write */
/* store size of passed MIDIHDR?? structure to know if dwOffset is available or not */
mh16->reserved = *lpParam2;
*lpParam1 = (DWORD)mh32;
*lpParam2 = sizeof(MIDIHDR);
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
}
break;
case MODM_UNPREPARE:
case MODM_LONGDATA:
{
LPMIDIHDR mh16 = MapSL(*lpParam1);
LPMIDIHDR mh32 = (LPMIDIHDR)mh16->lpNext;
*lpParam1 = (DWORD)mh32;
*lpParam2 = sizeof(MIDIHDR);
/* dwBufferLength can be reduced between prepare & write */
if (wMsg == MODM_LONGDATA && mh32->dwBufferLength < mh16->dwBufferLength) {
2006-11-08 22:24:36 +01:00
ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
mh32->dwBufferLength, mh16->dwBufferLength);
} else
mh32->dwBufferLength = mh16->dwBufferLength;
ret = WINMM_MAP_OKMEM;
}
break;
case MODM_CACHEPATCHES:
case MODM_CACHEDRUMPATCHES:
default:
FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
break;
}
return ret;
}
/**************************************************************************
* MMDRV_MidiOut_UnMap16To32W [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_MidiOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
switch (wMsg) {
case MODM_GETNUMDEVS:
case MODM_DATA:
case MODM_RESET:
case MODM_SETVOLUME:
ret = WINMM_MAP_OK;
break;
case MODM_OPEN:
case MODM_CLOSE:
case MODM_GETVOLUME:
FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
break;
case MODM_GETDEVCAPS:
{
LPMIDIOUTCAPSW moc32 = (LPMIDIOUTCAPSW)(*lpParam1);
LPMIDIOUTCAPS16 moc16 = *(LPMIDIOUTCAPS16*)((LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
moc16->wMid = moc32->wMid;
moc16->wPid = moc32->wPid;
moc16->vDriverVersion = moc32->vDriverVersion;
WideCharToMultiByte( CP_ACP, 0, moc32->szPname, -1, moc16->szPname,
sizeof(moc16->szPname), NULL, NULL );
moc16->wTechnology = moc32->wTechnology;
moc16->wVoices = moc32->wVoices;
moc16->wNotes = moc32->wNotes;
moc16->wChannelMask = moc32->wChannelMask;
moc16->dwSupport = moc32->dwSupport;
HeapFree(GetProcessHeap(), 0, (LPSTR)moc32 - sizeof(LPMIDIOUTCAPS16));
ret = WINMM_MAP_OK;
}
break;
case MODM_PREPARE:
case MODM_UNPREPARE:
case MODM_LONGDATA:
{
LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1);
LPMIDIHDR mh16 = MapSL(*(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR)));
assert(mh16->lpNext == mh32);
mh16->dwBufferLength = mh32->dwBufferLength;
mh16->dwBytesRecorded = mh32->dwBytesRecorded;
mh16->dwUser = mh32->dwUser;
mh16->dwFlags = mh32->dwFlags;
if (mh16->reserved >= sizeof(MIDIHDR))
mh16->dwOffset = mh32->dwOffset;
if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
HeapFree(GetProcessHeap(), 0, (LPSTR)mh32 - sizeof(LPMIDIHDR));
mh16->lpNext = 0;
}
ret = WINMM_MAP_OK;
}
break;
case MODM_CACHEPATCHES:
case MODM_CACHEDRUMPATCHES:
default:
FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
break;
}
return ret;
}
/**************************************************************************
* MMDRV_MidiOut_Map32WTo16 [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_MidiOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
switch (wMsg) {
case MODM_CLOSE:
case MODM_GETNUMDEVS:
case MODM_DATA:
case MODM_RESET:
case MODM_SETVOLUME:
ret = WINMM_MAP_OK;
break;
case MODM_GETDEVCAPS:
{
LPMIDIOUTCAPSW moc32 = (LPMIDIOUTCAPSW)*lpParam1;
LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMIDIOUTCAPSW)+sizeof(MIDIOUTCAPS16));
if (ptr) {
*(LPMIDIOUTCAPSW*)ptr = moc32;
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
*lpParam1 = (DWORD)MapLS(ptr) + sizeof(LPMIDIOUTCAPSW);
*lpParam2 = sizeof(MIDIOUTCAPS16);
}
break;
case MODM_PREPARE:
{
LPMIDIHDR mh32 = (LPMIDIHDR)*lpParam1;
LPMIDIHDR mh16;
LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
sizeof(LPMIDIHDR) + sizeof(MIDIHDR) + mh32->dwBufferLength);
if (ptr) {
*(LPMIDIHDR*)ptr = mh32;
mh16 = (LPMIDIHDR)((LPSTR)ptr + sizeof(LPMIDIHDR));
*lpParam1 = MapLS(mh16);
mh16->lpData = (LPSTR)*lpParam1 + sizeof(MIDIHDR);
/* data will be copied on WODM_WRITE */
mh16->dwBufferLength = mh32->dwBufferLength;
mh16->dwBytesRecorded = mh32->dwBytesRecorded;
mh16->dwUser = mh32->dwUser;
mh16->dwFlags = mh32->dwFlags;
/* FIXME: nothing on mh32->lpNext */
/* could link the mh32->lpNext at this level for memory house keeping */
mh16->dwOffset = (*lpParam2 >= sizeof(MIDIHDR)) ? mh32->dwOffset : 0;
mh32->lpNext = (LPMIDIHDR)mh16; /* for reuse in unprepare and write */
mh32->reserved = *lpParam2;
2006-11-08 22:24:36 +01:00
TRACE("mh16=%08lx mh16->lpData=%p mh32->buflen=%u mh32->lpData=%p\n",
*lpParam1, mh16->lpData, mh32->dwBufferLength, mh32->lpData);
*lpParam2 = sizeof(MIDIHDR);
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
}
break;
case MODM_UNPREPARE:
case MODM_LONGDATA:
{
LPMIDIHDR mh32 = (LPMIDIHDR)(*lpParam1);
LPMIDIHDR mh16 = (LPMIDIHDR)mh32->lpNext;
LPSTR ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR);
assert(*(LPMIDIHDR*)ptr == mh32);
if (wMsg == MODM_LONGDATA)
memcpy((LPSTR)mh16 + sizeof(MIDIHDR), mh32->lpData, mh32->dwBufferLength);
*lpParam1 = MapLS(mh16);
*lpParam2 = sizeof(MIDIHDR);
2006-11-08 22:24:36 +01:00
TRACE("mh16=%08lx mh16->lpData=%p mh32->buflen=%u mh32->lpData=%p\n",
*lpParam1, mh16->lpData, mh32->dwBufferLength, mh32->lpData);
/* dwBufferLength can be reduced between prepare & write */
if (wMsg == MODM_LONGDATA && mh16->dwBufferLength < mh32->dwBufferLength) {
2006-11-08 22:24:36 +01:00
ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
mh16->dwBufferLength, mh32->dwBufferLength);
} else
mh16->dwBufferLength = mh32->dwBufferLength;
ret = WINMM_MAP_OKMEM;
}
break;
case MODM_OPEN:
{
LPMIDIOPENDESC mod32 = (LPMIDIOPENDESC)*lpParam1;
LPVOID ptr;
LPMIDIOPENDESC16 mod16;
/* allocated data are mapped as follows:
LPMIDIOPENDESC ptr to orig lParam1
DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance
DWORD dwUser passed to driver
MIDIOPENDESC16 mod16: openDesc passed to driver
MIDIOPENSTRMID cIds
*/
ptr = HeapAlloc( GetProcessHeap(), 0,
sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD) + sizeof(MIDIOPENDESC16) +
mod32->cIds ? (mod32->cIds - 1) * sizeof(MIDIOPENSTRMID) : 0);
if (ptr) {
SEGPTR segptr = MapLS(ptr);
*(LPMIDIOPENDESC*)ptr = mod32;
*(LPDWORD)((char*)ptr + sizeof(LPMIDIOPENDESC)) = *lpdwUser;
mod16 = (LPMIDIOPENDESC16)((LPSTR)ptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD));
mod16->hMidi = HMIDI_16(mod32->hMidi);
mod16->dwCallback = mod32->dwCallback;
mod16->dwInstance = mod32->dwInstance;
mod16->dnDevNode = mod32->dnDevNode;
mod16->cIds = mod32->cIds;
memcpy(&mod16->rgIds, &mod32->rgIds, mod32->cIds * sizeof(MIDIOPENSTRMID));
*lpParam1 = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + 2*sizeof(DWORD);
*lpdwUser = (DWORD)segptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD);
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
}
break;
case MODM_GETVOLUME:
case MODM_CACHEPATCHES:
case MODM_CACHEDRUMPATCHES:
default:
FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
break;
}
return ret;
}
/**************************************************************************
* MMDRV_MidiOut_UnMap32WTo16 [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_MidiOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
switch (wMsg) {
case MODM_CLOSE:
case MODM_GETNUMDEVS:
case MODM_DATA:
case MODM_RESET:
case MODM_SETVOLUME:
ret = WINMM_MAP_OK;
break;
case MODM_GETDEVCAPS:
{
LPMIDIOUTCAPS16 moc16 = MapSL(*lpParam1);
LPSTR ptr = (LPSTR)moc16 - sizeof(LPMIDIOUTCAPSW);
LPMIDIOUTCAPSW moc32 = *(LPMIDIOUTCAPSW*)ptr;
moc32->wMid = moc16->wMid;
moc32->wPid = moc16->wPid;
moc32->vDriverVersion = moc16->vDriverVersion;
WideCharToMultiByte( CP_ACP, 0, moc32->szPname, -1, moc16->szPname,
sizeof(moc16->szPname), NULL, NULL );
moc32->wTechnology = moc16->wTechnology;
moc32->wVoices = moc16->wVoices;
moc32->wNotes = moc16->wNotes;
moc32->wChannelMask = moc16->wChannelMask;
moc32->dwSupport = moc16->dwSupport;
UnMapLS( *lpParam1 );
HeapFree( GetProcessHeap(), 0, ptr );
ret = WINMM_MAP_OK;
}
break;
case MODM_PREPARE:
case MODM_UNPREPARE:
case MODM_LONGDATA:
{
LPMIDIHDR mh16 = MapSL(*lpParam1);
LPSTR ptr = (LPSTR)mh16 - sizeof(LPMIDIHDR);
LPMIDIHDR mh32 = *(LPMIDIHDR*)ptr;
assert(mh32->lpNext == (LPMIDIHDR)mh16);
UnMapLS( *lpParam1 );
mh32->dwBytesRecorded = mh16->dwBytesRecorded;
mh32->dwUser = mh16->dwUser;
mh32->dwFlags = mh16->dwFlags;
if (wMsg == MODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
HeapFree( GetProcessHeap(), 0, ptr );
mh32->lpNext = 0;
}
ret = WINMM_MAP_OK;
}
break;
case MODM_OPEN:
{
LPMIDIOPENDESC16 mod16 = MapSL(*lpParam1);
LPSTR ptr = (LPSTR)mod16 - sizeof(LPMIDIOPENDESC) - 2*sizeof(DWORD);
UnMapLS( *lpParam1 );
**(DWORD**)(ptr + sizeof(LPMIDIOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPMIDIOPENDESC) + sizeof(DWORD));
HeapFree( GetProcessHeap(), 0, ptr );
ret = WINMM_MAP_OK;
}
break;
case MODM_GETVOLUME:
case MODM_CACHEPATCHES:
case MODM_CACHEDRUMPATCHES:
default:
FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
break;
}
return ret;
}
/**************************************************************************
* MMDRV_MidiOut_Callback [internal]
*/
2006-11-08 22:24:36 +01:00
static void CALLBACK MMDRV_MidiOut_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
switch (uMsg) {
case MOM_OPEN:
case MOM_CLOSE:
/* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
break;
case MOM_DONE:
if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
/* initial map is: 32 => 16 */
LPMIDIHDR mh16 = MapSL(dwParam1);
LPMIDIHDR mh32 = *(LPMIDIHDR*)((LPSTR)mh16 - sizeof(LPMIDIHDR));
dwParam1 = (DWORD)mh32;
mh32->dwFlags = mh16->dwFlags;
mh32->dwOffset = mh16->dwOffset;
if (mh32->reserved >= sizeof(MIDIHDR))
mh32->dwOffset = mh16->dwOffset;
} else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
/* initial map is: 16 => 32 */
LPMIDIHDR mh32 = (LPMIDIHDR)(dwParam1);
SEGPTR segmh16 = *(SEGPTR*)((LPSTR)mh32 - sizeof(LPMIDIHDR));
LPMIDIHDR mh16 = MapSL(segmh16);
dwParam1 = (DWORD)segmh16;
mh16->dwFlags = mh32->dwFlags;
if (mh16->reserved >= sizeof(MIDIHDR))
mh16->dwOffset = mh32->dwOffset;
}
/* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
break;
/* case MOM_POSITIONCB: */
default:
ERR("Unknown msg %u\n", uMsg);
}
MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
}
/* =================================
* W A V E I N M A P P E R S
* ================================= */
/**************************************************************************
* MMDRV_WaveIn_Map16To32W [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_WaveIn_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
switch (wMsg) {
case WIDM_GETNUMDEVS:
case WIDM_RESET:
case WIDM_START:
case WIDM_STOP:
ret = WINMM_MAP_OK;
break;
case WIDM_OPEN:
case WIDM_CLOSE:
FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
break;
case WIDM_GETDEVCAPS:
{
LPWAVEINCAPSW wic32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEINCAPS16) + sizeof(WAVEINCAPSW));
LPWAVEINCAPS16 wic16 = MapSL(*lpParam1);
if (wic32) {
*(LPWAVEINCAPS16*)wic32 = wic16;
wic32 = (LPWAVEINCAPSW)((LPSTR)wic32 + sizeof(LPWAVEINCAPS16));
*lpParam1 = (DWORD)wic32;
*lpParam2 = sizeof(WAVEINCAPSW);
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
}
break;
case WIDM_GETPOS:
{
LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
LPMMTIME16 mmt16 = MapSL(*lpParam1);
if (mmt32) {
*(LPMMTIME16*)mmt32 = mmt16;
mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
mmt32->wType = mmt16->wType;
*lpParam1 = (DWORD)mmt32;
*lpParam2 = sizeof(MMTIME);
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
}
break;
case WIDM_PREPARE:
{
LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
LPWAVEHDR wh16 = MapSL(*lpParam1);
if (wh32) {
*(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
wh32->lpData = MapSL((SEGPTR)wh16->lpData);
wh32->dwBufferLength = wh16->dwBufferLength;
wh32->dwBytesRecorded = wh16->dwBytesRecorded;
wh32->dwUser = wh16->dwUser;
wh32->dwFlags = wh16->dwFlags;
wh32->dwLoops = wh16->dwLoops;
/* FIXME: nothing on wh32->lpNext */
/* could link the wh32->lpNext at this level for memory house keeping */
wh16->lpNext = wh32; /* for reuse in unprepare and write */
*lpParam1 = (DWORD)wh32;
*lpParam2 = sizeof(WAVEHDR);
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
}
break;
case WIDM_ADDBUFFER:
case WIDM_UNPREPARE:
{
LPWAVEHDR wh16 = MapSL(*lpParam1);
LPWAVEHDR wh32 = (LPWAVEHDR)wh16->lpNext;
*lpParam1 = (DWORD)wh32;
*lpParam2 = sizeof(WAVEHDR);
/* dwBufferLength can be reduced between prepare & write */
if (wMsg == WIDM_ADDBUFFER && wh32->dwBufferLength < wh16->dwBufferLength) {
2006-11-08 22:24:36 +01:00
ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
wh32->dwBufferLength, wh16->dwBufferLength);
} else
wh32->dwBufferLength = wh16->dwBufferLength;
ret = WINMM_MAP_OKMEM;
}
break;
case WIDM_MAPPER_STATUS:
/* just a single DWORD */
*lpParam2 = (DWORD)MapSL(*lpParam2);
ret = WINMM_MAP_OK;
break;
default:
FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
break;
}
return ret;
}
/**************************************************************************
* MMDRV_WaveIn_UnMap16To32W [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_WaveIn_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
switch (wMsg) {
case WIDM_GETNUMDEVS:
case WIDM_RESET:
case WIDM_START:
case WIDM_STOP:
case WIDM_MAPPER_STATUS:
ret = WINMM_MAP_OK;
break;
case WIDM_OPEN:
case WIDM_CLOSE:
FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
break;
case WIDM_GETDEVCAPS:
{
LPWAVEINCAPSW wic32 = (LPWAVEINCAPSW)(*lpParam1);
LPWAVEINCAPS16 wic16 = *(LPWAVEINCAPS16*)((LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
wic16->wMid = wic32->wMid;
wic16->wPid = wic32->wPid;
wic16->vDriverVersion = wic32->vDriverVersion;
WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname,
sizeof(wic16->szPname), NULL, NULL );
wic16->dwFormats = wic32->dwFormats;
wic16->wChannels = wic32->wChannels;
HeapFree(GetProcessHeap(), 0, (LPSTR)wic32 - sizeof(LPWAVEINCAPS16));
ret = WINMM_MAP_OK;
}
break;
case WIDM_GETPOS:
{
LPMMTIME mmt32 = (LPMMTIME)(*lpParam1);
LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16));
MMSYSTEM_MMTIME32to16(mmt16, mmt32);
HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
ret = WINMM_MAP_OK;
}
break;
case WIDM_ADDBUFFER:
case WIDM_PREPARE:
case WIDM_UNPREPARE:
{
LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1);
LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)));
assert(wh16->lpNext == wh32);
wh16->dwBufferLength = wh32->dwBufferLength;
wh16->dwBytesRecorded = wh32->dwBytesRecorded;
wh16->dwUser = wh32->dwUser;
wh16->dwFlags = wh32->dwFlags;
wh16->dwLoops = wh32->dwLoops;
if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
wh16->lpNext = 0;
}
ret = WINMM_MAP_OK;
}
break;
default:
FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
break;
}
return ret;
}
/**************************************************************************
* MMDRV_WaveIn_Map32WTo16 [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_WaveIn_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
switch (wMsg) {
case WIDM_CLOSE:
case WIDM_GETNUMDEVS:
case WIDM_RESET:
case WIDM_START:
case WIDM_STOP:
ret = WINMM_MAP_OK;
break;
case WIDM_OPEN:
{
LPWAVEOPENDESC wod32 = (LPWAVEOPENDESC)*lpParam1;
int sz = sizeof(WAVEFORMATEX);
LPVOID ptr;
LPWAVEOPENDESC16 wod16;
/* allocated data are mapped as follows:
LPWAVEOPENDESC ptr to orig lParam1
DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance
DWORD dwUser passed to driver
WAVEOPENDESC16 wod16: openDesc passed to driver
WAVEFORMATEX openDesc->lpFormat passed to driver
xxx extra bytes to WAVEFORMATEX
*/
if (wod32->lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
TRACE("Allocating %u extra bytes (%d)\n", ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize, wod32->lpFormat->wFormatTag);
sz += ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize;
}
ptr = HeapAlloc( GetProcessHeap(), 0,
sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16) + sz);
if (ptr) {
SEGPTR seg_ptr = MapLS( ptr );
*(LPWAVEOPENDESC*)ptr = wod32;
*(LPDWORD)((char*)ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser;
wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD));
wod16->hWave = HWAVE_16(wod32->hWave);
wod16->lpFormat = (LPWAVEFORMATEX)(seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16));
memcpy(wod16 + 1, wod32->lpFormat, sz);
wod16->dwCallback = wod32->dwCallback;
wod16->dwInstance = wod32->dwInstance;
wod16->uMappedDeviceID = wod32->uMappedDeviceID;
wod16->dnDevNode = wod32->dnDevNode;
*lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD);
*lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD);
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
}
break;
case WIDM_PREPARE:
{
LPWAVEHDR wh32 = (LPWAVEHDR)*lpParam1;
LPWAVEHDR wh16;
LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
sizeof(LPWAVEHDR) + sizeof(WAVEHDR) + wh32->dwBufferLength);
if (ptr) {
SEGPTR seg_ptr = MapLS( ptr );
*(LPWAVEHDR*)ptr = wh32;
wh16 = (LPWAVEHDR)((LPSTR)ptr + sizeof(LPWAVEHDR));
wh16->lpData = (LPSTR)seg_ptr + sizeof(LPWAVEHDR) + sizeof(WAVEHDR);
/* data will be copied on WODM_WRITE */
wh16->dwBufferLength = wh32->dwBufferLength;
wh16->dwBytesRecorded = wh32->dwBytesRecorded;
wh16->dwUser = wh32->dwUser;
wh16->dwFlags = wh32->dwFlags;
wh16->dwLoops = wh32->dwLoops;
/* FIXME: nothing on wh32->lpNext */
/* could link the wh32->lpNext at this level for memory house keeping */
wh32->lpNext = wh16; /* for reuse in unprepare and write */
*lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
*lpParam2 = sizeof(WAVEHDR);
2006-11-20 11:27:18 +01:00
TRACE("wh16=%08lx wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
*lpParam1, wh16->lpData, wh32->dwBufferLength, wh32->lpData);
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
}
break;
case WIDM_ADDBUFFER:
case WIDM_UNPREPARE:
{
LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1);
LPWAVEHDR wh16 = wh32->lpNext;
LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
SEGPTR seg_ptr = MapLS( ptr );
assert(*(LPWAVEHDR*)ptr == wh32);
if (wMsg == WIDM_ADDBUFFER)
memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength);
*lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
*lpParam2 = sizeof(WAVEHDR);
2006-11-20 11:27:18 +01:00
TRACE("wh16=%08lx wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
*lpParam1, wh16->lpData, wh32->dwBufferLength, wh32->lpData);
/* dwBufferLength can be reduced between prepare & write */
if (wMsg == WIDM_ADDBUFFER && wh16->dwBufferLength < wh32->dwBufferLength) {
2006-11-08 22:24:36 +01:00
ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
wh16->dwBufferLength, wh32->dwBufferLength);
} else
wh16->dwBufferLength = wh32->dwBufferLength;
ret = WINMM_MAP_OKMEM;
}
break;
case WIDM_GETDEVCAPS:
{
LPWAVEINCAPSW wic32 = (LPWAVEINCAPSW)*lpParam1;
LPSTR ptr = HeapAlloc( GetProcessHeap(), 0 ,sizeof(LPWAVEINCAPSW) + sizeof(WAVEINCAPS16));
if (ptr) {
*(LPWAVEINCAPSW*)ptr = wic32;
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
*lpParam1 = MapLS(ptr) + sizeof(LPWAVEINCAPSW);
*lpParam2 = sizeof(WAVEINCAPS16);
}
break;
case WIDM_GETPOS:
{
LPMMTIME mmt32 = (LPMMTIME)*lpParam1;
LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16));
LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME));
if (ptr) {
*(LPMMTIME*)ptr = mmt32;
mmt16->wType = mmt32->wType;
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
*lpParam1 = MapLS(ptr) + sizeof(LPMMTIME);
*lpParam2 = sizeof(MMTIME16);
}
break;
case DRVM_MAPPER_STATUS:
{
LPDWORD p32 = (LPDWORD)*lpParam2;
*lpParam2 = MapLS(p32);
ret = WINMM_MAP_OKMEM;
}
break;
default:
FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
break;
}
return ret;
}
/**************************************************************************
* MMDRV_WaveIn_UnMap32WTo16 [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_WaveIn_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
switch (wMsg) {
case WIDM_CLOSE:
case WIDM_GETNUMDEVS:
case WIDM_RESET:
case WIDM_START:
case WIDM_STOP:
ret = WINMM_MAP_OK;
break;
case WIDM_OPEN:
{
LPWAVEOPENDESC16 wod16 = MapSL(*lpParam1);
LPSTR ptr = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD);
LPWAVEOPENDESC wod32 = *(LPWAVEOPENDESC*)ptr;
UnMapLS( *lpParam1 );
wod32->uMappedDeviceID = wod16->uMappedDeviceID;
**(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD));
HeapFree( GetProcessHeap(), 0, ptr );
ret = WINMM_MAP_OK;
}
break;
case WIDM_ADDBUFFER:
case WIDM_PREPARE:
case WIDM_UNPREPARE:
{
LPWAVEHDR wh16 = MapSL(*lpParam1);
LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
LPWAVEHDR wh32 = *(LPWAVEHDR*)ptr;
assert(wh32->lpNext == wh16);
wh32->dwBytesRecorded = wh16->dwBytesRecorded;
wh32->dwUser = wh16->dwUser;
wh32->dwFlags = wh16->dwFlags;
wh32->dwLoops = wh16->dwLoops;
UnMapLS( *lpParam1 );
if (wMsg == WIDM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
HeapFree( GetProcessHeap(), 0, ptr );
wh32->lpNext = 0;
}
ret = WINMM_MAP_OK;
}
break;
case WIDM_GETDEVCAPS:
{
LPWAVEINCAPS16 wic16 = MapSL(*lpParam1);
LPSTR ptr = (LPSTR)wic16 - sizeof(LPWAVEINCAPSW);
LPWAVEINCAPSW wic32 = *(LPWAVEINCAPSW*)ptr;
wic32->wMid = wic16->wMid;
wic32->wPid = wic16->wPid;
wic32->vDriverVersion = wic16->vDriverVersion;
WideCharToMultiByte( CP_ACP, 0, wic32->szPname, -1, wic16->szPname,
sizeof(wic16->szPname), NULL, NULL );
wic32->dwFormats = wic16->dwFormats;
wic32->wChannels = wic16->wChannels;
UnMapLS( *lpParam1 );
HeapFree( GetProcessHeap(), 0, ptr );
ret = WINMM_MAP_OK;
}
break;
case WIDM_GETPOS:
{
LPMMTIME16 mmt16 = MapSL(*lpParam1);
LPSTR ptr = (LPSTR)mmt16 - sizeof(LPMMTIME);
LPMMTIME mmt32 = *(LPMMTIME*)ptr;
MMSYSTEM_MMTIME16to32(mmt32, mmt16);
UnMapLS( *lpParam1 );
HeapFree( GetProcessHeap(), 0, ptr );
ret = WINMM_MAP_OK;
}
break;
case DRVM_MAPPER_STATUS:
{
UnMapLS( *lpParam2 );
ret = WINMM_MAP_OK;
}
break;
default:
FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
break;
}
return ret;
}
/**************************************************************************
* MMDRV_WaveIn_Callback [internal]
*/
2006-11-08 22:24:36 +01:00
static void CALLBACK MMDRV_WaveIn_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
switch (uMsg) {
case WIM_OPEN:
case WIM_CLOSE:
/* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
break;
case WIM_DATA:
if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
/* initial map is: 32 => 16 */
LPWAVEHDR wh16 = MapSL(dwParam1);
LPWAVEHDR wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR));
dwParam1 = (DWORD)wh32;
wh32->dwFlags = wh16->dwFlags;
wh32->dwBytesRecorded = wh16->dwBytesRecorded;
} else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
/* initial map is: 16 => 32 */
LPWAVEHDR wh32 = (LPWAVEHDR)(dwParam1);
SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
LPWAVEHDR wh16 = MapSL(segwh16);
dwParam1 = (DWORD)segwh16;
wh16->dwFlags = wh32->dwFlags;
wh16->dwBytesRecorded = wh32->dwBytesRecorded;
}
/* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
break;
default:
ERR("Unknown msg %u\n", uMsg);
}
MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
}
/* =================================
* W A V E O U T M A P P E R S
* ================================= */
/**************************************************************************
* MMDRV_WaveOut_Map16To32W [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_WaveOut_Map16To32W (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
switch (wMsg) {
/* nothing to do */
case WODM_BREAKLOOP:
case WODM_CLOSE:
case WODM_GETNUMDEVS:
case WODM_PAUSE:
case WODM_RESET:
case WODM_RESTART:
case WODM_SETPITCH:
case WODM_SETPLAYBACKRATE:
case WODM_SETVOLUME:
ret = WINMM_MAP_OK;
break;
case WODM_GETPITCH:
case WODM_GETPLAYBACKRATE:
case WODM_GETVOLUME:
case WODM_OPEN:
FIXME("Shouldn't be used: the corresponding 16 bit functions use the 32 bit interface\n");
break;
case WODM_GETDEVCAPS:
{
LPWAVEOUTCAPSW woc32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEOUTCAPS16) + sizeof(WAVEOUTCAPSW));
LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1);
if (woc32) {
*(LPWAVEOUTCAPS16*)woc32 = woc16;
woc32 = (LPWAVEOUTCAPSW)((LPSTR)woc32 + sizeof(LPWAVEOUTCAPS16));
*lpParam1 = (DWORD)woc32;
*lpParam2 = sizeof(WAVEOUTCAPSW);
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
}
break;
case WODM_GETPOS:
{
LPMMTIME mmt32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMMTIME16) + sizeof(MMTIME));
LPMMTIME16 mmt16 = MapSL(*lpParam1);
if (mmt32) {
*(LPMMTIME16*)mmt32 = mmt16;
mmt32 = (LPMMTIME)((LPSTR)mmt32 + sizeof(LPMMTIME16));
mmt32->wType = mmt16->wType;
*lpParam1 = (DWORD)mmt32;
*lpParam2 = sizeof(MMTIME);
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
}
break;
case WODM_PREPARE:
{
LPWAVEHDR wh32 = HeapAlloc(GetProcessHeap(), 0, sizeof(LPWAVEHDR) + sizeof(WAVEHDR));
LPWAVEHDR wh16 = MapSL(*lpParam1);
if (wh32) {
*(LPWAVEHDR*)wh32 = (LPWAVEHDR)*lpParam1;
wh32 = (LPWAVEHDR)((LPSTR)wh32 + sizeof(LPWAVEHDR));
wh32->lpData = MapSL((SEGPTR)wh16->lpData);
wh32->dwBufferLength = wh16->dwBufferLength;
wh32->dwBytesRecorded = wh16->dwBytesRecorded;
wh32->dwUser = wh16->dwUser;
wh32->dwFlags = wh16->dwFlags;
wh32->dwLoops = wh16->dwLoops;
/* FIXME: nothing on wh32->lpNext */
/* could link the wh32->lpNext at this level for memory house keeping */
wh16->lpNext = wh32; /* for reuse in unprepare and write */
*lpParam1 = (DWORD)wh32;
*lpParam2 = sizeof(WAVEHDR);
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
}
break;
case WODM_UNPREPARE:
case WODM_WRITE:
{
LPWAVEHDR wh16 = MapSL(*lpParam1);
LPWAVEHDR wh32 = (LPWAVEHDR)wh16->lpNext;
*lpParam1 = (DWORD)wh32;
*lpParam2 = sizeof(WAVEHDR);
/* dwBufferLength can be reduced between prepare & write */
if (wMsg == WODM_WRITE && wh32->dwBufferLength < wh16->dwBufferLength) {
2006-11-08 22:24:36 +01:00
ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
wh32->dwBufferLength, wh16->dwBufferLength);
} else
wh32->dwBufferLength = wh16->dwBufferLength;
ret = WINMM_MAP_OKMEM;
}
break;
case WODM_MAPPER_STATUS:
*lpParam2 = (DWORD)MapSL(*lpParam2);
ret = WINMM_MAP_OK;
break;
default:
FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
break;
}
return ret;
}
/**************************************************************************
* MMDRV_WaveOut_UnMap16To32W [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_WaveOut_UnMap16To32W(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{
WINMM_MapType ret = WINMM_MAP_MSGERROR;
switch (wMsg) {
/* nothing to do */
case WODM_BREAKLOOP:
case WODM_CLOSE:
case WODM_GETNUMDEVS:
case WODM_PAUSE:
case WODM_RESET:
case WODM_RESTART:
case WODM_SETPITCH:
case WODM_SETPLAYBACKRATE:
case WODM_SETVOLUME:
case WODM_MAPPER_STATUS:
ret = WINMM_MAP_OK;
break;
case WODM_GETPITCH:
case WODM_GETPLAYBACKRATE:
case WODM_GETVOLUME:
case WODM_OPEN:
FIXME("Shouldn't be used: those 16 bit functions use the 32 bit interface\n");
break;
case WODM_GETDEVCAPS:
{
LPWAVEOUTCAPSW woc32 = (LPWAVEOUTCAPSW)(*lpParam1);
LPWAVEOUTCAPS16 woc16 = *(LPWAVEOUTCAPS16*)((LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
woc16->wMid = woc32->wMid;
woc16->wPid = woc32->wPid;
woc16->vDriverVersion = woc32->vDriverVersion;
WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname,
sizeof(woc16->szPname), NULL, NULL );
woc16->dwFormats = woc32->dwFormats;
woc16->wChannels = woc32->wChannels;
woc16->dwSupport = woc32->dwSupport;
HeapFree(GetProcessHeap(), 0, (LPSTR)woc32 - sizeof(LPWAVEOUTCAPS16));
ret = WINMM_MAP_OK;
}
break;
case WODM_GETPOS:
{
LPMMTIME mmt32 = (LPMMTIME)(*lpParam1);
LPMMTIME16 mmt16 = *(LPMMTIME16*)((LPSTR)mmt32 - sizeof(LPMMTIME16));
MMSYSTEM_MMTIME32to16(mmt16, mmt32);
HeapFree(GetProcessHeap(), 0, (LPSTR)mmt32 - sizeof(LPMMTIME16));
ret = WINMM_MAP_OK;
}
break;
case WODM_PREPARE:
case WODM_UNPREPARE:
case WODM_WRITE:
{
LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1);
LPWAVEHDR wh16 = MapSL(*(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR)));
assert(wh16->lpNext == wh32);
wh16->dwBufferLength = wh32->dwBufferLength;
wh16->dwBytesRecorded = wh32->dwBytesRecorded;
wh16->dwUser = wh32->dwUser;
wh16->dwFlags = wh32->dwFlags;
wh16->dwLoops = wh32->dwLoops;
if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
HeapFree(GetProcessHeap(), 0, (LPSTR)wh32 - sizeof(LPWAVEHDR));
wh16->lpNext = 0;
}
ret = WINMM_MAP_OK;
}
break;
default:
FIXME("NIY: no conversion yet for %u [%lx,%lx]\n", wMsg, *lpParam1, *lpParam2);
break;
}
return ret;
}
/**************************************************************************
* MMDRV_WaveOut_Map32WTo16 [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_WaveOut_Map32WTo16 (UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2)
{
WINMM_MapType ret;
switch (wMsg) {
/* nothing to do */
case WODM_BREAKLOOP:
case WODM_CLOSE:
case WODM_GETNUMDEVS:
case WODM_PAUSE:
case WODM_RESET:
case WODM_RESTART:
case WODM_SETPITCH:
case WODM_SETPLAYBACKRATE:
case WODM_SETVOLUME:
ret = WINMM_MAP_OK;
break;
case WODM_GETDEVCAPS:
{
LPWAVEOUTCAPSW woc32 = (LPWAVEOUTCAPSW)*lpParam1;
LPSTR ptr = HeapAlloc( GetProcessHeap(), 0,
sizeof(LPWAVEOUTCAPSW) + sizeof(WAVEOUTCAPS16));
if (ptr) {
*(LPWAVEOUTCAPSW*)ptr = woc32;
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
*lpParam1 = MapLS(ptr) + sizeof(LPWAVEOUTCAPSW);
*lpParam2 = sizeof(WAVEOUTCAPS16);
}
break;
case WODM_GETPITCH:
FIXME("NIY: no conversion yet\n");
ret = WINMM_MAP_MSGERROR;
break;
case WODM_GETPLAYBACKRATE:
FIXME("NIY: no conversion yet\n");
ret = WINMM_MAP_MSGERROR;
break;
case WODM_GETPOS:
{
LPMMTIME mmt32 = (LPMMTIME)*lpParam1;
LPSTR ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMMTIME) + sizeof(MMTIME16));
LPMMTIME16 mmt16 = (LPMMTIME16)(ptr + sizeof(LPMMTIME));
if (ptr) {
*(LPMMTIME*)ptr = mmt32;
mmt16->wType = mmt32->wType;
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
*lpParam1 = MapLS(ptr) + sizeof(LPMMTIME);
*lpParam2 = sizeof(MMTIME16);
}
break;
case WODM_GETVOLUME:
FIXME("NIY: no conversion yet\n");
ret = WINMM_MAP_MSGERROR;
break;
case WODM_OPEN:
{
LPWAVEOPENDESC wod32 = (LPWAVEOPENDESC)*lpParam1;
int sz = sizeof(WAVEFORMATEX);
LPVOID ptr;
LPWAVEOPENDESC16 wod16;
/* allocated data are mapped as follows:
LPWAVEOPENDESC ptr to orig lParam1
DWORD orig dwUser, which is a pointer to DWORD:driver dwInstance
DWORD dwUser passed to driver
WAVEOPENDESC16 wod16: openDesc passed to driver
WAVEFORMATEX openDesc->lpFormat passed to driver
xxx extra bytes to WAVEFORMATEX
*/
if (wod32->lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
TRACE("Allocating %u extra bytes (%d)\n", ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize, wod32->lpFormat->wFormatTag);
sz += ((LPWAVEFORMATEX)wod32->lpFormat)->cbSize;
}
ptr = HeapAlloc( GetProcessHeap(), 0,
sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16) + sz);
if (ptr) {
SEGPTR seg_ptr = MapLS( ptr );
*(LPWAVEOPENDESC*)ptr = wod32;
*(LPDWORD)((char*)ptr + sizeof(LPWAVEOPENDESC)) = *lpdwUser;
wod16 = (LPWAVEOPENDESC16)((LPSTR)ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD));
wod16->hWave = HWAVE_16(wod32->hWave);
wod16->lpFormat = (LPWAVEFORMATEX)(seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD) + sizeof(WAVEOPENDESC16));
memcpy(wod16 + 1, wod32->lpFormat, sz);
wod16->dwCallback = wod32->dwCallback;
wod16->dwInstance = wod32->dwInstance;
wod16->uMappedDeviceID = wod32->uMappedDeviceID;
wod16->dnDevNode = wod32->dnDevNode;
*lpParam1 = seg_ptr + sizeof(LPWAVEOPENDESC) + 2*sizeof(DWORD);
*lpdwUser = seg_ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD);
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
}
break;
case WODM_PREPARE:
{
LPWAVEHDR wh32 = (LPWAVEHDR)*lpParam1;
LPWAVEHDR wh16;
LPVOID ptr = HeapAlloc( GetProcessHeap(), 0,
sizeof(LPWAVEHDR) + sizeof(WAVEHDR) + wh32->dwBufferLength);
if (ptr) {
SEGPTR seg_ptr = MapLS( ptr );
*(LPWAVEHDR*)ptr = wh32;
wh16 = (LPWAVEHDR)((LPSTR)ptr + sizeof(LPWAVEHDR));
wh16->lpData = (LPSTR)seg_ptr + sizeof(LPWAVEHDR) + sizeof(WAVEHDR);
/* data will be copied on WODM_WRITE */
wh16->dwBufferLength = wh32->dwBufferLength;
wh16->dwBytesRecorded = wh32->dwBytesRecorded;
wh16->dwUser = wh32->dwUser;
wh16->dwFlags = wh32->dwFlags;
wh16->dwLoops = wh32->dwLoops;
/* FIXME: nothing on wh32->lpNext */
/* could link the wh32->lpNext at this level for memory house keeping */
wh32->lpNext = wh16; /* for reuse in unprepare and write */
*lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
*lpParam2 = sizeof(WAVEHDR);
2006-11-20 11:27:18 +01:00
TRACE("wh16=%08lx wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
*lpParam1, wh16->lpData, wh32->dwBufferLength, wh32->lpData);
ret = WINMM_MAP_OKMEM;
} else {
ret = WINMM_MAP_NOMEM;
}
}
break;
case WODM_UNPREPARE:
case WODM_WRITE:
{
LPWAVEHDR wh32 = (LPWAVEHDR)(*lpParam1);
LPWAVEHDR wh16 = wh32->lpNext;
LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
SEGPTR seg_ptr = MapLS( ptr );
assert(*(LPWAVEHDR*)ptr == wh32);
if (wMsg == WODM_WRITE)
memcpy((LPSTR)wh16 + sizeof(WAVEHDR), wh32->lpData, wh32->dwBufferLength);
*lpParam1 = seg_ptr + sizeof(LPWAVEHDR);
*lpParam2 = sizeof(WAVEHDR);
2006-11-20 11:27:18 +01:00
TRACE("wh16=%08lx wh16->lpData=%p wh32->buflen=%u wh32->lpData=%p\n",
*lpParam1, wh16->lpData, wh32->dwBufferLength, wh32->lpData);
/* dwBufferLength can be reduced between prepare & write */
if (wMsg == WODM_WRITE && wh16->dwBufferLength < wh32->dwBufferLength) {
2006-11-08 22:24:36 +01:00
ERR("Size of buffer has been increased from %d to %d, keeping initial value\n",
wh16->dwBufferLength, wh32->dwBufferLength);
} else
wh16->dwBufferLength = wh32->dwBufferLength;
ret = WINMM_MAP_OKMEM;
}
break;
case DRVM_MAPPER_STATUS:
{
LPDWORD p32 = (LPDWORD)*lpParam2;
*lpParam2 = MapLS(p32);
ret = WINMM_MAP_OKMEM;
}
break;
default:
FIXME("NIY: no conversion yet\n");
ret = WINMM_MAP_MSGERROR;
break;
}
return ret;
}
/**************************************************************************
* MMDRV_WaveOut_UnMap32WTo16 [internal]
*/
2006-11-08 22:24:36 +01:00
static WINMM_MapType MMDRV_WaveOut_UnMap32WTo16(UINT wMsg, LPDWORD lpdwUser, DWORD_PTR* lpParam1, DWORD_PTR* lpParam2, MMRESULT fn_ret)
{
WINMM_MapType ret;
switch (wMsg) {
/* nothing to do */
case WODM_BREAKLOOP:
case WODM_CLOSE:
case WODM_GETNUMDEVS:
case WODM_PAUSE:
case WODM_RESET:
case WODM_RESTART:
case WODM_SETPITCH:
case WODM_SETPLAYBACKRATE:
case WODM_SETVOLUME:
ret = WINMM_MAP_OK;
break;
case WODM_GETDEVCAPS:
{
LPWAVEOUTCAPS16 woc16 = MapSL(*lpParam1);
LPSTR ptr = (LPSTR)woc16 - sizeof(LPWAVEOUTCAPSW);
LPWAVEOUTCAPSW woc32 = *(LPWAVEOUTCAPSW*)ptr;
woc32->wMid = woc16->wMid;
woc32->wPid = woc16->wPid;
woc32->vDriverVersion = woc16->vDriverVersion;
WideCharToMultiByte( CP_ACP, 0, woc32->szPname, -1, woc16->szPname,
sizeof(woc16->szPname), NULL, NULL );
woc32->dwFormats = woc16->dwFormats;
woc32->wChannels = woc16->wChannels;
woc32->dwSupport = woc16->dwSupport;
UnMapLS( *lpParam1 );
HeapFree( GetProcessHeap(), 0, ptr );
ret = WINMM_MAP_OK;
}
break;
case WODM_GETPITCH:
FIXME("NIY: no conversion yet\n");
ret = WINMM_MAP_MSGERROR;
break;
case WODM_GETPLAYBACKRATE:
FIXME("NIY: no conversion yet\n");
ret = WINMM_MAP_MSGERROR;
break;
case WODM_GETPOS:
{
LPMMTIME16 mmt16 = MapSL(*lpParam1);
LPSTR ptr = (LPSTR)mmt16 - sizeof(LPMMTIME);
LPMMTIME mmt32 = *(LPMMTIME*)ptr;
MMSYSTEM_MMTIME16to32(mmt32, mmt16);
UnMapLS( *lpParam1 );
HeapFree( GetProcessHeap(), 0, ptr );
ret = WINMM_MAP_OK;
}
break;
case WODM_OPEN:
{
LPWAVEOPENDESC16 wod16 = MapSL(*lpParam1);
LPSTR ptr = (LPSTR)wod16 - sizeof(LPWAVEOPENDESC) - 2*sizeof(DWORD);
LPWAVEOPENDESC wod32 = *(LPWAVEOPENDESC*)ptr;
wod32->uMappedDeviceID = wod16->uMappedDeviceID;
**(DWORD**)(ptr + sizeof(LPWAVEOPENDESC)) = *(LPDWORD)(ptr + sizeof(LPWAVEOPENDESC) + sizeof(DWORD));
UnMapLS( *lpParam1 );
HeapFree( GetProcessHeap(), 0, ptr );
ret = WINMM_MAP_OK;
}
break;
case WODM_PREPARE:
case WODM_UNPREPARE:
case WODM_WRITE:
{
LPWAVEHDR wh16 = MapSL(*lpParam1);
LPSTR ptr = (LPSTR)wh16 - sizeof(LPWAVEHDR);
LPWAVEHDR wh32 = *(LPWAVEHDR*)ptr;
assert(wh32->lpNext == wh16);
wh32->dwBytesRecorded = wh16->dwBytesRecorded;
wh32->dwUser = wh16->dwUser;
wh32->dwFlags = wh16->dwFlags;
wh32->dwLoops = wh16->dwLoops;
UnMapLS( *lpParam1 );
if (wMsg == WODM_UNPREPARE && fn_ret == MMSYSERR_NOERROR) {
HeapFree( GetProcessHeap(), 0, ptr );
wh32->lpNext = 0;
}
ret = WINMM_MAP_OK;
}
break;
case WODM_GETVOLUME:
FIXME("NIY: no conversion yet\n");
ret = WINMM_MAP_MSGERROR;
break;
case DRVM_MAPPER_STATUS:
{
UnMapLS( *lpParam2 );
ret = WINMM_MAP_OK;
}
break;
default:
FIXME("NIY: no conversion yet\n");
ret = WINMM_MAP_MSGERROR;
break;
}
return ret;
}
/**************************************************************************
* MMDRV_WaveOut_Callback [internal]
*/
2006-11-08 22:24:36 +01:00
static void CALLBACK MMDRV_WaveOut_Callback(HDRVR hDev, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
{
LPWINE_MLD mld = (LPWINE_MLD)dwInstance;
switch (uMsg) {
case WOM_OPEN:
case WOM_CLOSE:
/* dwParam1 & dwParam2 are supposed to be 0, nothing to do */
break;
case WOM_DONE:
if (mld->bFrom32 && !MMDRV_Is32(mld->mmdIndex)) {
/* initial map is: 32 => 16 */
LPWAVEHDR wh16 = MapSL(dwParam1);
LPWAVEHDR wh32 = *(LPWAVEHDR*)((LPSTR)wh16 - sizeof(LPWAVEHDR));
dwParam1 = (DWORD)wh32;
wh32->dwFlags = wh16->dwFlags;
} else if (!mld->bFrom32 && MMDRV_Is32(mld->mmdIndex)) {
/* initial map is: 16 => 32 */
LPWAVEHDR wh32 = (LPWAVEHDR)(dwParam1);
SEGPTR segwh16 = *(SEGPTR*)((LPSTR)wh32 - sizeof(LPWAVEHDR));
LPWAVEHDR wh16 = MapSL(segwh16);
dwParam1 = (DWORD)segwh16;
wh16->dwFlags = wh32->dwFlags;
}
/* else { 16 => 16 or 32 => 32, nothing to do, same struct is kept }*/
break;
default:
ERR("Unknown msg %u\n", uMsg);
}
MMDRV_Callback(mld, hDev, uMsg, dwParam1, dwParam2);
}
/* =================================
* M A P P E R S H A N D L I N G
* ================================= */
static LRESULT MMDRV_CallMMDrvFunc16(DWORD fp16, WORD dev, WORD msg, LONG instance,
LONG lp1, LONG lp2)
{
WORD args[8];
DWORD ret;
args[7] = dev;
args[6] = msg;
args[5] = HIWORD(instance);
args[4] = LOWORD(instance);
args[3] = HIWORD(lp1);
args[2] = LOWORD(lp1);
args[1] = HIWORD(lp2);
args[0] = LOWORD(lp2);
WOWCallback16Ex( fp16, WCB16_PASCAL, sizeof(args), args, &ret );
return LOWORD(ret);
}
/**************************************************************************
* MMDRV_GetDescription16 [internal]
*/
static BOOL MMDRV_GetDescription16(const char* fname, char* buf, int buflen)
{
OFSTRUCT ofs;
HFILE hFile;
WORD w;
DWORD dw;
BOOL ret = FALSE;
if ((hFile = OpenFile(fname, &ofs, OF_READ | OF_SHARE_DENY_WRITE)) == HFILE_ERROR) {
ERR("Can't open file %s (builtin driver ?)\n", fname);
return FALSE;
}
#define E(_x) do {TRACE _x;goto theEnd;} while(0)
if (_lread(hFile, &w, 2) != 2) E(("Can't read sig\n"));
if (w != ('Z' * 256 + 'M')) E(("Bad sig %04x\n", w));
if (_llseek(hFile, 0x3C, SEEK_SET) < 0) E(("Can't seek to ext header offset\n"));
if (_lread(hFile, &dw, 4) != 4) E(("Can't read ext header offset\n"));
2006-11-08 22:24:36 +01:00
if (_llseek(hFile, dw + 0x2C, SEEK_SET) < 0) E(("Can't seek to ext header.nr table %u\n", dw+0x2C));
if (_lread(hFile, &dw, 4) != 4) E(("Can't read nr table offset\n"));
2006-11-08 22:24:36 +01:00
if (_llseek(hFile, dw, SEEK_SET) < 0) E(("Can't seek to nr table %u\n", dw));
if (_lread(hFile, buf, 1) != 1) E(("Can't read descr length\n"));
buflen = min((int)(unsigned)(BYTE)buf[0], buflen - 1);
if (_lread(hFile, buf, buflen) != buflen) E(("Can't read descr (%d)\n", buflen));
buf[buflen] = '\0';
ret = TRUE;
TRACE("Got '%s' [%d]\n", buf, buflen);
theEnd:
_lclose(hFile);
return ret;
}
/******************************************************************
* MMDRV_LoadMMDrvFunc16
*
*/
2007-02-03 12:27:52 +01:00
static unsigned MMDRV_LoadMMDrvFunc16(LPCSTR drvName, LPWINE_DRIVER d,
LPWINE_MM_DRIVER lpDrv)
{
WINEMM_msgFunc16 func;
unsigned count = 0;
char buffer[128];
/*
* DESCRIPTION 'wave,aux,mixer:Creative Labs Sound Blaster 16 Driver'
* The beginning of the module description indicates the driver supports
* waveform, auxiliary, and mixer devices. Use one of the following
* device-type names, followed by a colon (:) to indicate the type of
* device your driver supports. If the driver supports more than one
* type of device, separate each device-type name with a comma (,).
*
* wave for waveform audio devices
* wavemapper for wave mappers
* midi for MIDI audio devices
* midimapper for midi mappers
* aux for auxiliary audio devices
* mixer for mixer devices
*/
if (d->d.d16.hDriver16) {
HMODULE16 hMod16 = GetDriverModuleHandle16(d->d.d16.hDriver16);
#define AA(_h,_w,_x,_y,_z) \
func = (WINEMM_msgFunc##_y) _z ((_h), #_x); \
if (func != NULL) \
{ lpDrv->parts[_w].u.fnMessage##_y = func; count++; \
TRACE("Got %d bit func '%s'\n", _y, #_x); }
#define A(_x,_y) AA(hMod16,_x,_y,16,GetProcAddress16)
A(MMDRV_AUX, auxMessage);
A(MMDRV_MIXER, mxdMessage);
A(MMDRV_MIDIIN, midMessage);
A(MMDRV_MIDIOUT,modMessage);
A(MMDRV_WAVEIN, widMessage);
A(MMDRV_WAVEOUT,wodMessage);
#undef A
#undef AA
}
if (TRACE_ON(winmm)) {
if (MMDRV_GetDescription16(drvName, buffer, sizeof(buffer)))
TRACE("%s => %s\n", drvName, buffer);
else
TRACE("%s => No description\n", drvName);
}
return count;
}
/* =================================
* M C I
* ================================= */
#if 0
/* FIXME: this code is kept for not yet implemented optimisation for an application
* using the 32A MCI interface and calling a 16 bit driver.
* For now, we're doing two conversions:
* - 32A => 32W (in 32 bit MCI code)
* - 32W => 16 in this file
*/
/*
* 0000 stop
* 0001 squeeze signed 4 bytes to 2 bytes *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2; S += 4
* 0010 squeeze unsigned 4 bytes to 2 bytes *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2; S += 4
* 0100
* 0101
* 0110 zero 4 bytes *(DWORD)D = 0 D += 4; S += 4
* 0111 copy string *(LPSTR*)D = seg dup(*(LPSTR*)S) D += 4; S += 4
* 1xxx copy xxx + 1 bytes memcpy(D, S, xxx + 1); D += xxx+1; S += xxx+1
*/
/**************************************************************************
* MCI_MsgMapper32ATo16_Create [internal]
*
* Helper for MCI_MapMsg32ATo16.
* Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit
* segmented pointer.
* map contains a list of action to be performed for the mapping (see list
* above)
* if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
*/
static WINMM_MapType MCI_MsgMapper32ATo16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
{
void* lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 );
LPBYTE p16, p32;
if (!lp) {
return WINMM_MAP_NOMEM;
}
p32 = (LPBYTE)(*ptr);
if (keep) {
*(void**)lp = *ptr;
p16 = (LPBYTE)lp + sizeof(void**);
*ptr = (char*)MapLS(lp) + sizeof(void**);
} else {
p16 = lp;
*ptr = (void*)MapLS(lp);
}
if (map == 0) {
memcpy(p16, p32, size16);
} else {
unsigned nibble;
unsigned sz;
while (map & 0xF) {
nibble = map & 0xF;
if (nibble & 0x8) {
sz = (nibble & 7) + 1;
memcpy(p16, p32, sz);
p16 += sz;
p32 += sz;
size16 -= sz; /* DEBUG only */
} else {
switch (nibble) {
case 0x1:
*(LPINT16)p16 = *(LPINT)p32;
p16 += sizeof(INT16);
p32 += sizeof(INT);
size16 -= sizeof(INT16);
break;
case 0x2:
*(LPUINT16)p16 = *(LPUINT)p32;
p16 += sizeof(UINT16);
p32 += sizeof(UINT);
size16 -= sizeof(UINT16);
break;
case 0x6:
*(LPDWORD)p16 = 0;
p16 += sizeof(DWORD);
p32 += sizeof(DWORD);
size16 -= sizeof(DWORD);
break;
case 0x7:
*(SEGPTR *)p16 = MapLS( *(LPSTR *)p32 );
p16 += sizeof(SEGPTR);
p32 += sizeof(LPSTR);
size16 -= sizeof(SEGPTR);
break;
default:
FIXME("Unknown nibble for mapping (%x)\n", nibble);
}
}
map >>= 4;
}
if (size16 != 0) /* DEBUG only */
FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
}
return WINMM_MAP_OKMEM;
}
/**************************************************************************
* MCI_MsgMapper32ATo16_Destroy [internal]
*
* Helper for MCI_UnMapMsg32ATo16.
*/
static WINMM_MapType MCI_MsgMapper32ATo16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
{
if (ptr) {
void* msg16 = MapSL((SEGPTR)ptr);
void* alloc;
LPBYTE p32, p16;
unsigned nibble;
UnMapLS( (SEGPTR)ptr );
if (kept) {
alloc = (char*)msg16 - sizeof(void**);
p32 = *(void**)alloc;
p16 = msg16;
if (map == 0) {
memcpy(p32, p16, size16);
} else {
while (map & 0xF) {
nibble = map & 0xF;
if (nibble & 0x8) {
memcpy(p32, p16, (nibble & 7) + 1);
p16 += (nibble & 7) + 1;
p32 += (nibble & 7) + 1;
size16 -= (nibble & 7) + 1;
} else {
switch (nibble) {
case 0x1:
*(LPINT)p32 = *(LPINT16)p16;
p16 += sizeof(INT16);
p32 += sizeof(INT);
size16 -= sizeof(INT16);
break;
case 0x2:
*(LPUINT)p32 = *(LPUINT16)p16;
p16 += sizeof(UINT16);
p32 += sizeof(UINT);
size16 -= sizeof(UINT16);
break;
case 0x6:
p16 += sizeof(UINT);
p32 += sizeof(UINT);
size16 -= sizeof(UINT);
break;
case 0x7:
UnMapLS( *(SEGPTR *)p16 );
p16 += sizeof(SEGPTR);
p32 += sizeof(char*);
size16 -= sizeof(SEGPTR);
break;
default:
FIXME("Unknown nibble for mapping (%x)\n", nibble);
}
}
map >>= 4;
}
if (size16 != 0) /* DEBUG only */
FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
}
} else {
alloc = msg16;
}
HeapFree( GetProcessHeap(), 0, alloc );
}
return WINMM_MAP_OK;
}
/**************************************************************************
* MCI_MapMsg32ATo16 [internal]
*
* Map a 32-A bit MCI message to a 16 bit MCI message.
*/
static WINMM_MapType MCI_MapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD* lParam)
{
int size;
BOOLEAN keep = FALSE;
DWORD map = 0;
if (*lParam == 0)
return WINMM_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_BREAK:
size = sizeof(MCI_BREAK_PARMS);
break;
/* case MCI_CAPTURE */
case MCI_CLOSE:
case MCI_CLOSE_DRIVER:
case MCI_CONFIGURE:
size = sizeof(MCI_GENERIC_PARMS);
break;
/* case MCI_COPY: */
case MCI_CUE:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS); break;
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_CUE_PARMS); break;*/ FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
/* case MCI_CUT:*/
case MCI_DELETE:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16); map = 0x0F1111FB; break;
case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS); break;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
/* case MCI_ESCAPE: */
case MCI_FREEZE:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS); map = 0x0001111B; break;
case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
case MCI_GETDEVCAPS:
keep = TRUE;
size = sizeof(MCI_GETDEVCAPS_PARMS);
break;
/* case MCI_INDEX: */
case MCI_INFO:
{
LPMCI_INFO_PARMSA mip32a = (LPMCI_INFO_PARMSA)(*lParam);
LPMCI_INFO_PARMS16 mip16;
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_INFO_PARMS16); break;
default: size = sizeof(MCI_INFO_PARMS16); break;
}
mip16 = HeapAlloc( GetProcessHeap(), 0, size);
if (mip16)
{
mip16->dwCallback = mip32a->dwCallback;
mip16->lpstrReturn = MapLS( mip32a->lpstrReturn );
mip16->dwRetSize = mip32a->dwRetSize;
if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) {
((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSA)mip32a)->dwItem;
}
} else {
return WINMM_MAP_NOMEM;
}
*lParam = MapLS(mip16);
}
return WINMM_MAP_OKMEM;
/* case MCI_MARK: */
/* case MCI_MONITOR: */
case MCI_OPEN:
case MCI_OPEN_DRIVER:
{
LPMCI_OPEN_PARMSA mop32a = (LPMCI_OPEN_PARMSA)(*lParam);
char* ptr = HeapAlloc( GetProcessHeap(), 0,
sizeof(LPMCI_OPEN_PARMSA) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD));
LPMCI_OPEN_PARMS16 mop16;
if (ptr) {
*(LPMCI_OPEN_PARMSA*)(ptr) = mop32a;
mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSA));
mop16->dwCallback = mop32a->dwCallback;
mop16->wDeviceID = mop32a->wDeviceID;
if (dwFlags & MCI_OPEN_TYPE) {
if (dwFlags & MCI_OPEN_TYPE_ID) {
/* dword "transparent" value */
mop16->lpstrDeviceType = (SEGPTR)mop32a->lpstrDeviceType;
} else {
/* string */
mop16->lpstrDeviceType = MapLS( mop32a->lpstrDeviceType );
}
} else {
/* nuthin' */
mop16->lpstrDeviceType = 0;
}
if (dwFlags & MCI_OPEN_ELEMENT) {
if (dwFlags & MCI_OPEN_ELEMENT_ID) {
mop16->lpstrElementName = (SEGPTR)mop32a->lpstrElementName;
} else {
mop16->lpstrElementName = MapLS( mop32a->lpstrElementName );
}
} else {
mop16->lpstrElementName = 0;
}
if (dwFlags & MCI_OPEN_ALIAS) {
mop16->lpstrAlias = MapLS( mop32a->lpstrAlias );
} else {
mop16->lpstrAlias = 0;
}
/* 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.
*/
memcpy(mop16 + 1, mop32a + 1, 2 * sizeof(DWORD));
} else {
return WINMM_MAP_NOMEM;
}
*lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_PARMSA);
}
return WINMM_MAP_OKMEM;
/* case MCI_PASTE:*/
case MCI_PAUSE:
size = sizeof(MCI_GENERIC_PARMS);
break;
case MCI_PLAY:
size = sizeof(MCI_PLAY_PARMS);
break;
case MCI_PUT:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break;
case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
case MCI_REALIZE:
size = sizeof(MCI_GENERIC_PARMS);
break;
case MCI_RECORD:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16); map = 0x0F1111FB; break;
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_RECORD_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
default: size = sizeof(MCI_RECORD_PARMS); break;
}
break;
case MCI_RESUME:
size = sizeof(MCI_GENERIC_PARMS);
break;
case MCI_SEEK:
switch (uDevType) {
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SEEK_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
default: size = sizeof(MCI_SEEK_PARMS); break;
}
break;
case MCI_SET:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS); break;
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SET_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
case MCI_DEVTYPE_SEQUENCER: size = sizeof(MCI_SEQ_SET_PARMS); break;
/* FIXME: normally the 16 and 32 bit structures are byte by byte aligned,
* so not doing anything should work...
*/
case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS); break;
default: size = sizeof(MCI_SET_PARMS); break;
}
break;
case MCI_SETAUDIO:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SETAUDIO_PARMS16);map = 0x0000077FF; break;
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
/* case MCI_SETTIMECODE:*/
/* case MCI_SIGNAL:*/
/* case MCI_SOUND:*/
case MCI_SPIN:
size = sizeof(MCI_SET_PARMS);
break;
case MCI_STATUS:
keep = TRUE;
switch (uDevType) {
/* FIXME:
* don't know if buffer for value is the one passed through lpstrDevice
* or is provided by MCI driver.
* Assuming solution 2: provided by MCI driver, so zeroing on entry
*/
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16); map = 0x0B6FF; break;
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
default: size = sizeof(MCI_STATUS_PARMS); break;
}
break;
case MCI_STEP:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS); break;
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STEP_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
case MCI_DEVTYPE_VIDEODISC: size = sizeof(MCI_VD_STEP_PARMS); break;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
case MCI_STOP:
size = sizeof(MCI_SET_PARMS);
break;
case MCI_SYSINFO:
{
LPMCI_SYSINFO_PARMSA msip32a = (LPMCI_SYSINFO_PARMSA)(*lParam);
LPMCI_SYSINFO_PARMS16 msip16;
char* ptr = HeapAlloc( GetProcessHeap(), 0,
sizeof(LPMCI_SYSINFO_PARMSA) + sizeof(MCI_SYSINFO_PARMS16) );
if (ptr) {
*(LPMCI_SYSINFO_PARMSA*)(ptr) = msip32a;
msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSA));
msip16->dwCallback = msip32a->dwCallback;
msip16->lpstrReturn = MapLS( msip32a->lpstrReturn );
msip16->dwRetSize = msip32a->dwRetSize;
msip16->dwNumber = msip32a->dwNumber;
msip16->wDeviceType = msip32a->wDeviceType;
} else {
return WINMM_MAP_NOMEM;
}
*lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_SYSINFO_PARMSA);
}
return WINMM_MAP_OKMEM;
/* case MCI_UNDO: */
case MCI_UNFREEZE:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break;
case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; break;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
case MCI_UPDATE:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16); map = 0x000B1111B; break;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
case MCI_WHERE:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break;
case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
case MCI_WINDOW:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7FB; break;
case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB; break;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
case DRV_OPEN:
{
LPMCI_OPEN_DRIVER_PARMSA modp32a = (LPMCI_OPEN_DRIVER_PARMSA)(*lParam);
LPMCI_OPEN_DRIVER_PARMS16 modp16;
char *ptr = HeapAlloc( GetProcessHeap(), 0,
sizeof(LPMCI_OPEN_DRIVER_PARMSA) + sizeof(MCI_OPEN_DRIVER_PARMS16));
if (ptr) {
*(LPMCI_OPEN_DRIVER_PARMSA*)(ptr) = modp32a;
modp16 = (LPMCI_OPEN_DRIVER_PARMS16)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSA));
modp16->wDeviceID = modp32a->wDeviceID;
modp16->lpstrParams = MapLS( modp32a->lpstrParams );
/* other fields are gonna be filled by the driver, don't copy them */
} else {
return WINMM_MAP_NOMEM;
}
*lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_DRIVER_PARMSA);
}
return WINMM_MAP_OKMEM;
case DRV_LOAD:
case DRV_ENABLE:
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:
return WINMM_MAP_OK;
default:
FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
return WINMM_MAP_MSGERROR;
}
return MCI_MsgMapper32ATo16_Create((void**)lParam, size, map, keep);
}
/**************************************************************************
* MCI_UnMapMsg32ATo16 [internal]
*/
static WINMM_MapType MCI_UnMapMsg32ATo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD lParam)
{
int size = 0;
BOOLEAN kept = FALSE; /* there is no need to compute size when kept is FALSE */
DWORD map = 0;
switch (wMsg) {
case MCI_BREAK:
break;
/* case MCI_CAPTURE */
case MCI_CLOSE:
case MCI_CLOSE_DRIVER:
case MCI_CONFIGURE:
break;
/* case MCI_COPY: */
case MCI_CUE:
break;
/* case MCI_CUT: */
case MCI_DELETE:
break;
/* case MCI_ESCAPE: */
case MCI_FREEZE:
break;
case MCI_GETDEVCAPS:
kept = TRUE;
size = sizeof(MCI_GETDEVCAPS_PARMS);
break;
/* case MCI_INDEX: */
case MCI_INFO:
{
LPMCI_INFO_PARMS16 mip16 = (LPMCI_INFO_PARMS16)MapSL(lParam);
UnMapLS( lParam );
UnMapLS( mip16->lpstrReturn );
HeapFree( GetProcessHeap(), 0, mip16 );
}
return WINMM_MAP_OK;
/* case MCI_MARK: */
/* case MCI_MONITOR: */
case MCI_OPEN:
case MCI_OPEN_DRIVER:
if (lParam) {
LPMCI_OPEN_PARMS16 mop16 = (LPMCI_OPEN_PARMS16)MapSL(lParam);
LPMCI_OPEN_PARMSA mop32a = *(LPMCI_OPEN_PARMSA*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSA));
UnMapLS( lParam );
mop32a->wDeviceID = mop16->wDeviceID;
if ((dwFlags & MCI_OPEN_TYPE) && !(dwFlags & MCI_OPEN_TYPE_ID))
UnMapLS( mop16->lpstrDeviceType );
if ((dwFlags & MCI_OPEN_ELEMENT) && !(dwFlags & MCI_OPEN_ELEMENT_ID))
UnMapLS( mop16->lpstrElementName );
if (dwFlags & MCI_OPEN_ALIAS)
UnMapLS( mop16->lpstrAlias );
HeapFree( GetProcessHeap(), 0, (char*)mop16 - sizeof(LPMCI_OPEN_PARMSA) );
}
return WINMM_MAP_OK;
/* case MCI_PASTE:*/
case MCI_PAUSE:
break;
case MCI_PLAY:
break;
case MCI_PUT:
break;
case MCI_REALIZE:
break;
case MCI_RECORD:
break;
case MCI_RESUME:
break;
case MCI_SEEK:
break;
case MCI_SET:
break;
case MCI_SETAUDIO:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: map = 0x0000077FF; break;
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
}
break;
/* case MCI_SETTIMECODE:*/
/* case MCI_SIGNAL:*/
/* case MCI_SOUND:*/
case MCI_SPIN:
break;
case MCI_STATUS:
kept = TRUE;
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO:
if (lParam) {
LPMCI_DGV_STATUS_PARMS16 mdsp16 = (LPMCI_DGV_STATUS_PARMS16)MapSL(lParam);
LPMCI_DGV_STATUS_PARMSA mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA));
UnMapLS( lParam );
if (mdsp16) {
mdsp32a->dwReturn = mdsp16->dwReturn;
if (dwFlags & MCI_DGV_STATUS_DISKSPACE) {
TRACE("MCI_STATUS (DGV) lpstrDrive=%08lx\n", mdsp16->lpstrDrive);
TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive));
UnMapLS( mdsp16->lpstrDrive );
}
HeapFree( GetProcessHeap(), 0, (char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA) );
} else {
return WINMM_MAP_NOMEM;
}
}
return WINMM_MAP_OKMEM;
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
default: size = sizeof(MCI_STATUS_PARMS); break;
}
break;
case MCI_STEP:
break;
case MCI_STOP:
break;
case MCI_SYSINFO:
if (lParam) {
LPMCI_SYSINFO_PARMS16 msip16 = (LPMCI_SYSINFO_PARMS16)MapSL(lParam);
LPMCI_SYSINFO_PARMSA msip32a = *(LPMCI_SYSINFO_PARMSA*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA));
UnMapLS( lParam );
if (msip16) {
msip16->dwCallback = msip32a->dwCallback;
UnMapLS( msip16->lpstrReturn );
HeapFree( GetProcessHeap(), 0, (char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSA) );
} else {
return WINMM_MAP_NOMEM;
}
}
return WINMM_MAP_OKMEM;
/* case MCI_UNDO: */
case MCI_UNFREEZE:
break;
case MCI_UPDATE:
break;
case MCI_WHERE:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break;
case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break;
default: break;
}
break;
case MCI_WINDOW:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7666; break;
case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666; break;
default: break;
}
/* FIXME: see map function */
break;
case DRV_OPEN:
if (lParam) {
LPMCI_OPEN_DRIVER_PARMS16 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)MapSL(lParam);
LPMCI_OPEN_DRIVER_PARMSA modp32a = *(LPMCI_OPEN_DRIVER_PARMSA*)((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA));
UnMapLS( lParam );
modp32a->wCustomCommandTable = modp16->wCustomCommandTable;
modp32a->wType = modp16->wType;
UnMapLS( modp16->lpstrParams );
HeapFree( GetProcessHeap(), 0, (char *)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA) );
}
return WINMM_MAP_OK;
case DRV_LOAD:
case DRV_ENABLE:
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 WINMM_MAP_OK;
default:
FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
return WINMM_MAP_MSGERROR;
}
return MCI_MsgMapper32ATo16_Destroy((void*)lParam, size, map, kept);
}
#endif
/**************************************************************************
* MCI_MapMsg16To32W [internal]
*/
2005-09-12 12:52:38 +02:00
static WINMM_MapType MCI_MapMsg16To32W(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD_PTR* lParam)
{
if (*lParam == 0)
return WINMM_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_FREEZE:
case MCI_GETDEVCAPS:
/* case MCI_INDEX: */
/* case MCI_MARK: */
/* case MCI_MONITOR: */
case MCI_PASTE:
case MCI_PAUSE:
case MCI_PLAY:
case MCI_PUT:
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_STATUS: /* FIXME: is wrong for digital video */
case MCI_STEP:
case MCI_STOP:
/* case MCI_UNDO: */
case MCI_UNFREEZE:
case MCI_UPDATE:
case MCI_WHERE:
*lParam = (DWORD)MapSL(*lParam);
return WINMM_MAP_OK;
case MCI_WINDOW:
/* in fact, I would also need the dwFlags... to see
* which members of lParam are effectively used
*/
*lParam = (DWORD)MapSL(*lParam);
FIXME("Current mapping may be wrong\n");
break;
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 WINMM_MAP_NOMEM;
}
*lParam = (DWORD)mbp32;
}
return WINMM_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 WINMM_MAP_NOMEM;
}
*lParam = (DWORD)mvep32w;
}
return WINMM_MAP_OKMEM;
case MCI_INFO:
{
LPMCI_INFO_PARMSW mip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_INFO_PARMSW));
LPMCI_INFO_PARMS16 mip16 = MapSL(*lParam);
/* FIXME this is wrong if device is of type
* MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
*/
if (mip32w) {
*(LPMCI_INFO_PARMS16*)(mip32w) = mip16;
mip32w = (LPMCI_INFO_PARMSW)((char*)mip32w + sizeof(LPMCI_INFO_PARMS16));
mip32w->dwCallback = mip16->dwCallback;
mip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mip16->dwRetSize * sizeof(WCHAR));
mip32w->dwRetSize = mip16->dwRetSize * sizeof(WCHAR);
} else {
return WINMM_MAP_NOMEM;
}
*lParam = (DWORD)mip32w;
}
return WINMM_MAP_OKMEM;
case MCI_OPEN:
case MCI_OPEN_DRIVER:
{
LPMCI_OPEN_PARMSW mop32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSW) + 2 * sizeof(DWORD));
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.
*/
memcpy(mop32w + 1, mop16 + 1, 2 * sizeof(DWORD));
} else {
return WINMM_MAP_NOMEM;
}
*lParam = (DWORD)mop32w;
}
return WINMM_MAP_OKMEM;
case MCI_SYSINFO:
{
LPMCI_SYSINFO_PARMSW msip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_SYSINFO_PARMSW));
LPMCI_SYSINFO_PARMS16 msip16 = MapSL(*lParam);
if (msip32w) {
*(LPMCI_SYSINFO_PARMS16*)(msip32w) = msip16;
msip32w = (LPMCI_SYSINFO_PARMSW)((char*)msip32w + sizeof(LPMCI_OPEN_PARMS16));
msip32w->dwCallback = msip16->dwCallback;
msip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, msip16->dwRetSize * sizeof(WCHAR));
msip32w->dwRetSize = msip16->dwRetSize;
msip32w->dwNumber = msip16->dwNumber;
msip32w->wDeviceType = msip16->wDeviceType;
} else {
return WINMM_MAP_NOMEM;
}
*lParam = (DWORD)msip32w;
}
return WINMM_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 WINMM_MAP_NOMEM;
}
*lParam = (DWORD)mbp32;
}
return WINMM_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 WINMM_MAP_OK;
default:
FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
}
return WINMM_MAP_MSGERROR;
}
/**************************************************************************
* MCI_UnMapMsg16To32W [internal]
*/
2005-09-12 12:52:38 +02:00
static WINMM_MapType MCI_UnMapMsg16To32W(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD_PTR lParam)
{
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_FREEZE:
case MCI_GETDEVCAPS:
/* case MCI_INDEX: */
/* case MCI_MARK: */
/* case MCI_MONITOR: */
case MCI_PASTE:
case MCI_PAUSE:
case MCI_PLAY:
case MCI_PUT:
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_STATUS:
case MCI_STEP:
case MCI_STOP:
/* case MCI_UNDO: */
case MCI_UNFREEZE:
case MCI_UPDATE:
case MCI_WHERE:
return WINMM_MAP_OK;
case MCI_WINDOW:
/* FIXME ?? see Map function */
return WINMM_MAP_OK;
case MCI_BREAK:
HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
return WINMM_MAP_OK;
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);
}
return WINMM_MAP_OK;
case MCI_INFO:
if (lParam) {
LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)lParam;
LPMCI_INFO_PARMS16 mip16 = *(LPMCI_INFO_PARMS16*)((char*)mip32w - sizeof(LPMCI_INFO_PARMS16));
WideCharToMultiByte(CP_ACP, 0,
mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR),
MapSL(mip16->lpstrReturn), mip16->dwRetSize,
NULL, NULL);
HeapFree(GetProcessHeap(), 0, (LPVOID)mip32w->lpstrReturn);
HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
}
return WINMM_MAP_OK;
case MCI_SYSINFO:
if (lParam) {
LPMCI_SYSINFO_PARMSW msip32w = (LPMCI_SYSINFO_PARMSW)lParam;
LPMCI_SYSINFO_PARMS16 msip16 = *(LPMCI_SYSINFO_PARMS16*)((char*)msip32w - sizeof(LPMCI_SYSINFO_PARMS16));
WideCharToMultiByte(CP_ACP, 0,
msip32w->lpstrReturn, msip32w->dwRetSize,
MapSL(msip16->lpstrReturn), msip16->dwRetSize,
NULL, NULL);
HeapFree(GetProcessHeap(), 0, (LPVOID)msip32w->lpstrReturn);
HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
}
return WINMM_MAP_OK;
case MCI_SOUND:
if (lParam) {
LPMCI_SOUND_PARMSW msp32W = (LPMCI_SOUND_PARMSW)lParam;
HeapFree(GetProcessHeap(), 0, (LPVOID)msp32W->lpstrSoundName);
HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
}
return WINMM_MAP_OK;
case MCI_OPEN:
case MCI_OPEN_DRIVER:
if (lParam) {
LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)lParam;
LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)((char*)mop32w - sizeof(LPMCI_OPEN_PARMS16));
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);
if (!HeapFree(GetProcessHeap(), 0, (LPVOID)(lParam - sizeof(LPMCI_OPEN_PARMS16))))
FIXME("bad free line=%d\n", __LINE__);
}
return WINMM_MAP_OK;
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 WINMM_MAP_OK;
default:
FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
}
return WINMM_MAP_MSGERROR;
}
/*
* 0000 stop
* 0001 squeeze signed 4 bytes to 2 bytes *( LPINT16)D = ( INT16)*( LPINT16)S; D += 2; S += 4
* 0010 squeeze unsigned 4 bytes to 2 bytes *(LPUINT16)D = (UINT16)*(LPUINT16)S; D += 2; S += 4
* 0100
* 0101
* 0110 zero 4 bytes *(DWORD)D = 0 D += 4; S += 4
* 0111 copy string *(LPSTR*)D = seg dup(*(LPSTR*)S) D += 4; S += 4
* 1xxx copy xxx + 1 bytes memcpy(D, S, xxx + 1); D += xxx+1; S += xxx+1
*/
/**************************************************************************
* MCI_MsgMapper32WTo16_Create [internal]
*
* Helper for MCI_MapMsg32WTo16.
* Maps the 32 bit pointer (*ptr), of size bytes, to an allocated 16 bit
* segmented pointer.
* map contains a list of action to be performed for the mapping (see list
* above)
* if keep is TRUE, keeps track of in 32 bit ptr in allocated 16 bit area.
*/
static WINMM_MapType MCI_MsgMapper32WTo16_Create(void** ptr, int size16, DWORD map, BOOLEAN keep)
{
void* lp = HeapAlloc( GetProcessHeap(), 0, (keep ? sizeof(void**) : 0) + size16 );
LPBYTE p16, p32;
if (!lp) {
return WINMM_MAP_NOMEM;
}
p32 = (LPBYTE)(*ptr);
if (keep) {
*(void**)lp = *ptr;
p16 = (LPBYTE)lp + sizeof(void**);
*ptr = (char*)MapLS(lp) + sizeof(void**);
} else {
p16 = lp;
*ptr = (void*)MapLS(lp);
}
if (map == 0) {
memcpy(p16, p32, size16);
} else {
unsigned nibble;
unsigned sz;
while (map & 0xF) {
nibble = map & 0xF;
if (nibble & 0x8) {
sz = (nibble & 7) + 1;
memcpy(p16, p32, sz);
p16 += sz;
p32 += sz;
size16 -= sz; /* DEBUG only */
} else {
switch (nibble) {
case 0x1:
*(LPINT16)p16 = *(LPINT)p32;
p16 += sizeof(INT16);
p32 += sizeof(INT);
size16 -= sizeof(INT16);
break;
case 0x2:
*(LPUINT16)p16 = *(LPUINT)p32;
p16 += sizeof(UINT16);
p32 += sizeof(UINT);
size16 -= sizeof(UINT16);
break;
case 0x6:
*(LPDWORD)p16 = 0;
p16 += sizeof(DWORD);
p32 += sizeof(DWORD);
size16 -= sizeof(DWORD);
break;
case 0x7:
*(SEGPTR *)p16 = MapLS( MCI_strdupWtoA( *(LPCWSTR *)p32 ) );
p16 += sizeof(SEGPTR);
p32 += sizeof(LPSTR);
size16 -= sizeof(SEGPTR);
break;
default:
FIXME("Unknown nibble for mapping (%x)\n", nibble);
}
}
map >>= 4;
}
if (size16 != 0) /* DEBUG only */
FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
}
return WINMM_MAP_OKMEM;
}
/**************************************************************************
* MCI_MsgMapper32WTo16_Destroy [internal]
*
* Helper for MCI_UnMapMsg32WTo16.
*/
static WINMM_MapType MCI_MsgMapper32WTo16_Destroy(void* ptr, int size16, DWORD map, BOOLEAN kept)
{
if (ptr) {
void* msg16 = MapSL((SEGPTR)ptr);
void* alloc;
LPBYTE p32, p16;
unsigned nibble;
UnMapLS( (SEGPTR)ptr );
if (kept) {
alloc = (char*)msg16 - sizeof(void**);
p32 = *(void**)alloc;
p16 = msg16;
if (map == 0) {
memcpy(p32, p16, size16);
} else {
while (map & 0xF) {
nibble = map & 0xF;
if (nibble & 0x8) {
memcpy(p32, p16, (nibble & 7) + 1);
p16 += (nibble & 7) + 1;
p32 += (nibble & 7) + 1;
size16 -= (nibble & 7) + 1;
} else {
switch (nibble) {
case 0x1:
*(LPINT)p32 = *(LPINT16)p16;
p16 += sizeof(INT16);
p32 += sizeof(INT);
size16 -= sizeof(INT16);
break;
case 0x2:
*(LPUINT)p32 = *(LPUINT16)p16;
p16 += sizeof(UINT16);
p32 += sizeof(UINT);
size16 -= sizeof(UINT16);
break;
case 0x6:
p16 += sizeof(UINT);
p32 += sizeof(UINT);
size16 -= sizeof(UINT);
break;
case 0x7:
HeapFree(GetProcessHeap(), 0, MapSL(*(SEGPTR *)p16));
UnMapLS( *(SEGPTR *)p16 );
p16 += sizeof(SEGPTR);
p32 += sizeof(char*);
size16 -= sizeof(SEGPTR);
break;
default:
FIXME("Unknown nibble for mapping (%x)\n", nibble);
}
}
map >>= 4;
}
if (size16 != 0) /* DEBUG only */
FIXME("Mismatch between 16 bit struct size and map nibbles serie\n");
}
} else {
alloc = msg16;
}
HeapFree( GetProcessHeap(), 0, alloc );
}
return WINMM_MAP_OK;
}
/**************************************************************************
* MCI_MapMsg32WTo16 [internal]
*
* Map a 32W bit MCI message to a 16 bit MCI message.
*/
2005-09-12 12:52:38 +02:00
static WINMM_MapType MCI_MapMsg32WTo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD_PTR* lParam)
{
int size;
BOOLEAN keep = FALSE;
DWORD map = 0;
if (*lParam == 0)
return WINMM_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_BREAK:
size = sizeof(MCI_BREAK_PARMS);
break;
/* case MCI_CAPTURE */
case MCI_CLOSE:
case MCI_CLOSE_DRIVER:
case MCI_CONFIGURE:
size = sizeof(MCI_GENERIC_PARMS);
break;
/* case MCI_COPY: */
case MCI_CUE:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_CUE_PARMS); break;
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_CUE_PARMS); break;*/ FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
/* case MCI_CUT:*/
case MCI_DELETE:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_DELETE_PARMS16); map = 0x0F1111FB; break;
case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_DELETE_PARMS); break;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
/* case MCI_ESCAPE: */
case MCI_FREEZE:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_FREEZE_PARMS); map = 0x0001111B; break;
case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
case MCI_GETDEVCAPS:
keep = TRUE;
size = sizeof(MCI_GETDEVCAPS_PARMS);
break;
/* case MCI_INDEX: */
case MCI_INFO:
{
LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)(*lParam);
char* ptr;
LPMCI_INFO_PARMS16 mip16;
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_INFO_PARMS16); break;
default: size = sizeof(MCI_INFO_PARMS16); break;
}
ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPMCI_INFO_PARMSW) + size);
if (ptr)
{
*(LPMCI_INFO_PARMSW*)ptr = mip32w;
mip16 = (LPMCI_INFO_PARMS16)(ptr + sizeof(LPMCI_INFO_PARMSW));
mip16->dwCallback = mip32w->dwCallback;
mip16->lpstrReturn = MapLS( HeapAlloc(GetProcessHeap(), 0, mip32w->dwRetSize / sizeof(WCHAR)) );
mip16->dwRetSize = mip32w->dwRetSize / sizeof(WCHAR);
if (uDevType == MCI_DEVTYPE_DIGITAL_VIDEO) {
((LPMCI_DGV_INFO_PARMS16)mip16)->dwItem = ((LPMCI_DGV_INFO_PARMSW)mip32w)->dwItem;
}
} else {
return WINMM_MAP_NOMEM;
}
*lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_INFO_PARMSW);
}
return WINMM_MAP_OKMEM;
/* case MCI_MARK: */
/* case MCI_MONITOR: */
case MCI_OPEN:
case MCI_OPEN_DRIVER:
{
LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)(*lParam);
char* ptr = HeapAlloc( GetProcessHeap(), 0,
sizeof(LPMCI_OPEN_PARMSW) + sizeof(MCI_OPEN_PARMS16) + 2 * sizeof(DWORD));
LPMCI_OPEN_PARMS16 mop16;
if (ptr) {
*(LPMCI_OPEN_PARMSW*)(ptr) = mop32w;
mop16 = (LPMCI_OPEN_PARMS16)(ptr + sizeof(LPMCI_OPEN_PARMSW));
mop16->dwCallback = mop32w->dwCallback;
mop16->wDeviceID = mop32w->wDeviceID;
if (dwFlags & MCI_OPEN_TYPE) {
if (dwFlags & MCI_OPEN_TYPE_ID) {
/* dword "transparent" value */
mop16->lpstrDeviceType = (SEGPTR)mop32w->lpstrDeviceType;
} else {
/* string */
mop16->lpstrDeviceType = MapLS( MCI_strdupWtoA(mop32w->lpstrDeviceType) );
}
} else {
/* nuthin' */
mop16->lpstrDeviceType = 0;
}
if (dwFlags & MCI_OPEN_ELEMENT) {
if (dwFlags & MCI_OPEN_ELEMENT_ID) {
mop16->lpstrElementName = (SEGPTR)mop32w->lpstrElementName;
} else {
mop16->lpstrElementName = MapLS( MCI_strdupWtoA(mop32w->lpstrElementName) );
}
} else {
mop16->lpstrElementName = 0;
}
if (dwFlags & MCI_OPEN_ALIAS) {
mop16->lpstrAlias = MapLS( MCI_strdupWtoA(mop32w->lpstrAlias) );
} else {
mop16->lpstrAlias = 0;
}
/* 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.
*/
memcpy(mop16 + 1, mop32w + 1, 2 * sizeof(DWORD));
} else {
return WINMM_MAP_NOMEM;
}
*lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_PARMSW);
}
return WINMM_MAP_OKMEM;
/* case MCI_PASTE:*/
case MCI_PAUSE:
size = sizeof(MCI_GENERIC_PARMS);
break;
case MCI_PLAY:
size = sizeof(MCI_PLAY_PARMS);
break;
case MCI_PUT:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break;
case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS); map = 0x0001111B; break;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
case MCI_REALIZE:
size = sizeof(MCI_GENERIC_PARMS);
break;
case MCI_RECORD:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECORD_PARMS16); map = 0x0F1111FB; break;
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_RECORD_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
default: size = sizeof(MCI_RECORD_PARMS); break;
}
break;
case MCI_RESUME:
size = sizeof(MCI_GENERIC_PARMS);
break;
case MCI_SEEK:
switch (uDevType) {
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SEEK_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
default: size = sizeof(MCI_SEEK_PARMS); break;
}
break;
case MCI_SET:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SET_PARMS); break;
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SET_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
case MCI_DEVTYPE_SEQUENCER: size = sizeof(MCI_SEQ_SET_PARMS); break;
/* FIXME: normally the 16 and 32 bit structures are byte by byte aligned,
* so not doing anything should work...
*/
case MCI_DEVTYPE_WAVEFORM_AUDIO:size = sizeof(MCI_WAVE_SET_PARMS); break;
default: size = sizeof(MCI_SET_PARMS); break;
}
break;
case MCI_SETAUDIO:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_SETAUDIO_PARMS16);map = 0x0000077FF; break;
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
/* case MCI_SETTIMECODE:*/
/* case MCI_SIGNAL:*/
/* case MCI_SOUND:*/
case MCI_SPIN:
size = sizeof(MCI_SET_PARMS);
break;
case MCI_STATUS:
keep = TRUE;
switch (uDevType) {
/* FIXME:
* don't know if buffer for value is the one passed through lpstrDevice
* or is provided by MCI driver.
* Assuming solution 2: provided by MCI driver, so zeroing on entry
*/
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STATUS_PARMS16); map = 0x0B6FF; break;
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
default: size = sizeof(MCI_STATUS_PARMS); break;
}
break;
case MCI_STEP:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_STEP_PARMS); break;
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STEP_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
case MCI_DEVTYPE_VIDEODISC: size = sizeof(MCI_VD_STEP_PARMS); break;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
case MCI_STOP:
size = sizeof(MCI_SET_PARMS);
break;
case MCI_SYSINFO:
{
LPMCI_SYSINFO_PARMSW msip32w = (LPMCI_SYSINFO_PARMSW)(*lParam);
LPMCI_SYSINFO_PARMS16 msip16;
char* ptr = HeapAlloc( GetProcessHeap(), 0,
sizeof(LPMCI_SYSINFO_PARMSW) + sizeof(MCI_SYSINFO_PARMS16) );
if (ptr) {
*(LPMCI_SYSINFO_PARMSW*)(ptr) = msip32w;
msip16 = (LPMCI_SYSINFO_PARMS16)(ptr + sizeof(LPMCI_SYSINFO_PARMSW));
msip16->dwCallback = msip32w->dwCallback;
msip16->lpstrReturn = MapLS( HeapAlloc(GetProcessHeap(), 0, msip32w->dwRetSize) );
msip16->dwRetSize = msip32w->dwRetSize;
msip16->dwNumber = msip32w->dwNumber;
msip16->wDeviceType = msip32w->wDeviceType;
} else {
return WINMM_MAP_NOMEM;
}
*lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_SYSINFO_PARMSW);
}
return WINMM_MAP_OKMEM;
/* case MCI_UNDO: */
case MCI_UNFREEZE:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; break;
case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; break;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
case MCI_UPDATE:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_UPDATE_PARMS16); map = 0x000B1111B; break;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
case MCI_WHERE:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break;
case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; keep = TRUE; break;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
case MCI_WINDOW:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7FB; break;
case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7FB; break;
default: size = sizeof(MCI_GENERIC_PARMS); break;
}
break;
case DRV_OPEN:
{
LPMCI_OPEN_DRIVER_PARMSW modp32w = (LPMCI_OPEN_DRIVER_PARMSW)(*lParam);
LPMCI_OPEN_DRIVER_PARMS16 modp16;
char *ptr = HeapAlloc( GetProcessHeap(), 0,
sizeof(LPMCI_OPEN_DRIVER_PARMSW) + sizeof(MCI_OPEN_DRIVER_PARMS16));
if (ptr) {
*(LPMCI_OPEN_DRIVER_PARMSW*)(ptr) = modp32w;
modp16 = (LPMCI_OPEN_DRIVER_PARMS16)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSW));
modp16->wDeviceID = modp32w->wDeviceID;
modp16->lpstrParams = MapLS( MCI_strdupWtoA(modp32w->lpstrParams) );
/* other fields are gonna be filled by the driver, don't copy them */
} else {
return WINMM_MAP_NOMEM;
}
*lParam = (LPARAM)MapLS(ptr) + sizeof(LPMCI_OPEN_DRIVER_PARMSW);
}
return WINMM_MAP_OKMEM;
case DRV_LOAD:
case DRV_ENABLE:
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:
return WINMM_MAP_OK;
default:
FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
return WINMM_MAP_MSGERROR;
}
return MCI_MsgMapper32WTo16_Create((void**)lParam, size, map, keep);
}
/**************************************************************************
* MCI_UnMapMsg32WTo16 [internal]
*/
2005-09-12 12:52:38 +02:00
static WINMM_MapType MCI_UnMapMsg32WTo16(WORD uDevType, WORD wMsg, DWORD dwFlags, DWORD_PTR lParam)
{
int size = 0;
BOOLEAN kept = FALSE; /* there is no need to compute size when kept is FALSE */
DWORD map = 0;
switch (wMsg) {
case MCI_BREAK:
break;
/* case MCI_CAPTURE */
case MCI_CLOSE:
case MCI_CLOSE_DRIVER:
case MCI_CONFIGURE:
break;
/* case MCI_COPY: */
case MCI_CUE:
break;
/* case MCI_CUT: */
case MCI_DELETE:
break;
/* case MCI_ESCAPE: */
case MCI_FREEZE:
break;
case MCI_GETDEVCAPS:
kept = TRUE;
size = sizeof(MCI_GETDEVCAPS_PARMS);
break;
/* case MCI_INDEX: */
case MCI_INFO:
if (lParam) {
LPMCI_INFO_PARMS16 mip16 = (LPMCI_INFO_PARMS16)MapSL(lParam);
LPMCI_INFO_PARMSW mip32w = *(LPMCI_INFO_PARMSW*)((char*)mip16 - sizeof(LPMCI_INFO_PARMSW));
MultiByteToWideChar(CP_ACP, 0, MapSL(mip16->lpstrReturn), mip16->dwRetSize,
mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR));
UnMapLS( lParam );
UnMapLS( mip16->lpstrReturn );
HeapFree( GetProcessHeap(), 0, (void*)MapSL(mip16->lpstrReturn) );
HeapFree( GetProcessHeap(), 0, (char*)mip16 - sizeof(LPMCI_OPEN_PARMSW) );
}
return WINMM_MAP_OK;
/* case MCI_MARK: */
/* case MCI_MONITOR: */
case MCI_OPEN:
case MCI_OPEN_DRIVER:
if (lParam) {
LPMCI_OPEN_PARMS16 mop16 = (LPMCI_OPEN_PARMS16)MapSL(lParam);
LPMCI_OPEN_PARMSW mop32w = *(LPMCI_OPEN_PARMSW*)((char*)mop16 - sizeof(LPMCI_OPEN_PARMSW));
UnMapLS( lParam );
mop32w->wDeviceID = mop16->wDeviceID;
if ((dwFlags & MCI_OPEN_TYPE) && !(dwFlags & MCI_OPEN_TYPE_ID))
{
HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrDeviceType));
UnMapLS( mop16->lpstrDeviceType );
}
if ((dwFlags & MCI_OPEN_ELEMENT) && !(dwFlags & MCI_OPEN_ELEMENT_ID))
{
HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrElementName));
UnMapLS( mop16->lpstrElementName );
}
if (dwFlags & MCI_OPEN_ALIAS)
{
HeapFree(GetProcessHeap(), 0, MapSL(mop16->lpstrAlias));
UnMapLS( mop16->lpstrAlias );
}
HeapFree( GetProcessHeap(), 0, (char*)mop16 - sizeof(LPMCI_OPEN_PARMSW) );
}
return WINMM_MAP_OK;
/* case MCI_PASTE:*/
case MCI_PAUSE:
break;
case MCI_PLAY:
break;
case MCI_PUT:
break;
case MCI_REALIZE:
break;
case MCI_RECORD:
break;
case MCI_RESUME:
break;
case MCI_SEEK:
break;
case MCI_SET:
break;
case MCI_SETAUDIO:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: map = 0x0000077FF; break;
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_SETAUDIO_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
}
break;
/* case MCI_SETTIMECODE:*/
/* case MCI_SIGNAL:*/
/* case MCI_SOUND:*/
case MCI_SPIN:
break;
case MCI_STATUS:
kept = TRUE;
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO:
if (lParam) {
LPMCI_DGV_STATUS_PARMS16 mdsp16 = (LPMCI_DGV_STATUS_PARMS16)MapSL(lParam);
LPMCI_DGV_STATUS_PARMSA mdsp32a = *(LPMCI_DGV_STATUS_PARMSA*)((char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA));
UnMapLS( lParam );
if (mdsp16) {
mdsp32a->dwReturn = mdsp16->dwReturn;
if (dwFlags & MCI_DGV_STATUS_DISKSPACE) {
2006-11-08 22:24:36 +01:00
TRACE("MCI_STATUS (DGV) lpstrDrive=%08x\n", mdsp16->lpstrDrive);
TRACE("MCI_STATUS (DGV) lpstrDrive=%s\n", (LPSTR)MapSL(mdsp16->lpstrDrive));
UnMapLS( mdsp16->lpstrDrive );
}
HeapFree( GetProcessHeap(), 0, (char*)mdsp16 - sizeof(LPMCI_DGV_STATUS_PARMSA) );
} else {
return WINMM_MAP_NOMEM;
}
}
return WINMM_MAP_OKMEM;
case MCI_DEVTYPE_VCR: /*size = sizeof(MCI_VCR_STATUS_PARMS); break;*/FIXME("NIY vcr\n"); return WINMM_MAP_NOMEM;
default: size = sizeof(MCI_STATUS_PARMS); break;
}
break;
case MCI_STEP:
break;
case MCI_STOP:
break;
case MCI_SYSINFO:
if (lParam) {
LPMCI_SYSINFO_PARMS16 msip16 = (LPMCI_SYSINFO_PARMS16)MapSL(lParam);
LPMCI_SYSINFO_PARMSW msip32w = *(LPMCI_SYSINFO_PARMSW*)((char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSW));
UnMapLS( lParam );
if (msip16) {
MultiByteToWideChar(CP_ACP, 0, MapSL(msip16->lpstrReturn), msip16->dwRetSize,
msip32w->lpstrReturn, msip32w->dwRetSize/sizeof(WCHAR));
UnMapLS( msip16->lpstrReturn );
HeapFree( GetProcessHeap(), 0, MapSL(msip16->lpstrReturn) );
HeapFree( GetProcessHeap(), 0, (char*)msip16 - sizeof(LPMCI_SYSINFO_PARMSW) );
} else {
return WINMM_MAP_NOMEM;
}
}
return WINMM_MAP_OKMEM;
/* case MCI_UNDO: */
case MCI_UNFREEZE:
break;
case MCI_UPDATE:
break;
case MCI_WHERE:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break;
case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_RECT_PARMS16); map = 0x0001111B; kept = TRUE; break;
default: break;
}
break;
case MCI_WINDOW:
switch (uDevType) {
case MCI_DEVTYPE_DIGITAL_VIDEO: size = sizeof(MCI_DGV_WINDOW_PARMS16); if (dwFlags & MCI_DGV_WINDOW_TEXT) map = 0x7666; break;
case MCI_DEVTYPE_OVERLAY: size = sizeof(MCI_OVLY_WINDOW_PARMS16); if (dwFlags & MCI_OVLY_WINDOW_TEXT) map = 0x7666; break;
default: break;
}
/* FIXME: see map function */
break;
case DRV_OPEN:
if (lParam) {
LPMCI_OPEN_DRIVER_PARMS16 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)MapSL(lParam);
LPMCI_OPEN_DRIVER_PARMSW modp32w = *(LPMCI_OPEN_DRIVER_PARMSW*)((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSW));
UnMapLS( lParam );
modp32w->wCustomCommandTable = modp16->wCustomCommandTable;
modp32w->wType = modp16->wType;
HeapFree(GetProcessHeap(), 0, MapSL(modp16->lpstrParams));
UnMapLS( modp16->lpstrParams );
HeapFree( GetProcessHeap(), 0, (char *)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSW) );
}
return WINMM_MAP_OK;
case DRV_LOAD:
case DRV_ENABLE:
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 WINMM_MAP_OK;
default:
FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
return WINMM_MAP_MSGERROR;
}
return MCI_MsgMapper32WTo16_Destroy((void*)lParam, size, map, kept);
}
void MMDRV_Init16(void)
{
#define A(_x,_y) MMDRV_InstallMap(_x, \
MMDRV_##_y##_Map16To32W, MMDRV_##_y##_UnMap16To32W, \
MMDRV_##_y##_Map32WTo16, MMDRV_##_y##_UnMap32WTo16, \
MMDRV_##_y##_Callback)
A(MMDRV_AUX, Aux);
A(MMDRV_MIXER, Mixer);
A(MMDRV_MIDIIN, MidiIn);
A(MMDRV_MIDIOUT, MidiOut);
A(MMDRV_WAVEIN, WaveIn);
A(MMDRV_WAVEOUT, WaveOut);
#undef A
pFnCallMMDrvFunc16 = MMDRV_CallMMDrvFunc16;
pFnLoadMMDrvFunc16 = MMDRV_LoadMMDrvFunc16;
pFnMciMapMsg16To32W = MCI_MapMsg16To32W;
pFnMciUnMapMsg16To32W = MCI_UnMapMsg16To32W;
pFnMciMapMsg32WTo16 = MCI_MapMsg32WTo16;
pFnMciUnMapMsg32WTo16 = MCI_UnMapMsg32WTo16;
}