mmebuddy.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_SOUND_OVERLAPPED
struct	_MMFUNCTION_TABLE
struct	_SOUND_THREAD
struct	_SOUND_DEVICE
struct	_SOUND_DEVICE_INSTANCE
struct	_WAVEHDR_EXTENSION

Macros
#define	AllocateStruct(thing)    (thing*) AllocateMemory(sizeof(thing))
#define	StringLengthToBytes(chartype, string_length)    ( ( string_length + 1 ) * sizeof(chartype) )
#define	AllocateWideString(string_length)    (PWSTR) AllocateMemory(StringLengthToBytes(WCHAR, string_length))
#define	ZeroWideString(string)    ZeroMemory(string, StringLengthToBytes(WCHAR, wcslen(string)))
#define	CopyWideString(dest, source)    CopyMemory(dest, source, StringLengthToBytes(WCHAR, wcslen(source)))
#define	MinimumOf(value_a, value_b)    ( value_a < value_b ? value_a : value_b )
#define	MaximumOf(value_a, value_b)    ( value_a > value_b ? value_a : value_b )
#define	SOUND_DEVICE_TYPE_TO_INDEX(x)    ( x - MIN_SOUND_DEVICE_TYPE )
#define	INDEX_TO_SOUND_DEVICE_TYPE(x)    ( x + MIN_SOUND_DEVICE_TYPE )
#define	IsValidSoundDeviceType   IS_VALID_SOUND_DEVICE_TYPE
#define	VALIDATE_MMSYS_PARAMETER(parameter_condition)
#define	MMSUCCESS(result)    ( result == MMSYSERR_NOERROR )
#define	DEFINE_GETCAPS_FUNCTYPE(func_typename, caps_type)
#define	MmePrepareWaveHeader(private_handle, header)    PrepareWaveHeader((PSOUND_DEVICE_INSTANCE)private_handle, (PWAVEHDR)header)
#define	MmeUnprepareWaveHeader(private_handle, header)    UnprepareWaveHeader((PSOUND_DEVICE_INSTANCE)private_handle, (PWAVEHDR)header)
#define	MmeWriteWaveHeader(private_handle, header)    WriteWaveHeader((PSOUND_DEVICE_INSTANCE)private_handle, (PWAVEHDR)header)

Typedefs
typedef UCHAR	MMDEVICE_TYPE
typedef UCHAR *	PMMDEVICE_TYPE
typedef struct _SOUND_OVERLAPPED	SOUND_OVERLAPPED
typedef struct _SOUND_OVERLAPPED *	PSOUND_OVERLAPPED
typedef MMRESULT(*	WAVE_COMMIT_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN PVOID OffsetPtr, IN DWORD Bytes, IN PSOUND_OVERLAPPED Overlap, IN LPOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine)
typedef MMRESULT(*	MMMIXERQUERY_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN DWORD DeviceId, IN UINT uMsg, IN LPVOID Parameter, IN DWORD Flags)
typedef MMRESULT(*	MMWAVEQUERYFORMATSUPPORT_FUNC) (IN struct _SOUND_DEVICE *Device, IN PWAVEFORMATEX WaveFormat, IN DWORD WaveFormatSize)
typedef MMRESULT(*	MMWAVESETFORMAT_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *Instance, IN DWORD DeviceId, IN PWAVEFORMATEX WaveFormat, IN DWORD WaveFormatSize)
typedef MMRESULT(*	MMOPEN_FUNC) (IN struct _SOUND_DEVICE *SoundDevice, OUT PVOID *Handle)
typedef MMRESULT(*	MMCLOSE_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN PVOID Handle)
typedef MMRESULT(*	MMWAVEHEADER_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN PWAVEHDR WaveHeader)
typedef MMRESULT(*	MMBUFFER_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN PVOID Buffer, IN DWORD Length)
typedef MMRESULT(*	MMGETPOS_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN MMTIME *Time)
typedef MMRESULT(*	MMSETSTATE_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN BOOL bStart)
typedef MMRESULT(*	MMQUERYDEVICEINTERFACESTRING_FUNC) (IN MMDEVICE_TYPE DeviceType, IN DWORD DeviceId, IN LPWSTR Interface, IN DWORD InterfaceLength, OUT DWORD *InterfaceSize)
typedef MMRESULT(*	MMRESETSTREAM_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN MMDEVICE_TYPE DeviceType, IN BOOLEAN bStartReset)
typedef struct _MMFUNCTION_TABLE	MMFUNCTION_TABLE
typedef struct _MMFUNCTION_TABLE *	PMMFUNCTION_TABLE
typedef MMRESULT(*	SOUND_THREAD_REQUEST_HANDLER) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN PVOID Parameter)
typedef struct _SOUND_THREAD	SOUND_THREAD
typedef struct _SOUND_THREAD *	PSOUND_THREAD
typedef struct _SOUND_DEVICE	SOUND_DEVICE
typedef struct _SOUND_DEVICE *	PSOUND_DEVICE
typedef struct _SOUND_DEVICE_INSTANCE	SOUND_DEVICE_INSTANCE
typedef struct _SOUND_DEVICE_INSTANCE *	PSOUND_DEVICE_INSTANCE
typedef struct _WAVEHDR_EXTENSION	WAVEHDR_EXTENSION
typedef struct _WAVEHDR_EXTENSION *	PWAVEHDR_EXTENSION

Functions
	DEFINE_GETCAPS_FUNCTYPE (MMGETCAPS_FUNC, PVOID)
	DEFINE_GETCAPS_FUNCTYPE (MMGETWAVEOUTCAPS_FUNC, LPWAVEOUTCAPS)
	DEFINE_GETCAPS_FUNCTYPE (MMGETWAVEINCAPS_FUNC, LPWAVEINCAPS)
	DEFINE_GETCAPS_FUNCTYPE (MMGETMIDIOUTCAPS_FUNC, LPMIDIOUTCAPS)
	DEFINE_GETCAPS_FUNCTYPE (MMGETMIDIINCAPS_FUNC, LPMIDIINCAPS)
MMRESULT	InitEntrypointMutexes (VOID)
VOID	CleanupEntrypointMutexes (VOID)
VOID	AcquireEntrypointMutex (IN MMDEVICE_TYPE DeviceType)
VOID	ReleaseEntrypointMutex (IN MMDEVICE_TYPE DeviceType)
VOID	NotifyMmeClient (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN UINT Message, IN DWORD_PTR Parameter)
MMRESULT	MmeGetSoundDeviceCapabilities (IN MMDEVICE_TYPE DeviceType, IN DWORD DeviceId, IN PVOID Capabilities, IN DWORD CapabilitiesSize)
MMRESULT	MmeOpenDevice (IN MMDEVICE_TYPE DeviceType, IN UINT DeviceId, IN LPWAVEOPENDESC OpenParameters, IN DWORD Flags, OUT DWORD_PTR *PrivateHandle)
MMRESULT	MmeCloseDevice (IN DWORD_PTR PrivateHandle)
MMRESULT	MmeGetPosition (IN MMDEVICE_TYPE DeviceType, IN DWORD DeviceId, IN DWORD_PTR PrivateHandle, IN MMTIME *Time, IN DWORD Size)
MMRESULT	MmeGetDeviceInterfaceString (IN MMDEVICE_TYPE DeviceType, IN DWORD DeviceId, IN LPWSTR Interface, IN DWORD InterfaceLength, OUT DWORD *InterfaceSize)
MMRESULT	MmeSetState (IN DWORD_PTR PrivateHandle, IN BOOL bStart)
MMRESULT	MmeResetWavePlayback (IN DWORD_PTR PrivateHandle)
MMRESULT	GetSoundDeviceCapabilities (IN PSOUND_DEVICE SoundDevice, IN DWORD DeviceId, OUT PVOID Capabilities, IN DWORD CapabilitiesSize)
ULONG	GetSoundDeviceCount (IN MMDEVICE_TYPE DeviceType)
BOOLEAN	IsValidSoundDevice (IN PSOUND_DEVICE SoundDevice)
MMRESULT	ListSoundDevice (IN MMDEVICE_TYPE DeviceType, IN PVOID Identifier OPTIONAL, OUT PSOUND_DEVICE *SoundDevice OPTIONAL)
MMRESULT	UnlistSoundDevice (IN MMDEVICE_TYPE DeviceType, IN PSOUND_DEVICE SoundDevice)
MMRESULT	UnlistSoundDevices (IN MMDEVICE_TYPE DeviceType)
VOID	UnlistAllSoundDevices (VOID)
MMRESULT	GetSoundDevice (IN MMDEVICE_TYPE DeviceType, IN DWORD DeviceIndex, OUT PSOUND_DEVICE *Device)
MMRESULT	GetSoundDeviceIdentifier (IN PSOUND_DEVICE SoundDevice, OUT PVOID *Identifier)
MMRESULT	GetSoundDeviceType (IN PSOUND_DEVICE SoundDevice, OUT PMMDEVICE_TYPE DeviceType)
MMRESULT	SetSoundDeviceFunctionTable (IN PSOUND_DEVICE SoundDevice, IN PMMFUNCTION_TABLE FunctionTable)
MMRESULT	GetSoundDeviceFunctionTable (IN PSOUND_DEVICE SoundDevice, OUT PMMFUNCTION_TABLE *FunctionTable)
BOOLEAN	IsValidSoundDeviceInstance (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance)
MMRESULT	CreateSoundDeviceInstance (IN PSOUND_DEVICE SoundDevice, OUT PSOUND_DEVICE_INSTANCE *SoundDeviceInstance)
MMRESULT	DestroySoundDeviceInstance (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance)
MMRESULT	DestroyAllSoundDeviceInstances (IN PSOUND_DEVICE SoundDevice)
MMRESULT	GetSoundDeviceFromInstance (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, OUT PSOUND_DEVICE *SoundDevice)
MMRESULT	GetSoundDeviceInstanceHandle (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, OUT PVOID *Handle)
MMRESULT	SetSoundDeviceInstanceMmeData (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN HDRVR MmeHandle, IN DWORD_PTR ClientCallback, IN DWORD_PTR ClientCallbackData, IN DWORD Flags)
MMRESULT	CreateSoundThread (OUT PSOUND_THREAD *Thread)
MMRESULT	DestroySoundThread (IN PSOUND_THREAD Thread)
MMRESULT	CallSoundThread (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN SOUND_THREAD_REQUEST_HANDLER RequestHandler, IN PVOID Parameter OPTIONAL)
PVOID	AllocateMemory (IN UINT Size)
VOID	FreeMemory (IN PVOID Pointer)
UINT	GetMemoryAllocationCount (VOID)
UINT	GetDigitCount (IN UINT Number)
MMRESULT	Win32ErrorToMmResult (IN UINT ErrorCode)
MMRESULT	TranslateInternalMmResult (IN MMRESULT Result)
MMRESULT	QueryWaveDeviceFormatSupport (IN PSOUND_DEVICE SoundDevice, IN LPWAVEFORMATEX Format, IN DWORD FormatSize)
MMRESULT	SetWaveDeviceFormat (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN DWORD DeviceId, IN LPWAVEFORMATEX Format, IN DWORD FormatSize)
MMRESULT	EnqueueWaveHeader (PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN PVOID Parameter)
VOID	CompleteWaveHeader (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN PWAVEHDR Header)
MMRESULT	PrepareWaveHeader (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN PWAVEHDR Header)
MMRESULT	UnprepareWaveHeader (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN PWAVEHDR Header)
MMRESULT	WriteWaveHeader (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN PWAVEHDR Header)
VOID	DoWaveStreaming (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance)
VOID CALLBACK	CompleteIO (IN DWORD dwErrorCode, IN DWORD dwNumberOfBytesTransferred, IN LPOVERLAPPED lpOverlapped)
MMRESULT	CommitWaveHeaderToKernelDevice (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN PWAVEHDR Header, IN WAVE_COMMIT_FUNC CommitFunction)
MMRESULT	WriteFileEx_Committer (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN PVOID OffsetPtr, IN DWORD Length, IN PSOUND_OVERLAPPED Overlap, IN LPOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine)
MMRESULT	StopStreaming (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance)
VOID	InitiateSoundStreaming (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance)
MMRESULT	OpenKernelSoundDeviceByName (IN PWSTR DevicePath, IN BOOLEAN ReadOnly, OUT PHANDLE Handle)
MMRESULT	OpenKernelSoundDevice (IN PSOUND_DEVICE SoundDevice, IN BOOLEAN ReadOnly, OUT PHANDLE Handle)
MMRESULT	CloseKernelSoundDevice (IN HANDLE Handle)
MMRESULT	SyncOverlappedDeviceIoControl (IN HANDLE SoundDeviceInstance, IN DWORD IoControlCode, IN LPVOID InBuffer, IN DWORD InBufferSize, OUT LPVOID OutBuffer, IN DWORD OutBufferSize, OUT LPDWORD BytesTransferred OPTIONAL)

