header.c File Reference

#include "precomp.h"

Include dependency graph for header.c:

Go to the source code of this file.

Classes
struct	THREADED_WAVEHEADER_PARAMETERS

Functions
MMRESULT	WaveHeaderOperationInSoundThread (PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN PVOID Parameter)
MMRESULT	WaveHeaderOperation (MMWAVEHEADER_FUNC Function, PSOUND_DEVICE_INSTANCE SoundDeviceInstance, PWAVEHDR Header)
VOID	SanitizeWaveHeader (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)
MMRESULT	EnqueueWaveHeader (PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN PVOID Parameter)
VOID	CompleteWaveHeader (IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance, IN PWAVEHDR Header)

Function Documentation

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().

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().

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;
}

SanitizeWaveHeader()

VOID SanitizeWaveHeader

(

PWAVEHDR

Header

)

Definition at line 64 of file header.c.

{
    PWAVEHDR_EXTENSION Extension = (PWAVEHDR_EXTENSION) Header->reserved;
    SND_ASSERT( Extension );
 
    Header->dwBytesRecorded = 0;
 
    Extension->BytesCommitted = 0;
    Extension->BytesCompleted = 0;
}

Referenced by WriteWaveHeader().

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;
}

WaveHeaderOperation()

MMRESULT WaveHeaderOperation	(	MMWAVEHEADER_FUNC	Function,
		PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		PWAVEHDR	Header
	)

Definition at line 42 of file header.c.

{
    THREADED_WAVEHEADER_PARAMETERS Parameters;
 
    Parameters.Function = Function;
    Parameters.Header = Header;
 
    return CallSoundThread(SoundDeviceInstance,
                           WaveHeaderOperationInSoundThread,
                           &Parameters);
}

WaveHeaderOperationInSoundThread()

MMRESULT WaveHeaderOperationInSoundThread	(	PSOUND_DEVICE_INSTANCE	SoundDeviceInstance,
		IN PVOID	Parameter
	)

Definition at line 33 of file header.c.

{
    THREADED_WAVEHEADER_PARAMETERS* Parameters = (THREADED_WAVEHEADER_PARAMETERS*) Parameter;
    return Parameters->Function(SoundDeviceInstance, Parameters->Header);
}

Referenced by WaveHeaderOperation().

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;
}