/*++
*
* WOW v1.0
*
* Copyright (c) 1991, Microsoft Corporation
*
* WMMSTRU1.C
* WOW32 16-bit MultiMedia structure conversion support
* Contains support for mciSendCommand Thunk message Parms.
* Also contains some debug support functions.
*
* History:
* Created 14-Jul-1992 by Stephen Estrop (stephene)
*
--*/
//
// We define NO_STRICT so that the compiler doesn't moan and groan when
// I use the FARPROC type for the Multi-Media api loading.
//
#define NO_STRICT
#include "precomp.h"
#pragma hdrstop
#if 0
MODNAME(wmmstru1.c);
#if DBG
int mmDebugLevel = -1;
MCI_MESSAGE_NAMES mciMessageNames[32] = {
{ MCI_OPEN, "MCI_OPEN" },
{ MCI_CLOSE, "MCI_CLOSE" },
{ MCI_ESCAPE, "MCI_ESCAPE" },
{ MCI_PLAY, "MCI_PLAY" },
{ MCI_SEEK, "MCI_SEEK" },
{ MCI_STOP, "MCI_STOP" },
{ MCI_PAUSE, "MCI_PAUSE" },
{ MCI_INFO, "MCI_INFO" },
{ MCI_GETDEVCAPS, "MCI_GETDEVCAPS" },
{ MCI_SPIN, "MCI_SPIN" },
{ MCI_SET, "MCI_SET" },
{ MCI_STEP, "MCI_STEP" },
{ MCI_RECORD, "MCI_RECORD" },
{ MCI_SYSINFO, "MCI_SYSINFO" },
{ MCI_BREAK, "MCI_BREAK" },
{ MCI_SOUND, "MCI_SOUND" },
{ MCI_SAVE, "MCI_SAVE" },
{ MCI_STATUS, "MCI_STATUS" },
{ MCI_CUE, "MCI_CUE" },
{ MCI_REALIZE, "MCI_REALIZE" },
{ MCI_WINDOW, "MCI_WINDOW" },
{ MCI_PUT, "MCI_PUT" },
{ MCI_WHERE, "MCI_WHERE" },
{ MCI_FREEZE, "MCI_FREEZE" },
{ MCI_UNFREEZE, "MCI_UNFREEZE" },
{ MCI_LOAD, "MCI_LOAD" },
{ MCI_CUT, "MCI_CUT" },
{ MCI_COPY, "MCI_COPY" },
{ MCI_PASTE, "MCI_PASTE" },
{ MCI_UPDATE, "MCI_UPDATE" },
{ MCI_RESUME, "MCI_RESUME" },
{ MCI_DELETE, "MCI_DELETE" }
};
#endif
//
// The following are required for the dynamic linking of Multi-Media code
// from within WOW. They are all defined in wmmedia.c
//
extern FARPROC mmAPIEatCmdEntry;
extern FARPROC mmAPIGetParamSize;
extern FARPROC mmAPISendCmdW;
extern FINDCMDITEM mmAPIFindCmdItem;
/**********************************************************************\
*
* ThunkMciCommand16
*
* This function converts a 16 bit mci command request into an
* equiverlant 32 bit request.
*
* The ideas behind this function were stolen from ThunkWMMsg16,
* see wmsg16.c and mciDebugOut see mci.c
*
* We return 0 if the thunk was OK, any other value should be used as
* an error code. If the thunk failed all allocated resources will
* be freed by this function. If the thunk was sucessful (ie. returned 0)
* UnThunkMciCommand16 MUST be called to free allocated resources.
*
* Here are the assumptions that I have used to perform the thunking:
*
* 1. MCI_OPEN is a special case.
*
* 2. If the message is NOT defined in mmsystem.h then it is treated as a
* "user" command. If a user command table is associated with the given
* device ID we use this command table as an aid to perform the thunking.
* If a user command table is NOT associated with the device ID the
* command does NOT GET THUNKED, we return straight away, calling
* mciSendCommand only to get a relevant error code.
*
* 3. If the command IS defined in mmsystem.h we perfrom a "manual" thunk
* of the command IF the associated PARMS structure contains ReservedX
* fields. We mask out the associated flags as each field is thunked.
*
* 4. If there are any flags left then we use the command table
* as an aid to perform the thunking.
*
\**********************************************************************/
INT ThunkMciCommand16( MCIDEVICEID DeviceID, UINT OrigCommand, DWORD OrigFlags,
DWORD OrigParms, PDWORD pNewParms, LPWSTR *lplpCommand,
PUINT puTable )
{
#if DBG
register int i;
int n;
dprintf3(( "ThunkMciCommand16 :" ));
dprintf5(( " OrigDevice -> %lX", DeviceID ));
n = sizeof(mciMessageNames) / sizeof(MCI_MESSAGE_NAMES);
for ( i = 0; i < n; i++ ) {
if ( mciMessageNames[i].uMsg == OrigCommand ) {
break;
}
}
dprintf3(( "OrigCommand -> 0x%lX", (DWORD)OrigCommand ));
//
// Special case MCI_STATUS. I get loads of these from mplayer.
// I only want to display MCI_STATUS messages if the debug level is
// set to level 3, that way I won't get swamped with them.
//
if ( mciMessageNames[i].uMsg != MCI_STATUS ) {
if ( i != n ) {
dprintf2(( "Command Name -> %s", mciMessageNames[i].lpstMsgName ));
}
else {
dprintf2(( "Command Name -> UNKNOWN COMMAND (%x)", OrigCommand ));
}
}
else {
dprintf3(( "Command Name -> MCI_STATUS" ));
}
dprintf5(( "OrigFlags -> 0x%lX", OrigFlags ));
dprintf5(( "OrigParms -> 0x%lX", OrigParms ));
#endif
//
// Get some storage for the Mci parameter block, and handle the
// notify window handle (if supplied).
//
if ( (*pNewParms = AllocMciParmBlock( &OrigFlags, OrigParms )) == 0L ) {
return MCIERR_OUT_OF_MEMORY;
}
//
// We thunk the MCI_OPEN command and all other commands that contain a
// "ReservedX" field in their PARMS structure here. We mask out each
// flag as it is processed, if any flags are left we use the command
// table to complete the thunk.
//
// The following commands have ReservedX fields:
// MCI_WINDOW
// MCI_SET
//
// This means that MOST COMMANDS GET THUNKED VIA THE COMMAND TABLE.
//
switch ( OrigCommand ) {
case MCI_OPEN:
//
// MCI_OPEN is a special case message that I don't
// how to deal with yet.
//
ThunkOpenCmd( &OrigFlags, OrigParms, *pNewParms );
return 0;
//
// The next four commands have Reserved padding fields
// these have to thunked manually.
//
case MCI_SET:
ThunkSetCmd( DeviceID, &OrigFlags, OrigParms, *pNewParms );
break;
case MCI_WINDOW:
ThunkWindowCmd( DeviceID, &OrigFlags, OrigParms, *pNewParms );
break;
//
// Have to special case this command because the command table
// is not correct.
//
case MCI_SETVIDEO:
ThunkSetVideoCmd( DeviceID, &OrigFlags, OrigParms, *pNewParms );
break;
//
// These two commands don't have any command extensions
// so we return immediately.
//
case MCI_SYSINFO:
ThunkSysInfoCmd( &OrigFlags, OrigParms, *pNewParms );
return 0;
case MCI_BREAK:
ThunkBreakCmd( &OrigFlags, OrigParms, *pNewParms );
return 0;
}
//
// Find the command table for the given command ID.
// We always load the command table this is because the command table is
// needed for UnThunking.
//
*lplpCommand = (*mmAPIFindCmdItem)( DeviceID, NULL, (LPWSTR)OrigCommand,
NULL, puTable );
//
// If the command table is not found we return straight away.
// Note that storage has been allocated for pNewParms and that the
// MCI_WAIT and MCI_NOTIFY flags have been thunked.
// We do not return an error here, but call mciSendCommand to
// let it determine a suitable error code, we must also call
// UnthunkMciCommand to free the allocated storage.
//
if ( *lplpCommand == NULL ) {
dprintf(( "Command table not found !!" ));
return 0;
}
dprintf4(( "Command table has been loaded -> 0x%lX", *lplpCommand ));
//
// If OrigFlags is not equal to 0 we still have work to do !
// Note that this will be true for the majority of cases.
//
if ( OrigFlags ) {
dprintf3(( "Thunking via command table" ));
//
// Now we thunk the command
//
return ThunkCommandViaTable( *lplpCommand, OrigFlags, OrigParms,
*pNewParms );
}
return 0;
}
/**********************************************************************\
* AllocMciParmBlock
*
* Get some storage for the Mci parameter block. I always allocate
* MCI_MAX_PARAM_SLOTS * DWORD amount as this allows for any command
* extensions.
*
* As we know that the first dword field is a Window handle
* this field is taken care of here. Also the MCI_WAIT flag is
* masked out if it is set.
*
\**********************************************************************/
DWORD AllocMciParmBlock( PDWORD pOrigFlags, DWORD OrigParms )
{
LPMCI_GENERIC_PARMS lpGenParms;
PMCI_GENERIC_PARMS16 lpGenParmsOrig;
UINT AllocSize = sizeof(DWORD) * MCI_MAX_PARAM_SLOTS;
//
// Get, check and set the required storage.
//
lpGenParms = (LPMCI_GENERIC_PARMS)malloc_w( AllocSize );
if ( lpGenParms == NULL ) {
return 0L;
}
RtlZeroMemory( lpGenParms, AllocSize );
dprintf4(( "AllocMciParmBlock: Allocated storage -> 0x%lX", lpGenParms ));
//
// Look for the notify flag and thunk accordingly
//
if ( *pOrigFlags & MCI_NOTIFY ) {
GETVDMPTR( OrigParms, sizeof(MCI_GENERIC_PARMS16), lpGenParmsOrig );
dprintf4(( "AllocMciParmBlock: Got MCI_NOTIFY flag." ));
// Note FETCHWORD of a DWORD below, same as LOWORD(FETCHDWORD(dw)),
// only faster.
lpGenParms->dwCallback =
(DWORD)HWND32( FETCHWORD( lpGenParmsOrig->dwCallback ) );
FREEVDMPTR( lpGenParmsOrig );
*pOrigFlags ^= MCI_NOTIFY;
}
//
// If the MCI_WAIT flag is present, mask it out.
//
if ( *pOrigFlags & MCI_WAIT ) {
dprintf4(( "AllocMciParmBlock: Got MCI_WAIT flag." ));
*pOrigFlags ^= MCI_WAIT;
}
return (DWORD)lpGenParms;
}
/**********************************************************************\
* ThunkOpenCmd
*
* Thunk the Open mci command parms.
\**********************************************************************/
DWORD ThunkOpenCmd( PDWORD pOrigFlags, DWORD OrigParms, DWORD pNewParms )
{
//
// The purpose of this union is to aid the creation of a 32 bit
// Open Parms structure that is suitable for all known MCI devices.
//
typedef union {
MCI_OPEN_PARMS OpenParms;
MCI_WAVE_OPEN_PARMS OpenWaveParms;
MCI_ANIM_OPEN_PARMS OpenAnimParms; // Note: Animation and
MCI_OVLY_OPEN_PARMS OpenOvlyParms; // overlay parms are identical
} MCI_ALL_OPEN_PARMS, *PMCI_ALL_OPEN_PARMS;
//
// The following pointers will be used to point to
// the original 16-bit Parms structure.
//
PMCI_OPEN_PARMS16 lpOpenParms16;
PMCI_WAVE_OPEN_PARMS16 lpOpenWaveParms16;
//
// Note: MCI_ANIM_OPEN_PARMS16 and MCI_OVLY_OPEN_PARMS16 structures are
// identical.
//
PMCI_ANIM_OPEN_PARMS16 lpOpenAnimParms16;
//
// pOp will point to the 32 bit open Parms structure after
// we have finished all the thunking.
//
PMCI_ALL_OPEN_PARMS pOp = (PMCI_ALL_OPEN_PARMS)pNewParms;
//
// We first do the fields that are common to all open requests.
// Set up the VDM ptr for lpOpenParms16 to point to OrigParms
//
GETVDMPTR( OrigParms, sizeof(MCI_OPEN_PARMS16), lpOpenParms16 );
//
// Now scan our way thru all the known MCI_OPEN flags, thunking as
// necessary.
//
// Start at the Device Type field
//
if ( *pOrigFlags & MCI_OPEN_TYPE ) {
if ( *pOrigFlags & MCI_OPEN_TYPE_ID ) {
dprintf4(( "ThunkOpenCmd: Got MCI_OPEN_TYPE_ID flag." ));
pOp->OpenParms.lpstrDeviceType =
(LPSTR)( FETCHDWORD( lpOpenParms16->lpstrDeviceType ) );
dprintf5(( "lpstrDeviceType -> %ld", pOp->OpenParms.lpstrDeviceType ));
*pOrigFlags ^= (MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID);
}
else {
dprintf4(( "ThunkOpenCmd: Got MCI_OPEN_TYPE flag" ));
GETPSZPTR( lpOpenParms16->lpstrDeviceType,
pOp->OpenParms.lpstrDeviceType );
dprintf5(( "lpstrDeviceType -> %s", pOp->OpenParms.lpstrDeviceType ));
dprintf5(( "lpstrDeviceType -> 0x%lX", pOp->OpenParms.lpstrDeviceType ));
*pOrigFlags ^= MCI_OPEN_TYPE;
}
}
//
// Now do the Element Name field
//
if ( *pOrigFlags & MCI_OPEN_ELEMENT ) {
if ( *pOrigFlags & MCI_OPEN_ELEMENT_ID ) {
dprintf4(( "ThunkOpenCmd: Got MCI_OPEN_ELEMENT_ID flag" ));
pOp->OpenParms.lpstrElementName =
(LPSTR)( FETCHDWORD( lpOpenParms16->lpstrElementName ) );
dprintf5(( "lpstrElementName -> %ld", pOp->OpenParms.lpstrElementName ));
*pOrigFlags ^= (MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID);
}
else {
dprintf4(( "ThunkOpenCmd: Got MCI_OPEN_ELEMENT flag" ));
GETPSZPTR( lpOpenParms16->lpstrElementName,
pOp->OpenParms.lpstrElementName );
dprintf5(( "lpstrElementName -> %s", pOp->OpenParms.lpstrElementName ));
dprintf5(( "lpstrElementName -> 0x%lX", pOp->OpenParms.lpstrElementName ));
*pOrigFlags ^= MCI_OPEN_ELEMENT;
}
}
//
// Now do the Alias Name field
//
if ( *pOrigFlags & MCI_OPEN_ALIAS ) {
dprintf4(( "ThunkOpenCmd: Got MCI_OPEN_ALIAS flag" ));
GETPSZPTR( lpOpenParms16->lpstrAlias, pOp->OpenParms.lpstrAlias );
dprintf5(( "lpstrAlias -> %s", pOp->OpenParms.lpstrAlias ));
dprintf5(( "lpstrAlias -> 0x%lX", pOp->OpenParms.lpstrAlias ));
*pOrigFlags ^= MCI_OPEN_ALIAS;
}
//
// Clear the MCI_OPEN_SHAREABLE flag if it is set
//
if ( *pOrigFlags & MCI_OPEN_SHAREABLE ) {
dprintf4(( "ThunkOpenCmd: Got MCI_OPEN_SHAREABLE flag." ));
*pOrigFlags ^= MCI_OPEN_SHAREABLE;
}
//
// Free the VDM pointer before returning
//
FREEVDMPTR( lpOpenParms16 );
//
// If we don't have any extended flags I can return now
//
if ( *pOrigFlags == 0 ) {
return (DWORD)pOp;
}
//
// If there are any flags left then these are intended for an extended
// form of MCI open. Three different forms are known, these being:
// MCI_ANIM_OPEN_PARMS
// MCI_OVLY_OPEN_PARMS
// MCI_WAVE_OPEN_PARMS
//
// If I could tell what sort of device I had I could thunk the
// extensions with no problems, but we don't have a device ID yet
// so I can't figure out what sort of device I have without parsing
// the parameters that I already know about.
//
// But, I am in luck; MCI_WAVE_OPEN_PARMS has one extended parameter
// dwBufferSeconds which has a MCI_WAVE_OPEN_BUFFER flag associated with
// it. This field is also a DWORD in the other two parms structures.
//
if ( *pOrigFlags & MCI_WAVE_OPEN_BUFFER ) {
//
// Set up the VDM ptr for lpOpenWaveParms16 to point to OrigParms
//
GETVDMPTR( OrigParms, sizeof(MCI_WAVE_OPEN_PARMS16),
lpOpenWaveParms16 );
dprintf4(( "ThunkOpenCmd: Got MCI_WAVE_OPEN_BUFFER flag." ));
pOp->OpenWaveParms.dwBufferSeconds =
FETCHDWORD( lpOpenWaveParms16->dwBufferSeconds );
dprintf5(( "dwBufferSeconds -> %ld", pOp->OpenWaveParms.dwBufferSeconds ));
//
// Free the VDM pointer before returning
//
FREEVDMPTR( lpOpenWaveParms16 );
*pOrigFlags ^= MCI_WAVE_OPEN_BUFFER;
}
//
// Now look for MCI_ANIM_OPEN_PARM and MCI_OVLY_OPEN_PARMS extensions.
//
if ( (*pOrigFlags & MCI_ANIM_OPEN_PARENT)
|| (*pOrigFlags & MCI_ANIM_OPEN_WS) ) {
//
// Set up the VDM ptr for lpOpenAnimParms16 to point to OrigParms
//
GETVDMPTR( OrigParms, sizeof(MCI_ANIM_OPEN_PARMS16),
lpOpenAnimParms16 );
//
// Check MCI_ANIN_OPEN_PARENT flag, this also checks
// the MCI_OVLY_OPEN_PARENT flag too.
//
if ( *pOrigFlags & MCI_ANIM_OPEN_PARENT ) {
dprintf4(( "ThunkOpenCmd: Got MCI_Xxxx_OPEN_PARENT flag." ));
pOp->OpenAnimParms.hWndParent =
HWND32(FETCHWORD(lpOpenAnimParms16->hWndParent) );
*pOrigFlags ^= MCI_ANIM_OPEN_PARENT;
}
//
// Check MCI_ANIN_OPEN_WS flag, this also checks
// the MCI_OVLY_OPEN_WS flag too.
//
if ( *pOrigFlags & MCI_ANIM_OPEN_WS ) {
dprintf4(( "ThunkOpenCmd: Got MCI_Xxxx_OPEN_WS flag." ));
pOp->OpenAnimParms.dwStyle =
FETCHDWORD( lpOpenAnimParms16->dwStyle );
dprintf5(( "dwStyle -> %ld", pOp->OpenAnimParms.dwStyle ));
*pOrigFlags ^= MCI_ANIM_OPEN_WS;
}
//
// Free the VDM pointer before returning
//
FREEVDMPTR( lpOpenAnimParms16 );
}
//
// Check the MCI_ANIN_OPEN_NOSTATIC flag
//
if ( *pOrigFlags & MCI_ANIM_OPEN_NOSTATIC ) {
dprintf4(( "ThunkOpenCmd: Got MCI_ANIM_OPEN_NOSTATIC flag." ));
*pOrigFlags ^= MCI_ANIM_OPEN_NOSTATIC;
}
return (DWORD)pOp;
}
/**********************************************************************\
* ThunkSetCmd
*
* Thunk the ThunkSetCmd mci command parms.
*
* The following are "basic" flags that all devices must support.
* MCI_SET_AUDIO
* MCI_SET_DOOR_CLOSED
* MCI_SET_DOOR_OPEN
* MCI_SET_TIME_FORMAT
* MCI_SET_VIDEO
* MCI_SET_ON
* MCI_SET_OFF
*
* The following are "extended" flags that "sequencer" devices support.
* MCI_SEQ_SET_MASTER
* MCI_SEQ_SET_OFFSET
* MCI_SEQ_SET_PORT
* MCI_SEQ_SET_SLAVE
* MCI_SEQ_SET_TEMPO
*
* The following are "extended" flags that "sequencer" devices support.
* MCI_WAVE_INPUT
* MCI_WAVE_OUTPUT
* MCI_WAVE_SET_ANYINPUT
* MCI_WAVE_SET_ANYOUTPUT
* MCI_WAVE_SET_AVGBYTESPERSEC
* MCI_WAVE_SET_BITSPERSAMPLES
* MCI_WAVE_SET_BLOCKALIGN
* MCI_WAVE_SET_CHANNELS
* MCI_WAVE_SET_FORMAT_TAG
* MCI_WAVE_SET_SAMPLESPERSEC
*
\**********************************************************************/
DWORD ThunkSetCmd( MCIDEVICEID DeviceID, PDWORD pOrigFlags, DWORD OrigParms,
DWORD pNewParms )
{
//
// This purpose of this union is to aid the creation of a 32 bit Set
// Parms structure that is suitable for all known MCI devices.
//
typedef union {
MCI_SET_PARMS SetParms;
MCI_WAVE_SET_PARMS SetWaveParms;
MCI_SEQ_SET_PARMS SetSeqParms;
} MCI_ALL_SET_PARMS, *PMCI_ALL_SET_PARMS;
//
// The following pointers will be used to point to the original
// 16-bit Parms structure.
//
PMCI_SET_PARMS16 lpSetParms16;
PMCI_WAVE_SET_PARMS16 lpSetWaveParms16;
PMCI_SEQ_SET_PARMS16 lpSetSeqParms16;
//
// pSet will point to the 32 bit Set Parms structure after
// we have finished all the thunking.
//
PMCI_ALL_SET_PARMS pSet = (PMCI_ALL_SET_PARMS)pNewParms;
//
// GetDevCaps is used to determine what sort of device are dealing
// with. We need this information to determine if we should use
// standard, wave or sequencer MCI_SET structure.
//
MCI_GETDEVCAPS_PARMS GetDevCaps;
DWORD dwRetVal;
//
// Set up the VDM ptr for lpSetParms16 to point to OrigParms
//
GETVDMPTR( OrigParms, sizeof(MCI_SET_PARMS16), lpSetParms16 );
//
// First do the fields that are common to all devices. Thunk the
// dwAudio field.
//
if ( *pOrigFlags & MCI_SET_AUDIO ) {
dprintf4(( "ThunkSetCmd: Got MCI_SET_AUDIO flag." ));
pSet->SetParms.dwAudio = FETCHDWORD( lpSetParms16->dwAudio );
dprintf5(( "dwAudio -> %ld", pSet->SetParms.dwAudio ));
*pOrigFlags ^= MCI_SET_AUDIO; // Mask out the flag
}
//
// Thunk the dwTimeFormat field.
//
if ( *pOrigFlags & MCI_SET_TIME_FORMAT ) {
dprintf4(( "ThunkSetCmd: Got MCI_SET_TIME_FORMAT flag." ));
pSet->SetParms.dwTimeFormat = FETCHDWORD( lpSetParms16->dwTimeFormat );
dprintf5(( "dwTimeFormat -> %ld", pSet->SetParms.dwTimeFormat ));
*pOrigFlags ^= MCI_SET_TIME_FORMAT; // Mask out the flag
}
//
// Mask out the MCI_SET_DOOR_CLOSED
//
if ( *pOrigFlags & MCI_SET_DOOR_CLOSED ) {
dprintf4(( "ThunkSetCmd: Got MCI_SET_DOOR_CLOSED flag." ));
*pOrigFlags ^= MCI_SET_DOOR_CLOSED; // Mask out the flag
}
//
// Mask out the MCI_SET_DOOR_OPEN
//
if ( *pOrigFlags & MCI_SET_DOOR_OPEN ) {
dprintf4(( "ThunkSetCmd: Got MCI_SET_DOOR_OPEN flag." ));
*pOrigFlags ^= MCI_SET_DOOR_OPEN; // Mask out the flag
}
//
// Mask out the MCI_SET_VIDEO
//
if ( *pOrigFlags & MCI_SET_VIDEO ) {
dprintf4(( "ThunkSetCmd: Got MCI_SET_VIDEO flag." ));
*pOrigFlags ^= MCI_SET_VIDEO; // Mask out the flag
}
//
// Mask out the MCI_SET_ON
//
if ( *pOrigFlags & MCI_SET_ON ) {
dprintf4(( "ThunkSetCmd: Got MCI_SET_ON flag." ));
*pOrigFlags ^= MCI_SET_ON; // Mask out the flag
}
//
// Mask out the MCI_SET_OFF
//
if ( *pOrigFlags & MCI_SET_OFF ) {
dprintf4(( "ThunkSetCmd: Got MCI_SET_OFF flag." ));
*pOrigFlags ^= MCI_SET_OFF; // Mask out the flag
}
//
// Free the VDM pointer as we have finished with it
//
FREEVDMPTR( lpSetParms16 );
//
// We have done all the standard flags. If there are any flags
// still set we must have an extended command.
//
if ( *pOrigFlags == 0 ) {
return (DWORD)pSet;
}
//
// Now we need to determine what type of device we are
// dealing with. We can do this by send an MCI_GETDEVCAPS
// command to the device. (We might as well use the Unicode
// version of mciSendCommand and avoid another thunk).
//
RtlZeroMemory( &GetDevCaps, sizeof(MCI_GETDEVCAPS_PARMS) );
GetDevCaps.dwItem = MCI_GETDEVCAPS_DEVICE_TYPE;
dwRetVal = (*mmAPISendCmdW)( DeviceID, MCI_GETDEVCAPS, MCI_GETDEVCAPS_ITEM,
(DWORD)&GetDevCaps );
//
// What do we do if dwRetCode is not equal to 0 ? If this is the
// case it probably means that we have been given a duff device ID,
// anyway it is pointless to carry on with the thunk so I will clear
// the *pOrigFlags variable and return. This means that the 32 bit version
// of mciSendCommand will get called with only half the message thunked,
// but as there is probably already a problem with the device or
// the device ID is duff, mciSendCommand should be able to work out a
// suitable error code to return to the application.
//
if ( dwRetVal ) {
*pOrigFlags = 0;
return (DWORD)pSet;
}
switch ( GetDevCaps.dwReturn ) {
case MCI_DEVTYPE_WAVEFORM_AUDIO:
//
// Set up the VDM ptr for lpSetWaveParms16 to point to OrigParms
//
dprintf3(( "ThunkSetCmd: Got a WaveAudio device." ));
GETVDMPTR( OrigParms, sizeof(MCI_WAVE_SET_PARMS16),
lpSetWaveParms16 );
//
// Thunk the wInput field.
//
if ( *pOrigFlags & MCI_WAVE_INPUT ) {
dprintf4(( "ThunkSetCmd: Got MCI_WAVE_INPUT flag." ));
pSet->SetWaveParms.wInput =
FETCHWORD( lpSetWaveParms16->wInput );
dprintf5(( "wInput -> %u", pSet->SetWaveParms.wInput ));
*pOrigFlags ^= MCI_WAVE_INPUT;
}
//
// Thunk the wOutput field.
//
if ( *pOrigFlags & MCI_WAVE_OUTPUT ) {
dprintf4(( "ThunkSetCmd: Got MCI_WAVE_OUTPUT flag." ));
pSet->SetWaveParms.wOutput =
FETCHWORD( lpSetWaveParms16->wOutput );
dprintf5(( "wOutput -> %u", pSet->SetWaveParms.wOutput ));
*pOrigFlags ^= MCI_WAVE_OUTPUT;
}
//
// Thunk the wFormatTag field.
//
if ( *pOrigFlags & MCI_WAVE_SET_FORMATTAG ) {
dprintf4(( "ThunkSetCmd: Got MCI_WAVE_SET_FORMATTAG flag." ));
pSet->SetWaveParms.wFormatTag =
FETCHWORD( lpSetWaveParms16->wFormatTag );
dprintf5(( "wFormatTag -> %u", pSet->SetWaveParms.wFormatTag ));
*pOrigFlags ^= MCI_WAVE_SET_FORMATTAG;
}
//
// Thunk the nChannels field.
//
if ( *pOrigFlags & MCI_WAVE_SET_CHANNELS ) {
dprintf4(( "ThunkSetCmd: Got MCI_WAVE_SET_CHANNELS flag." ));
pSet->SetWaveParms.nChannels =
FETCHWORD( lpSetWaveParms16->nChannels );
dprintf5(( "nChannels -> %u", pSet->SetWaveParms.nChannels ));
*pOrigFlags ^= MCI_WAVE_SET_CHANNELS;
}
//
// Thunk the nSamplesPerSec field.
//
if ( *pOrigFlags & MCI_WAVE_SET_SAMPLESPERSEC ) {
dprintf4(( "ThunkSetCmd: Got MCI_WAVE_SET_SAMPLESPERSEC flag." ));
pSet->SetWaveParms.nSamplesPerSec =
FETCHDWORD( lpSetWaveParms16->nSamplesPerSecond );
dprintf5(( "nSamplesPerSec -> %u", pSet->SetWaveParms.nSamplesPerSec ));
*pOrigFlags ^= MCI_WAVE_SET_SAMPLESPERSEC;
}
//
// Thunk the nAvgBytesPerSec field.
//
if ( *pOrigFlags & MCI_WAVE_SET_AVGBYTESPERSEC ) {
dprintf4(( "ThunkSetCmd: Got MCI_WAVE_SET_AVGBYTESPERSEC flag." ));
pSet->SetWaveParms.nAvgBytesPerSec =
FETCHDWORD( lpSetWaveParms16->nAvgBytesPerSec );
dprintf5(( "nAvgBytesPerSec -> %u", pSet->SetWaveParms.nAvgBytesPerSec ));
*pOrigFlags ^= MCI_WAVE_SET_AVGBYTESPERSEC;
}
//
// Thunk the nBlockAlign field.
//
if ( *pOrigFlags & MCI_WAVE_SET_BLOCKALIGN ) {
dprintf4(( "ThunkSetCmd: Got MCI_WAVE_SET_BLOCKALIGN flag." ));
pSet->SetWaveParms.nBlockAlign =
FETCHWORD( lpSetWaveParms16->nBlockAlign );
dprintf5(( "nBlockAlign -> %u", pSet->SetWaveParms.nBlockAlign ));
*pOrigFlags ^= MCI_WAVE_SET_BLOCKALIGN;
}
//
// Thunk the nBitsPerSample field.
//
if ( *pOrigFlags & MCI_WAVE_SET_BITSPERSAMPLE ) {
dprintf4(( "ThunkSetCmd: Got MCI_WAVE_SET_BITSPERSAMPLE flag." ));
pSet->SetWaveParms.wBitsPerSample =
FETCHWORD( lpSetWaveParms16->wBitsPerSample );
dprintf5(( "wBitsPerSamples -> %u", pSet->SetWaveParms.wBitsPerSample ));
*pOrigFlags ^= MCI_WAVE_SET_BITSPERSAMPLE;
}
FREEVDMPTR( lpSetWaveParms16 );
break;
case MCI_DEVTYPE_SEQUENCER:
//
// Set up the VDM ptr for lpSetSeqParms16 to point to OrigParms
//
dprintf3(( "ThunkSetCmd: Got a Sequencer device." ));
GETVDMPTR( OrigParms, sizeof(MCI_WAVE_SET_PARMS16),
lpSetSeqParms16 );
//
// Thunk the dwMaster field.
//
if ( *pOrigFlags & MCI_SEQ_SET_MASTER ) {
dprintf4(( "ThunkSetCmd: Got MCI_SEQ_SET_MASTER flag." ));
pSet->SetSeqParms.dwMaster =
FETCHDWORD( lpSetSeqParms16->dwMaster );
dprintf5(( "dwMaster -> %ld", pSet->SetSeqParms.dwMaster ));
*pOrigFlags ^= MCI_SEQ_SET_MASTER;
}
//
// Thunk the dwPort field.
//
if ( *pOrigFlags & MCI_SEQ_SET_PORT ) {
dprintf4(( "ThunkSetCmd: Got MCI_SEQ_SET_PORT flag." ));
pSet->SetSeqParms.dwPort =
FETCHDWORD( lpSetSeqParms16->dwPort );
dprintf5(( "dwPort -> %ld", pSet->SetSeqParms.dwPort ));
*pOrigFlags ^= MCI_SEQ_SET_PORT;
}
//
// Thunk the dwOffset field.
//
if ( *pOrigFlags & MCI_SEQ_SET_OFFSET ) {
dprintf4(( "ThunkSetCmd: Got MCI_SEQ_SET_OFFSET flag." ));
pSet->SetSeqParms.dwOffset=
FETCHDWORD( lpSetSeqParms16->dwOffset );
dprintf5(( "dwOffset -> %ld", pSet->SetSeqParms.dwOffset ));
*pOrigFlags ^= MCI_SEQ_SET_OFFSET;
}
//
// Thunk the dwSlave field.
//
if ( *pOrigFlags & MCI_SEQ_SET_SLAVE ) {
dprintf4(( "ThunkSetCmd: Got MCI_SEQ_SET_SLAVE flag." ));
pSet->SetSeqParms.dwSlave =
FETCHDWORD( lpSetSeqParms16->dwSlave );
dprintf5(( "dwSlave -> %ld", pSet->SetSeqParms.dwSlave ));
*pOrigFlags ^= MCI_SEQ_SET_SLAVE;
}
//
// Thunk the dwTempo field.
//
if ( *pOrigFlags & MCI_SEQ_SET_TEMPO ) {
dprintf4(( "ThunkSetCmd: Got MCI_SEQ_SET_TEMPO flag." ));
pSet->SetSeqParms.dwTempo =
FETCHDWORD( lpSetSeqParms16->dwTempo );
dprintf5(( "dwTempo -> %ld", pSet->SetSeqParms.dwTempo ));
*pOrigFlags ^= MCI_SEQ_SET_TEMPO;
}
FREEVDMPTR( lpSetSeqParms16 );
break;
}
return (DWORD)pSet;
}
/**********************************************************************\
* ThunkSetVideoCmd
*
* Thunk the SetVideo mci command parms.
*
\**********************************************************************/
DWORD ThunkSetVideoCmd( MCIDEVICEID DeviceID, PDWORD pOrigFlags,
DWORD OrigParms, DWORD pNewParms )
{
//
// The following pointers will be used to point to the original
// 16-bit Parms structure.
//
LPMCI_DGV_SETVIDEO_PARMS lpSetParms16;
//
// pSet will point to the 32 bit SetVideo Parms structure after
// we have finished all the thunking.
//
LPMCI_DGV_SETVIDEO_PARMS pSet = (LPMCI_DGV_SETVIDEO_PARMS)pNewParms;
//
// Set up the VDM ptr for lpSetParms16 to point to OrigParms
//
GETVDMPTR( OrigParms, sizeof(MCI_DGV_SETVIDEO_PARMS), lpSetParms16 );
if ( *pOrigFlags & MCI_DGV_SETVIDEO_ITEM ) {
dprintf4(( "ThunkSetVideoCmd: Got MCI_DGV_SETVIDEO_ITEM flag." ));
pSet->dwItem = FETCHDWORD( lpSetParms16->dwItem );
dprintf5(( "dwItem -> %ld", pSet->dwItem ));
*pOrigFlags ^= MCI_DGV_SETVIDEO_ITEM; // Mask out the flag
}
if ( *pOrigFlags & MCI_DGV_SETVIDEO_VALUE ) {
if ( pSet->dwItem == MCI_DGV_SETVIDEO_PALHANDLE ) {
HPAL16 hpal16;
dprintf4(( "ThunkSetVideoCmd: Got MCI_DGV_SETVIDEO_PALHANLE." ));
hpal16 = (HPAL16)LOWORD( FETCHDWORD( lpSetParms16->dwValue ) );
pSet->dwValue = (DWORD)HPALETTE32( hpal16 );
dprintf5(( "\t-> 0x%X", hpal16 ));
}
else {
dprintf4(( "ThunkSetVideoCmd: Got an MCI_INTEGER." ));
pSet->dwValue = FETCHDWORD( lpSetParms16->dwValue );
dprintf5(( "dwValue -> %ld", pSet->dwValue ));
}
*pOrigFlags ^= MCI_DGV_SETVIDEO_VALUE; // Mask out the flag
}
//
// Turn off the MCI_SET_ON FLAG.
//
if ( *pOrigFlags & MCI_SET_ON ) {
dprintf4(( "ThunkSetVideoCmd: Got MCI_SET_ON flag." ));
*pOrigFlags ^= MCI_SET_ON; // Mask out the flag
}
//
// Turn off the MCI_SET_OFF FLAG.
//
if ( *pOrigFlags & MCI_SET_OFF ) {
dprintf4(( "ThunkSetVideoCmd: Got MCI_SET_OFF flag." ));
*pOrigFlags ^= MCI_SET_OFF; // Mask out the flag
}
return (DWORD)pSet;
}
/**********************************************************************\
* ThunkSysInfoCmd
*
* Thunk the SysInfo mci command parms.
\**********************************************************************/
DWORD ThunkSysInfoCmd( PDWORD pOrigFlags, DWORD OrigParms, DWORD pNewParms )
{
//
// lpSysInfoParms16 points to the 16 bit parameter block
// passed to us by the WOW application.
//
PMCI_SYSINFO_PARMS16 lpSysInfoParms16;
//
// pSys will point to the 32 bit SysInfo Parms structure after
// we have finished all the thunking.
//
PMCI_SYSINFO_PARMS pSys = (PMCI_SYSINFO_PARMS)pNewParms;
//
// Set up the VDM ptr for lpSysInfoParms16 to point to OrigParms
//
GETVDMPTR( OrigParms, sizeof(MCI_SYSINFO_PARMS16), lpSysInfoParms16 );
//
// Thunk the dwRetSize, dwNumber and wDeviceType parameters.
//
pSys->dwRetSize = FETCHDWORD( lpSysInfoParms16->dwRetSize );
dprintf5(( "dwRetSize -> %ld", pSys->dwRetSize ));
pSys->dwNumber = FETCHDWORD( lpSysInfoParms16->dwNumber );
dprintf5(( "dwNumber -> %ld", pSys->dwNumber ));
pSys->wDeviceType = (DWORD)FETCHWORD( lpSysInfoParms16->wDeviceType );
dprintf5(( "wDeviceType -> %ld", pSys->wDeviceType ));
//
// Thunk lpstrReturn
//
if ( pSys->dwRetSize > 0 ) {
GETVDMPTR( lpSysInfoParms16->lpstrReturn, pSys->dwRetSize,
pSys->lpstrReturn );
dprintf5(( "lpstrReturn -> 0x%lX", lpSysInfoParms16->lpstrReturn ));
}
else {
dprintf1(( "ThunkSysInfoCmd: lpstrReturn is 0 bytes long !!!" ));
/* lpstrReturn has been set to NULL by RtlZeroMemory above */
}
//
// Free the VDM pointer as we have finished with it
//
FREEVDMPTR( lpSysInfoParms16 );
return (DWORD)pSys;
}
/**********************************************************************\
* ThunkBreakCmd
*
* Thunk the Break mci command parms.
\**********************************************************************/
DWORD ThunkBreakCmd( PDWORD pOrigFlags, DWORD OrigParms, DWORD pNewParms )
{
//
// lpBreakParms16 points to the 16 bit parameter block
// passed to us by the WOW application.
//
PMCI_BREAK_PARMS16 lpBreakParms16;
//
// pBrk will point to the 32 bit Break Parms structure after
// we have finished all the thunking.
//
PMCI_BREAK_PARMS pBrk = (PMCI_BREAK_PARMS)pNewParms;
//
// Set up the VDM ptr for lpBreakParms16 to point to OrigParms
//
GETVDMPTR( OrigParms, sizeof(MCI_BREAK_PARMS16), lpBreakParms16 );
//
// Check for the MCI_BREAK_KEY flag
//
if ( *pOrigFlags & MCI_BREAK_KEY ) {
dprintf4(( "ThunkBreakCmd: Got MCI_BREAK_KEY flag." ));
pBrk->nVirtKey = (int)FETCHWORD( lpBreakParms16->nVirtKey );
dprintf5(( "nVirtKey -> %d", pBrk->nVirtKey ));
}
//
// Check for the MCI_BREAK_HWND flag
//
if ( *pOrigFlags & MCI_BREAK_HWND ) {
dprintf4(( "ThunkBreakCmd: Got MCI_BREAK_HWND flag." ));
pBrk->hwndBreak = HWND32(FETCHWORD(lpBreakParms16->hwndBreak));
}
//
// Free the VDM pointer as we have finished with it
//
FREEVDMPTR( lpBreakParms16 );
return (DWORD)pBrk;
}
/**********************************************************************\
* ThunkWindowCmd
*
* Thunk the mci Window command parms.
\**********************************************************************/
DWORD ThunkWindowCmd( MCIDEVICEID DeviceID, PDWORD pOrigFlags, DWORD OrigParms,
DWORD pNewParms )
{
//
// lpAni will point to the 32 bit Anim Window Parms
// structure after we have finished all the thunking.
//
PMCI_ANIM_WINDOW_PARMS lpAni = (PMCI_ANIM_WINDOW_PARMS)pNewParms;
//
// lpAniParms16 point to the 16 bit parameter block
// passed to us by the WOW application.
//
PMCI_ANIM_WINDOW_PARMS16 lpAniParms16;
//
// GetDevCaps is used to determine what sort of device are dealing
// with. We need this information to determine if we should use
// overlay or animation MCI_WINDOW structure.
//
MCI_GETDEVCAPS_PARMS GetDevCaps;
DWORD dwRetVal;
//
// Now we need to determine what type of device we are
// dealing with. We can do this by send an MCI_GETDEVCAPS
// command to the device. (We might as well use the Unicode
// version of mciSendCommand and avoid another thunk).
//
RtlZeroMemory( &GetDevCaps, sizeof(MCI_GETDEVCAPS_PARMS) );
GetDevCaps.dwItem = MCI_GETDEVCAPS_DEVICE_TYPE;
dwRetVal = (*mmAPISendCmdW)( DeviceID, MCI_GETDEVCAPS, MCI_GETDEVCAPS_ITEM,
(DWORD)&GetDevCaps );
//
// What do we do if dwRetCode is not equal to 0 ? If this is the
// case it probably means that we have been given a duff device ID,
// anyway it is pointless to carry on with the thunk so I will clear
// the *pOrigFlags variable and return. This means that the 32 bit version
// of mciSendCommand will get called with only half the message thunked,
// but as there is probably already a problem with the device or
// the device ID is duff, mciSendCommand should be able to work out a
// suitable error code to return to the application.
//
if ( dwRetVal ) {
*pOrigFlags = 0;
return pNewParms;
}
//
// Do we have an Animation or Overlay device type ?
// Because Animation and Overlay have identical flags and
// parms structures they can share the same code.
//
if ( GetDevCaps.dwReturn == MCI_DEVTYPE_ANIMATION
|| GetDevCaps.dwReturn == MCI_DEVTYPE_OVERLAY
|| GetDevCaps.dwReturn == MCI_DEVTYPE_DIGITAL_VIDEO ) {
//
// Set up the VDM ptr for lpWineParms16 to point to OrigParms
//
GETVDMPTR( OrigParms, sizeof(MCI_ANIM_WINDOW_PARMS16),
lpAniParms16 );
//
// Check for the MCI_ANIM_WINDOW_TEXT
//
if ( *pOrigFlags & MCI_ANIM_WINDOW_TEXT ) {
dprintf4(( "ThunkWindowCmd: Got MCI_Xxxx_WINDOW_TEXT flag." ));
GETPSZPTR( lpAniParms16->lpstrText, lpAni->lpstrText );
dprintf5(( "lpstrText -> %s", lpAni->lpstrText ));
dprintf5(( "lpstrText -> 0x%lX", lpAni->lpstrText ));
*pOrigFlags ^= MCI_ANIM_WINDOW_TEXT;
}
//
// Check for the MCI_ANIM_WINDOW_HWND flag
//
if ( *pOrigFlags & MCI_ANIM_WINDOW_HWND ) {
dprintf4(( "ThunkWindowCmd: Got MCI_Xxxx_WINDOW_HWND flag." ));
lpAni->hWnd = HWND32( FETCHWORD( lpAniParms16->hWnd ) );
dprintf5(( "hWnd -> 0x%lX", lpAni->hWnd ));
*pOrigFlags ^= MCI_ANIM_WINDOW_HWND;
}
//
// Check for the MCI_ANIM_WINDOW_STATE flag
//
if ( *pOrigFlags & MCI_ANIM_WINDOW_STATE ) {
dprintf4(( "ThunkWindowCmd: Got MCI_Xxxx_WINDOW_STATE flag." ));
lpAni->nCmdShow = FETCHWORD( lpAniParms16->nCmdShow );
dprintf5(( "nCmdShow -> 0x%lX", lpAni->nCmdShow ));
*pOrigFlags ^= MCI_ANIM_WINDOW_STATE;
}
//
// Check for the MCI_ANIM_WINDOW_DISABLE_STRETCH flag
//
if ( *pOrigFlags & MCI_ANIM_WINDOW_DISABLE_STRETCH ) {
dprintf4(( "ThunkWindowCmd: Got MCI_Xxxx_WINDOW_DISABLE_STRETCH flag." ));
*pOrigFlags ^= MCI_ANIM_WINDOW_DISABLE_STRETCH;
}
//
// Check for the MCI_ANIM_WINDOW_ENABLE_STRETCH flag
//
if ( *pOrigFlags & MCI_ANIM_WINDOW_ENABLE_STRETCH ) {
dprintf4(( "ThunkWindowCmd: Got MCI_Xxxx_WINDOW_ENABLE_STRETCH flag." ));
*pOrigFlags ^= MCI_ANIM_WINDOW_ENABLE_STRETCH;
}
//
// Free the VDM pointer as we have finished with it
//
FREEVDMPTR( lpAniParms16 );
return (DWORD)lpAni;
}
return pNewParms;
}
/**********************************************************************\
* ThunkCommandViaTable
*
\**********************************************************************/
INT ThunkCommandViaTable( LPWSTR lpCommand, DWORD dwFlags, DWORD OrigParms,
DWORD pNewParms )
{
#if DBG
static LPSTR f_name = "ThunkCommandViaTable: ";
#endif
LPWSTR lpFirstParameter;
UINT wID;
DWORD dwValue;
UINT wOffset16, wOffset1stParm16;
UINT wOffset32, wOffset1stParm32;
UINT wParamSize;
DWORD dwParm16;
PDWORD pdwOrig16;
PDWORD pdwParm32;
DWORD dwMask = 1;
//
// Calculate the size of this command parameter block in terms
// of bytes, then get a VDM pointer to the OrigParms.
//
GETVDMPTR( OrigParms, GetSizeOfParameter( lpCommand ), pdwOrig16 );
dprintf3(( "%s16 bit Parms -> %lX", f_name, pdwOrig16 ));
//
// Skip past command entry
//
lpCommand = (LPWSTR)((LPBYTE)lpCommand +
(*mmAPIEatCmdEntry)( lpCommand, NULL, NULL ));
//
// Get the next entry
//
lpFirstParameter = lpCommand;
//
// Skip past the DWORD return value
//
wOffset1stParm32 = wOffset1stParm16 = 4;
lpCommand = (LPWSTR)((LPBYTE)lpCommand +
(*mmAPIEatCmdEntry)( lpCommand, &dwValue, &wID ));
//
// If it is a return value, skip it
//
if ( wID == MCI_RETURN ) {
//
// Look for a string return type, these are a special case.
//
if ( dwValue == MCI_STRING ) {
DWORD dwStrlen;
LPSTR *lplpStr;
//
// Get string pointer and length
//
dwParm16 = FETCHDWORD(*(LPDWORD)((LPBYTE)pdwOrig16 + 4));
dwStrlen = FETCHDWORD(*(LPDWORD)((LPBYTE)pdwOrig16 + 8));
//
// Copy string pointer
//
lplpStr = (LPSTR *)((LPBYTE)pNewParms + 4);
if ( dwStrlen > 0 ) {
GETVDMPTR( dwParm16, dwStrlen, *lplpStr );
dprintf5(( "%sReturn string -> 0x%lX", f_name, *lplpStr ));
dprintf5(( "%sReturn length -> 0x%lX", f_name, dwStrlen ));
}
//
// Copy string length
//
pdwParm32 = (LPDWORD)((LPBYTE)pNewParms + 8);
*pdwParm32 = dwStrlen;
}
//
// Adjust the offset of the first parameter. Remember that RECTS
// are a different size in 16-bit world.
//
wParamSize = (*mmAPIGetParamSize)( dwValue, wID );
wOffset1stParm16 += (dwValue == MCI_RECT ? sizeof(RECT16) : wParamSize);
wOffset1stParm32 += wParamSize;
//
// Save the new first parameter
//
lpFirstParameter = lpCommand;
}
//
// Walk through each flag
//
while ( dwMask != 0 ) {
//
// Is this bit set?
//
if ( (dwFlags & dwMask) != 0 ) {
wOffset16 = wOffset1stParm16;
wOffset32 = wOffset1stParm32;
lpCommand = (LPWSTR)((LPBYTE)lpFirstParameter +
(*mmAPIEatCmdEntry)( lpFirstParameter,
&dwValue, &wID ));
//
// What parameter uses this bit?
//
while ( wID != MCI_END_COMMAND && dwValue != dwMask ) {
wParamSize = (*mmAPIGetParamSize)( dwValue, wID );
wOffset16 += (wID == MCI_RECT ? sizeof( RECT16 ) : wParamSize);
wOffset32 += wParamSize;
if ( wID == MCI_CONSTANT ) {
while ( wID != MCI_END_CONSTANT ) {
lpCommand = (LPWSTR)((LPBYTE)lpCommand +
(*mmAPIEatCmdEntry)( lpCommand, NULL, &wID ));
}
}
lpCommand = (LPWSTR)((LPBYTE)lpCommand +
(*mmAPIEatCmdEntry)( lpCommand, &dwValue, &wID ));
}
if ( wID != MCI_END_COMMAND ) {
//
// Thunk the argument if there is one. The argument is at
// wOffset16 from the start of OrigParms.
// This offset is in bytes.
//
dprintf5(( "%sOffset 16 -> 0x%lX", f_name, wOffset16 ));
dprintf5(( "%sOffset 32 -> 0x%lX", f_name, wOffset32 ));
if ( wID != MCI_FLAG ) {
dwParm16 = FETCHDWORD(*(LPDWORD)((LPBYTE)pdwOrig16 + wOffset16));
pdwParm32 = (LPDWORD)((LPBYTE)pNewParms + wOffset32);
}
switch ( wID ) {
case MCI_STRING:
{
LPSTR str16 = (LPSTR)dwParm16;
LPSTR str32 = (LPSTR)*pdwParm32;
dprintf4(( "%sGot STRING flag -> 0x%lX", f_name, dwMask ));
GETPSZPTR( str16, str32 );
dprintf5(( "%s\t-> 0x%lX", f_name, *pdwParm32 ));
dprintf5(( "%s\t-> %s", f_name, *pdwParm32 ));
}
break;
case MCI_HWND:
{
HWND16 hwnd16;
dprintf4(( "%sGot HWND flag -> 0x%lX", f_name, dwMask ));
hwnd16 = (HWND16)LOWORD( dwParm16 );
*pdwParm32 = (DWORD)HWND32( hwnd16 );
dprintf5(( "\t-> 0x%X", hwnd16 ));
}
break;
case MCI_HPAL:
{
HPAL16 hpal16;
dprintf4(( "%sGot HPAL flag -> 0x%lX", f_name, dwMask ));
hpal16 = (HPAL16)LOWORD( dwParm16 );
*pdwParm32 = (DWORD)HPALETTE32( hpal16 );
dprintf5(( "\t-> 0x%X", hpal16 ));
}
break;
case MCI_HDC:
{
HDC16 hdc16;
dprintf4(( "%sGot HDC flag -> 0x%lX", f_name, dwMask ));
hdc16 = (HDC16)LOWORD( dwParm16 );
*pdwParm32 = (DWORD)HDC32( hdc16 );
dprintf5(( "\t-> 0x%X", hdc16 ));
}
break;
case MCI_RECT:
{
PRECT16 pRect16 = (PRECT16)((LPBYTE)pdwOrig16 + wOffset16);
PRECT pRect32 = (PRECT)pdwParm32;
dprintf4(( "%sGot RECT flag -> 0x%lX", f_name, dwMask ));
pRect32->top = (LONG)pRect16->top;
pRect32->bottom = (LONG)pRect16->bottom;
pRect32->left = (LONG)pRect16->left;
pRect32->right = (LONG)pRect16->right;
}
break;
case MCI_CONSTANT:
case MCI_INTEGER:
dprintf4(( "%sGot INTEGER flag -> 0x%lX", f_name, dwMask ));
*pdwParm32 = dwParm16;
dprintf5(( "\t-> 0x%lX", dwParm16 ));
break;
}
}
}
//
// Go to the next flag
//
dwMask <<= 1;
}
//
// Free the VDM pointer as we have finished with it
//
FREEVDMPTR( pdwOrig16 );
return 0;
}
/**********************************************************************\
* GetSizeOfParameter
*
\**********************************************************************/
UINT GetSizeOfParameter( LPWSTR lpCommand )
{
#if DBG
static LPSTR f_name = "GetSizeOfParameter";
#endif
UINT wOffset;
UINT wID;
DWORD dwValue;
//
// Skip past command entry
//
lpCommand = (LPWSTR)((LPBYTE)lpCommand + (*mmAPIEatCmdEntry)( lpCommand,
NULL, NULL ));
//
// Skip past the DWORD return value
//
wOffset = 4;
//
// Get the first parameter slot entry
//
lpCommand = (LPWSTR)((LPBYTE)lpCommand +
(*mmAPIEatCmdEntry)( lpCommand, &dwValue, &wID ));
//
// If it is a return value, skip it
//
if ( wID == MCI_RETURN ) {
//
// Don't forget that RECT's are smaller in 16-bit world.
// Other parameters are OK though
//
if ( dwValue == MCI_RECT ) {
wOffset += sizeof( RECT16 );
}
else {
wOffset += (*mmAPIGetParamSize)( dwValue, wID );
}
//
// Get first proper entry that is not a return field.
//
lpCommand = (LPWSTR)((LPBYTE)lpCommand +
(*mmAPIEatCmdEntry)( lpCommand, &dwValue, &wID ));
}
//
// What parameter uses this bit?
//
while ( wID != MCI_END_COMMAND ) {
//
// Don't forget that RECT's are smaller in 16-bit world.
// Other parameters are OK though
//
if ( wID == MCI_RECT ) {
wOffset += sizeof( RECT16 );
}
else {
wOffset += (*mmAPIGetParamSize)( dwValue, wID );
}
//
// If we have a constant we need to skip the entries in
// the command table.
//
if ( wID == MCI_CONSTANT ) {
while ( wID != MCI_END_CONSTANT ) {
lpCommand = (LPWSTR)((LPBYTE)lpCommand
+ (*mmAPIEatCmdEntry)( lpCommand, NULL, &wID ));
}
}
//
// Get the next entry
//
lpCommand = (LPWSTR)((LPBYTE)lpCommand
+ (*mmAPIEatCmdEntry)( lpCommand, &dwValue, &wID ));
}
dprintf4(( "%sSizeof Cmd Params -> %u bytes", f_name, wOffset ));
return wOffset;
}
#if DBG
/*--------------------------------------------------------------------*\
MCI WOW DEBUGGING FUNCTIONS
\*--------------------------------------------------------------------*/
/**********************************************************************\
* wow32MciDebugOutput
*
* Output a formated message to the debug terminal.
*
\**********************************************************************/
VOID wow32MciDebugOutput( LPSTR lpszFormatStr, ... )
{
CHAR buf[256];
UINT n;
va_list va;
va_start(va, lpszFormatStr);
n = vsprintf(buf, lpszFormatStr, va);
va_end(va);
buf[n++] = '\n';
buf[n] = 0;
OutputDebugString(buf);
}
/**********************************************************************\
* wow32MciSetDebugLevel
*
* Query and set the debug level.
\**********************************************************************/
VOID wow32MciSetDebugLevel( VOID )
{
int DebugLevel;
//
// First see if a specific WOW32MCI key has been defined.
// If one hasn't been defined DebugLevel will be set to '999'.
//
DebugLevel = (int)GetProfileInt( "MMDEBUG", "WOW32MCI", 999 );
//
// If DebugLevel == '999' then an WOW32MCI key has not been defined,
// so try a "WOW32" key. This time if the key has not been defined
// set the debug level to 0, ie. no debugging info should be
// displayed.
//
if ( DebugLevel == 999 ) {
DebugLevel = (int)GetProfileInt( "MMDEBUG", "WOW32", 0 );
}
mmDebugLevel = DebugLevel;
}
#endif
#endif