Macro Definition Documentation

AllocateStruct

#define AllocateStruct

(

thing

)

(thing*) AllocateMemory(sizeof(thing))

Definition at line 27 of file mmebuddy.h.

AllocateWideString

#define AllocateWideString

(

string_length

)

(PWSTR) AllocateMemory(StringLengthToBytes(WCHAR, string_length))

Definition at line 33 of file mmebuddy.h.

CopyWideString

#define CopyWideString	(		dest,
			source
	)		CopyMemory(dest, source, StringLengthToBytes(WCHAR, wcslen(source)))

Definition at line 39 of file mmebuddy.h.

DEFINE_GETCAPS_FUNCTYPE

#define DEFINE_GETCAPS_FUNCTYPE	(		func_typename,
			caps_type
	)

Value:

    typedef MMRESULT (*func_typename)( \
        IN  struct _SOUND_DEVICE* SoundDevice, \
        IN  DWORD DeviceId, \
        OUT caps_type Capabilities, \
        IN  DWORD CapabilitiesSize);

Definition at line 93 of file mmebuddy.h.

INDEX_TO_SOUND_DEVICE_TYPE

#define INDEX_TO_SOUND_DEVICE_TYPE

(

x

)

( x + MIN_SOUND_DEVICE_TYPE )

Definition at line 61 of file mmebuddy.h.

IsValidSoundDeviceType

#define IsValidSoundDeviceType   IS_VALID_SOUND_DEVICE_TYPE

Definition at line 69 of file mmebuddy.h.

MaximumOf

#define MaximumOf	(		value_a,
			value_b
	)		( value_a > value_b ? value_a : value_b )

Definition at line 50 of file mmebuddy.h.

MinimumOf

#define MinimumOf	(		value_a,
			value_b
	)		( value_a < value_b ? value_a : value_b )

Definition at line 47 of file mmebuddy.h.

MmePrepareWaveHeader

#define MmePrepareWaveHeader	(		private_handle,
			header
	)		PrepareWaveHeader((PSOUND_DEVICE_INSTANCE)private_handle, (PWAVEHDR)header)

Definition at line 387 of file mmebuddy.h.

MmeUnprepareWaveHeader

#define MmeUnprepareWaveHeader	(		private_handle,
			header
	)		UnprepareWaveHeader((PSOUND_DEVICE_INSTANCE)private_handle, (PWAVEHDR)header)

Definition at line 390 of file mmebuddy.h.

MmeWriteWaveHeader

#define MmeWriteWaveHeader	(		private_handle,
			header
	)		WriteWaveHeader((PSOUND_DEVICE_INSTANCE)private_handle, (PWAVEHDR)header)

Definition at line 393 of file mmebuddy.h.

MMSUCCESS

#define MMSUCCESS

(

result

)

( result == MMSYSERR_NOERROR )

Definition at line 80 of file mmebuddy.h.

SOUND_DEVICE_TYPE_TO_INDEX

#define SOUND_DEVICE_TYPE_TO_INDEX

(

x

)

( x - MIN_SOUND_DEVICE_TYPE )

Definition at line 58 of file mmebuddy.h.

StringLengthToBytes

#define StringLengthToBytes	(		chartype,
			string_length
	)		( ( string_length + 1 ) * sizeof(chartype) )

Definition at line 30 of file mmebuddy.h.

VALIDATE_MMSYS_PARAMETER

#define VALIDATE_MMSYS_PARAMETER

(

parameter_condition

)

Value:

    { \
        if ( ! (parameter_condition) ) \
        { \
            SND_ERR(L"FAILED parameter check: %hS at File %S Line %lu\n", #parameter_condition, __FILE__, __LINE__); \
            return MMSYSERR_INVALPARAM; \
        } \
    }

Definition at line 71 of file mmebuddy.h.

ZeroWideString

#define ZeroWideString

(

string

)

ZeroMemory(string, StringLengthToBytes(WCHAR, wcslen(string)))

Definition at line 36 of file mmebuddy.h.

Typedef Documentation

MMBUFFER_FUNC

typedef MMRESULT(* MMBUFFER_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN PVOID Buffer, IN DWORD Length)

Definition at line 166 of file mmebuddy.h.

MMCLOSE_FUNC

typedef MMRESULT(* MMCLOSE_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN PVOID Handle)

Definition at line 158 of file mmebuddy.h.

MMDEVICE_TYPE

typedef UCHAR MMDEVICE_TYPE

Definition at line 88 of file mmebuddy.h.

MMFUNCTION_TABLE

typedef struct _MMFUNCTION_TABLE MMFUNCTION_TABLE

MMGETPOS_FUNC

typedef MMRESULT(* MMGETPOS_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN MMTIME *Time)

Definition at line 171 of file mmebuddy.h.

MMMIXERQUERY_FUNC

typedef MMRESULT(* MMMIXERQUERY_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN DWORD DeviceId, IN UINT uMsg, IN LPVOID Parameter, IN DWORD Flags)

Definition at line 136 of file mmebuddy.h.

MMOPEN_FUNC

typedef MMRESULT(* MMOPEN_FUNC) (IN struct _SOUND_DEVICE *SoundDevice, OUT PVOID *Handle)

Definition at line 154 of file mmebuddy.h.

MMQUERYDEVICEINTERFACESTRING_FUNC

typedef MMRESULT(* MMQUERYDEVICEINTERFACESTRING_FUNC) (IN MMDEVICE_TYPE DeviceType, IN DWORD DeviceId, IN LPWSTR Interface, IN DWORD InterfaceLength, OUT DWORD *InterfaceSize)

Definition at line 181 of file mmebuddy.h.

MMRESETSTREAM_FUNC

typedef MMRESULT(* MMRESETSTREAM_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN MMDEVICE_TYPE DeviceType, IN BOOLEAN bStartReset)

Definition at line 188 of file mmebuddy.h.

MMSETSTATE_FUNC

typedef MMRESULT(* MMSETSTATE_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN BOOL bStart)

Definition at line 176 of file mmebuddy.h.

MMWAVEHEADER_FUNC

typedef MMRESULT(* MMWAVEHEADER_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN PWAVEHDR WaveHeader)

Definition at line 162 of file mmebuddy.h.

MMWAVEQUERYFORMATSUPPORT_FUNC

typedef MMRESULT(* MMWAVEQUERYFORMATSUPPORT_FUNC) (IN struct _SOUND_DEVICE *Device, IN PWAVEFORMATEX WaveFormat, IN DWORD WaveFormatSize)

Definition at line 143 of file mmebuddy.h.

MMWAVESETFORMAT_FUNC

typedef MMRESULT(* MMWAVESETFORMAT_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *Instance, IN DWORD DeviceId, IN PWAVEFORMATEX WaveFormat, IN DWORD WaveFormatSize)

Definition at line 148 of file mmebuddy.h.

PMMDEVICE_TYPE

typedef UCHAR * PMMDEVICE_TYPE

Definition at line 88 of file mmebuddy.h.

PMMFUNCTION_TABLE

typedef struct _MMFUNCTION_TABLE * PMMFUNCTION_TABLE

PSOUND_DEVICE

typedef struct _SOUND_DEVICE * PSOUND_DEVICE

PSOUND_DEVICE_INSTANCE

typedef struct _SOUND_DEVICE_INSTANCE * PSOUND_DEVICE_INSTANCE

PSOUND_OVERLAPPED

typedef struct _SOUND_OVERLAPPED * PSOUND_OVERLAPPED

PSOUND_THREAD

typedef struct _SOUND_THREAD * PSOUND_THREAD

PWAVEHDR_EXTENSION

typedef struct _WAVEHDR_EXTENSION * PWAVEHDR_EXTENSION

SOUND_DEVICE

typedef struct _SOUND_DEVICE SOUND_DEVICE

SOUND_DEVICE_INSTANCE

typedef struct _SOUND_DEVICE_INSTANCE SOUND_DEVICE_INSTANCE

SOUND_OVERLAPPED

typedef struct _SOUND_OVERLAPPED SOUND_OVERLAPPED

SOUND_THREAD

typedef struct _SOUND_THREAD SOUND_THREAD

SOUND_THREAD_REQUEST_HANDLER

typedef MMRESULT(* SOUND_THREAD_REQUEST_HANDLER) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN PVOID Parameter)

Definition at line 230 of file mmebuddy.h.

WAVE_COMMIT_FUNC

typedef MMRESULT(* WAVE_COMMIT_FUNC) (IN struct _SOUND_DEVICE_INSTANCE *SoundDeviceInstance, IN PVOID OffsetPtr, IN DWORD Bytes, IN PSOUND_OVERLAPPED Overlap, IN LPOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine)

Definition at line 129 of file mmebuddy.h.

WAVEHDR_EXTENSION

typedef struct _WAVEHDR_EXTENSION WAVEHDR_EXTENSION

Function Documentation

AcquireEntrypointMutex()

VOID AcquireEntrypointMutex

(

IN MMDEVICE_TYPE

DeviceType

)

Definition at line 75 of file reentrancy.c.

{
    UCHAR i;
 
    SND_ASSERT( IS_VALID_SOUND_DEVICE_TYPE(DeviceType) );
    i = SOUND_DEVICE_TYPE_TO_INDEX(DeviceType);
 
    SND_ASSERT( EntrypointMutexes[i] );
 
    WaitForSingleObject(EntrypointMutexes[i], INFINITE);
}

Referenced by auxMessage(), midMessage(), MmeCloseDevice(), MmeOpenDevice(), modMessage(), mxdMessage(), widMessage(), and wodMessage().

AllocateMemory()

PVOID AllocateMemory

(

IN UINT

Size

)

Definition at line 20 of file utility.c.

{
    PVOID Pointer = NULL;
 
    if ( ! ProcessHeapHandle )
        ProcessHeapHandle = GetProcessHeap();
 
    Pointer = HeapAlloc(ProcessHeapHandle, HEAP_ZERO_MEMORY, Size);
 
    if ( ! Pointer )
        return NULL;
 
    ++ CurrentAllocations;
 
    return Pointer;
}

CallSoundThread()

MMRESULT CallSoundThread	(	IN PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		IN SOUND_THREAD_REQUEST_HANDLER	RequestHandler,
		IN PVOID Parameter	OPTIONAL
	)

Definition at line 71 of file thread.c.

{
    PSOUND_THREAD Thread;
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceInstance(SoundDeviceInstance) );
    VALIDATE_MMSYS_PARAMETER( RequestHandler );
 
    Thread = SoundDeviceInstance->Thread;
 
    SND_TRACE(L"Waiting for READY event\n");
    WaitForSingleObject(Thread->Events.Ready, INFINITE);
 
    Thread->Request.Result = MMSYSERR_NOTSUPPORTED;
    Thread->Request.Handler = RequestHandler;
    Thread->Request.SoundDeviceInstance = SoundDeviceInstance;
    Thread->Request.Parameter = Parameter;
 
    /* Notify the thread it has work to do */
    SND_TRACE(L"Setting REQUEST event\n");
    SetEvent(Thread->Events.Request);
 
    /* Wait for the work to be done */
    SND_TRACE(L"Waiting for DONE event\n");
    WaitForSingleObject(Thread->Events.Done, INFINITE);
 
    return Thread->Request.Result;
}

Referenced by StopStreaming(), WaveActivateSoundStreaming(), WaveHeaderOperation(), and WriteWaveHeader().

CleanupEntrypointMutexes()

VOID CleanupEntrypointMutexes

(

VOID

)

CloseKernelSoundDevice()

MMRESULT CloseKernelSoundDevice

(

IN HANDLE

Handle

)

Definition at line 58 of file kernel.c.

{
    VALIDATE_MMSYS_PARAMETER( Handle );
 
    CloseHandle(Handle);
 
    return MMSYSERR_NOERROR;
}

Referenced by CloseNt4SoundDevice(), GetNt4SoundDeviceCapabilities(), and QueryNt4WaveDeviceFormatSupport().

CommitWaveHeaderToKernelDevice()

