able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/mvdm/wow32/wmmedia2.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

3383 lines
106 KiB
C
Raw Blame History

/***********************************************************************\
*
* WOW v1.0
*
* Copyright (c) 1991, Microsoft Corporation
*
* WMMEDIA2.C
* WOW32 16-bit MultiMedia API support
*
* Contains:
* Midi IN apis
* Midi OUT apis
* Wave IN apis
* Wave OUT apis
*
*
* History:
* Created 21-Jan-1992 by Mike Tricker (MikeTri), after jeffpar
* Changed 15-Jul-1992 by Mike Tricker (MikeTri), fixing GetDevCaps calls
* 26-Jul-1992 by Stephen Estrop (StephenE) thunks for mciSendCommand
* 30-Jul-1992 by Mike Tricker (MikeTri), fixing Wave/Midi/MMIO
* 03-Aug-1992 by Mike Tricker (MikeTri), added proper error handling
* 08-Oct-1992 by StephenE spawned from the original wmmedia.c
*
\***********************************************************************/
//
// 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
#define OEMRESOURCE
#include "precomp.h"
#pragma hdrstop
#if 0
MODNAME(wmmedia2.c);
// A 32 bit ptr to the 16 bit callback data
extern PCALLBACK_DATA pCallBackData;
extern CRITICAL_SECTION mmCriticalSection;
#if DBG
/*
** AllocCount maintains a count of the number XXM_DONE messages that
** we expect to receive before the device is closed. When the device is
** closed this count should be zero.
**
*/
int AllocWaveCount = 0;
int AllocMidiCount = 0;
int mmTraceWave = 0;
int mmTraceMidi = 0;
#endif
/* ---------------------------------------------------------------------
** MIDI Output API's
** ---------------------------------------------------------------------
*/
/**********************************************************************\
*
* WMM32midiOutGetNumDevs
*
* This function retrieves the number of MIDI output devices present
* in the system.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiOutGetNumDevs(PVDMFRAME pFrame)
{
static FARPROC mmAPI = NULL;
ULONG ul;
UNREFERENCED_PARAMETER(pFrame);
GET_MULTIMEDIA_API( "midiOutGetNumDevs", mmAPI, MMSYSERR_NODRIVER );
trace_midi(( "midiOutGetNumDevs()" ));
ul = GETWORD16((*mmAPI)() );
trace_midi(( "-> %ld\n", ul ));
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiOutGetDevCaps
*
* This function queries a specified MIDI output device to determine its
* capabilities.
*
*
*
* We will now change things...
*
* Step 1: get the ENTIRE Caps structure, irrespective of the number of bytes
* requested
* (previously I was getting the requested number of bytes via
* parg16->f3 (plus 2 'cos of the WORD -> UINT change for version -
* which was wrong anyway...) )
*
* Step 2: thunk the ENTIRE structure in to a 16 bit local variable
*
* Step 3: RtlCopyMemory the REQUESTED number of bytes from the local copy
* to the "real" structure within the app
*
* Thanks to RCBS for sorting me out once again !
*
*
*
\**********************************************************************/
ULONG FASTCALL WMM32midiOutGetDevCaps(PVDMFRAME pFrame)
{
register PMIDIOUTGETDEVCAPS16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
MIDIOUTCAPS midioutcaps;
GET_MULTIMEDIA_API( "midiOutGetDevCapsA", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTGETDEVCAPS16), parg16);
trace_midi(( "midiOutGetDevCaps( %x, %x, %x )", INT32( parg16->f1 ),
DWORD32( parg16->f2 ), UINT32( parg16->f3 ) ));
/*
** If the size parameter was zero return straight away. Note that this
** is not an error.
*/
if ( UINT32( parg16->f3 ) == 0 ) {
ul = MMSYSERR_NOERROR;
}
else {
ul = GETWORD16((*mmAPI)( INT32(parg16->f1), &midioutcaps,
sizeof(MIDIOUTCAPS) ));
/*
** This must now thunk the ENTIRE structure, then copy parg16->f3
** bytes onto the "real" structure in the app, but only if the call
** returned success.
*/
if ( ul == MMSYSERR_NOERROR ) {
ul = PUTMIDIOUTCAPS16(parg16->f2, &midioutcaps, UINT32(parg16->f3));
}
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiOutGetErrorText
*
* This function retrieves a textual description of the error
* identified by the specified error number.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiOutGetErrorText(PVDMFRAME pFrame)
{
register PMIDIOUTGETERRORTEXT16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul = MMSYSERR_NOERROR;
PSZ pszText;
GET_MULTIMEDIA_API( "midiOutGetErrorTextA", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTGETERRORTEXT16), parg16);
trace_midi(( "midiOutGetErrorText( %x, %x, %x )", UINT32( parg16->f1 ),
DWORD32( parg16->f2 ), UINT32( parg16->f3 ) ));
/*
** Test against a zero length string and a NULL pointer. If 0 is passed
** as the buffer length then the manual says we should return
** MMSYSERR_NOERR. MMGETOPTPTR only returns a pointer if parg16->f2 is
** not NULL.
*/
MMGETOPTPTR( parg16->f2, UINT32(parg16->f3), pszText );
if ( pszText != NULL ) {
ul = GETWORD16((*mmAPI)( UINT32(parg16->f1), pszText,
UINT32(parg16->f3) ));
FLUSHVDMPTR(DWORD32(parg16->f2), UINT32(parg16->f3), pszText);
FREEVDMPTR(pszText);
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/***********************************************************************\
*
* WMM32midiOutOpen
*
* This function opens a specified MIDI output device for playback.
*
\***********************************************************************/
ULONG FASTCALL WMM32midiOutOpen(PVDMFRAME pFrame)
{
register PMIDIOUTOPEN16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul = MMSYSERR_NOERROR;
UINT uDevID;
PINSTANCEDATA pInstanceData;
LPHMIDIOUT lpHMidiOut; // pointer to handle in 16 bit app space
HMIDIOUT Hand32; // 32bit handle
GET_MULTIMEDIA_API( "midiOutOpen", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTOPEN16), parg16);
trace_midi(( "midiOutOpen( %x, %x, %x, %x, %x )",
DWORD32( parg16->f1 ), INT32 ( parg16->f2 ),
DWORD32( parg16->f3 ), DWORD32( parg16->f4 ),
DWORD32( parg16->f5 ) ));
/*
** Get the device ID. We use INT32 here not UINT32 to make sure that
** negative values (such as MIDI_MAPPER (-1)) get thunked correctly.
*/
uDevID = (UINT)INT32(parg16->f2);
/*
** Map the 16 bit pointer is one was specified.
*/
MMGETOPTPTR( parg16->f1, sizeof(HMIDIOUT16), lpHMidiOut );
if ( lpHMidiOut ) {
/*
** Create InstanceData block to be used by our callback routine.
**
** NOTE: Although we malloc it here we don't free it.
** This is not a mistake - it must not be freed before the
** callback routine has used it - so it does the freeing.
**
** If the malloc fails we bomb down to the bottom,
** set ul to MMSYSERR_NOMEM and exit gracefully.
**
** We always have a callback functions. This is to ensure that
** the MIDIHDR structure keeps getting copied back from
** 32 bit space to 16 bit, as it contains flags which
** applications are liable to keep checking.
*/
if ( pInstanceData = malloc_w(sizeof(INSTANCEDATA)) ) {
dprintf2(( "WM32midiOutOpen: Allocated instance buffer at %8X",
pInstanceData ));
pInstanceData->dwCallback = DWORD32(parg16->f3);
pInstanceData->dwCallbackInstance = DWORD32(parg16->f4);
pInstanceData->dwFlags = DWORD32(parg16->f5);
ul = GETWORD16((*mmAPI)( &Hand32, uDevID,
(DWORD)W32CommonDeviceOpen,
(DWORD)pInstanceData,
CALLBACK_FUNCTION ));
}
else {
ul = MMSYSERR_NOMEM;
}
/*
** If the call returns success update the 16 bit handle,
** otherwise don't, and free the memory we malloc'd earlier, as
** the callback that would have freed it will never get callled.
*/
if ( ul == MMSYSERR_NOERROR ) {
HMIDIOUT16 Hand16 = GETHMIDIOUT16(Hand32);
trace_midi(( "Handle -> %x", Hand16 ));
STOREWORD ( *lpHMidiOut, Hand16 );
FLUSHVDMPTR( DWORD32(parg16->f1), sizeof(HMIDIOUT16),
lpHMidiOut );
}
/*
** We only free the memory if we actually allocated any
*/
else if ( pInstanceData ) {
free_w(pInstanceData);
}
/*
** Regardless of sucess or failure we need to free the pointer
** to the 16 bit MidiIn handle.
*/
FREEVDMPTR ( lpHMidiOut );
}
else {
ul = MMSYSERR_INVALPARAM;
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiOutClose
*
* This function closes the specified MIDI output device.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiOutClose(PVDMFRAME pFrame)
{
register PMIDIOUTCLOSE16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
GET_MULTIMEDIA_API( "midiOutClose", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTCLOSE16), parg16);
trace_midi(( "midiOutClose( %x )", WORD32( parg16->f1 ) ));
ul = GETWORD16( (*mmAPI)(HMIDIOUT32(parg16->f1) ));
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiOutPrepareHeader
*
* This function prepares the specified midiform header.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiOutPrepareHeader(PVDMFRAME pFrame)
{
register PMIDIOUTPREPAREHEADER3216 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
MIDIHDR midihdr;
GET_MULTIMEDIA_API( "midiOutPrepareHeader", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTPREPAREHEADER3216), parg16);
trace_midi(( "midiOutPrepareHeader( %x %x %x)", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ), WORD32( parg16->f3 ) ));
GETMIDIHDR16(parg16->f2, &midihdr);
ul = GETWORD16((*mmAPI)( HMIDIOUT32(parg16->f1),
&midihdr, WORD32(parg16->f3) ) );
/*
** Only update the 16 bit structure if the call returns success
**
*/
if ( !ul ) {
PUTMIDIHDR16(parg16->f2, &midihdr);
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiOutUnprepareHeader
*
* This function prepares the specified midiform header.
* This function cleans up the preparation performed by midiOutPrepareHeader.
* The function must be called after the device driver has finished with a
* data block. You must call this function before freeing the data buffer.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiOutUnprepareHeader(PVDMFRAME pFrame)
{
register PMIDIOUTUNPREPAREHEADER3216 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
MIDIHDR midihdr;
GET_MULTIMEDIA_API( "midiOutUnprepareHeader", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTUNPREPAREHEADER3216), parg16);
trace_midi(( "midiOutUnprepareHeader( %x %x %x)", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ), WORD32( parg16->f3 ) ));
GETMIDIHDR16(parg16->f2, &midihdr);
ul = GETWORD16((*mmAPI)( HMIDIOUT32(parg16->f1),
&midihdr, WORD32(parg16->f3) ) );
/*
** Only update the 16 bit structure if the call returns success
*/
if (!ul) {
PUTMIDIHDR16(parg16->f2, &midihdr);
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiOutShortMsg
*
* This function sends a short MIDI message to the specified MIDI output device.
* Use this function to send any MIDI message except for system exclusive
* messages.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiOutShortMsg(PVDMFRAME pFrame)
{
register PMIDIOUTSHORTMSG16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
GET_MULTIMEDIA_API( "midiOutShortMsg", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTSHORTMSG16), parg16);
trace_midi(( "midiOutShortMsg( %x, %x )", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ) ));
ul = GETWORD16((*mmAPI)( HMIDIOUT32(parg16->f1), DWORD32(parg16->f2) ));
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiOutLongMsg
*
* This function sends a long MIDI message to the specified MIDI output
* device. Use this function to send system exclusive messages or to
* send a buffer filled with short messages.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiOutLongMsg(PVDMFRAME pFrame)
{
register PMIDIOUTLONGMSG16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
PMIDIHDR32 pMidihdr32;
GET_MULTIMEDIA_API( "midiOutLongMsg", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTLONGMSG16), parg16);
trace_midi(( "midiOutLongMsg( %x, %x, %x )", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ), UINT32( parg16->f3 ) ));
/*
** If the given size of the MIDIHDR structure is too small
** or the lphdr is invalid return an error
**
*/
if ( UINT32(parg16->f3) < sizeof(MIDIHDR16)
|| HIWORD( DWORD32(parg16->f2) ) == 0 ) {
ul = MMSYSERR_INVALPARAM;
}
else {
if ( pMidihdr32 = malloc_w(sizeof(MIDIHDR32)) ) {
PMIDIHDR lpwhdr;
#if DBG
AllocMidiCount++;
dprintf2(( "M>> %8X (%d)", pMidihdr32, AllocMidiCount ));
#endif
/* Copy across the midi header stuff. Note that lpwhdr (a
** 32 bit ptr to a 32 bit midi header) is used to make the
** pointer stuff a bit less hairy.
**
** pMidihdr32->pMidihdr32 is a 32 bit ptr to a 16 bit midi header
** pMidihdr32->pMidihdr16 is a 16 bit ptr to a 16 bit midi header
** pMidihdr32->Midihdr is a 32 bit midi header
*/
lpwhdr = &(pMidihdr32->Midihdr);
pMidihdr32->pMidihdr16 = (PMIDIHDR16)DWORD32(parg16->f2);
pMidihdr32->pMidihdr32 = GETMIDIHDR16(DWORD32(parg16->f2), lpwhdr);
/*
** GETMIDIHDR16 can return NULL, in which case we should set
** lpwhdr to NULL too and call midiOutLongMessage only to get the
** correct error code.
*/
if ( pMidihdr32->pMidihdr32 == NULL ) {
lpwhdr = NULL;
}
ul = GETWORD16( (*mmAPI)( HMIDIOUT32(parg16->f1), lpwhdr,
UINT32(parg16->f3) ) );
/*
** If the call fails we need to free the memory we malloc'd
** above, as the callback that would have freed it will never
** get called.
**
*/
if ( ul == MMSYSERR_NOERROR ) {
/*
** Make sure we reflect any changes that midiOutLongMessage did
** to the MIDIHDR back to 16 bit land.
**
** This is important because some apps poll the
** MHDR_DONE bit !!
*/
COPY_MIDIOUTHDR16_FLAGS( pMidihdr32->pMidihdr32,
pMidihdr32->Midihdr );
}
else {
#if DBG
AllocMidiCount--;
dprintf2(( "M<< \t%8X (%d)", pMidihdr32,
AllocMidiCount ));
#endif
free_w( pMidihdr32 );
}
}
else {
ul = MMSYSERR_NOMEM;
}
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiOutReset
*
* This function turns off all notes on al MIDI channels for the specified
* MIDI output deice.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiOutReset(PVDMFRAME pFrame)
{
register PMIDIOUTRESET16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
GET_MULTIMEDIA_API( "midiOutReset", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTRESET16), parg16);
trace_midi(( "midiOutReset( %x )", WORD32( parg16->f1 ) ));
ul = GETWORD16((*mmAPI)( HMIDIOUT32(parg16->f1) ));
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiOutGetVolume
*
* This function returns the current volume setting of a MIDI output device.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiOutGetVolume(PVDMFRAME pFrame)
{
register PMIDIOUTGETVOLUME16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
LPDWORD lpdwVolume;
DWORD dwVolume;
GET_MULTIMEDIA_API( "midiOutGetVolume", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTGETVOLUME16), parg16);
trace_midi(( "midiOutGetVolume( %x, %x )", INT32( parg16->f1 ),
DWORD32( parg16->f2 ) ));
ul = GETWORD16((*mmAPI)( INT32(parg16->f1), &dwVolume ));
if ( ul == MMSYSERR_NOERROR ) {
MMGETOPTPTR( parg16->f2, sizeof(DWORD), lpdwVolume);
if ( lpdwVolume ) {
STOREDWORD ( *lpdwVolume, dwVolume );
FLUSHVDMPTR( DWORD32(parg16->f2), sizeof(DWORD), lpdwVolume );
FREEVDMPTR ( lpdwVolume );
}
else {
ul = MMSYSERR_INVALPARAM;
}
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiOutSetVolume
*
* This function sets the volume of a MIDI output device.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiOutSetVolume(PVDMFRAME pFrame)
{
register PMIDIOUTSETVOLUME16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
GET_MULTIMEDIA_API( "midiOutSetVolume", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTSETVOLUME16), parg16);
trace_midi(( "midiOutSetVolume( %x, %x )", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ) ));
ul = GETWORD16((*mmAPI)( INT32(parg16->f1), DWORD32(parg16->f2) ));
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiOutCachePatches
*
* This function requests that an internal MIDI synthesizer device preload a
* specified set of patches. Some synthesizers are not capable of keeping all
* patches loaded simultaneously and must load data from disk when they receive
* MIDI program change messages. Caching patches ensures specified patches are
* immediately available.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiOutCachePatches(PVDMFRAME pFrame)
{
register PMIDIOUTCACHEPATCHES16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul = MMSYSERR_INVALPARAM;
LPPATCHARRAY lppa1;
GET_MULTIMEDIA_API( "midiOutCachePatches", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTCACHEPATCHES16), parg16);
trace_midi(( "midiOutCachePatches( %x, %x, %x, %x )", WORD32( parg16->f1 ),
UINT32( parg16->f2 ), DWORD32( parg16->f3 ),
UINT32( parg16->f4 ) ));
/*
** GETMISCPTR checks that parg16->f3 is not zero so we need not bother.
*/
GETMISCPTR( DWORD32( parg16->f3 ), lppa1 );
if ( lppa1 ) {
ul = GETWORD16((*mmAPI)( HMIDIOUT32(parg16->f1), UINT32(parg16->f2),
lppa1, UINT32(parg16->f4) ));
FREEMISCPTR( lppa1 );
}
else {
dprintf1(( "WMM32midiOutCachePatches passed a NULL pointer" ));
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiOutCacheDrumPatches
*
* This function requests that an internal MIDI synthesizer device preload a
* specified set of key-based percussion patches. Some synthesizers are not
* capable of keeping all percussion patches loaded simultaneously. Caching
* patches ensures specified patches are immediately available.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiOutCacheDrumPatches(PVDMFRAME pFrame)
{
register PMIDIOUTCACHEDRUMPATCHES16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul = MMSYSERR_INVALPARAM;
LPKEYARRAY lpka1;
GET_MULTIMEDIA_API( "midiOutCacheDrumPatches", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTCACHEDRUMPATCHES16), parg16);
trace_midi(( "midiOutCacheDrumPatches( %x, %x, %x, %x )",
WORD32( parg16->f1 ), UINT32( parg16->f2 ),
DWORD32( parg16->f3 ), UINT32( parg16->f4 ) ));
GETMISCPTR( DWORD32( parg16->f3 ), lpka1 );
if ( lpka1 ) {
ul = GETWORD16((*mmAPI)( HMIDIOUT32(parg16->f1), UINT32(parg16->f2),
lpka1, UINT32(parg16->f4) ) );
FREEMISCPTR(lpka1);
}
else {
dprintf1(( "WMM32midiOutCacheDrumPatches passed a NULL pointer" ));
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiOutGetID
*
* This function gets the device ID for a MIDI output device.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiOutGetID(PVDMFRAME pFrame)
{
register PMIDIOUTGETID16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
UINT dwDeviceID32;
LPWORD lpwDeviceID16;
GET_MULTIMEDIA_API( "midiOutGetID", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTGETID16), parg16);
trace_midi(( "midiOutGetID( %x, %x )", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ) ));
ul = GETWORD16((*mmAPI)( (HMIDIOUT)HMIDIOUT32(parg16->f1), &dwDeviceID32 ));
/*
** Only copy the ID back to 16 bit space if the call was sucessful
**
*/
if ( ul == MMSYSERR_NOERROR ) {
MMGETOPTPTR( parg16->f2, sizeof(WORD), lpwDeviceID16 );
if ( lpwDeviceID16 ) {
STOREWORD ( *lpwDeviceID16, dwDeviceID32 );
FLUSHVDMPTR( DWORD32(parg16->f2), sizeof(WORD), lpwDeviceID16 );
FREEVDMPTR ( lpwDeviceID16 );
}
else {
ul = MMSYSERR_INVALPARAM;
}
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiOutMessage
*
* This function sends a message to the specified MIDI output device.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiOutMessage(PVDMFRAME pFrame)
{
register PMIDIOUTMESSAGE3216 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
GET_MULTIMEDIA_API( "midiOutMessage", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTMESSAGE16), parg16);
trace_midi(( "midiOutMessage( %x, %x, %x, %x )",
WORD32( parg16->f1 ), UINT32( parg16->f2 ),
DWORD32( parg16->f3 ), DWORD32( parg16->f4 ) ));
if ( (UINT32(parg16->f2) >= DRV_BUFFER_LOW)
&& (UINT32(parg16->f2) <= DRV_BUFFER_HIGH) ) {
LPDWORD lpdwParam1;
GETMISCPTR(parg16->f3, lpdwParam1);
ul = GETDWORD16((*mmAPI)( HMIDIOUT32(parg16->f1), UINT32(parg16->f2),
(DWORD)lpdwParam1, DWORD32(parg16->f4)));
FREEMISCPTR(lpdwParam1);
} else {
ul = GETDWORD16((*mmAPI)( HMIDIOUT32(parg16->f1),
MAKELONG( WORD32(parg16->f2), 0xFFFF ),
DWORD32(parg16->f3), DWORD32(parg16->f4) ));
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/* ---------------------------------------------------------------------
** MIDI Input API's
** ---------------------------------------------------------------------
*/
/**********************************************************************\
*
* WMM32midiInGetNumDevs
*
* This function retrieves the number of MIDI input devices in the system.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiInGetNumDevs(PVDMFRAME pFrame)
{
static FARPROC mmAPI = NULL;
ULONG ul;
GET_MULTIMEDIA_API( "midiInGetNumDevs", mmAPI, MMSYSERR_NODRIVER );
UNREFERENCED_PARAMETER(pFrame);
trace_midi(( "midiInGetNumDevs()" ));
ul = GETWORD16((*mmAPI)() );
trace_midi(( "-> %ld\n", ul ));
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiInGetDevCaps
*
* This function queries a specified MIDI input device to determine its
* capabilities.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiInGetDevCaps(PVDMFRAME pFrame)
{
ULONG ul;
MIDIINCAPS midiincaps1;
register PMIDIINGETDEVCAPS16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "midiInGetDevCapsA", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIINGETDEVCAPS16), parg16);
trace_midi(( "midiInGetDevCaps( %x, %x, %x )", INT32( parg16->f1 ),
DWORD32( parg16->f2 ), UINT32( parg16->f3 ) ));
if ( UINT32( parg16->f3 ) == 0 ) {
ul = MMSYSERR_NOERROR;
}
else {
ul = GETWORD16((*mmAPI)(INT32(parg16->f1), &midiincaps1,
sizeof(MIDIINCAPS) ) );
/*
** This must now thunk the ENTIRE structure, then copy parg16->f3
** bytes onto the "real" structure in the app, but only if the
** call returned success.
*/
if ( ul == MMSYSERR_NOERROR ) {
ul = PUTMIDIINCAPS16( parg16->f2, &midiincaps1, UINT32(parg16->f3) );
}
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiInGetErrorText
*
* This function retrieves a textual description of the error identified by the
* specified error number.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiInGetErrorText(PVDMFRAME pFrame)
{
register PMIDIINGETERRORTEXT16 parg16;
ULONG ul = MMSYSERR_NOERROR;
PSZ pszText;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "midiInGetErrorTextA", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR( pFrame, sizeof(MIDIINGETERRORTEXT16), parg16 );
trace_midi(( "midiInGetErrorText( %x, %x, %x )", UINT32( parg16->f1 ),
DWORD32( parg16->f2 ), UINT32( parg16->f3 ) ));
/*
** Test against a zero length string and a NULL pointer. If 0 is passed
** as the buffer length then the manual says we should return
** MMSYSERR_NOERR.
*/
MMGETOPTPTR( parg16->f2, UINT32(parg16->f3), pszText );
if ( pszText != NULL ) {
ul = GETWORD16( (*mmAPI)( UINT32(parg16->f1), pszText,
UINT32(parg16->f3) ) );
FLUSHVDMPTR( DWORD32(parg16->f2), UINT32(parg16->f3), pszText);
FREEVDMPTR( pszText );
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiInOpen
*
* This function opens a specified MIDI input device.
*
\***********************************************************************/
ULONG FASTCALL WMM32midiInOpen(PVDMFRAME pFrame)
{
ULONG ul=0;
UINT uDevID;
PINSTANCEDATA pInstanceData;
LPHMIDIIN lpHMidiIn; // pointer to handle in 16 bit app space
HMIDIIN Hand32; // 32bit handle
register PMIDIINOPEN16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "midiInOpen", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIINOPEN16), parg16);
trace_midi(( "midiInOpen( %x, %x, %x, %x, %x )",
DWORD32( parg16->f1 ), INT32 ( parg16->f2 ),
DWORD32( parg16->f3 ), DWORD32( parg16->f4 ),
DWORD32( parg16->f5 ) ));
/*
** Get the device ID. We use INT32 here not UINT32 to make sure that
** negative values (such as MIDI_MAPPER (-1)) get thunked correctly.
*/
uDevID = (UINT)INT32(parg16->f2);
/*
** Map the 16 bit pointer is one was specified.
*/
MMGETOPTPTR( parg16->f1, sizeof(HMIDIIN), lpHMidiIn );
if ( lpHMidiIn ) {
/*
** Create InstanceData block to be used by our callback routine.
**
** NOTE: Although we malloc it here we don't free it.
** This is not a mistake - it must not be freed before the
** callback routine has used it - so it does the freeing.
**
** If the malloc fails we bomb down to the bottom,
** set ul to MMSYSERR_NOMEM and exit gracefully.
**
** We always have a callback functions. This is to ensure that
** the MIDIHDR structure keeps getting copied back from
** 32 bit space to 16 bit, as it contains flags which
** applications are liable to keep checking.
*/
if ( pInstanceData = malloc_w(sizeof(INSTANCEDATA) ) ) {
dprintf2(( "WM32midiInOpen: Allocated instance buffer at %8X",
pInstanceData ));
pInstanceData->dwCallback = DWORD32(parg16->f3);
pInstanceData->dwCallbackInstance = DWORD32(parg16->f4);
pInstanceData->dwFlags = DWORD32(parg16->f5);
ul = GETWORD16((*mmAPI)( &Hand32, uDevID,
(DWORD)W32CommonDeviceOpen,
(DWORD)pInstanceData,
CALLBACK_FUNCTION ));
}
else {
ul = (ULONG)MMSYSERR_NOMEM;
}
/*
** If the call returns success update the 16 bit handle,
** otherwise don't, and free the memory we malloc'd earlier, as
** the callback that would have freed it will never get callled.
*/
if ( ul == MMSYSERR_NOERROR ) {
HMIDIIN16 Hand16 = GETHMIDIIN16(Hand32);
trace_midi(( "Handle -> %x", Hand16 ));
STOREWORD ( *lpHMidiIn, Hand16 );
FLUSHVDMPTR( DWORD32(parg16->f1), sizeof(HMIDIIN), lpHMidiIn );
}
/*
** We only free the memory if we actually allocated any and the
** 32 bit call failed.
*/
else if ( pInstanceData ) {
free_w(pInstanceData);
}
/*
** Regardless of sucess or failure we need to free the pointer
** to the 16 bit MidiIn handle.
*/
FREEVDMPTR ( lpHMidiIn );
}
else {
ul = MMSYSERR_INVALPARAM;
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiInClose
*
* This function closes the specified MIDI input device.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiInClose(PVDMFRAME pFrame)
{
ULONG ul;
register PMIDIINCLOSE16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "midiInClose", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIINCLOSE16), parg16);
trace_midi(( "midiInClose( %x )", WORD32( parg16->f1 ) ));
ul = GETWORD16((*mmAPI)(HMIDIIN32(parg16->f1) ) );
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiInPrepareHeader
*
* This function prepares the specified midiform header.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiInPrepareHeader(PVDMFRAME pFrame)
{
register PMIDIOUTPREPAREHEADER3216 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
MIDIHDR midihdr;
GET_MULTIMEDIA_API( "midiInPrepareHeader", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTPREPAREHEADER3216), parg16);
trace_midi(( "midiInPrepareHeader( %x %x %x)", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ), WORD32( parg16->f3 ) ));
GETMIDIHDR16(parg16->f2, &midihdr);
ul = GETWORD16((*mmAPI)( HMIDIOUT32(parg16->f1),
&midihdr, WORD32(parg16->f3) ) );
/*
** Only update the 16 bit structure if the call returns success
**
*/
if ( !ul ) {
PUTMIDIHDR16(parg16->f2, &midihdr);
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiInUnprepareHeader
*
* This function prepares the specified midiform header.
* This function cleans up the preparation performed by midiInPrepareHeader.
* The function must be called after the device driver has finished with a
* data block. You must call this function before freeing the data buffer.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiInUnprepareHeader(PVDMFRAME pFrame)
{
register PMIDIOUTUNPREPAREHEADER3216 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
MIDIHDR midihdr;
GET_MULTIMEDIA_API( "midiInUnprepareHeader", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIOUTUNPREPAREHEADER3216), parg16);
trace_midi(( "midiInUnprepareHeader( %x %x %x)", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ), WORD32( parg16->f3 ) ));
GETMIDIHDR16(parg16->f2, &midihdr);
ul = GETWORD16((*mmAPI)( HMIDIOUT32(parg16->f1),
&midihdr, WORD32(parg16->f3) ) );
/*
** Only update the 16 bit structure if the call returns success
*/
if (!ul) {
PUTMIDIHDR16(parg16->f2, &midihdr);
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiInAddBuffer
*
* This function sends an input buffer to a specified opened MIDI input device.
* When the buffer is filled, it is sent back to the application. Input buffers
* are used only for system exclusive messages.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiInAddBuffer(PVDMFRAME pFrame)
{
ULONG ul;
PMIDIHDR32 pMidihdr32;
register PMIDIINADDBUFFER16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "midiInAddBuffer", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIINADDBUFFER16), parg16);
trace_midi(( "midiInAddBuffer( %x, %x, %x )", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ), UINT32( parg16->f3 ) ));
/*
** If the given size of the MIDIHDR structure is too small
** or the lphdr is invalid return an error
**
*/
if ( UINT32(parg16->f3) < sizeof(MIDIHDR16)
|| HIWORD( DWORD32(parg16->f2) ) == 0 ) {
ul = (ULONG)MMSYSERR_INVALPARAM;
}
else {
if (pMidihdr32 = malloc_w(sizeof(MIDIHDR32) ) ) {
PMIDIHDR lpwhdr;
#if DBG
AllocMidiCount++;
dprintf2(( "M>> %8X (%d)", pMidihdr32, AllocMidiCount ));
#endif
/* Copy across the midi header stuff. Note that lpwhdr (a
** 32 bit ptr to a 32 bit midi header) is used to make the
** pointer stuff a bit less hairy.
**
** pMidihdr32->Midihdr is a 32 bit midi header
** pMidihdr32->pMidihdr16 is a 16 bit ptr to a 16 bit midi header
** pMidihdr32->pMidihdr32 is a 32 bit ptr to a 16 bit midi header
*/
lpwhdr = &(pMidihdr32->Midihdr);
pMidihdr32->pMidihdr16 = (PMIDIHDR16)DWORD32(parg16->f2);
pMidihdr32->pMidihdr32 = GETMIDIHDR16(DWORD32(parg16->f2), lpwhdr);
/*
** GETMIDIHDR16 can return NULL, in which case we should set
** lpwhdr to NULL too and call midiInAddBuffer only to get the
** correct error code.
*/
if ( pMidihdr32->pMidihdr32 == NULL ) {
lpwhdr = NULL;
}
ul = GETWORD16((*mmAPI)( HMIDIIN32(parg16->f1), lpwhdr,
UINT32(parg16->f3) ));
/*
** If the call fails we need to free the memory we malloc'd
** above, as the callback that would have freed it will never
** get called.
**
*/
if ( ul == MMSYSERR_NOERROR ) {
/*
** Make sure we reflect any changes that midiInAddBuffer did
** to the MIDIHDR back to 16 bit land.
**
** This is important because some apps poll the
** MHDR_DONE bit !!
*/
COPY_MIDIINHDR16_FLAGS( pMidihdr32->pMidihdr32,
pMidihdr32->Midihdr );
}
else {
#if DBG
AllocMidiCount--;
dprintf2(( "M<< \t%8X (%d)", pMidihdr32,
AllocMidiCount ));
#endif
free_w( pMidihdr32 );
}
}
else {
ul = (ULONG)MMSYSERR_NOMEM;
}
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiInStart
*
* This function starts MIDI input on the specified MIDI input device.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiInStart(PVDMFRAME pFrame)
{
ULONG ul;
register PMIDIINSTART16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "midiInStart", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIINSTART16), parg16);
trace_midi(( "midiInStart( %x )", WORD32( parg16->f1 ) ));
ul = GETWORD16((*mmAPI)(HMIDIIN32(parg16->f1) ) );
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiInStop
*
* This function terminates MIDI input on the specified MIDI input device.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiInStop(PVDMFRAME pFrame)
{
ULONG ul;
register PMIDIINSTOP16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "midiInStop", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIINSTOP16), parg16);
trace_midi(( "midiInStop( %x )", WORD32( parg16->f1 ) ));
ul = GETWORD16((*mmAPI)(HMIDIIN32(parg16->f1) ) );
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiInReset
*
* This function stops input on a given MIDI input device and marks all pending
* input buffers as done.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiInReset(PVDMFRAME pFrame)
{
ULONG ul;
register PMIDIINRESET16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "midiInReset", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIINRESET16), parg16);
trace_midi(( "midiInReset( %x )", WORD32( parg16->f1 ) ));
ul = GETWORD16((*mmAPI)(HMIDIIN32(parg16->f1) ) );
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiInGetID
*
* This function gets the device ID for a MIDI input device.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiInGetID(PVDMFRAME pFrame)
{
register PMIDIINGETID16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
UINT dwDeviceID32;
LPWORD lpwDeviceID16;
GET_MULTIMEDIA_API( "midiInGetID", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIINGETID16), parg16);
trace_midi(( "midiInGetID( %x, %x )", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ) ));
ul = GETWORD16((*mmAPI)( HMIDIIN32(parg16->f1), &dwDeviceID32 ));
/*
** Only copy the ID back to 16 bit space if the call was sucessful
**
*/
if ( ul == MMSYSERR_NOERROR ) {
MMGETOPTPTR( parg16->f2, sizeof(WORD), lpwDeviceID16 );
if ( lpwDeviceID16 ) {
STOREWORD ( *lpwDeviceID16, dwDeviceID32 );
FLUSHVDMPTR( DWORD32(parg16->f2), sizeof(WORD), lpwDeviceID16 );
FREEVDMPTR ( lpwDeviceID16 );
}
else {
ul = MMSYSERR_INVALPARAM;
}
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32midiInMessage
*
* This function sends a message to the specified MIDI input device.
*
\**********************************************************************/
ULONG FASTCALL WMM32midiInMessage(PVDMFRAME pFrame)
{
ULONG ul;
register PMIDIINMESSAGE3216 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "midiInMessage", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(MIDIINMESSAGE16), parg16);
trace_midi(( "midiInMessage( %x, %x, %x, %x )",
WORD32( parg16->f1 ), UINT32( parg16->f2 ),
DWORD32( parg16->f3 ), DWORD32( parg16->f4 ) ));
if ( (UINT32(parg16->f2) >= DRV_BUFFER_LOW)
&& (UINT32(parg16->f2) <= DRV_BUFFER_HIGH) ) {
LPDWORD lpdwParam1;
GETMISCPTR(parg16->f3, lpdwParam1);
ul = GETDWORD16((*mmAPI)( HMIDIIN32(parg16->f1), UINT32(parg16->f2),
(DWORD)lpdwParam1, DWORD32(parg16->f4)));
FREEMISCPTR(lpdwParam1);
} else {
ul = GETDWORD16((*mmAPI)( HMIDIIN32(parg16->f1),
MAKELONG( WORD32(parg16->f2), 0xFFFF ),
DWORD32(parg16->f3), DWORD32(parg16->f4) ));
}
trace_midi(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/* ---------------------------------------------------------------------
** WAVE Output API's
** ---------------------------------------------------------------------
*/
/**********************************************************************\
*
* WMM32waveOutGetNumDevs
*
* This function retrieves the number of waveform output devices present in the
* system.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutGetNumDevs(PVDMFRAME pFrame)
{
static FARPROC mmAPI = NULL;
ULONG ul;
GET_MULTIMEDIA_API( "waveOutGetNumDevs", mmAPI, MMSYSERR_NODRIVER );
trace_wave(( "waveOutGetNumDevs()" ));
ul = GETWORD16((*mmAPI)() );
trace_wave(( "-> %ld\n", ul ));
RETURN(ul);
UNREFERENCED_PARAMETER(pFrame);
}
/**********************************************************************\
*
* WMM32waveOutGetDevCaps
*
* This function queries a specified waveform device to determine its
* capabilities.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutGetDevCaps(PVDMFRAME pFrame)
{
register PWAVEOUTGETDEVCAPS16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
WAVEOUTCAPS waveoutcaps;
GET_MULTIMEDIA_API( "waveOutGetDevCapsA", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTGETDEVCAPS16), parg16);
trace_wave(( "waveOutGetDevCaps( %x, %x, %x )", INT32( parg16->f1 ),
DWORD32( parg16->f2 ), UINT32( parg16->f3 ) ));
/*
** If the size parameter was zero return straight away. Note that this
** is not an error.
*/
if ( UINT32( parg16->f3 ) == 0 ) {
ul = MMSYSERR_NOERROR;
}
else {
ul = GETWORD16((*mmAPI)( INT32(parg16->f1), &waveoutcaps,
sizeof(WAVEOUTCAPS) ));
/*
** Don't update the 16 bit structure if the call failed
**
*/
if ( ul == MMSYSERR_NOERROR ) {
ul = PUTWAVEOUTCAPS16(parg16->f2, &waveoutcaps, UINT32(parg16->f3));
}
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutGetErrorText
*
* This function retrieves a textual description of the error identified by the
* specified error number.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutGetErrorText(PVDMFRAME pFrame)
{
register PWAVEOUTGETERRORTEXT16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul = MMSYSERR_NOERROR;
PSZ pszText;
GET_MULTIMEDIA_API( "waveOutGetErrorTextA", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTGETERRORTEXT16), parg16);
trace_wave(( "waveOutGetErrorText( %x, %x, %x )", UINT32( parg16->f1 ),
DWORD32( parg16->f2 ), UINT32( parg16->f3 ) ));
/*
** Test against a zero length string and a NULL pointer. If 0 is passed
** as the buffer length then the manual says we should return
** MMSYSERR_NOERR. MMGETOPTPTR only returns a pointer if parg16->f2 is
** not NULL.
*/
MMGETOPTPTR( parg16->f2, UINT32(parg16->f3), pszText );
if ( pszText != NULL ) {
ul = GETWORD16( (*mmAPI)( UINT32(parg16->f1), pszText,
UINT32(parg16->f3) ) );
FLUSHVDMPTR( DWORD32(parg16->f2), UINT32(parg16->f3), pszText);
FREEVDMPTR(pszText);
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutOpen
*
* This function opens a specified waveform output device for playback.
*
* As of November 1992 we map the 16 bit Wave Format data directly to the
* the 32 bit side, no thunking of the parameters is performed.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutOpen(PVDMFRAME pFrame)
{
ULONG ul = MMSYSERR_NOERROR;
UINT uDevID;
PINSTANCEDATA pInstanceData = NULL;
DWORD dwFlags;
PWAVEFORMAT16 lpWaveformData;
LPHWAVEOUT lphWaveOut = NULL; // pointer to handle in 16 bit app space
HWAVEOUT Hand32; // 32bit handle
register PWAVEOUTOPEN16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveOutOpen", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTOPEN16), parg16);
trace_wave(( "waveOutOpen( %x, %x, %x, %x, %x, %x )",
DWORD32( parg16->f1 ), INT32 ( parg16->f2 ),
DWORD32( parg16->f3 ), DWORD32( parg16->f4 ),
DWORD32( parg16->f5 ), DWORD32( parg16->f6 ) ));
/*
** Get the device ID. We use INT32 here not UINT32 to make sure that
** negative values (such as WAVE_MAPPER (-1)) get thunked correctly.
** Also, get the flags to be used.
*/
uDevID = (UINT)INT32(parg16->f2);
dwFlags = DWORD32(parg16->f6);
/*
** Get a pointer to the WAVEFORMAT structure. Because the format of this
** structure is exactly the same in 32 and 16 bit land I will use
** GETMISCPTR to get a generic pointer to the data. The stuff being
** pointed to could be full of unaligned WORDs, but the 32 bit code
** would have to cope with this anyway.
*/
GETMISCPTR( parg16->f3, lpWaveformData );
if ( lpWaveformData == (PWAVEFORMAT16)NULL ) {
ul = (ULONG)MMSYSERR_INVALPARAM;
goto exit_function;
}
/*
** We don't need a callback routine when the WAVE_FORMAT_QUERY flag
** is specified.
*/
if ( !(dwFlags & WAVE_FORMAT_QUERY) ) {
/*
** Map the 16 bit pointer is one was specified.
*/
MMGETOPTPTR( parg16->f1, sizeof(HWAVEOUT), lphWaveOut );
if ( lphWaveOut == NULL ) {
ul = MMSYSERR_INVALPARAM;
}
/*
** Create InstanceData block to be used by our callback routine.
**
** NOTE: Although we malloc it here we don't free it.
** This is not a mistake - it must not be freed before the
** callback routine has used it - so it does the freeing.
**
** If the malloc fails we bomb down to the bottom,
** set ul to MMSYSERR_NOMEM and exit gracefully.
**
** We always have a callback functions. This is to ensure that
** the WAVEHDR structure keeps getting copied back from
** 32 bit space to 16 bit, as it contains flags which
** applications are liable to keep checking.
*/
else if ( pInstanceData = malloc_w(sizeof(INSTANCEDATA) ) ) {
DWORD dwNewFlags = CALLBACK_FUNCTION;
dprintf2(( "WM32waveOutOpen: Allocated instance buffer at %8X",
pInstanceData ));
pInstanceData->dwCallback = DWORD32(parg16->f4);;
pInstanceData->dwCallbackInstance = DWORD32(parg16->f5);
pInstanceData->dwFlags = dwFlags;
dwNewFlags |= (dwFlags & WAVE_ALLOWSYNC);
ul = GETWORD16((*mmAPI)( &Hand32, uDevID,
(LPWAVEFORMAT)lpWaveformData,
(DWORD)W32CommonDeviceOpen,
(DWORD)pInstanceData, dwNewFlags ));
/*
** If the call returns success update the 16 bit handle,
** otherwise don't, and free the memory we malloc'd earlier, as
** the callback that would have freed it will never get callled.
*/
if ( ul == MMSYSERR_NOERROR ) {
HWAVEOUT16 Hand16 = GETHWAVEOUT16(Hand32);
trace_wave(( "Handle -> %x", Hand16 ));
STOREWORD ( *lphWaveOut, Hand16);
FLUSHVDMPTR( DWORD32(parg16->f1), sizeof(HWAVEOUT),
lphWaveOut );
}
else {
dprintf2(( "WM32waveOutOpen: Freeing instance buffer at %8X",
pInstanceData ));
free_w(pInstanceData);
}
/*
** Regardless of sucess or failure we need to free the pointer
** to the 16 bit WaveOut handle.
*/
FREEVDMPTR ( lphWaveOut );
}
else {
ul = (ULONG)MMSYSERR_NOMEM;
}
}
else {
ul = GETWORD16((*mmAPI)( NULL, uDevID, (LPWAVEFORMAT)lpWaveformData,
DWORD32(parg16->f4), DWORD32(parg16->f5),
dwFlags ));
}
/*
** Regardless of sucess or failure we need to free the pointer to the
** 16 bit WaveFormatData.
*/
FREEMISCPTR( lpWaveformData );
exit_function:
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutClose
*
* This function closes the specified waveform output device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutClose(PVDMFRAME pFrame)
{
register PWAVEOUTCLOSE16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
GET_MULTIMEDIA_API( "waveOutClose", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTCLOSE16), parg16);
trace_wave(( "waveOutClose( %x )", WORD32( parg16->f1 ) ));
ul = GETWORD16((*mmAPI)( HWAVEOUT32(parg16->f1) ));
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutPrepareHeader
*
* This function prepares the specified waveform header.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutPrepareHeader(PVDMFRAME pFrame)
{
register PWAVEOUTPREPAREHEADER3216 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
WAVEHDR wavehdr;
GET_MULTIMEDIA_API( "waveOutPrepareHeader", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTPREPAREHEADER3216), parg16);
trace_wave(( "waveOutPrepareHeader( %x %x %x)", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ), WORD32( parg16->f3 ) ));
GETWAVEHDR16(parg16->f2, &wavehdr);
ul = GETWORD16((*mmAPI)( HWAVEOUT32(parg16->f1),
&wavehdr, WORD32(parg16->f3) ) );
/*
** Only update the 16 bit structure if the call returns success
**
*/
if ( !ul ) {
PUTWAVEHDR16(parg16->f2, &wavehdr);
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutUnprepareHeader
*
* This function prepares the specified waveform header.
* This function cleans up the preparation performed by waveOutPrepareHeader.
* The function must be called after the device driver has finished with a
* data block. You must call this function before freeing the data buffer.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutUnprepareHeader(PVDMFRAME pFrame)
{
register PWAVEOUTUNPREPAREHEADER3216 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
WAVEHDR wavehdr;
GET_MULTIMEDIA_API( "waveOutUnprepareHeader", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTUNPREPAREHEADER3216), parg16);
trace_wave(( "waveOutUnprepareHeader( %x %x %x)", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ), WORD32( parg16->f3 ) ));
GETWAVEHDR16(parg16->f2, &wavehdr);
ul = GETWORD16((*mmAPI)( HWAVEOUT32(parg16->f1),
&wavehdr, WORD32(parg16->f3) ) );
/*
** Only update the 16 bit structure if the call returns success
*/
if (!ul) {
PUTWAVEHDR16(parg16->f2, &wavehdr);
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutWrite
*
* This function sends a data block to the specified waveform output device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutWrite(PVDMFRAME pFrame)
{
register PWAVEOUTWRITE16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
PWAVEHDR32 pWavehdr32;
GET_MULTIMEDIA_API( "waveOutWrite", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTWRITE16), parg16);
trace_wave(( "waveOutWrite( %x, %x, %x)", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ), UINT32( parg16->f3 ) ));
/*
** If the given size of the WAVEHDR structure is too small
** or the lphdr is invalid return an error
**
*/
if ( UINT32(parg16->f3) < sizeof(WAVEHDR16)
|| HIWORD( DWORD32(parg16->f2) ) == 0 ) {
ul = (ULONG)MMSYSERR_INVALPARAM;
}
else {
if ( pWavehdr32 = malloc_w( sizeof(WAVEHDR32) ) ) {
PWAVEHDR lpwhdr; /* used to simplify ptr stuff later on */
#if DBG
AllocWaveCount++;
dprintf2(( "W>> %8X (%d)", pWavehdr32, AllocWaveCount ));
#endif
/* Copy across the wave header stuff. Note that lpwhdr (a
** 32 bit ptr to a 32 bit wave header) is used to make the
** pointer stuff a bit less hairy.
**
** pWavehdr32->Wavehdr is a 32 bit wave header
** pWavehdr32->pWavehdr16 is a 16 bit ptr to a 16 bit wave header
** pWavehdr32->pWavehdr32 is a 32 bit ptr to a 16 bit wave header
*/
lpwhdr = &(pWavehdr32->Wavehdr);
pWavehdr32->pWavehdr16 = (PWAVEHDR16)DWORD32(parg16->f2);
pWavehdr32->pWavehdr32 = GETWAVEHDR16(DWORD32(parg16->f2), lpwhdr);
/*
** GETWAVEHDR16 can return NULL, in which case we should set
** lpwhdr to NULL too and call waveOutWrite only to get the
** correct error code.
*/
if ( pWavehdr32->pWavehdr32 == NULL ) {
lpwhdr = NULL;
}
ul = GETWORD16( (*mmAPI)( HWAVEOUT32(parg16->f1),
lpwhdr, UINT32(parg16->f3) ) );
/* If the call fails we need to free the memory we malloc'd
** above, as the callback that would have freed it will never
** get called.
*/
if ( ul == MMSYSERR_NOERROR ) {
/* Make sure we reflect any changes that waveOutWrite did
** to the WAVEHDR back to 16 bit land.
**
** This is important because some apps (waveedit) poll the
** WHDR_DONE bit !!
*/
COPY_WAVEOUTHDR16_FLAGS( pWavehdr32->pWavehdr32,
pWavehdr32->Wavehdr );
}
else {
#if DBG
AllocWaveCount--;
dprintf2(( "W<< \t%8X (%d)", pWavehdr32,
AllocWaveCount ));
#endif
free_w( pWavehdr32 );
}
}
else {
ul = (ULONG)MMSYSERR_NOMEM;
}
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutPause
*
* This function pauses playback on a specified waveform output device. The
* current playback position is saved. Use wavOutRestart to resume playback from
* the current playback position.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutPause(PVDMFRAME pFrame)
{
ULONG ul;
register PWAVEOUTPAUSE16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveOutPause", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTPAUSE16), parg16);
trace_wave(( "waveOutGetPause( %x )", WORD32( parg16->f1 ) ));
ul = GETWORD16((*mmAPI)( HWAVEOUT32(parg16->f1) ));
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutRestart
*
* This function restarts a paused waveform output device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutRestart(PVDMFRAME pFrame)
{
ULONG ul;
register PWAVEOUTRESTART16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveOutRestart", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTRESTART16), parg16);
trace_wave(( "waveOutRestart( %x )", WORD32( parg16->f1 ) ));
ul = GETWORD16((*mmAPI)( HWAVEOUT32(parg16->f1) ));
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutReset
*
* This function stops playback on a given waveform output device and resets the
* current position to 0. All pending playback buffers are marked as done and
* returned to the application.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutReset(PVDMFRAME pFrame)
{
ULONG ul;
register PWAVEOUTRESET16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveOutReset", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTRESET16), parg16);
trace_wave(( "waveOutReset( %x )", WORD32( parg16->f1 ) ));
ul = GETWORD16( (*mmAPI)( HWAVEOUT32(parg16->f1) ));
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutGetPosition
*
* This function retrieves the current palyback position of the specified
* waveform output device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutGetPosition(PVDMFRAME pFrame)
{
register PWAVEOUTGETPOSITION16 parg16;
static FARPROC mmAPI = NULL;
MMTIME mmtime;
ULONG ul = MMSYSERR_INVALPARAM;
GET_MULTIMEDIA_API( "waveOutGetPosition", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTGETPOSITION16), parg16);
trace_wave(( "waveOutGetPosition( %x, %x, %x )", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ), UINT32( parg16->f3 ) ));
/*
** If the given size of the MMTIME structure is too small return an error
**
** There is a problem here on MIPS. For some reason the MIPS
** compiler thinks a MMTIME16 structure is 10 bytes big. We
** have a pragma in wowmmed.h to align this structure on byte
** boundaries therefore I guess this is a compiler bug!
**
** If the input structure is not large enough we return immediately
*/
#ifdef MIPS_COMPILER_PACKING_BUG
if ( UINT32(parg16->f3) >= 8 ) {
#else
if ( UINT32(parg16->f3) >= sizeof(MMTIME16) ) {
#endif
ul = GETMMTIME16( parg16->f2, &mmtime);
if ( ul == MMSYSERR_NOERROR ) {
ul = GETWORD16((*mmAPI)( HWAVEOUT32(parg16->f1),
&mmtime, sizeof(MMTIME) ));
/*
** Only update the 16 bit structure if the call returns success
**
*/
if ( ul == MMSYSERR_NOERROR ) {
ul = PUTMMTIME16( parg16->f2, &mmtime);
}
}
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutGetPitch
*
* This function queries the current pitch setting of a waveform output device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutGetPitch(PVDMFRAME pFrame)
{
register PWAVEOUTGETPITCH16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul = MMSYSERR_INVALPARAM;
LPDWORD lpdwPitch;
DWORD dwPitch;
GET_MULTIMEDIA_API( "waveOutGetPitch", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTGETPITCH16), parg16);
trace_wave(( "waveOutGetPitch( %x, %x )", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ) ));
ul = GETWORD16((*mmAPI)( HWAVEOUT32(parg16->f1), &dwPitch ));
if ( ul == MMSYSERR_NOERROR ) {
MMGETOPTPTR( parg16->f2, sizeof(DWORD), lpdwPitch);
if ( lpdwPitch ) {
STOREDWORD ( *lpdwPitch, dwPitch );
FLUSHVDMPTR( DWORD32(parg16->f2), sizeof(DWORD), lpdwPitch );
FREEVDMPTR ( lpdwPitch );
}
else {
ul = MMSYSERR_INVALPARAM;
}
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutSetPitch
*
* This function sets the pitch of a waveform output device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutSetPitch(PVDMFRAME pFrame)
{
register PWAVEOUTSETPITCH16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
GET_MULTIMEDIA_API( "waveOutSetPitch", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTSETPITCH16), parg16);
trace_wave(( "waveOutSetPitch( %x, %x )", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ) ));
ul = GETWORD16((*mmAPI)( HWAVEOUT32(parg16->f1), DWORD32(parg16->f2) ));
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutGetVolume
*
* This function queries the current volume setting of a waveform output device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutGetVolume(PVDMFRAME pFrame)
{
register PWAVEOUTGETVOLUME16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
LPDWORD lpdwVolume;
DWORD dwVolume;
GET_MULTIMEDIA_API( "waveOutGetVolume", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTGETVOLUME16), parg16);
trace_wave(( "waveOutGetVolume( %x, %x )", INT32( parg16->f1 ),
DWORD32( parg16->f2 ) ));
ul = GETWORD16((*mmAPI)( INT32(parg16->f1), &dwVolume ));
if ( ul == MMSYSERR_NOERROR ) {
MMGETOPTPTR( parg16->f2, sizeof(DWORD), lpdwVolume);
if ( lpdwVolume ) {
STOREDWORD ( *lpdwVolume, dwVolume );
FLUSHVDMPTR( DWORD32(parg16->f2), sizeof(DWORD), lpdwVolume );
FREEVDMPTR ( lpdwVolume );
}
else {
ul = MMSYSERR_INVALPARAM;
}
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutSetVolume
*
* This function sets the volume of a waveform output device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutSetVolume(PVDMFRAME pFrame)
{
ULONG ul;
register PWAVEOUTSETVOLUME16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveOutSetVolume", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTSETVOLUME16), parg16);
trace_wave(( "waveOutSetVolume( %x, %x )", INT32( parg16->f1 ),
DWORD32( parg16->f2 ) ));
ul = GETWORD16((*mmAPI)( INT32(parg16->f1), DWORD32(parg16->f2) ));
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutGetPlaybackRate
*
* This function queries the current playback rate setting of a waveform output
* device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutGetPlaybackRate(PVDMFRAME pFrame)
{
register PWAVEOUTGETPLAYBACKRATE16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
LPDWORD lpdwRate;
DWORD dwRate;
GET_MULTIMEDIA_API( "waveOutGetPlaybackRate", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTGETPLAYBACKRATE16), parg16);
trace_wave(( "waveOutGetPlaybackRate( %x, %x )", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ) ));
ul = GETWORD16((*mmAPI)( HWAVEOUT32(parg16->f1), &dwRate ));
if ( ul == MMSYSERR_NOERROR ) {
MMGETOPTPTR( parg16->f2, sizeof(DWORD), lpdwRate );
if ( lpdwRate ) {
STOREDWORD ( *lpdwRate, dwRate );
FLUSHVDMPTR( DWORD32(parg16->f2), sizeof(DWORD), lpdwRate );
FREEVDMPTR ( lpdwRate );
}
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutSetPlaybackRate
*
* This function sets the playback rate of a waveform output device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutSetPlaybackRate(PVDMFRAME pFrame)
{
ULONG ul;
register PWAVEOUTSETPLAYBACKRATE16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveOutSetPlaybackRate", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTSETPLAYBACKRATE16), parg16);
trace_wave(( "waveOutSetPlaybackRate( %x, %x )", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ) ));
ul = GETWORD16((*mmAPI)( HWAVEOUT32(parg16->f1), DWORD32(parg16->f2) ));
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutBreakLoop
*
* This function breaks a loop on a given waveform output device and allows
* playback to continue with the next block in the driver list.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutBreakLoop(PVDMFRAME pFrame)
{
ULONG ul;
register PWAVEOUTBREAKLOOP16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveOutBreakLoop", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTBREAKLOOP16), parg16);
trace_wave(( "waveOutBreakLoop( %x )", WORD32( parg16->f1 ) ));
ul = GETWORD16((*mmAPI)( HWAVEOUT32(parg16->f1) ));
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutGetID
*
* This function gets the device ID for a waveform output device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutGetID(PVDMFRAME pFrame)
{
register PWAVEOUTGETID16 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
UINT dwDeviceID32;
LPWORD lpwDeviceID16;
GET_MULTIMEDIA_API( "waveOutGetID", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTGETID16), parg16);
trace_wave(( "waveOutGetID( %x, %x )", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ) ));
ul = GETWORD16((*mmAPI)( HWAVEOUT32(parg16->f1), &dwDeviceID32 ));
/*
** Only copy the ID back to 16 bit space if the call was sucessful
**
*/
if ( ul == MMSYSERR_NOERROR ) {
MMGETOPTPTR( parg16->f2, sizeof(WORD), lpwDeviceID16 );
if ( lpwDeviceID16 ) {
STOREWORD ( *lpwDeviceID16, dwDeviceID32 );
FLUSHVDMPTR( DWORD32(parg16->f2), sizeof(WORD), lpwDeviceID16 );
FREEVDMPTR ( lpwDeviceID16 );
}
else {
ul = MMSYSERR_INVALPARAM;
}
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveOutMessage
*
* This function send a message to a waveform output device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveOutMessage(PVDMFRAME pFrame)
{
ULONG ul;
register PWAVEOUTMESSAGE3216 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveOutMessage", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEOUTMESSAGE16), parg16);
trace_wave(( "waveOutMessage( %x, %x, %x, %x )",
WORD32( parg16->f1 ), UINT32( parg16->f2 ),
DWORD32( parg16->f3 ), DWORD32( parg16->f4 ) ));
if ( (UINT32(parg16->f2) >= DRV_BUFFER_LOW)
&& (UINT32(parg16->f2) <= DRV_BUFFER_HIGH) ) {
LPDWORD lpdwParam1;
GETMISCPTR(parg16->f3, lpdwParam1);
ul = GETDWORD16((*mmAPI)( HWAVEOUT32(parg16->f1), UINT32(parg16->f2),
(DWORD)lpdwParam1, DWORD32(parg16->f4) ));
FREEMISCPTR(lpdwParam1);
} else {
ul = GETDWORD16((*mmAPI)( HWAVEOUT32(parg16->f1),
MAKELONG( WORD32(parg16->f2), 0xFFFF ),
DWORD32(parg16->f3), DWORD32(parg16->f4) ));
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/* ---------------------------------------------------------------------
** WAVE Input API's
** ---------------------------------------------------------------------
*/
/**********************************************************************\
*
* WMM32waveInGetNumDevs
*
* This function returns the number of waveform input devices.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveInGetNumDevs(PVDMFRAME pFrame)
{
ULONG ul;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveInGetNumDevs", mmAPI, MMSYSERR_NODRIVER );
UNREFERENCED_PARAMETER(pFrame);
trace_wave(( "waveInGetNumDevs()" ));
ul = GETWORD16((*mmAPI)() );
trace_wave(( "-> %ld\n", ul ));
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveInGetDevCaps
*
* This function queries a specified waveform input device to determine its
* capabilities.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveInGetDevCaps(PVDMFRAME pFrame)
{
ULONG ul;
WAVEINCAPS waveincaps1;
register PWAVEINGETDEVCAPS16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveInGetDevCapsA", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEINGETDEVCAPS16), parg16);
trace_wave(( "waveInGetDevCaps( %x, %x, %x )", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ), UINT32( parg16->f3 ) ));
/*
** If the size parameter was zero return straight away. Note that this
** is not an error.
*/
if ( UINT32( parg16->f3 ) == 0 ) {
ul = MMSYSERR_NOERROR;
}
else {
ul = GETWORD16((*mmAPI)(INT32(parg16->f1), &waveincaps1,
sizeof(WAVEINCAPS) ) );
/*
** Don't update the 16 bit structure if the call failed
**
*/
if ( ul == MMSYSERR_NOERROR ) {
ul = PUTWAVEINCAPS16(parg16->f2, &waveincaps1, UINT32(parg16->f3));
}
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveInGetErrorText
*
* This function retrieves a textual description of the error identified by the
* specified error number.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveInGetErrorText(PVDMFRAME pFrame)
{
ULONG ul = MMSYSERR_NOERROR;
PSZ pszText;
register PWAVEINGETERRORTEXT16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveInGetErrorTextA", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEINGETERRORTEXT16), parg16);
trace_wave(( "waveInGetErrorText( %x, %x, %x )", UINT32( parg16->f1 ),
DWORD32( parg16->f2 ), UINT32( parg16->f3 ) ));
/*
** Test against a zero length string and a NULL pointer. If 0 is passed
** as the buffer length then the manual says we should return
** MMSYSERR_NOERR. MMGETOPTPTR only returns a pointer if parg16->f2 is
** not NULL.
*/
MMGETOPTPTR( parg16->f2, UINT32(parg16->f3), pszText );
if ( pszText != NULL ) {
ul = GETWORD16((*mmAPI)( UINT32(parg16->f1), pszText,
UINT32(parg16->f3) ));
FLUSHVDMPTR( DWORD32(parg16->f2), UINT32(parg16->f3), pszText);
FREEVDMPTR(pszText);
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveInOpen
*
* This function opens a specified waveform input device for recording.
*
* As of November 1992 we map the 16 bit Wave Format data directly to the
* the 32 bit side, no thunking of the parameters is performed.
*
*
\**********************************************************************/
ULONG FASTCALL WMM32waveInOpen(PVDMFRAME pFrame)
{
ULONG ul=0;
UINT uDevID;
PINSTANCEDATA pInstanceData = NULL;
DWORD dwFlags;
PWAVEFORMAT16 lpWaveformData;
LPHWAVEIN lphWaveIn; // pointer to handle in 16 bit app space
HWAVEIN Hand32; // 32bit handle
register PWAVEINOPEN16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveInOpen", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEINOPEN16), parg16);
trace_wave(( "waveInOpen( %x, %x, %x, %x, %x, %x )",
DWORD32( parg16->f1 ), INT32 ( parg16->f2 ),
DWORD32( parg16->f3 ), DWORD32( parg16->f4 ),
DWORD32( parg16->f5 ), DWORD32( parg16->f6 ) ));
/*
** Get the device ID. We use INT32 here not UINT32 to make sure that
** negative values (such as WAVE_MAPPER (-1)) get thunked correctly.
*/
uDevID = (UINT)INT32(parg16->f2);
/*
** Get the flags to be used.
*/
dwFlags = DWORD32(parg16->f6);
/*
** Get a pointer to the WAVEFORMAT structure. Because the format of this
** structure is exactly the same in 32 and 16 bit land I will use
** GETMISCPTR to get a generic pointer to the data. The stuff being
** pointed to could be full of unaligned WORDs, but the 32 bit code
** would have to cope with this anyway.
*/
GETMISCPTR( DWORD32(parg16->f3), lpWaveformData );
if ( lpWaveformData == (PWAVEFORMAT16)NULL ) {
ul = (ULONG)MMSYSERR_INVALPARAM;
goto exit_function;
}
/*
** We don't need a callback routine when the WAVE_FORMAT_QUERY flag
** is specified.
*/
if ( !( dwFlags & WAVE_FORMAT_QUERY ) ) {
/*
** Map the 16 bit pointer is one was specified.
*/
MMGETOPTPTR( parg16->f1, sizeof(HWAVEIN), lphWaveIn );
if ( lphWaveIn == NULL ) {
ul = MMSYSERR_INVALPARAM;
}
/*
** Create InstanceData block to be used by our callback routine.
**
** NOTE: Although we malloc it here we don't free it.
** This is not a mistake - it must not be freed before the
** callback routine has used it - so it does the freeing.
**
** If the malloc fails we bomb down to the bottom,
** set ul to MMSYSERR_NOMEM and exit gracefully.
**
** We always have a callback functions. This is to ensure that
** the WAVEHDR structure keeps getting copied back from
** 32 bit space to 16 bit, as it contains flags which
** applications are liable to keep checking.
*/
else if ( pInstanceData = malloc_w(sizeof(INSTANCEDATA) ) ) {
DWORD dwNewFlags = CALLBACK_FUNCTION;
dprintf2(( "WM32waveInOpen: Allocated instance buffer at %8X",
pInstanceData ));
pInstanceData->dwCallback = DWORD32(parg16->f4);;
pInstanceData->dwCallbackInstance = DWORD32(parg16->f5);
pInstanceData->dwFlags = dwFlags;
dwNewFlags |= (dwFlags & WAVE_ALLOWSYNC);
ul = GETWORD16( (*mmAPI)( &Hand32, uDevID,
(LPWAVEFORMAT)lpWaveformData,
(DWORD)W32CommonDeviceOpen,
(DWORD)pInstanceData, dwNewFlags ) );
/*
** If the call returns success update the 16 bit handle,
** otherwise don't, and free the memory we malloc'd earlier, as
** the callback that would have freed it will never get callled.
*/
if ( ul == MMSYSERR_NOERROR ) {
HWAVEIN16 Hand16 = GETHWAVEIN16(Hand32);
trace_wave(( "Handle -> %x", Hand16 ));
STOREWORD ( *lphWaveIn, Hand16 );
FLUSHVDMPTR( DWORD32(parg16->f1), sizeof(HWAVEIN), lphWaveIn );
}
else {
free_w(pInstanceData);
}
/*
** Regardless of sucess or failure we need to free the pointer
** to the 16 bit WaveIn handle.
*/
FREEVDMPTR ( lphWaveIn );
}
else {
ul = (ULONG)MMSYSERR_NOMEM;
}
}
else {
ul = GETWORD16( (*mmAPI)( NULL, uDevID, (LPWAVEFORMAT)lpWaveformData,
DWORD32(parg16->f4),
DWORD32(parg16->f5), dwFlags) );
}
/*
** Regardless of sucess or failure we need to free the pointer to the
** 16 bit WaveFormatData.
*/
FREEMISCPTR( lpWaveformData );
exit_function:
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveInClose
*
* This function closes the specified waveform input device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveInClose(PVDMFRAME pFrame)
{
ULONG ul;
register PWAVEINCLOSE16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveInClose", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEINCLOSE16), parg16);
trace_wave(( "waveInClose( %x )", WORD32( parg16->f1 ) ));
ul = GETWORD16((*mmAPI)( HWAVEIN32(parg16->f1) ));
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveInPrepareHeader
*
* This function prepares the specified waveform header.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveInPrepareHeader(PVDMFRAME pFrame)
{
register PWAVEINPREPAREHEADER3216 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
WAVEHDR wavehdr;
GET_MULTIMEDIA_API( "waveInPrepareHeader", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEINPREPAREHEADER3216), parg16);
trace_wave(( "waveInPrepareHeader( %x %x %x)", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ), WORD32( parg16->f3 ) ));
GETWAVEHDR16(parg16->f2, &wavehdr);
ul = GETWORD16((*mmAPI)( HWAVEIN32(parg16->f1),
&wavehdr, WORD32(parg16->f3) ) );
/*
** Only update the 16 bit structure if the call returns success
**
*/
if ( !ul ) {
PUTWAVEHDR16(parg16->f2, &wavehdr);
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveInUnprepareHeader
*
* This function prepares the specified waveform header.
* This function cleans up the preparation performed by waveInPrepareHeader.
* The function must be called after the device driver has finished with a
* data block. You must call this function before freeing the data buffer.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveInUnprepareHeader(PVDMFRAME pFrame)
{
register PWAVEINUNPREPAREHEADER3216 parg16;
static FARPROC mmAPI = NULL;
ULONG ul;
WAVEHDR wavehdr;
GET_MULTIMEDIA_API( "waveInUnprepareHeader", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEINUNPREPAREHEADER3216), parg16);
trace_wave(( "waveInUnprepareHeader( %x %x %x)", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ), WORD32( parg16->f3 ) ));
GETWAVEHDR16(parg16->f2, &wavehdr);
ul = GETWORD16((*mmAPI)( HWAVEIN32(parg16->f1),
&wavehdr, WORD32(parg16->f3) ) );
/*
** Only update the 16 bit structure if the call returns success
*/
if (!ul) {
PUTWAVEHDR16(parg16->f2, &wavehdr);
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveInAddBuffer
*
* This function sends an input buffer to a waveform input device.
* When the buffer is filled it is sent back to the application.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveInAddBuffer(PVDMFRAME pFrame)
{
ULONG ul;
PWAVEHDR32 pWavehdr32;
register PWAVEINADDBUFFER16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveInAddBuffer", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEINADDBUFFER16), parg16);
trace_wave(( "waveInAddBuffer( %x, %x, %x)", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ), UINT32( parg16->f3 ) ));
/*
** If the given size of the WAVEHDR structure is too small
** or the lphdr is invalid return an error
**
*/
if ( UINT32(parg16->f3) < sizeof(WAVEHDR16)
|| HIWORD( DWORD32(parg16->f2) ) == 0 ) {
ul = (ULONG)MMSYSERR_INVALPARAM;
}
else {
if (pWavehdr32 = malloc_w(sizeof(WAVEHDR32) ) ) {
PWAVEHDR lpwhdr; /* used to simplify ptr stuff later on */
#if DBG
AllocWaveCount++;
dprintf2(( "W>> %8X (%d)", pWavehdr32, AllocWaveCount ));
#endif
/* Copy across the wave header stuff. Note that lpwhdr (a
** 32 bit ptr to a 32 bit wave header) is used to make the
** pointer stuff a bit less hairy.
**
** pWavehdr32->Wavehdr is a 32 bit wave header
** pWavehdr32->pWavehdr16 is a 16 bit ptr to a 16 bit wave header
** pWavehdr32->pWavehdr32 is a 32 bit ptr to a 16 bit wave header
*/
lpwhdr = &(pWavehdr32->Wavehdr);
pWavehdr32->pWavehdr16 = (PWAVEHDR16)DWORD32(parg16->f2);
pWavehdr32->pWavehdr32 = GETWAVEHDR16(DWORD32(parg16->f2), lpwhdr);
/*
** GETWAVEHDR16 can return NULL, in which case we should set
** lpwhdr to NULL too and call waveInAddBuffer only to get the
** correct error code.
*/
if ( pWavehdr32->pWavehdr32 == NULL ) {
lpwhdr = NULL;
}
ul = GETWORD16( (*mmAPI)( HWAVEIN32(parg16->f1),
lpwhdr, UINT32(parg16->f3) ) );
/*
** If the call fails we need to free the memory we malloc'd
** above, as the callback that would have freed it will never
** get called.
**
*/
if ( ul == MMSYSERR_NOERROR ) {
/*
** Make sure we reflect any changes that waveInAddBuffer did
** to the WAVEHDR back to 16 bit land.
**
** This is important because some apps (waveedit) poll the
** WHDR_DONE bit !!
*/
COPY_WAVEINHDR16_FLAGS( pWavehdr32->pWavehdr32,
pWavehdr32->Wavehdr );
}
else {
#if DBG
AllocWaveCount--;
dprintf2(( "W<< \t%8X (%d)", pWavehdr32,
AllocWaveCount ));
#endif
free_w( pWavehdr32 );
}
}
else {
ul = (ULONG)MMSYSERR_NOMEM;
}
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveInStart
*
* This function starts input on the specified waveform input device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveInStart(PVDMFRAME pFrame)
{
ULONG ul;
register PWAVEINSTART16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveInStart", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEINSTART16), parg16);
trace_wave(( "waveInStart( %x )", WORD32( parg16->f1 ) ));
ul = GETWORD16((*mmAPI)( HWAVEIN32(parg16->f1) ));
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveInStop
*
* This function stops waveform input.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveInStop(PVDMFRAME pFrame)
{
ULONG ul;
register PWAVEINSTOP16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveInStop", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEINSTOP16), parg16);
trace_wave(( "waveInStop( %x )", WORD32( parg16->f1 ) ));
ul = GETWORD16((*mmAPI)( HWAVEIN32(parg16->f1) ));
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveInReset
*
* This function stops input on a given waveform input device and resets the
* current position to 0. All pending buffers are marked as done and returned
* to the application.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveInReset(PVDMFRAME pFrame)
{
ULONG ul;
register PWAVEINRESET16 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveInReset", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEINRESET16), parg16);
trace_wave(( "waveInReset( %x )", WORD32( parg16->f1 ) ));
ul = GETWORD16((*mmAPI)( HWAVEIN32(parg16->f1) ));
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveInGetPosition
*
* This function retrieves the current input position of the specified waveform
* input device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveInGetPosition(PVDMFRAME pFrame)
{
register PWAVEINGETPOSITION16 parg16;
MMTIME mmtime;
ULONG ul = MMSYSERR_INVALPARAM;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveInGetPosition", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEINGETPOSITION16), parg16);
trace_wave(( "waveInGetPosition( %x, %x, %x )", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ), UINT32( parg16->f3 ) ));
/*
** If the given size of the MMTIME structure is too small return an error
**
** There is a problem here on MIPS. For some reason the MIPS
** compiler thinks a MMTIME16 structure is 10 bytes big. We
** have a pragma in wowmmed.h to align this structure on byte
** boundaries therefore I guess this is a compiler bug!
**
** If the input structure is not large enough we return immediately
*/
#ifdef MIPS_COMPILER_PACKING_BUG
if ( UINT32(parg16->f3) >= 8 ) {
#else
if ( UINT32(parg16->f3) >= sizeof(MMTIME16) ) {
#endif
ul = GETMMTIME16( parg16->f2, &mmtime );
if ( ul == MMSYSERR_NOERROR ) {
ul = GETWORD16((*mmAPI)( HWAVEIN32(parg16->f1),
&mmtime, sizeof(MMTIME) ));
/*
** Only update the 16 bit structure if the call returns success
**
*/
if ( ul == MMSYSERR_NOERROR ) {
ul = PUTMMTIME16( parg16->f2, &mmtime );
}
}
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveInGetID
*
* This function gets the device ID for a waveform input device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveInGetID(PVDMFRAME pFrame)
{
register PWAVEINGETID16 parg16;
ULONG ul;
UINT dwDeviceID32;
LPWORD lpwDeviceID16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveInGetID", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEINGETID16), parg16);
trace_wave(( "waveInGetID( %x, %x )", WORD32( parg16->f1 ),
DWORD32( parg16->f2 ) ));
ul = GETWORD16((*mmAPI)( HWAVEIN32(parg16->f1), &dwDeviceID32 ));
/*
** Only copy the ID back to 16 bit space if the call was sucessful
**
*/
if ( ul == MMSYSERR_NOERROR ) {
MMGETOPTPTR( parg16->f2, sizeof(WORD), lpwDeviceID16 );
if ( lpwDeviceID16 ) {
STOREWORD ( *lpwDeviceID16, dwDeviceID32 );
FLUSHVDMPTR( DWORD32(parg16->f2), sizeof(WORD), lpwDeviceID16 );
FREEVDMPTR ( lpwDeviceID16 );
}
else {
ul = MMSYSERR_INVALPARAM;
}
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* WMM32waveInMessage
*
* This function sends a message to a waveform input device.
*
\**********************************************************************/
ULONG FASTCALL WMM32waveInMessage(PVDMFRAME pFrame)
{
ULONG ul;
register PWAVEINMESSAGE3216 parg16;
static FARPROC mmAPI = NULL;
GET_MULTIMEDIA_API( "waveInMessage", mmAPI, MMSYSERR_NODRIVER );
GETARGPTR(pFrame, sizeof(WAVEINMESSAGE16), parg16);
trace_wave(( "waveInMessage( %x, %x, %x, %x )", WORD32( parg16->f1 ),
UINT32( parg16->f2 ), DWORD32( parg16->f3 ),
DWORD32( parg16->f4 ) ));
if ( (UINT32(parg16->f2) >= DRV_BUFFER_LOW)
&& (UINT32(parg16->f2) <= DRV_BUFFER_HIGH) ) {
LPDWORD lpdwParam1;
GETMISCPTR(parg16->f3, lpdwParam1);
ul = GETDWORD16((*mmAPI)( HWAVEIN32(parg16->f1), UINT32(parg16->f2),
(DWORD)lpdwParam1, DWORD32(parg16->f4) ));
FREEMISCPTR(lpdwParam1);
} else {
ul = GETDWORD16((*mmAPI)( HWAVEIN32(parg16->f1),
MAKELONG( WORD32(parg16->f2), 0xFFFF ),
DWORD32(parg16->f3), DWORD32(parg16->f4) ));
}
trace_wave(( "-> %ld\n", ul ));
FREEARGPTR(parg16);
RETURN(ul);
}
/**********************************************************************\
*
* W32CommonDeviceOpen
*
* This routine is the callback which is ALWAYS called by wave and midi
* functions. This is done to ensure that the XXXXHDR structure keeps
* getting copied back from 32 bit space to 16 bit, as it contains flags
* which the application is liable to keep checking.
*
* The way this whole business works is that the wave/midi data stays in 16
* bit space, but the XXXXHDR is copied to the 32 bit side, with the
* address of the data thunked accordingly so that Robin's device driver
* can still get at the data but we don't have the performance penalty of
* copying it back and forth all the time, not least because it is liable
* to be rather large...
*
* It also handles the tidying up of memory which is reserved to store
* the XXXXHDR, and the instance data (HWND/Callback address; instance
* data; flags) which the xxxxOpen calls pass to this routine, enabling
* it to forward messages or call callback as required.
*
* This routine handles all the messages that get sent from Robin's
* driver, and in fact thunks them back to the correct 16 bit form. In
* theory there should be no MM_ format messages from the 16 bit side, so
* I can zap 'em out of WMSG16. However the 32 bit side should thunk the
* mesages correctly and forward them to the 16 bit side and thence to
* the app.
*
* However... I discover that somewhere in the system the wParam Msg
* parameter (which is 32 bits in Win32 and 16 bits in Win16) is having
* the top 16 bits trashed (zeroed actually). As I pass a 32 bit handle
* in it, to be thunked in WMDISP32 back to a 16 bit handle, the loss of
* the top 16 bits is not conducive to correct thunking. Soooo, no more
* thunking in WMDISP32 - I do it all here and Post the correct 16 bit
* message.
*
* Hence WMTBL32 (the 32 bit message switch table) contains the
* NoThunking entry for all the MM_ messages - I'll do 'em myself thank
* you.
*
*
* For the MM_WIM_DATA and MM_WOM_DONE message dwParam1 points to the
* following data struture.
*
* P32HDR is a 32 bit pointer to the original 16 bit header
* P16HDR is a 16 bit far pointer to the original 16 bit header
*
* If we need to refernece the original header we must do via the
* P32HDR pointer.
*
* +---------+
* | P32HDR +----->+---------+
* +---------+ | 16 bit |
* | P16HDR +----->| | This is the original
* dwParam1 ----->+---------+ | Wave | wave header passed to
* | 32 bit | | Header | us by the Win 16 app.
* This is the 32 | | | |
* bit wave | Wave | +---------+
* header that we | Header |
* thunked at | |
* earlier. +---------+
*
*
* We must ensure that the 32 bit structure is completely hidden from the
* 16 bit application, ie. the 16 bit app only see's the wave header that it
* passed to us earlier.
*
*
* NOTE: dwParam2 is junk
*
*
\**********************************************************************/
VOID W32CommonDeviceOpen( HANDLE handle, UINT uMsg, DWORD dwInstance,
DWORD dwParam1, DWORD dwParam2 )
{
PWAVEHDR32 pWavehdr32;
PMIDIHDR32 pMidihdr32;
PINSTANCEDATA pInstanceData;
WORD Handle;
switch (uMsg) {
/* ------------------------------------------------------------
** MIDI INPUT MESSAGES
** ------------------------------------------------------------
*/
case MM_MIM_LONGDATA:
/*
** This message is sent to a window when an input buffer has been
** filled with MIDI system-exclusive data and is being returned to
** the application.
*/
case MM_MIM_LONGERROR:
/*
** This message is sent to a window when an invalid MIDI
** system-exclusive message is received.
*/
pMidihdr32 = (PMIDIHDR32)( (PBYTE)dwParam1 - (sizeof(PMIDIHDR16) * 2) );
WOW32ASSERT( pMidihdr32 );
COPY_MIDIINHDR16_FLAGS( pMidihdr32->pMidihdr32, pMidihdr32->Midihdr );
dwParam1 = (DWORD)pMidihdr32->pMidihdr16;
case MM_MIM_DATA:
/*
** This message is sent to a window when a MIDI message is
** received by a MIDI input device.
*/
case MM_MIM_ERROR:
/*
** This message is sent to a window when an invalid MIDI message
** is received.
*/
case MM_MIM_OPEN:
/*
** This message is sent to a window when a MIDI input device is opened.
** We process this message the same way as MM_MIM_CLOSE (see below)
*/
case MM_MIM_CLOSE:
/*
** This message is sent to a window when a MIDI input device is
** closed. The device handle is no longer valid once this message
** has been sent.
*/
Handle = GETHMIDIIN16(handle);
break;
/* ------------------------------------------------------------
** MIDI OUTPUT MESSAGES
** ------------------------------------------------------------
*/
case MM_MOM_DONE:
/*
** This message is sent to a window when the specified
** system-exclusive buffer has been played and is being returned to
** the application.
*/
pMidihdr32 = (PMIDIHDR32)( (PBYTE)dwParam1 - (sizeof(PMIDIHDR16) * 2) );
WOW32ASSERT( pMidihdr32 );
COPY_MIDIOUTHDR16_FLAGS( pMidihdr32->pMidihdr32, pMidihdr32->Midihdr );
dwParam1 = (DWORD)pMidihdr32->pMidihdr16;
case MM_MOM_OPEN:
/*
** This message is sent to a window when a MIDI output device is opened.
** We process this message the same way as MM_MOM_CLOSE (see below)
*/
case MM_MOM_CLOSE:
/*
** This message is sent to a window when a MIDI output device is
** closed. The device handle is no longer valid once this message
** has been sent.
*/
Handle = GETHMIDIOUT16(handle);
break;
/* ------------------------------------------------------------
** WAVE INPUT MESSAGES
** ------------------------------------------------------------
*/
case MM_WIM_DATA:
/*
** This message is sent to a window when waveform data is present
** in the input buffer and the buffer is being returned to the
** application. The message can be sent either when the buffer
** is full, or after the waveInReset function is called.
*/
pWavehdr32 = (PWAVEHDR32)( (PBYTE)dwParam1 - (sizeof(PWAVEHDR16) * 2));
WOW32ASSERT( pWavehdr32 );
COPY_WAVEINHDR16_FLAGS( pWavehdr32->pWavehdr32, pWavehdr32->Wavehdr );
dwParam1 = (DWORD)pWavehdr32->pWavehdr16;
case MM_WIM_OPEN:
/*
** This message is sent to a window when a waveform input
** device is opened.
**
** We process this message the same way as MM_WIM_CLOSE (see below)
*/
case MM_WIM_CLOSE:
/*
** This message is sent to a window when a waveform input device is
** closed. The device handle is no longer valid once the message has
** been sent.
*/
Handle = GETHWAVEIN16(handle);
break;
/* ------------------------------------------------------------
** WAVE OUTPUT MESSAGES
** ------------------------------------------------------------
*/
case MM_WOM_DONE:
/*
** This message is sent to a window when the specified output
** buffer is being returned to the application. Buffers are returned
** to the application when they have been played, or as the result of
** a call to waveOutReset.
*/
pWavehdr32 = (PWAVEHDR32)( (PBYTE)dwParam1 - (sizeof(PWAVEHDR16) * 2));
WOW32ASSERT( pWavehdr32 );
COPY_WAVEOUTHDR16_FLAGS( pWavehdr32->pWavehdr32, pWavehdr32->Wavehdr );
dwParam1 = (DWORD)pWavehdr32->pWavehdr16;
case MM_WOM_OPEN:
/*
** This message is sent to a window when a waveform output device
** is opened.
**
** We process this message the same way as MM_WOM_CLOSE (see below)
*/
case MM_WOM_CLOSE:
/*
** This message is sent to a window when a waveform output device
** is closed. The device handle is no longer valid once the
** message has been sent.
*/
Handle = GETHWAVEOUT16(handle);
break;
#if DBG
default:
dprintf(( "Unknown message received in CallBack function " ));
dprintf(( "best call StephenE or MikeTri" ));
return;
#endif
}
/*
** Now make the CallBack, or PostMessage call depending
** on the flags passed to original (wave|midi)(In|Out)Open call.
*/
pInstanceData = (PINSTANCEDATA)dwInstance;
WOW32ASSERT( pInstanceData );
switch (pInstanceData->dwFlags & CALLBACK_TYPEMASK) {
case CALLBACK_WINDOW:
dprintf2(( "WINDOW callback identified" ));
PostMessage( HWND32( LOWORD(pInstanceData->dwCallback) ),
uMsg, Handle, dwParam1 );
break;
case CALLBACK_TASK:
case CALLBACK_FUNCTION: {
DWORD dwFlags;
if ( (pInstanceData->dwFlags & CALLBACK_TYPEMASK) == CALLBACK_TASK ) {
dprintf2(( "TASK callback identified" ));
dwFlags = DCB_TASK;
}
else {
dprintf2(( "FUNCTION callback identified" ));
dwFlags = DCB_FUNCTION;
}
WOW32DriverCallback( pInstanceData->dwCallback,
dwFlags,
Handle,
LOWORD( uMsg ),
pInstanceData->dwCallbackInstance,
dwParam1,
dwParam2 );
}
break;
}
/*
** Now, free up any storage that was allocated during the waveOutOpen
** and waveInOpen. This should only be freed during the MM_WOM_CLOSE or
** MM_WIM_CLOSE message.
**
** Also, free up any storage that was allocated during the waveOutWrite
** and waveInAddBuffer call. This should only be freed during the
** MM_WOM_DONE or MM_WIM_DATA message.
*/
switch (uMsg) {
case MM_MIM_CLOSE:
case MM_MOM_CLOSE:
case MM_WIM_CLOSE:
case MM_WOM_CLOSE:
dprintf2(( "W32CommonDeviceOpen: Freeing device open buffer at %X",
pInstanceData ));
dprintf2(( "Alloc Midi count = %d", AllocMidiCount ));
dprintf2(( "Alloc Wave count = %d", AllocWaveCount ));
free_w( pInstanceData );
FREEHWAVEIN16( Handle );
break;
case MM_WIM_DATA:
case MM_WOM_DONE:
# if DBG
AllocWaveCount--;
dprintf2(( "W<< \t%8X (%d)", pWavehdr32, AllocWaveCount ));
# endif
free_w( pWavehdr32 );
break;
case MM_MIM_LONGDATA:
case MM_MIM_LONGERROR:
case MM_MOM_DONE:
# if DBG
AllocMidiCount--;
dprintf2(( "M<< \t%8X (%d)", pMidihdr32, AllocMidiCount ));
# endif
free_w( pMidihdr32 );
break;
}
}
#endif
Reference in a new issue View git blame Copy permalink