MMRESULT CommitWaveHeaderToKernelDevice	(	IN PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		IN PWAVEHDR	Header,
		IN WAVE_COMMIT_FUNC	CommitFunction
	)

CompleteIO()

VOID CALLBACK CompleteIO	(	IN DWORD	dwErrorCode,
		IN DWORD	dwNumberOfBytesTransferred,
		IN LPOVERLAPPED	lpOverlapped
	)

Definition at line 168 of file streaming.c.

{
    MMDEVICE_TYPE DeviceType;
    PSOUND_DEVICE SoundDevice;
    PSOUND_DEVICE_INSTANCE SoundDeviceInstance;
    PSOUND_OVERLAPPED SoundOverlapped = (PSOUND_OVERLAPPED) lpOverlapped;
    PWAVEHDR WaveHdr;
    PWAVEHDR_EXTENSION HdrExtension;
    MMRESULT Result;
    DWORD Bytes;
 
    WaveHdr = (PWAVEHDR) SoundOverlapped->Header;
    SND_ASSERT( WaveHdr );
 
    HdrExtension = (PWAVEHDR_EXTENSION) WaveHdr->reserved;
    SND_ASSERT( HdrExtension );
 
    SoundDeviceInstance = SoundOverlapped->SoundDeviceInstance;
 
    Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
    SND_ASSERT( MMSUCCESS(Result) );
 
    Result = GetSoundDeviceType(SoundDevice, &DeviceType);
    SND_ASSERT( MMSUCCESS(Result) );
 
    do
    {
 
        /* We have an available buffer now */
        -- SoundDeviceInstance->OutstandingBuffers;
 
        /* Did we finish a WAVEHDR and aren't looping? */
        if (HdrExtension->BytesCompleted + dwNumberOfBytesTransferred >= WaveHdr->dwBufferLength &&
            SoundDeviceInstance->LoopsRemaining == 0)
        {
            /* Wave buffer fully completed */
            Bytes = WaveHdr->dwBufferLength - HdrExtension->BytesCompleted;
 
            HdrExtension->BytesCompleted += Bytes;
            dwNumberOfBytesTransferred -= Bytes;
 
            CompleteWaveHeader(SoundDeviceInstance, WaveHdr);
            SND_TRACE(L"%d/%d bytes of wavehdr completed\n", HdrExtension->BytesCompleted, WaveHdr->dwBufferLength);
        }
        else
        {
            /* Do we loop a header? */
            if (HdrExtension->BytesCommitted == WaveHdr->dwBufferLength &&
                SoundDeviceInstance->LoopsRemaining != 0)
            {
                /* Reset amount of bytes and decrement loop count, to play next iteration */
                HdrExtension->BytesCommitted = 0;
 
                if (SoundDeviceInstance->LoopsRemaining != INFINITE)
                    --SoundDeviceInstance->LoopsRemaining;
                SND_TRACE(L"Looping the header, remaining loops %u\n", SoundDeviceInstance->LoopsRemaining);
            }
            else
            {
                /* Partially completed */
                HdrExtension->BytesCompleted += dwNumberOfBytesTransferred;
                SND_TRACE(L"%u/%u bytes of wavehdr completed\n", HdrExtension->BytesCompleted, WaveHdr->dwBufferLength);
            }
 
            break;
        }
 
        /* Move to next wave header */
        WaveHdr = WaveHdr->lpNext;
 
        if (!WaveHdr)
        {
            /* No following WaveHdr */
            SND_ASSERT(dwNumberOfBytesTransferred == 0);
            break;
        }
 
        HdrExtension = (PWAVEHDR_EXTENSION) WaveHdr->reserved;
        SND_ASSERT( HdrExtension );
 
 
    }while(dwNumberOfBytesTransferred);
 
    // AUDIO-BRANCH DIFF
    // completion callback is performed in a thread
    DoWaveStreaming(SoundDeviceInstance);
 
    //CompleteWavePortion(SoundDeviceInstance, dwNumberOfBytesTransferred);
 
    FreeMemory(lpOverlapped);
}

Referenced by DoWaveStreaming().

CompleteWaveHeader()

VOID CompleteWaveHeader	(	IN PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		IN PWAVEHDR	Header
	)

Definition at line 274 of file header.c.

{
    PWAVEHDR PrevHdr = NULL, CurrHdr = NULL;
    PWAVEHDR_EXTENSION Extension;
    PSOUND_DEVICE SoundDevice;
    MMDEVICE_TYPE DeviceType;
    MMRESULT Result;
 
    SND_TRACE(L"BUFFER COMPLETE :)\n");
 
    // TODO: Set header flags?
    // TODO: Call client
    // TODO: Streaming
 
    //DoWaveStreaming(SoundDeviceInstance);
 
    Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
    SND_ASSERT( MMSUCCESS(Result) );
    Result = GetSoundDeviceType(SoundDevice, &DeviceType);
    SND_ASSERT( MMSUCCESS(Result) );
 
    Extension = (PWAVEHDR_EXTENSION)Header->reserved;
    SND_ASSERT( Extension );
 
    /* Remove the header from the queue, like so */
    if ( SoundDeviceInstance->HeadWaveHeader == Header )
    {
        SoundDeviceInstance->HeadWaveHeader = Header->lpNext;
 
        SND_TRACE(L"Dropping head node\n");
 
        /* If nothing after the head, then there is no tail */
        if ( Header->lpNext == NULL )
        {
            SND_TRACE(L"Dropping tail node\n");
            SoundDeviceInstance->TailWaveHeader = NULL;
        }
    }
    else
    {
        PrevHdr = NULL;
        CurrHdr = SoundDeviceInstance->HeadWaveHeader;
 
        SND_TRACE(L"Relinking nodes\n");
 
        while ( CurrHdr != Header )
        {
            PrevHdr = CurrHdr;
            CurrHdr = CurrHdr->lpNext;
            SND_ASSERT( CurrHdr );
        }
 
        SND_ASSERT( PrevHdr );
 
        PrevHdr->lpNext = CurrHdr->lpNext;
 
        /* If this is the tail node, update the tail */
        if ( Header->lpNext == NULL )
        {
            SND_TRACE(L"Updating tail node\n");
            SoundDeviceInstance->TailWaveHeader = PrevHdr;
        }
    }
 
    /* Make sure we're not using this as the current buffer any more, either! */
/*
    if ( SoundDeviceInstance->CurrentWaveHeader == Header )
    {
        SoundDeviceInstance->CurrentWaveHeader = Header->lpNext;
    }
*/
 
    DUMP_WAVEHDR_QUEUE(SoundDeviceInstance);
 
    SND_TRACE(L"Returning buffer to client...\n");
 
    /* Update the header */
    Header->dwFlags &= ~WHDR_INQUEUE;
    Header->dwFlags |= WHDR_DONE;
 
    if ( DeviceType == WAVE_IN_DEVICE_TYPE )
    {
        // FIXME: We won't be called on incomplete buffer!
        Header->dwBytesRecorded = Extension->BytesCompleted;
    }
 
    /* Safe to do this without thread protection, as we're done with the header */
    NotifyMmeClient(SoundDeviceInstance,
                    DeviceType == WAVE_OUT_DEVICE_TYPE ? WOM_DONE : WIM_DATA,
                    (DWORD_PTR)Header);
}

Referenced by CompleteIO(), and StopStreamingInSoundThread().

CreateSoundDeviceInstance()

MMRESULT CreateSoundDeviceInstance	(	IN PSOUND_DEVICE	SoundDevice,
		OUT PSOUND_DEVICE_INSTANCE *	SoundDeviceInstance
	)

Definition at line 162 of file deviceinstance.c.

{
    MMRESULT Result;
    PMMFUNCTION_TABLE FunctionTable;
 
    SND_TRACE(L"Creating a sound device instance\n");
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDevice(SoundDevice) );
    VALIDATE_MMSYS_PARAMETER( SoundDeviceInstance != NULL );
 
    Result = AllocateSoundDeviceInstance(SoundDeviceInstance);
 
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    /* Get the "open" routine from the function table, and validate it */
    Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
    if ( ! MMSUCCESS(Result) )
    {
        FreeSoundDeviceInstance(*SoundDeviceInstance);
        return TranslateInternalMmResult(Result);
    }
 
    if ( FunctionTable->Open == NULL )
    {
        FreeSoundDeviceInstance(*SoundDeviceInstance);
        return MMSYSERR_NOTSUPPORTED;
    }
 
    /* Set up the members of the structure */
    (*SoundDeviceInstance)->Next = NULL;
    (*SoundDeviceInstance)->Device = SoundDevice;
    (*SoundDeviceInstance)->Handle = NULL;
    (*SoundDeviceInstance)->Thread = NULL;
 
    (*SoundDeviceInstance)->WinMM.Handle = INVALID_HANDLE_VALUE;
    (*SoundDeviceInstance)->WinMM.ClientCallback = 0;
    (*SoundDeviceInstance)->WinMM.ClientCallbackInstanceData = 0;
    (*SoundDeviceInstance)->WinMM.Flags = 0;
 
    /* Initialise the members of the struct used by the sound thread */
    (*SoundDeviceInstance)->HeadWaveHeader = NULL;
    (*SoundDeviceInstance)->TailWaveHeader = NULL;
 
    (*SoundDeviceInstance)->OutstandingBuffers = 0;
 
    (*SoundDeviceInstance)->LoopsRemaining = 0;
 
    /* Create the streaming thread (TODO - is this for wave only?) */
    Result = CreateSoundThread(&(*SoundDeviceInstance)->Thread);
    if ( ! MMSUCCESS(Result) )
    {
        FreeSoundDeviceInstance(*SoundDeviceInstance);
        return TranslateInternalMmResult(Result);
    }
 
    /* Add the instance to the list */
    Result = ListSoundDeviceInstance(SoundDevice, *SoundDeviceInstance);
    if ( ! MMSUCCESS(Result) )
    {
        FreeSoundDeviceInstance(*SoundDeviceInstance);
        return TranslateInternalMmResult(Result);
    }
 
    /* Try and open the device */
    Result = FunctionTable->Open(SoundDevice, (&(*SoundDeviceInstance)->Handle));
    if ( ! MMSUCCESS(Result) )
    {
        UnlistSoundDeviceInstance(*SoundDeviceInstance);
        FreeSoundDeviceInstance(*SoundDeviceInstance);
        return TranslateInternalMmResult(Result);
    }
 
    return MMSYSERR_NOERROR;
}

Referenced by MmeOpenDevice().

CreateSoundThread()

MMRESULT CreateSoundThread

(

OUT PSOUND_THREAD *

Thread

)

Definition at line 209 of file thread.c.

{
    MMRESULT Result;
    PSOUND_THREAD NewThread;
 
    VALIDATE_MMSYS_PARAMETER( Thread );
 
    NewThread = AllocateStruct(SOUND_THREAD);
    if ( ! NewThread )
        return MMSYSERR_NOMEM;
 
    /* Prepare the events we'll be using to sync. everything */
    Result = CreateSoundThreadEvents(&NewThread->Events.Ready,
                                     &NewThread->Events.Request,
                                     &NewThread->Events.Done);
 
    if ( ! MMSUCCESS(Result) )
    {
        FreeMemory(NewThread);
        return TranslateInternalMmResult(Result);
    }
 
    SND_TRACE(L"Creating a sound thread\n");
    NewThread->Handle = CreateThread(NULL,
                                     0,
                                     &SoundThreadMain,
                                     (LPVOID) NewThread,
                                     CREATE_SUSPENDED,
                                     NULL);
 
    /* Something went wrong, bail out! */
    if ( NewThread->Handle == INVALID_HANDLE_VALUE )
    {
        SND_ERR(L"Sound thread creation failed!\n");
        DestroySoundThreadEvents(NewThread->Events.Ready,
                                 NewThread->Events.Request,
                                 NewThread->Events.Done);
 
        FreeMemory(NewThread);
 
        return Win32ErrorToMmResult(GetLastError());
    }
 
    /* Wake the thread up */
    if ( ResumeThread(NewThread->Handle) == -1 )
    {
        SND_ERR(L"Failed to resume thread!\n");
        CloseHandle(NewThread->Handle);
        DestroySoundThreadEvents(NewThread->Events.Ready,
                                 NewThread->Events.Request,
                                 NewThread->Events.Done);
 
        FreeMemory(NewThread);
        return Win32ErrorToMmResult(GetLastError());
    }
 
    /* If all is well we can now give the thread to the caller */
    *Thread = NewThread;
    return MMSYSERR_NOERROR;
}

Referenced by CreateSoundDeviceInstance().

DEFINE_GETCAPS_FUNCTYPE() [1/5]

DEFINE_GETCAPS_FUNCTYPE	(	MMGETCAPS_FUNC	,
		PVOID
	)

DEFINE_GETCAPS_FUNCTYPE() [2/5]

DEFINE_GETCAPS_FUNCTYPE	(	MMGETMIDIINCAPS_FUNC	,
		LPMIDIINCAPS
	)

DEFINE_GETCAPS_FUNCTYPE() [3/5]

DEFINE_GETCAPS_FUNCTYPE	(	MMGETMIDIOUTCAPS_FUNC	,
		LPMIDIOUTCAPS
	)

DEFINE_GETCAPS_FUNCTYPE() [4/5]

DEFINE_GETCAPS_FUNCTYPE	(	MMGETWAVEINCAPS_FUNC	,
		LPWAVEINCAPS
	)

DEFINE_GETCAPS_FUNCTYPE() [5/5]

DEFINE_GETCAPS_FUNCTYPE	(	MMGETWAVEOUTCAPS_FUNC	,
		LPWAVEOUTCAPS
	)

DestroyAllSoundDeviceInstances()

MMRESULT DestroyAllSoundDeviceInstances

(

IN PSOUND_DEVICE

SoundDevice

)

Definition at line 305 of file deviceinstance.c.

{
    MMRESULT Result;
    PSOUND_DEVICE_INSTANCE SoundDeviceInstance, NextDeviceInstance;
 
    SoundDeviceInstance = SoundDevice->HeadInstance;
 
    while ( SoundDeviceInstance )
    {
        NextDeviceInstance = SoundDeviceInstance->Next;
        Result = DestroySoundDeviceInstance(SoundDeviceInstance);
        SND_ASSERT( MMSUCCESS(Result) );
        SoundDeviceInstance = NextDeviceInstance;
    }
 
    return MMSYSERR_NOERROR;
}

DestroySoundDeviceInstance()

MMRESULT DestroySoundDeviceInstance

(

IN PSOUND_DEVICE_INSTANCE

SoundDeviceInstance

)

Definition at line 241 of file deviceinstance.c.

{
    MMRESULT Result;
    PMMFUNCTION_TABLE FunctionTable;
    PSOUND_DEVICE SoundDevice;
    PVOID Handle;
 
    SND_TRACE(L"Destroying a sound device instance\n");
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceInstance(SoundDeviceInstance) );
 
    Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    Result = GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    /* Get the "close" routine from the function table, and validate it */
    Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    SND_ASSERT( FunctionTable->Close );
    if ( FunctionTable->Close == NULL )
    {
        /* This indicates bad practice, really! If you can open, why not close?! */
        return MMSYSERR_NOTSUPPORTED;
    }
 
    /* Stop the streaming thread */
    if ( SoundDeviceInstance->Thread )
    {
        Result = DestroySoundThread(SoundDeviceInstance->Thread);
        SND_ASSERT( MMSUCCESS(Result) );    /* It should succeed! */
        if ( ! MMSUCCESS(Result ) )
        {
            return TranslateInternalMmResult(Result);
        }
    }
 
    /* Blank this out here */
    SoundDeviceInstance->Thread = NULL;
 
    /* Try and close the device */
    Result = FunctionTable->Close(SoundDeviceInstance, Handle);
    SND_ASSERT( MMSUCCESS(Result) );    /* It should succeed! */
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    /* Drop it from the list */
    Result = UnlistSoundDeviceInstance(SoundDeviceInstance);
    SND_ASSERT( MMSUCCESS(Result) );    /* It should succeed! */
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    FreeSoundDeviceInstance(SoundDeviceInstance);
 
    return MMSYSERR_NOERROR;
}

Referenced by DestroyAllSoundDeviceInstances(), and MmeCloseDevice().

DestroySoundThread()

MMRESULT DestroySoundThread

(

IN PSOUND_THREAD

Thread

)

Definition at line 272 of file thread.c.

{
    VALIDATE_MMSYS_PARAMETER( Thread );
    SND_ASSERT( Thread->Handle != INVALID_HANDLE_VALUE );
 
    SND_TRACE(L"Terminating sound thread\n");
 
    /* Tell the thread to terminate itself */
    TerminateSoundThread(Thread);
 
    SND_TRACE(L"Sound thread terminated, performing cleanup of thread resources\n");
 
    CloseHandle(Thread->Handle);    /* Is this needed? */
    Thread->Handle = INVALID_HANDLE_VALUE;
 
    DestroySoundThreadEvents(Thread->Events.Ready,
                             Thread->Events.Request,
                             Thread->Events.Done);
 
    /* Wipe and free the memory used for the thread */
    ZeroMemory(Thread, sizeof(SOUND_THREAD));
    FreeMemory(Thread);
 
    SND_TRACE(L"Finished thread cleanup\n");
 
    return MMSYSERR_NOERROR;
}

Referenced by DestroySoundDeviceInstance().

DoWaveStreaming()

VOID DoWaveStreaming

(

IN PSOUND_DEVICE_INSTANCE

SoundDeviceInstance

)

Definition at line 19 of file streaming.c.

{
    MMRESULT Result;
    MMDEVICE_TYPE DeviceType;
    PSOUND_DEVICE SoundDevice;
    PMMFUNCTION_TABLE FunctionTable;
    PWAVEHDR Header;
    PWAVEHDR_EXTENSION HeaderExtension;
 
    Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
    SND_ASSERT( MMSUCCESS(Result) );
 
    Result = GetSoundDeviceType(SoundDevice, &DeviceType);
    SND_ASSERT( MMSUCCESS(Result) );
 
    Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
    SND_ASSERT( MMSUCCESS(Result) );
    SND_ASSERT( FunctionTable );
    SND_ASSERT( FunctionTable->CommitWaveBuffer );
 
    /* No point in doing anything if no resources available to use */
    if ( SoundDeviceInstance->OutstandingBuffers >= SoundDeviceInstance->BufferCount )
    {
        SND_TRACE(L"DoWaveStreaming: No available buffers to stream with - doing nothing\n");
        return;
    }
 
    /* Is there any work to do? */
    Header = SoundDeviceInstance->HeadWaveHeader;
 
    if ( ! Header )
    {
        SND_TRACE(L"DoWaveStreaming: No work to do - doing nothing\n");
        return;
    }
 
    /* Do we need to loop a header? */
    if (DeviceType == WAVE_OUT_DEVICE_TYPE && (Header->dwFlags & WHDR_BEGINLOOP))
    {
        if ((Header->dwFlags & WHDR_ENDLOOP))
        {
            /* Get loop count */
            SoundDeviceInstance->LoopsRemaining = Header->dwLoops;
        }
        else
        {
            /* Report and help notice such a case */
            SND_WARN(L"Looping multiple headers is UNIMPLEMENTED. Will play once only\n");
            SND_ASSERT((Header->dwFlags & (WHDR_BEGINLOOP | WHDR_ENDLOOP)) == (WHDR_BEGINLOOP | WHDR_ENDLOOP));
        }
    }
 
    while ( ( SoundDeviceInstance->OutstandingBuffers < SoundDeviceInstance->BufferCount ) &&
            ( Header ) && SoundDeviceInstance->ResetInProgress == FALSE)
    {
        HeaderExtension = (PWAVEHDR_EXTENSION) Header->reserved;
        SND_ASSERT( HeaderExtension );
 
        /* Saniy checks */
        SND_ASSERT(Header->dwFlags & WHDR_PREPARED);
        SND_ASSERT(Header->dwFlags & WHDR_INQUEUE);
 
        /* Can never be *above* the length */
        SND_ASSERT( HeaderExtension->BytesCommitted <= Header->dwBufferLength );
 
        /* Is this header entirely committed? */
        if ( HeaderExtension->BytesCommitted == Header->dwBufferLength )
        {
            {
                /* Move on to the next header */
                SND_ASSERT(Header != Header->lpNext);
                Header = Header->lpNext;
            }
        }
        else
        {
            PSOUND_OVERLAPPED Overlap;
            LPVOID OffsetPtr;
            DWORD BytesRemaining, BytesToCommit;
            BOOL OK;
 
            /* Where within the header buffer to stream from */
            OffsetPtr = Header->lpData + HeaderExtension->BytesCommitted;
 
            /* How much of this header has not been committed */
            BytesRemaining = Header->dwBufferLength - HeaderExtension->BytesCommitted;
 
            /* We can commit anything up to the buffer size limit */
            BytesToCommit = BytesRemaining > SoundDeviceInstance->FrameSize ?
                            SoundDeviceInstance->FrameSize :
                            BytesRemaining;
 
            /* Should always have something to commit by this point */
            SND_ASSERT( BytesToCommit > 0 );
 
            /* We need a new overlapped info structure for each buffer */
            Overlap = AllocateStruct(SOUND_OVERLAPPED);
 
            if ( Overlap )
            {
                ZeroMemory(Overlap, sizeof(SOUND_OVERLAPPED));
                Overlap->SoundDeviceInstance = SoundDeviceInstance;
                Overlap->Header = Header;
 
                /* Adjust the commit-related counters */
                HeaderExtension->BytesCommitted += BytesToCommit;
                ++ SoundDeviceInstance->OutstandingBuffers;
 
                OK = MMSUCCESS(FunctionTable->CommitWaveBuffer(SoundDeviceInstance,
                                                               OffsetPtr,
                                                               BytesToCommit,
                                                               Overlap,
                                                               CompleteIO));
 
                if ( ! OK )
                {
                    /* Clean-up and try again on the next iteration (is this OK?) */
                    SND_WARN(L"FAILED\n");
 
                    FreeMemory(Overlap);
                    HeaderExtension->BytesCommitted -= BytesToCommit;
                    -- SoundDeviceInstance->OutstandingBuffers;
                }
            }
        }
    }
}

Referenced by CompleteIO(), EnqueueWaveHeader(), and PerformWaveStreaming().

EnqueueWaveHeader()

MMRESULT EnqueueWaveHeader	(	PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		IN PVOID	Parameter
	)

Definition at line 218 of file header.c.

{
    PWAVEHDR WaveHeader = (PWAVEHDR) Parameter;
 
    VALIDATE_MMSYS_PARAMETER( SoundDeviceInstance );
    VALIDATE_MMSYS_PARAMETER( Parameter );
 
    /* Initialise */
    WaveHeader->lpNext = NULL;
 
    /* Set the "in queue" flag */
    WaveHeader->dwFlags |= WHDR_INQUEUE;
 
    if ( ! SoundDeviceInstance->HeadWaveHeader )
    {
        /* This is the first header in the queue */
        SND_TRACE(L"Enqueued first wave header\n");
        SoundDeviceInstance->HeadWaveHeader = WaveHeader;
        SoundDeviceInstance->TailWaveHeader = WaveHeader;
 
        /* Only do wave streaming when the stream has not been paused */
        if (SoundDeviceInstance->bPaused == FALSE)
        {
            DoWaveStreaming(SoundDeviceInstance);
        }
    }
    else
    {
        /* There are already queued headers - make this one the tail */
        SND_TRACE(L"Enqueued next wave header\n");
 
        /* FIXME - Make sure that the buffer has not already been added to the list */
        if ( SoundDeviceInstance->TailWaveHeader != WaveHeader )
        {
            SND_ASSERT(SoundDeviceInstance->TailWaveHeader != WaveHeader);
 
            SoundDeviceInstance->TailWaveHeader->lpNext = WaveHeader;
            SoundDeviceInstance->TailWaveHeader = WaveHeader;
            DUMP_WAVEHDR_QUEUE(SoundDeviceInstance);
 
            /* Only do wave streaming when the stream has not been paused */
            if ( SoundDeviceInstance->bPaused == FALSE )
            {
                DoWaveStreaming(SoundDeviceInstance);
            }
        }
    }
 
    DUMP_WAVEHDR_QUEUE(SoundDeviceInstance);
 
    return MMSYSERR_NOERROR;
}

Referenced by WriteWaveHeader().

FreeMemory()

VOID FreeMemory

(

IN PVOID

Pointer

)

Definition at line 42 of file utility.c.

{
    SND_ASSERT( ProcessHeapHandle );
    SND_ASSERT( Pointer );
 
    HeapFree(ProcessHeapHandle, 0, Pointer);
 
    -- CurrentAllocations;
}

GetDigitCount()

UINT GetDigitCount

(

IN UINT

Number

)

Definition at line 68 of file utility.c.

{
    UINT Value = Number;
    ULONG Digits = 1;
 
    while ( Value > 9 )
    {
        Value /= 10;
        ++ Digits;
    }
 
    return Digits;
}

Referenced by DetectNt4SoundDevices(), and OpenSoundDeviceRegKey().

GetMemoryAllocationCount()

UINT GetMemoryAllocationCount

(

VOID

)

GetSoundDevice()

MMRESULT GetSoundDevice	(	IN MMDEVICE_TYPE	DeviceType,
		IN DWORD	DeviceIndex,
		OUT PSOUND_DEVICE *	Device
	)

Definition at line 289 of file devicelist.c.

{
    UCHAR TypeIndex = SOUND_DEVICE_TYPE_TO_INDEX(DeviceType);
    DWORD CurrentIndex = 0;
    PSOUND_DEVICE CurrentDevice;
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceType(DeviceType) );
 
    if ( DeviceIndex >= SoundDeviceCounts[TypeIndex] )
    {
        SND_ERR(L"Invalid device ID %d for type %d\n", DeviceIndex, DeviceType);
        return MMSYSERR_BADDEVICEID;
    }
 
    CurrentDevice = SoundDeviceListHeads[TypeIndex];
 
    /* Following the earlier checks, the index should be valid here. */
    for ( CurrentIndex = 0; CurrentIndex != DeviceIndex; ++ CurrentIndex )
    {
        SND_ASSERT( CurrentDevice );
        CurrentDevice = CurrentDevice->Next;
    }
 
    SND_TRACE(L"Returning sound device %x\n", CurrentDevice);
 
    *SoundDevice = CurrentDevice;
 
    return MMSYSERR_NOERROR;
}

Referenced by MmeGetDeviceInterfaceString(), MmeGetLineInfo(), MmeGetSoundDeviceCapabilities(), and MmeOpenDevice().

GetSoundDeviceCapabilities()

MMRESULT GetSoundDeviceCapabilities	(	IN PSOUND_DEVICE	SoundDevice,
		IN DWORD	DeviceId,
		OUT PVOID	Capabilities,
		IN DWORD	CapabilitiesSize
	)

Definition at line 24 of file capabilities.c.

{
    MMDEVICE_TYPE DeviceType;
    PMMFUNCTION_TABLE FunctionTable;
    BOOLEAN GoodSize = FALSE;
    MMRESULT Result;
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDevice(SoundDevice) );
    VALIDATE_MMSYS_PARAMETER( Capabilities );
    VALIDATE_MMSYS_PARAMETER( CapabilitiesSize > 0 );
 
    /* Obtain the device type */
    Result = GetSoundDeviceType(SoundDevice, &DeviceType);
    SND_ASSERT( Result == MMSYSERR_NOERROR );
 
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    /* Obtain the function table */
    Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
    SND_ASSERT( Result == MMSYSERR_NOERROR );
 
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    SND_ASSERT( IS_VALID_SOUND_DEVICE_TYPE(DeviceType) );
 
    /* Check that the capabilities structure is of a valid size */
    switch ( DeviceType )
    {
        case WAVE_OUT_DEVICE_TYPE :
        {
            GoodSize = CapabilitiesSize >= sizeof(WAVEOUTCAPSW);
            break;
        }
        case WAVE_IN_DEVICE_TYPE :
        {
            GoodSize = CapabilitiesSize >= sizeof(WAVEINCAPSW);
            break;
        }
        case MIDI_OUT_DEVICE_TYPE :
        {
            GoodSize = CapabilitiesSize >= sizeof(MIDIOUTCAPSW);
            break;
        }
        case MIDI_IN_DEVICE_TYPE :
        {
            GoodSize = CapabilitiesSize >= sizeof(MIDIINCAPSW);
            break;
        }
        case AUX_DEVICE_TYPE :
        {
            GoodSize = CapabilitiesSize >= sizeof(AUXCAPSW);
            break;
        }
        case MIXER_DEVICE_TYPE :
        {
            GoodSize = CapabilitiesSize >= sizeof(MIXERCAPSW);
            break;
        }
    };
 
    if ( ! GoodSize )
    {
        SND_ERR(L"Device capabilities structure too small\n");
        return MMSYSERR_INVALPARAM;
    }
 
    /* Call the "get capabilities" function within the function table */
    SND_ASSERT( FunctionTable->GetCapabilities );
 
    if ( ! FunctionTable->GetCapabilities )
        return MMSYSERR_NOTSUPPORTED;
 
    return FunctionTable->GetCapabilities(SoundDevice,
                                          DeviceId,
                                          Capabilities,
                                          CapabilitiesSize);
}

Referenced by MmeGetSoundDeviceCapabilities().

GetSoundDeviceCount()

ULONG GetSoundDeviceCount

(

IN MMDEVICE_TYPE

DeviceType

)

Definition at line 67 of file devicelist.c.

{
    ULONG Index = SOUND_DEVICE_TYPE_TO_INDEX(DeviceType);
 
    if ( ! IsValidSoundDeviceType(DeviceType) )
    {
        return 0;
    }
 
    SND_TRACE(L"Returning a count of %d devices\n", SoundDeviceCounts[Index]);
    return SoundDeviceCounts[Index];
}

Referenced by auxMessage(), midMessage(), modMessage(), mxdMessage(), widMessage(), and wodMessage().

GetSoundDeviceFromInstance()

MMRESULT GetSoundDeviceFromInstance	(	IN PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		OUT PSOUND_DEVICE *	SoundDevice
	)

Definition at line 325 of file deviceinstance.c.

{
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceInstance(SoundDeviceInstance) );
    VALIDATE_MMSYS_PARAMETER( SoundDevice );
 
    *SoundDevice = SoundDeviceInstance->Device;
 
    return MMSYSERR_NOERROR;
}

Referenced by CompleteIO(), CompleteWaveHeader(), DestroySoundDeviceInstance(), DoWaveStreaming(), MmeCloseDevice(), MmeGetLineInfo(), MmeGetPosition(), MmeSetState(), PrepareWaveHeader(), SetWaveDeviceFormat(), StopStreaming(), StopStreamingInSoundThread(), UnlistSoundDeviceInstance(), UnprepareWaveHeader(), WdmAudCloseSoundDeviceByLegacy(), WdmAudCloseSoundDeviceByMMixer(), WdmAudCommitWaveBufferByLegacy(), WdmAudCommitWaveBufferByMMixer(), WdmAudGetWavePositionByLegacy(), WdmAudSetWaveDeviceFormatByLegacy(), WdmAudSetWaveDeviceFormatByMMixer(), WdmAudSetWaveStateByLegacy(), WdmAudSetWaveStateByMMixer(), and WriteWaveHeader().

GetSoundDeviceFunctionTable()

MMRESULT GetSoundDeviceFunctionTable	(	IN PSOUND_DEVICE	SoundDevice,
		OUT PMMFUNCTION_TABLE *	FunctionTable
	)

Definition at line 47 of file functiontable.c.

{
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDevice(SoundDevice) );
    VALIDATE_MMSYS_PARAMETER( FunctionTable );
 
    *FunctionTable = &SoundDevice->FunctionTable;
 
    return MMSYSERR_NOERROR;
}

Referenced by CreateSoundDeviceInstance(), DestroySoundDeviceInstance(), DoWaveStreaming(), GetSoundDeviceCapabilities(), MmeGetDeviceInterfaceString(), MmeGetLineInfo(), MmeGetPosition(), MmeSetState(), PrepareWaveHeader(), QueryWaveDeviceFormatSupport(), SetWaveDeviceFormat(), StopStreamingInSoundThread(), UnprepareWaveHeader(), and WriteWaveHeader().

GetSoundDeviceIdentifier()

MMRESULT GetSoundDeviceIdentifier	(	IN PSOUND_DEVICE	SoundDevice,
		OUT PVOID *	Identifier
	)

Definition at line 328 of file devicelist.c.

{
    VALIDATE_MMSYS_PARAMETER( SoundDevice );
    VALIDATE_MMSYS_PARAMETER( Identifier );
 
    /* The caller should not modify this! */
    *Identifier = SoundDevice->Identifier;
 
    return MMSYSERR_NOERROR;
}

Referenced by OpenNt4KernelSoundDevice(), and WdmAudSetWaveDeviceFormatByLegacy().

GetSoundDeviceInstanceHandle()

MMRESULT GetSoundDeviceInstanceHandle	(	IN PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		OUT PVOID *	Handle
	)

Definition at line 338 of file deviceinstance.c.

{
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceInstance(SoundDeviceInstance) );
    VALIDATE_MMSYS_PARAMETER( Handle );
 
    *Handle = SoundDeviceInstance->Handle;
 
    return MMSYSERR_NOERROR;
}

Referenced by DestroySoundDeviceInstance(), SetNt4WaveDeviceFormat(), WdmAudCommitWaveBufferByLegacy(), WdmAudGetWavePositionByLegacy(), WdmAudQueryMixerInfoByLegacy(), WdmAudResetStreamByLegacy(), WdmAudSetWaveStateByLegacy(), WriteFileEx_Committer(), and WriteFileEx_Remixer().

GetSoundDeviceType()

MMRESULT GetSoundDeviceType	(	IN PSOUND_DEVICE	SoundDevice,
		OUT PMMDEVICE_TYPE	DeviceType
	)

Definition at line 346 of file devicelist.c.

{
    VALIDATE_MMSYS_PARAMETER( SoundDevice );
    VALIDATE_MMSYS_PARAMETER( DeviceType );
 
    *DeviceType = SoundDevice->Type;
 
    return MMSYSERR_NOERROR;
}

Referenced by CompleteIO(), CompleteWaveHeader(), DoWaveStreaming(), GetNt4SoundDeviceCapabilities(), GetSoundBlasterDeviceCapabilities(), GetSoundDeviceCapabilities(), MmeCloseDevice(), QueryWaveDeviceFormatSupport(), SetWaveDeviceFormat(), StopStreaming(), StopStreamingInSoundThread(), WdmAudCloseSoundDeviceByLegacy(), WdmAudCloseSoundDeviceByMMixer(), WdmAudCommitWaveBufferByLegacy(), WdmAudCommitWaveBufferByMMixer(), WdmAudGetCapabilitiesByLegacy(), WdmAudGetCapabilitiesByMMixer(), WdmAudGetWavePositionByLegacy(), WdmAudSetWaveDeviceFormatByLegacy(), WdmAudSetWaveDeviceFormatByMMixer(), WdmAudSetWaveStateByLegacy(), and WdmAudSetWaveStateByMMixer().

InitEntrypointMutexes()

MMRESULT InitEntrypointMutexes

(

VOID

)

InitiateSoundStreaming()

VOID InitiateSoundStreaming

(

IN PSOUND_DEVICE_INSTANCE

SoundDeviceInstance

)

Definition at line 409 of file streaming.c.

{
    HANDLE hThread;
 
    hThread = CreateThread(NULL, 0, WaveActivateSoundStreaming, (PVOID)SoundDeviceInstance, 0, NULL);
 
    if (hThread != NULL)
        CloseHandle(hThread);
}

Referenced by MmeSetState().

IsValidSoundDevice()

BOOLEAN IsValidSoundDevice

(

IN PSOUND_DEVICE

SoundDevice

)

Definition at line 87 of file devicelist.c.

{
    UCHAR TypeIndex;
    PSOUND_DEVICE CurrentDevice;
 
    if ( ! SoundDevice )
        return FALSE;
 
    /* Go through all the device lists */
    for ( TypeIndex = 0; TypeIndex < SOUND_DEVICE_TYPES; ++ TypeIndex )
    {
        CurrentDevice = SoundDeviceListHeads[TypeIndex];
 
        while ( CurrentDevice )
        {
            if ( CurrentDevice == SoundDevice )
            {
                /* Found the device */
                return TRUE;
            }
 
            CurrentDevice = CurrentDevice->Next;
        }
    }
 
    /* If we get here, nothing was found */
    return FALSE;
}

Referenced by CreateSoundDeviceInstance(), GetSoundDeviceCapabilities(), GetSoundDeviceFunctionTable(), ListSoundDeviceInstance(), OpenNt4KernelSoundDevice(), OpenNt4SoundDevice(), QueryNt4WaveDeviceFormatSupport(), QueryWaveDeviceFormatSupport(), SetSoundDeviceFunctionTable(), and UnlistSoundDevice().

IsValidSoundDeviceInstance()

BOOLEAN IsValidSoundDeviceInstance

(

IN PSOUND_DEVICE_INSTANCE

SoundDeviceInstance

)

Definition at line 60 of file deviceinstance.c.

{
    PSOUND_DEVICE SoundDevice;
    PSOUND_DEVICE_INSTANCE CurrentInstance;
 
    if ( ! SoundDeviceInstance )
        return FALSE;
 
    /* GetSoundDeviceFromInstance would send us into a recursive loop... */
    SoundDevice = SoundDeviceInstance->Device;
    SND_ASSERT(SoundDevice);
 
    CurrentInstance = SoundDevice->HeadInstance;
 
    while ( CurrentInstance )
    {
        if ( CurrentInstance == SoundDeviceInstance )
            return TRUE;
 
        CurrentInstance = CurrentInstance->Next;
    }
 
    return FALSE;
}

Referenced by CallSoundThread(), CloseNt4SoundDevice(), DestroySoundDeviceInstance(), GetSoundDeviceFromInstance(), GetSoundDeviceInstanceHandle(), MmeCloseDevice(), MmeGetPosition(), MmeSetState(), PrepareWaveHeader(), SetNt4WaveDeviceFormat(), SetSoundDeviceInstanceMmeData(), SetWaveDeviceFormat(), StopStreaming(), UnlistSoundDeviceInstance(), UnprepareWaveHeader(), and WriteWaveHeader().

ListSoundDevice()

MMRESULT ListSoundDevice	(	IN MMDEVICE_TYPE	DeviceType,
		IN PVOID Identifier	OPTIONAL,
		OUT PSOUND_DEVICE *SoundDevice	OPTIONAL
	)

Definition at line 131 of file devicelist.c.

{
    MMRESULT Result;
    PSOUND_DEVICE NewDevice;
    UCHAR TypeIndex = SOUND_DEVICE_TYPE_TO_INDEX(DeviceType);
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceType(DeviceType) );
 
    Result = AllocateSoundDevice(DeviceType, &NewDevice);
 
    if ( ! MMSUCCESS(Result) )
    {
        SND_ERR(L"Failed to allocate SOUND_DEVICE structure\n");
        return Result;
    }
 
    if ( ! SoundDeviceListHeads[TypeIndex] )
    {
        SND_TRACE(L"Putting first entry into device list %d\n", DeviceType);
        SoundDeviceListHeads[TypeIndex] = NewDevice;
        SoundDeviceListTails[TypeIndex] = NewDevice;
    }
    else
    {
        SND_TRACE(L"Putting another entry into device list %d\n", DeviceType);
        SoundDeviceListTails[TypeIndex]->Next = NewDevice;
        SoundDeviceListTails[TypeIndex] = NewDevice;
    }
 
    /* Add to the count */
    ++ SoundDeviceCounts[TypeIndex];
 
    /* Set up the default function table */
    SetSoundDeviceFunctionTable(NewDevice, NULL);
 
    /* Set up other members of the structure */
    NewDevice->Identifier = Identifier;
    NewDevice->HeadInstance = NULL;
    NewDevice->TailInstance = NULL;
 
    /* Fill in the caller's PSOUND_DEVICE */
    if ( SoundDevice )
    {
        *SoundDevice = NewDevice;
    }
 
    return MMSYSERR_NOERROR;
}

Referenced by FoundDevice(), and PopulateWdmDeviceList().

MmeCloseDevice()

MMRESULT MmeCloseDevice

(

IN DWORD_PTR

PrivateHandle

)

Definition at line 225 of file mmewrap.c.

{
    MMRESULT Result;
    PSOUND_DEVICE_INSTANCE SoundDeviceInstance;
    PSOUND_DEVICE SoundDevice;
    MMDEVICE_TYPE DeviceType;
    UINT Message = 0;
 
    SND_TRACE(L"Closing wave device (WIDM_CLOSE / WODM_CLOSE)\n");
 
    VALIDATE_MMSYS_PARAMETER( PrivateHandle );
    SoundDeviceInstance = (PSOUND_DEVICE_INSTANCE) PrivateHandle;
 
    if ( ! IsValidSoundDeviceInstance(SoundDeviceInstance) )
        return MMSYSERR_INVALHANDLE;
 
    Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    Result = GetSoundDeviceType(SoundDevice, &DeviceType);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
 
    /* TODO: Check device is stopped! */
 
 
    if (DeviceType != MIXER_DEVICE_TYPE)
    {
        ReleaseEntrypointMutex(DeviceType);
 
        if (DeviceType == WAVE_OUT_DEVICE_TYPE)
            Message = WOM_CLOSE;
        else if (DeviceType == WAVE_IN_DEVICE_TYPE)
            Message = WIM_CLOSE;
        else if (DeviceType == MIDI_IN_DEVICE_TYPE)
            Message = MIM_CLOSE;
        else if (DeviceType == MIDI_OUT_DEVICE_TYPE)
            Message = MOM_CLOSE;
 
        /* TODO: Work with MIDI devices too */
        NotifyMmeClient(SoundDeviceInstance,
                        Message,
                        0);
        AcquireEntrypointMutex(DeviceType);
    }
 
    Result = DestroySoundDeviceInstance(SoundDeviceInstance);
 
    return Result;
}

Referenced by midMessage(), modMessage(), mxdMessage(), widMessage(), and wodMessage().

MmeGetDeviceInterfaceString()

MMRESULT MmeGetDeviceInterfaceString	(	IN MMDEVICE_TYPE	DeviceType,
		IN DWORD	DeviceId,
		IN LPWSTR	Interface,
		IN DWORD	InterfaceLength,
		OUT DWORD *	InterfaceSize
	)

Definition at line 294 of file mmewrap.c.

{
    MMRESULT Result;
    PSOUND_DEVICE SoundDevice;
    PMMFUNCTION_TABLE FunctionTable;
 
    Result = GetSoundDevice(DeviceType, DeviceId, &SoundDevice);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    if ( FunctionTable->GetDeviceInterfaceString == NULL )
    {
        /* querying device interface string / size not supported */
        return MMSYSERR_NOTSUPPORTED;
    }
 
    /* Call the driver */
    Result = FunctionTable->GetDeviceInterfaceString(DeviceType, DeviceId, Interface, InterfaceLength, InterfaceSize);
 
    return Result;
}

Referenced by midMessage(), modMessage(), mxdMessage(), widMessage(), and wodMessage().

MmeGetPosition()

MMRESULT MmeGetPosition	(	IN MMDEVICE_TYPE	DeviceType,
		IN DWORD	DeviceId,
		IN DWORD_PTR	PrivateHandle,
		IN MMTIME *	Time,
		IN DWORD	Size
	)

Definition at line 327 of file mmewrap.c.

{
    MMRESULT Result;
    PSOUND_DEVICE_INSTANCE SoundDeviceInstance;
    PSOUND_DEVICE SoundDevice;
    PMMFUNCTION_TABLE FunctionTable;
 
    VALIDATE_MMSYS_PARAMETER( PrivateHandle );
    SoundDeviceInstance = (PSOUND_DEVICE_INSTANCE) PrivateHandle;
 
    if ( ! IsValidSoundDeviceInstance(SoundDeviceInstance) )
        return MMSYSERR_INVALHANDLE;
 
    Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    if ( Size != sizeof(MMTIME) )
        return MMSYSERR_INVALPARAM;
 
    Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    if ( FunctionTable->GetPos == NULL )
    {
        /* This indicates bad practice, really! If you can open, why not close?! */
        return MMSYSERR_NOTSUPPORTED;
    }
 
    /* Call the driver */
    Result = FunctionTable->GetPos(SoundDeviceInstance, Time);
 
    return Result;
}

Referenced by wodMessage().

MmeGetSoundDeviceCapabilities()

MMRESULT MmeGetSoundDeviceCapabilities	(	IN MMDEVICE_TYPE	DeviceType,
		IN DWORD	DeviceId,
		IN PVOID	Capabilities,
		IN DWORD	CapabilitiesSize
	)

Definition at line 103 of file mmewrap.c.

{
    PSOUND_DEVICE SoundDevice;
    MMRESULT Result;
 
    SND_TRACE(L"MME *_GETCAPS for device %d of type %d\n", DeviceId, DeviceType);
 
    /* FIXME: Validate device ID */
    VALIDATE_MMSYS_PARAMETER( Capabilities );
    VALIDATE_MMSYS_PARAMETER( IS_VALID_SOUND_DEVICE_TYPE(DeviceType) );
 
    /* Our parameter checks are done elsewhere */
 
    Result = GetSoundDevice(DeviceType, DeviceId, &SoundDevice);
 
    if ( ! MMSUCCESS(Result) )
        return Result;
 
    return GetSoundDeviceCapabilities(SoundDevice,
                                      DeviceId,
                                      Capabilities,
                                      CapabilitiesSize);
}

Referenced by auxMessage(), midMessage(), modMessage(), mxdMessage(), widMessage(), and wodMessage().

MmeOpenDevice()

MMRESULT MmeOpenDevice	(	IN MMDEVICE_TYPE	DeviceType,
		IN UINT	DeviceId,
		IN LPWAVEOPENDESC	OpenParameters,
		IN DWORD	Flags,
		OUT DWORD_PTR *	PrivateHandle
	)

Definition at line 132 of file mmewrap.c.

{
    MMRESULT Result;
    UINT Message;
    PSOUND_DEVICE SoundDevice;
    PSOUND_DEVICE_INSTANCE SoundDeviceInstance;
    LPWAVEFORMATEX Format = NULL;
 
    SND_TRACE(L"Opening device");
 
    VALIDATE_MMSYS_PARAMETER( IS_WAVE_DEVICE_TYPE(DeviceType) || IS_MIXER_DEVICE_TYPE(DeviceType) || IS_MIDI_DEVICE_TYPE(DeviceType) );    /* FIXME? wave in too? */
    VALIDATE_MMSYS_PARAMETER( OpenParameters );
 
    Result = GetSoundDevice(DeviceType, DeviceId, &SoundDevice);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    if (DeviceType == WAVE_IN_DEVICE_TYPE || DeviceType == WAVE_OUT_DEVICE_TYPE)
    {
        Format = OpenParameters->lpFormat;
 
        /* Does this device support the format? */
        Result = QueryWaveDeviceFormatSupport(SoundDevice, Format, sizeof(WAVEFORMATEX));
        if ( ! MMSUCCESS(Result) )
        {
            SND_ERR(L"Format not supported\n");
            return TranslateInternalMmResult(Result);
        }
 
        /* If the caller just wanted to know if a format is supported, end here */
        if ( Flags & WAVE_FORMAT_QUERY )
            return MMSYSERR_NOERROR;
    }
 
    /* Check that winmm gave us a private handle to fill */
    VALIDATE_MMSYS_PARAMETER( PrivateHandle );
 
    /* Create a sound device instance and open the sound device */
    Result = CreateSoundDeviceInstance(SoundDevice, &SoundDeviceInstance);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    Result = SetWaveDeviceFormat(SoundDeviceInstance, DeviceId, Format, sizeof(WAVEFORMATEX));
    if ( ! MMSUCCESS(Result) )
    {
        /* TODO: Destroy sound instance */
        return TranslateInternalMmResult(Result);
    }
 
    /* Store the device instance pointer in the private handle */
    *PrivateHandle = (DWORD_PTR)SoundDeviceInstance;
 
    /* Store the additional information we were given - FIXME: Need flags! */
    SetSoundDeviceInstanceMmeData(SoundDeviceInstance,
                                  (HDRVR)OpenParameters->hWave, /* works because LPMIXEROPENDESC/etc has also the handle as first member */
                                  OpenParameters->dwCallback,
                                  OpenParameters->dwInstance,
                                  Flags);
 
    if (DeviceType == WAVE_OUT_DEVICE_TYPE || DeviceType == WAVE_IN_DEVICE_TYPE ||
        DeviceType == MIDI_OUT_DEVICE_TYPE || DeviceType == MIDI_IN_DEVICE_TYPE)
    {
        /* Let the application know the device is open */
 
        if (DeviceType == WAVE_OUT_DEVICE_TYPE)
            Message = WOM_OPEN;
        else if (DeviceType == WAVE_IN_DEVICE_TYPE)
            Message = WIM_OPEN;
        else if (DeviceType == MIDI_IN_DEVICE_TYPE)
            Message = MIM_OPEN;
        else
            Message = MOM_OPEN;
 
        ReleaseEntrypointMutex(DeviceType);
 
        NotifyMmeClient(SoundDeviceInstance,
                        Message,
                        0);
 
        AcquireEntrypointMutex(DeviceType);
    }
 
    SND_TRACE(L"device now open\n");
 
    return MMSYSERR_NOERROR;
}

Referenced by midMessage(), modMessage(), mxdMessage(), widMessage(), and wodMessage().

MmeResetWavePlayback()

MMRESULT MmeResetWavePlayback

(

IN DWORD_PTR

PrivateHandle

)

Definition at line 280 of file mmewrap.c.

{
    PSOUND_DEVICE_INSTANCE SoundDeviceInstance;
 
    SND_TRACE(L"Resetting wave device (WODM_RESET)\n");
 
    VALIDATE_MMSYS_PARAMETER( PrivateHandle );
    SoundDeviceInstance = (PSOUND_DEVICE_INSTANCE) PrivateHandle;
 
    return StopStreaming(SoundDeviceInstance);
}

Referenced by widMessage(), and wodMessage().

MmeSetState()

MMRESULT MmeSetState	(	IN DWORD_PTR	PrivateHandle,
		IN BOOL	bStart
	)

Definition at line 19 of file mmewrap.c.

{
    MMRESULT Result;
    PMMFUNCTION_TABLE FunctionTable;
    PSOUND_DEVICE SoundDevice;
    PSOUND_DEVICE_INSTANCE SoundDeviceInstance;
    BOOL OldState;
 
    VALIDATE_MMSYS_PARAMETER( PrivateHandle );
    SoundDeviceInstance = (PSOUND_DEVICE_INSTANCE) PrivateHandle;
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceInstance(SoundDeviceInstance) );
 
    Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    /* Get the function table, and validate it */
    Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    SND_ASSERT( FunctionTable->SetState );
    if ( FunctionTable->SetState == NULL )
    {
        /* FIXME */
        return MMSYSERR_NOTSUPPORTED;
    }
    /* Try change state */
    Result = FunctionTable->SetState(SoundDeviceInstance, bStart);
 
    if ( MMSUCCESS(Result) )
    {
        /* Get old audio stream state */
        OldState = SoundDeviceInstance->bPaused;
 
        /* Store audio stream pause state */
        SoundDeviceInstance->bPaused = !bStart;
 
        if (SoundDeviceInstance->bPaused == FALSE && OldState)
        {
            InitiateSoundStreaming(SoundDeviceInstance);
        }
    }
 
    return Result;
}

Referenced by midMessage(), widMessage(), and wodMessage().

NotifyMmeClient()

VOID NotifyMmeClient	(	IN PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		IN UINT	Message,
		IN DWORD_PTR	Parameter
	)

Definition at line 75 of file mmewrap.c.

{
    SND_ASSERT( SoundDeviceInstance );
 
    SND_TRACE(L"MME client callback - message %d, parameter %d\n",
              (int) Message,
              (int) Parameter);
 
    if ( SoundDeviceInstance->WinMM.ClientCallback )
    {
        DriverCallback(SoundDeviceInstance->WinMM.ClientCallback,
                       HIWORD(SoundDeviceInstance->WinMM.Flags),
                       SoundDeviceInstance->WinMM.Handle,
                       Message,
                       SoundDeviceInstance->WinMM.ClientCallbackInstanceData,
                       Parameter,
                       0);
    }
}

Referenced by CompleteWaveHeader(), MmeCloseDevice(), and MmeOpenDevice().

OpenKernelSoundDevice()

MMRESULT OpenKernelSoundDevice	(	IN PSOUND_DEVICE	SoundDevice,
		IN BOOLEAN	ReadOnly,
		OUT PHANDLE	Handle
	)

OpenKernelSoundDeviceByName()

MMRESULT OpenKernelSoundDeviceByName	(	IN PWSTR	DevicePath,
		IN BOOLEAN	ReadOnly,
		OUT PHANDLE	Handle
	)

Definition at line 23 of file kernel.c.

{
    DWORD AccessRights;
 
    VALIDATE_MMSYS_PARAMETER( DevicePath );
    VALIDATE_MMSYS_PARAMETER( Handle );
 
    AccessRights = ReadOnly ? GENERIC_READ : GENERIC_READ | GENERIC_WRITE;
 
    SND_TRACE(L"OpenKernelSoundDeviceByName: %wS\n", DevicePath);
    *Handle = CreateFile(DevicePath,
                         AccessRights,
                         FILE_SHARE_WRITE,  /* FIXME? Should be read also? */
                         NULL,
                         OPEN_EXISTING,
                         ReadOnly ? 0 : FILE_FLAG_OVERLAPPED,
                         NULL);
 
    if ( *Handle == INVALID_HANDLE_VALUE )
    {
        SND_ERR(L"CreateFile filed - winerror %d\n", GetLastError());
        return Win32ErrorToMmResult(GetLastError());
    }
 
    return MMSYSERR_NOERROR;
}

Referenced by DetectNt4SoundDevices(), and OpenNt4KernelSoundDevice().

PrepareWaveHeader()

MMRESULT PrepareWaveHeader	(	IN PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		IN PWAVEHDR	Header
	)

Definition at line 89 of file header.c.

{
    MMRESULT Result;
    PSOUND_DEVICE SoundDevice;
    PMMFUNCTION_TABLE FunctionTable;
    PWAVEHDR_EXTENSION Extension;
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceInstance(SoundDeviceInstance) );
    VALIDATE_MMSYS_PARAMETER( Header );
 
    SND_TRACE(L"Preparing wave header\n");
 
    Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    Extension = AllocateStruct(WAVEHDR_EXTENSION);
    if ( ! Extension )
        return MMSYSERR_NOMEM;
 
    Header->reserved = (DWORD_PTR) Extension;
    Extension->BytesCommitted = 0;
    Extension->BytesCompleted = 0;
 
    /* Configure the flags */
    Header->dwFlags |= WHDR_PREPARED;
 
    return MMSYSERR_NOERROR;
}

QueryWaveDeviceFormatSupport()

MMRESULT QueryWaveDeviceFormatSupport	(	IN PSOUND_DEVICE	SoundDevice,
		IN LPWAVEFORMATEX	Format,
		IN DWORD	FormatSize
	)

Definition at line 14 of file format.c.

{
    MMRESULT Result;
    MMDEVICE_TYPE DeviceType;
    PMMFUNCTION_TABLE FunctionTable;
 
    SND_TRACE(L"Querying wave format support\n");
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDevice(SoundDevice) );
    VALIDATE_MMSYS_PARAMETER( Format );
    VALIDATE_MMSYS_PARAMETER( FormatSize >= sizeof(WAVEFORMATEX) );
 
    Result = GetSoundDeviceType(SoundDevice, &DeviceType);
    SND_ASSERT( Result == MMSYSERR_NOERROR );
 
    /* Ensure we have a wave device (TODO: check if this applies to wavein as well) */
    VALIDATE_MMSYS_PARAMETER( IS_WAVE_DEVICE_TYPE(DeviceType) );
 
    /* Obtain the function table */
    Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
    SND_ASSERT( Result == MMSYSERR_NOERROR );
 
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    if ( ! FunctionTable->QueryWaveFormatSupport )
        return MMSYSERR_NOTSUPPORTED;
 
    return FunctionTable->QueryWaveFormatSupport(SoundDevice, Format, FormatSize);
}

Referenced by MmeOpenDevice().

ReleaseEntrypointMutex()

VOID ReleaseEntrypointMutex

(

IN MMDEVICE_TYPE

DeviceType

)

Definition at line 92 of file reentrancy.c.

{
    UCHAR i;
 
    SND_ASSERT( IS_VALID_SOUND_DEVICE_TYPE(DeviceType) );
    i = SOUND_DEVICE_TYPE_TO_INDEX(DeviceType);
 
    SND_ASSERT( EntrypointMutexes[i] );
 
    ReleaseMutex(EntrypointMutexes[i]);
}

Referenced by auxMessage(), midMessage(), MmeCloseDevice(), MmeOpenDevice(), modMessage(), mxdMessage(), widMessage(), and wodMessage().

SetSoundDeviceFunctionTable()

MMRESULT SetSoundDeviceFunctionTable	(	IN PSOUND_DEVICE	SoundDevice,
		IN PMMFUNCTION_TABLE	FunctionTable
	)

Definition at line 21 of file functiontable.c.

{
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDevice(SoundDevice) );
    VALIDATE_MMSYS_PARAMETER( FunctionTable );
 
    /* Zero out the existing function table (if present) */
    ZeroMemory(&SoundDevice->FunctionTable, sizeof(MMFUNCTION_TABLE));
 
    if ( ! FunctionTable )
        return MMSYSERR_INVALPARAM;
 
    /* Fill in the client-supplied functions */
    CopyMemory(&SoundDevice->FunctionTable,
                FunctionTable,
                sizeof(MMFUNCTION_TABLE));
 
    return MMSYSERR_NOERROR;
}

Referenced by FoundDevice(), ListSoundDevice(), and PopulateWdmDeviceList().

SetSoundDeviceInstanceMmeData()

MMRESULT SetSoundDeviceInstanceMmeData	(	IN PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		IN HDRVR	MmeHandle,
		IN DWORD_PTR	ClientCallback,
		IN DWORD_PTR	ClientCallbackData,
		IN DWORD	Flags
	)

Definition at line 351 of file deviceinstance.c.

{
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceInstance(SoundDeviceInstance) );
 
    SND_TRACE(L"Setting MME data - handle %x, callback %x, instance data %x, flags %x\n",
              MmeHandle, ClientCallback, ClientCallbackData, Flags);
 
    SoundDeviceInstance->WinMM.Handle = MmeHandle;
    SoundDeviceInstance->WinMM.ClientCallback = ClientCallback;
    SoundDeviceInstance->WinMM.ClientCallbackInstanceData = ClientCallbackData;
    SoundDeviceInstance->WinMM.Flags = Flags;
 
    return MMSYSERR_NOERROR;
}

Referenced by MmeOpenDevice().

SetWaveDeviceFormat()

MMRESULT SetWaveDeviceFormat	(	IN PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		IN DWORD	DeviceId,
		IN LPWAVEFORMATEX	Format,
		IN DWORD	FormatSize
	)

Definition at line 49 of file format.c.

{
    MMRESULT Result;
    MMDEVICE_TYPE DeviceType;
    PMMFUNCTION_TABLE FunctionTable;
    PSOUND_DEVICE SoundDevice;
 
    SND_TRACE(L"Setting wave format\n");
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceInstance(SoundDeviceInstance) );
 
    Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    Result = GetSoundDeviceType(SoundDevice, &DeviceType);
    SND_ASSERT( Result == MMSYSERR_NOERROR );
    if (DeviceType == WAVE_IN_DEVICE_TYPE || DeviceType == WAVE_OUT_DEVICE_TYPE)
    {
        VALIDATE_MMSYS_PARAMETER( Format );
        VALIDATE_MMSYS_PARAMETER( FormatSize >= sizeof(WAVEFORMATEX) );
    }
 
    /* Ensure we have a wave device (TODO: check if this applies to wavein as well) */
    VALIDATE_MMSYS_PARAMETER( IS_WAVE_DEVICE_TYPE(DeviceType) || IS_MIDI_DEVICE_TYPE(DeviceType) || IS_MIXER_DEVICE_TYPE(DeviceType));
 
    /* Obtain the function table */
    Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
    SND_ASSERT( Result == MMSYSERR_NOERROR );
 
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    if ( ! FunctionTable->SetWaveFormat )
        return MMSYSERR_NOTSUPPORTED;
 
    return FunctionTable->SetWaveFormat(SoundDeviceInstance, DeviceId, Format, FormatSize);
}

Referenced by MmeOpenDevice().

StopStreaming()

MMRESULT StopStreaming

(

IN PSOUND_DEVICE_INSTANCE

SoundDeviceInstance

)

Definition at line 360 of file streaming.c.

{
    MMRESULT Result;
    PSOUND_DEVICE SoundDevice;
    MMDEVICE_TYPE DeviceType;
 
    if ( ! IsValidSoundDeviceInstance(SoundDeviceInstance) )
        return MMSYSERR_INVALHANDLE;
 
    Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    Result = GetSoundDeviceType(SoundDevice, &DeviceType);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    if ( DeviceType != WAVE_OUT_DEVICE_TYPE && DeviceType != WAVE_IN_DEVICE_TYPE )
        return MMSYSERR_NOTSUPPORTED;
 
    return CallSoundThread(SoundDeviceInstance,
                           StopStreamingInSoundThread,
                           NULL);
}

Referenced by MmeResetWavePlayback().

SyncOverlappedDeviceIoControl()

MMRESULT SyncOverlappedDeviceIoControl	(	IN HANDLE	SoundDeviceInstance,
		IN DWORD	IoControlCode,
		IN LPVOID	InBuffer,
		IN DWORD	InBufferSize,
		OUT LPVOID	OutBuffer,
		IN DWORD	OutBufferSize,
		OUT LPDWORD BytesTransferred	OPTIONAL
	)

Definition at line 298 of file misc.c.

{
    OVERLAPPED Overlapped;
    BOOLEAN IoResult;
    DWORD Transferred = 0;
 
    /* Overlapped I/O is done here - this is used for waiting for completion */
    ZeroMemory(&Overlapped, sizeof(OVERLAPPED));
    Overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 
    if (!Overlapped.hEvent)
        return GetLastError();
 
    /* Talk to the device */
    IoResult = DeviceIoControl(Handle,
                               IoControlCode,
                               InBuffer,
                               InBufferSize,
                               OutBuffer,
                               OutBufferSize,
                               BytesTransferred,
                               &Overlapped);
 
    /* If failure occurs, make sure it's not just due to the overlapped I/O */
    if (!IoResult)
    {
        if ( GetLastError() != ERROR_IO_PENDING )
        {
            CloseHandle(Overlapped.hEvent);
            return GetLastError();
        }
    }
 
    /* Wait for the I/O to complete */
    IoResult = GetOverlappedResult(Handle,
                                   &Overlapped,
                                   &Transferred,
                                   TRUE);
 
    /* Don't need this any more */
    CloseHandle(Overlapped.hEvent);
 
    if (!IoResult)
        return GetLastError();
 
    if ( BytesTransferred )
        *BytesTransferred = Transferred;
 
    return ERROR_SUCCESS;
}

Referenced by DoDataIntersection(), GetFilterNodeProperty(), GetFilterPinCommunication(), GetFilterPinCount(), GetFilterPinDataFlow(), GetFilterPinDataRanges(), GetNt4SoundDeviceCapabilities(), IDirectSoundCaptureBufferImpl_GetCurrentPosition(), IDirectSoundCaptureBufferImpl_Start(), IDirectSoundCaptureBufferImpl_Stop(), IDirectSoundNotify_fnSetNotificationPositions(), MixerEventThreadRoutine(), MixerThreadRoutine(), PrimaryDirectSoundBuffer_GetPosition(), PrimaryDirectSoundBuffer_SetState(), QueryNt4WaveDeviceFormatSupport(), SetNt4WaveDeviceFormat(), SetPinFormat(), WdmAudCloseSoundDeviceByLegacy(), WdmAudGetCapabilitiesByLegacy(), WdmAudGetDeviceInterfaceStringByLegacy(), WdmAudGetNumWdmDevsByLegacy(), WdmAudGetWavePositionByLegacy(), WdmAudQueryMixerInfoByLegacy(), WdmAudResetStreamByLegacy(), WdmAudSetMixerDeviceFormatByLegacy(), WdmAudSetWaveDeviceFormatByLegacy(), and WdmAudSetWaveStateByLegacy().

TranslateInternalMmResult()

MMRESULT TranslateInternalMmResult

(

IN MMRESULT

Result

)

Definition at line 132 of file utility.c.

{
    switch ( Result )
    {
        case MMSYSERR_INVALPARAM :
        case MMSYSERR_INVALFLAG :
        {
            return MMSYSERR_ERROR;
        }
    }
 
    return Result;
}

Referenced by CreateSoundDeviceInstance(), CreateSoundThread(), DestroySoundDeviceInstance(), GetNt4SoundDeviceCapabilities(), GetSoundDeviceCapabilities(), MmeCloseDevice(), MmeGetDeviceInterfaceString(), MmeGetLineInfo(), MmeGetPosition(), MmeOpenDevice(), MmeSetState(), OpenNt4KernelSoundDevice(), PopulateWdmDeviceList(), PrepareWaveHeader(), QueryNt4WaveDeviceFormatSupport(), QueryWaveDeviceFormatSupport(), SetNt4WaveDeviceFormat(), SetWaveDeviceFormat(), StopStreaming(), UnlistSoundDeviceInstance(), UnprepareWaveHeader(), WdmAudCloseSoundDeviceByLegacy(), WdmAudCloseSoundDeviceByMMixer(), WdmAudCommitWaveBufferByLegacy(), WdmAudCommitWaveBufferByMMixer(), WdmAudGetCapabilitiesByLegacy(), WdmAudGetDeviceInterfaceStringByLegacy(), WdmAudGetNumWdmDevsByLegacy(), WdmAudGetWavePositionByLegacy(), WdmAudSetMixerDeviceFormatByLegacy(), WdmAudSetWaveDeviceFormatByLegacy(), WdmAudSetWaveDeviceFormatByMMixer(), WdmAudSetWaveStateByLegacy(), and WriteWaveHeader().

UnlistAllSoundDevices()

VOID UnlistAllSoundDevices

(

VOID

)

UnlistSoundDevice()

MMRESULT UnlistSoundDevice	(	IN MMDEVICE_TYPE	DeviceType,
		IN PSOUND_DEVICE	SoundDevice
	)

Definition at line 188 of file devicelist.c.

{
    PSOUND_DEVICE CurrentDevice, PreviousDevice;
 
    UCHAR TypeIndex = SOUND_DEVICE_TYPE_TO_INDEX(DeviceType);
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceType(DeviceType) );
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDevice(SoundDevice) );
 
    PreviousDevice = NULL;
    CurrentDevice = SoundDeviceListHeads[TypeIndex];
 
    while ( CurrentDevice )
    {
        if ( CurrentDevice == SoundDevice )
        {
            if ( ! PreviousDevice )
            {
                /* This is the head node */
                SND_TRACE(L"Removing head node from device list %d\n", DeviceType);
                SoundDeviceListHeads[TypeIndex] =
                    SoundDeviceListHeads[TypeIndex]->Next;
            }
            else
            {
                SND_TRACE(L"Removing node from device list %d\n", DeviceType);
                /* There are nodes before this one - cut our device out */
                PreviousDevice->Next = CurrentDevice->Next;
            }
 
            if ( ! CurrentDevice->Next )
            {
                /* This is the tail node */
                SND_TRACE(L"Removing tail node from device list %d\n", DeviceType);
                SoundDeviceListTails[TypeIndex] = PreviousDevice;
            }
        }
 
        PreviousDevice = CurrentDevice;
        CurrentDevice = CurrentDevice->Next;
    }
 
    /* Subtract from the count */
    -- SoundDeviceCounts[TypeIndex];
 
    /* Finally, free up the deleted entry */
    FreeSoundDevice(SoundDevice);
 
    return MMSYSERR_NOERROR;
}

Referenced by UnlistSoundDevices().

UnlistSoundDevices()

MMRESULT UnlistSoundDevices

(

IN MMDEVICE_TYPE

DeviceType

)

Definition at line 245 of file devicelist.c.

{
    UCHAR TypeIndex;
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceType(DeviceType) );
 
    SND_TRACE(L"Unlisting all sound devices of type %d\n", DeviceType);
 
    TypeIndex = SOUND_DEVICE_TYPE_TO_INDEX(DeviceType);
 
    /* Munch away at the head of the list until it's drained */
    while ( SoundDeviceCounts[TypeIndex] > 0 )
    {
        MMRESULT Result;
        Result = UnlistSoundDevice(DeviceType, SoundDeviceListHeads[TypeIndex]);
        SND_ASSERT( Result == MMSYSERR_NOERROR );
    }
 
    return MMSYSERR_NOERROR;
}

Referenced by UnlistAllSoundDevices().

UnprepareWaveHeader()

MMRESULT UnprepareWaveHeader	(	IN PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		IN PWAVEHDR	Header
	)

Definition at line 126 of file header.c.

{
    MMRESULT Result;
    PSOUND_DEVICE SoundDevice;
    PMMFUNCTION_TABLE FunctionTable;
    PWAVEHDR_EXTENSION Extension;
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceInstance(SoundDeviceInstance) );
    VALIDATE_MMSYS_PARAMETER( Header );
 
    SND_TRACE(L"Un-preparing wave header\n");
 
    Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    SND_ASSERT( Header->reserved );
    Extension = (PWAVEHDR_EXTENSION) Header->reserved;
    FreeMemory(Extension);
 
    /* Configure the flags */
    Header->dwFlags &= ~WHDR_PREPARED;
 
    return MMSYSERR_NOERROR;
}

Win32ErrorToMmResult()

MMRESULT Win32ErrorToMmResult

(

IN UINT

ErrorCode

)

Definition at line 87 of file utility.c.

{
    switch ( ErrorCode )
    {
        case NO_ERROR :
        case ERROR_IO_PENDING :
            return MMSYSERR_NOERROR;
 
        case ERROR_BUSY :
            return MMSYSERR_ALLOCATED;
 
        case ERROR_NOT_SUPPORTED :
        case ERROR_INVALID_FUNCTION :
            return MMSYSERR_NOTSUPPORTED;
 
        case ERROR_NOT_ENOUGH_MEMORY :
            return MMSYSERR_NOMEM;
 
        case ERROR_ACCESS_DENIED :
            return MMSYSERR_BADDEVICEID;
 
        case ERROR_INSUFFICIENT_BUFFER :
            return MMSYSERR_INVALPARAM;
 
        case ERROR_INVALID_PARAMETER :
            return MMSYSERR_INVALPARAM;
 
 
        default :
            return MMSYSERR_ERROR;
    }
}

Referenced by CreateSoundThread(), InitEntrypointMutexes(), OpenKernelSoundDeviceByName(), and SyncOverlappedDeviceIoControl().

WriteFileEx_Committer()

MMRESULT WriteFileEx_Committer	(	IN PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		IN PVOID	OffsetPtr,
		IN DWORD	Length,
		IN PSOUND_OVERLAPPED	Overlap,
		IN LPOVERLAPPED_COMPLETION_ROUTINE	CompletionRoutine
	)

Definition at line 264 of file streaming.c.

{
    HANDLE Handle;
 
    VALIDATE_MMSYS_PARAMETER( SoundDeviceInstance );
    VALIDATE_MMSYS_PARAMETER( OffsetPtr );
    VALIDATE_MMSYS_PARAMETER( Overlap );
    VALIDATE_MMSYS_PARAMETER( CompletionRoutine );
 
    GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
 
    if ( ! WriteFileEx(Handle, OffsetPtr, Length, (LPOVERLAPPED)Overlap, CompletionRoutine) )
    {
        // TODO
    }
 
    return MMSYSERR_NOERROR;
}

Referenced by FoundDevice().

WriteWaveHeader()

MMRESULT WriteWaveHeader	(	IN PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		IN PWAVEHDR	Header
	)

Definition at line 159 of file header.c.

{
    MMRESULT Result;
    PSOUND_DEVICE SoundDevice;
    PMMFUNCTION_TABLE FunctionTable;
 
    VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceInstance(SoundDeviceInstance) );
    VALIDATE_MMSYS_PARAMETER( Header );
 
    SND_TRACE(L"Submitting wave header\n");
 
    Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
    if ( ! MMSUCCESS(Result) )
        return TranslateInternalMmResult(Result);
 
    if ( ! FunctionTable->CommitWaveBuffer )
        return MMSYSERR_NOTSUPPORTED;
 
    /*
        A few minor sanity checks - any custom checks should've been carried
        out during wave header preparation etc.
    */
    VALIDATE_MMSYS_PARAMETER( Header->lpData != NULL );
    VALIDATE_MMSYS_PARAMETER( Header->dwBufferLength > 0 );
    VALIDATE_MMSYS_PARAMETER( Header->dwFlags & WHDR_PREPARED );
    VALIDATE_MMSYS_PARAMETER( ! (Header->dwFlags & WHDR_INQUEUE) );
 
    SanitizeWaveHeader(Header);
 
    /* Clear the "done" flag for the buffer */
    Header->dwFlags &= ~WHDR_DONE;
 
    Result = CallSoundThread(SoundDeviceInstance,
                             EnqueueWaveHeader,
                             Header);
 
    return Result;
}