mmdrv.h File Reference

#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <winioctl.h>
#include "mmioctl.h"
#include "mmddk.h"

Include dependency graph for mmdrv.h:

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

Go to the source code of this file.

Classes
struct	WaveOverlapInfo
union	MediaHeader
struct	_ThreadInfo
struct	_LoopInfo
struct	_SessionInfo

Macros
#define	WIN32_NO_STATUS
#define	MAX_DEVICES   256
#define	MAX_DEVICE_NAME_LENGTH   256
#define	MAX_BUFFER_SIZE   1048576
#define	MAX_WAVE_BYTES   1048576
#define	WHDR_COMPLETE   0x80000000
#define	IsWaveDevice(devicetype)   ( ( devicetype == WaveOutDevice ) || ( devicetype == WaveInDevice ) )
#define	IsMidiDevice(devicetype)   ( ( devicetype == MidiOutDevice ) || ( devicetype == MidiInDevice ) )
#define	IsAuxDevice(devicetype)   ( devicetype == AuxDevice )
#define	DRVM_TERMINATE   0xFFFFFFFE
#define	DRVM_INVALID   0xFFFFFFFF
#define	ASSERT(condition)

Typedefs
typedef DWORD	ThreadFunction
typedef struct _ThreadInfo	ThreadInfo
typedef struct _LoopInfo	LoopInfo
typedef struct _SessionInfo	SessionInfo

Enumerations
enum	DeviceType {   WaveOutDevice, WaveInDevice, MidiOutDevice, MidiInDevice,   AuxDevice }
enum	WaveState { WavePlaying, WaveStopped, WaveReset, WaveRestart }

Functions
BOOL	NotifyClient (SessionInfo *session_info, DWORD message, DWORD_PTR parameter1, DWORD_PTR parameter2)
MMRESULT	ErrorToMmResult (UINT error_code)
MMRESULT	CobbleDeviceName (DeviceType device_type, UINT device_id, PWCHAR out_device_name)
MMRESULT	OpenKernelDevice (DeviceType device_type, UINT device_id, DWORD access, HANDLE *handle)
VOID	CloseKernelDevice (HANDLE device_handle)
MMRESULT	SetDeviceData (HANDLE device_handle, DWORD ioctl, PBYTE input_buffer, DWORD buffer_size)
MMRESULT	GetDeviceData (HANDLE device_handle, DWORD ioctl, PBYTE output_buffer, DWORD buffer_size)
MMRESULT	CreateSession (DeviceType device_type, UINT device_id, SessionInfo **session_info)
VOID	DestroySession (SessionInfo *session)
SessionInfo *	GetSession (DeviceType device_type, UINT device_id)
MMRESULT	StartSessionThread (SessionInfo *session_info)
MMRESULT	CallSessionThread (SessionInfo *session_info, ThreadFunction function, PVOID thread_parameter)
DWORD	HandleBySessionThread (DWORD_PTR private_handle, DWORD_PTR message, DWORD_PTR parameter)
DWORD	GetDeviceCount (DeviceType device_type)
DWORD	GetDeviceCapabilities (DeviceType device_type, UINT device_id, DWORD_PTR capabilities, DWORD capabilities_size)
DWORD	OpenDevice (DeviceType device_type, UINT device_id, PVOID open_descriptor, DWORD flags, DWORD_PTR private_handle)
DWORD	CloseDevice (DWORD_PTR private_handle)
DWORD	PauseDevice (DWORD private_handle)
DWORD	RestartDevice (DWORD private_handle)
DWORD	ResetDevice (DWORD private_handle)
DWORD	GetPosition (DWORD private_handle, PMMTIME time, DWORD time_size)
DWORD	BreakLoop (DWORD private_handle)
DWORD	QueryWaveFormat (DeviceType device_type, PVOID lpFormat)
DWORD	WriteWaveBuffer (DWORD_PTR private_handle, PWAVEHDR wave_header, DWORD wave_header_size)
DWORD	WaveThread (LPVOID parameter)
VOID	PerformWaveIO (SessionInfo *session_info)

Variables
CRITICAL_SECTION	critical_section

Macro Definition Documentation

ASSERT

#define ASSERT

(

condition

)

Value:

if ( ! (condition) ) \
        DPRINT("ASSERT FAILED: %s\n", #condition);

Definition at line 176 of file mmdrv.h.

DRVM_INVALID

#define DRVM_INVALID   0xFFFFFFFF

Definition at line 87 of file mmdrv.h.

DRVM_TERMINATE

#define DRVM_TERMINATE   0xFFFFFFFE

Definition at line 86 of file mmdrv.h.

IsAuxDevice

#define IsAuxDevice

(

devicetype

)

( devicetype == AuxDevice )

Definition at line 56 of file mmdrv.h.

IsMidiDevice

#define IsMidiDevice

(

devicetype

)

( ( devicetype == MidiOutDevice ) || ( devicetype == MidiInDevice ) )

Definition at line 53 of file mmdrv.h.

IsWaveDevice

#define IsWaveDevice

(

devicetype

)

( ( devicetype == WaveOutDevice ) || ( devicetype == WaveInDevice ) )

Definition at line 50 of file mmdrv.h.

MAX_BUFFER_SIZE

#define MAX_BUFFER_SIZE   1048576

Definition at line 30 of file mmdrv.h.

MAX_DEVICE_NAME_LENGTH

#define MAX_DEVICE_NAME_LENGTH   256

Definition at line 29 of file mmdrv.h.

MAX_DEVICES

#define MAX_DEVICES   256

Definition at line 28 of file mmdrv.h.

MAX_WAVE_BYTES

#define MAX_WAVE_BYTES   1048576

Definition at line 31 of file mmdrv.h.

WHDR_COMPLETE

#define WHDR_COMPLETE   0x80000000

Definition at line 34 of file mmdrv.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 19 of file mmdrv.h.

Typedef Documentation

LoopInfo

typedef struct _LoopInfo LoopInfo

SessionInfo

typedef struct _SessionInfo SessionInfo

ThreadFunction

typedef DWORD ThreadFunction

Definition at line 85 of file mmdrv.h.

ThreadInfo

typedef struct _ThreadInfo ThreadInfo

Enumeration Type Documentation

DeviceType

enum DeviceType

Enumerator
WaveOutDevice
WaveInDevice
MidiOutDevice
MidiInDevice
AuxDevice

Definition at line 41 of file mmdrv.h.

{
    WaveOutDevice,
    WaveInDevice,
    MidiOutDevice,
    MidiInDevice,
    AuxDevice
} DeviceType;

WaveState

enum WaveState

Enumerator
WavePlaying
WaveStopped
WaveReset
WaveRestart

Definition at line 89 of file mmdrv.h.

{
    WavePlaying,
    WaveStopped,
    WaveReset,
    WaveRestart
} WaveState;

Function Documentation

BreakLoop()

DWORD BreakLoop

(

DWORD

private_handle

)

CallSessionThread()

MMRESULT CallSessionThread	(	SessionInfo *	session_info,
		ThreadFunction	function,
		PVOID	thread_parameter
	)

Definition at line 219 of file session.c.

{
    ASSERT(session_info);

    session_info->thread.function = function;
    session_info->thread.parameter = thread_parameter;

    DPRINT("Calling session thread\n");
    SetEvent(session_info->thread.go_event);

    DPRINT("Waiting for thread response\n");
    WaitForSingleObject(session_info->thread.ready_event, INFINITE);

    return session_info->thread.result;
}

Referenced by CloseDevice(), HandleBySessionThread(), and WriteWaveBuffer().

CloseDevice()

DWORD CloseDevice

(

DWORD_PTR

private_handle

)

Definition at line 239 of file common.c.

{
    MMRESULT result;
    SessionInfo* session_info = (SessionInfo*) private_handle;
    /* TODO: Maybe this is best off inside the playback thread? */

    ASSERT(session_info);

    result = CallSessionThread(session_info, WODM_CLOSE, 0);

    if ( result == MMSYSERR_NOERROR )
    {
        /* TODO: Wait for it to be safe to terminate */

        CloseKernelDevice(session_info->kernel_device_handle);

        DestroySession(session_info);
    }

    return result;
}

CloseKernelDevice()

VOID CloseKernelDevice

(

HANDLE

device_handle

)

Definition at line 132 of file kernel.c.

{
    CloseHandle(device_handle);
}

Referenced by CloseDevice(), and GetDeviceCapabilities().

CobbleDeviceName()

MMRESULT CobbleDeviceName	(	DeviceType	device_type,
		UINT	device_id,
		PWCHAR	out_device_name
	)

Definition at line 28 of file kernel.c.

{
    WCHAR base_device_name[MAX_DEVICE_NAME_LENGTH];

    /* Work out the base name from the device type */

    switch ( device_type )
    {
        case WaveOutDevice :
            wsprintf(base_device_name, L"%ls", WAVE_OUT_DEVICE_NAME);
            break;

        case WaveInDevice :
            wsprintf(base_device_name, L"%ls", WAVE_IN_DEVICE_NAME);
            break;

        case MidiOutDevice :
            wsprintf(base_device_name, L"%ls", MIDI_OUT_DEVICE_NAME);
            break;

        case MidiInDevice :
            wsprintf(base_device_name, L"%ls", MIDI_IN_DEVICE_NAME);
            break;

        case AuxDevice :
            wsprintf(base_device_name, L"%ls", AUX_DEVICE_NAME);
            break;

        default :
            return MMSYSERR_BADDEVICEID;
    };

    /* Now append the device number, removing the leading \Device */

    wsprintf(out_device_name,
             L"\\\\.%ls%d",
             base_device_name + strlen("\\Device"),
             device_id);

    return MMSYSERR_NOERROR;
}

Referenced by OpenKernelDevice().

CreateSession()

MMRESULT CreateSession	(	DeviceType	device_type,
		UINT	device_id,
		SessionInfo **	session_info
	)

Definition at line 63 of file session.c.

{
    HANDLE heap = GetProcessHeap();

    ASSERT(session_info);

    EnterCriticalSection(&session_lock);

    /* Ensure we're not creating a duplicate session */

    if ( GetSession(device_type, device_id) )
    {
        DPRINT("Already allocated session\n");
        LeaveCriticalSection(&session_lock);
        return MMSYSERR_ALLOCATED;
    }

    *session_info = HeapAlloc(heap, HEAP_ZERO_MEMORY, sizeof(SessionInfo));

    if ( ! *session_info )
    {
        DPRINT("Failed to allocate mem for session info\n");
        LeaveCriticalSection(&session_lock);
        return MMSYSERR_NOMEM;
    }

    (*session_info)->device_type = device_type;
    (*session_info)->device_id = device_id;

    /* Add to the list */

    (*session_info)->next = session_list;
    session_list = *session_info;

    LeaveCriticalSection(&session_lock);

    return MMSYSERR_NOERROR;
}

Referenced by CsrSbCreateSession(), OpenDevice(), and SmpLoadSubSystem().

DestroySession()

VOID DestroySession

(

SessionInfo *

session

)

Definition at line 113 of file session.c.

{
    HANDLE heap = GetProcessHeap();
    SessionInfo* session_node;
    SessionInfo* session_prev;

    /* TODO: More cleanup stuff */

    /* Remove from the list */

    EnterCriticalSection(&session_lock);

    session_node = session_list;
    session_prev = NULL;

    while ( session_node )
    {
        if ( session_node == session )
        {
            /* Bridge the gap for when we go */
            session_prev->next = session->next;
            break;
        }

        /* Save the previous node, fetch the next */
        session_prev = session_node;
        session_node = session_node->next;
    }

    LeaveCriticalSection(&session_lock);

    HeapFree(heap, 0, session);
}

Referenced by CloseDevice(), and OpenDevice().

ErrorToMmResult()

MMRESULT ErrorToMmResult

(

UINT

error_code

)

Definition at line 22 of file common.c.

{
    switch ( error_code )
    {
        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;
    };

    /* If all else fails, it's just a plain old error */

    return MMSYSERR_ERROR;
}

Referenced by GetDeviceCapabilities(), GetDeviceData(), and OpenKernelDevice().

GetDeviceCapabilities()

DWORD GetDeviceCapabilities	(	DeviceType	device_type,
		UINT	device_id,
		DWORD_PTR	capabilities,
		DWORD	capabilities_size
	)

Definition at line 84 of file common.c.

{
    MMRESULT result;
    DWORD ioctl;
    HANDLE handle;
    DWORD bytes_returned;
    BOOL device_io_result;

    ASSERT(capabilities);

    /* Choose the right IOCTL for the job */

    if ( IsWaveDevice(device_type) )
        ioctl = IOCTL_WAVE_GET_CAPABILITIES;
    else if ( IsMidiDevice(device_type) )
        ioctl = IOCTL_MIDI_GET_CAPABILITIES;
    else if ( IsAuxDevice(device_type) )
        return MMSYSERR_NOTSUPPORTED; /* TODO */
    else
        return MMSYSERR_NOTSUPPORTED;

    result = OpenKernelDevice(device_type,
                              device_id,
                              GENERIC_READ,
                              &handle);

    if ( result != MMSYSERR_NOERROR )
    {
        DPRINT("Failed to open kernel device\n");
        return result;
    }

    device_io_result = DeviceIoControl(handle,
                                       ioctl,
                                       NULL,
                                       0,
                                       (LPVOID) capabilities,
                                       capabilities_size,
                                       &bytes_returned,
                                       NULL);

    /* Translate result */

    if ( device_io_result )
        result = MMSYSERR_NOERROR;
    else
        result = ErrorToMmResult(GetLastError());

    /* Clean up and return */

    CloseKernelDevice(handle);

    return result;
}

GetDeviceCount()

DWORD GetDeviceCount

(

DeviceType

device_type

)

Definition at line 58 of file common.c.

{
    UINT index = 0;
    HANDLE handle;

    /* Cycle through devices until an error occurs */

    while ( OpenKernelDevice(device_type, index, GENERIC_READ, &handle) == MMSYSERR_NOERROR )
    {
        CloseHandle(handle);
        index ++;
    }

    DPRINT("Found %d devices of type %d\n", index, device_type);

    return index;
}

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

GetDeviceData()

MMRESULT GetDeviceData	(	HANDLE	device_handle,
		DWORD	ioctl,
		PBYTE	output_buffer,
		DWORD	buffer_size
	)

Definition at line 152 of file kernel.c.

{
    OVERLAPPED overlap;
    DWORD bytes_returned;
    BOOL success;
    DWORD transfer;

    DPRINT("GetDeviceData\n");

    memset(&overlap, 0, sizeof(overlap));

    overlap.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

    if ( ! overlap.hEvent )
        return MMSYSERR_NOMEM;

    success = DeviceIoControl(device_handle,
                              ioctl,
                              NULL,
                              0,
                              output_buffer,
                              buffer_size,
                              &bytes_returned,
                              &overlap);

    if ( ! success )
    {
        if ( GetLastError() == ERROR_IO_PENDING )
        {
            if ( ! GetOverlappedResult(device_handle, &overlap, &transfer, TRUE) )
            {
                CloseHandle(overlap.hEvent);
                return ErrorToMmResult(GetLastError());
            }
        }
        else
        {
            CloseHandle(overlap.hEvent);
            return ErrorToMmResult(GetLastError());
        }
    }

    while ( TRUE )
    {
        SetEvent(overlap.hEvent);

        if ( WaitForSingleObjectEx(overlap.hEvent, 0, TRUE) != WAIT_IO_COMPLETION )
        {
            break;
        }
    }

    CloseHandle(overlap.hEvent);

    return MMSYSERR_NOERROR;
}

GetPosition()

DWORD GetPosition	(	DWORD	private_handle,
		PMMTIME	time,
		DWORD	time_size
	)

Referenced by DECLARE_INTERFACE_(), and wodMessage().

GetSession()

SessionInfo* GetSession	(	DeviceType	device_type,
		UINT	device_id
	)

Definition at line 30 of file session.c.

{
    SessionInfo* session_info;

    EnterCriticalSection(&session_lock);
    session_info = session_list;

    while ( session_info )
    {
        if ( ( session_info->device_type == device_type ) &&
             ( session_info->device_id == device_id ) )
        {
            LeaveCriticalSection(&session_lock);
            return session_info;
        }

        session_info = session_info->next;
    }

    LeaveCriticalSection(&session_lock);
    return NULL;
}

Referenced by CreateSession().

HandleBySessionThread()

DWORD HandleBySessionThread	(	DWORD_PTR	private_handle,
		DWORD_PTR	message,
		DWORD_PTR	parameter
	)

Definition at line 240 of file session.c.

{
    return CallSessionThread((SessionInfo*) private_handle,
                             message,
                             (PVOID) parameter);
}

Referenced by wodMessage().

NotifyClient()

BOOL NotifyClient	(	SessionInfo *	session_info,
		DWORD	message,
		DWORD_PTR	parameter1,
		DWORD_PTR	parameter2
	)

Definition at line 25 of file mme.c.

{
    return DriverCallback(session_info->callback,
                          HIWORD(session_info->flags),
                          session_info->mme_handle,
                          message,
                          session_info->app_user_data,
                          parameter1,
                          parameter2);
}

Referenced by OpenDevice(), and ReturnCompletedBuffers().

OpenDevice()

DWORD OpenDevice	(	DeviceType	device_type,
		UINT	device_id,
		PVOID	open_descriptor,
		DWORD	flags,
		DWORD_PTR	private_handle
	)

Definition at line 153 of file common.c.

{
    SessionInfo* session_info;
    MMRESULT result;
    DWORD message;

    /* This will automatically check for duplicate sessions */
    result = CreateSession(device_type, device_id, &session_info);

    if ( result != MMSYSERR_NOERROR )
    {
        DPRINT("Couldn't allocate session info\n");
        return result;
    }

    result = OpenKernelDevice(device_type,
                              device_id,
                              GENERIC_READ,
                              &session_info->kernel_device_handle);

    if ( result != MMSYSERR_NOERROR )
    {
        DPRINT("Failed to open kernel device\n");
        DestroySession(session_info);
        return result;
    }

    /* Set common session data */

    session_info->flags = flags;

    /* Set wave/MIDI specific data */

    if ( IsWaveDevice(device_type) )
    {
        LPWAVEOPENDESC wave_open_desc = (LPWAVEOPENDESC) open_descriptor;
        session_info->callback = wave_open_desc->dwCallback;
        session_info->mme_wave_handle = wave_open_desc->hWave;
        session_info->app_user_data = wave_open_desc->dwInstance;
    }
    else
    {
        DPRINT("Only wave devices are supported at present!\n");
        DestroySession(session_info);
        return MMSYSERR_NOTSUPPORTED;
    }

    /* Start the processing thread */

    result = StartSessionThread(session_info);

    if ( result != MMSYSERR_NOERROR )
    {
        DestroySession(session_info);
        return result;
    }

    /* Store the session info */

    *((SessionInfo**)private_handle) = session_info;

    /* Send the right message */

    message = (device_type == WaveOutDevice) ? WOM_OPEN :
              (device_type == WaveInDevice) ? WIM_OPEN :
              (device_type == MidiOutDevice) ? MOM_OPEN :
              (device_type == MidiInDevice) ? MIM_OPEN : 0xFFFFFFFF;

    NotifyClient(session_info, message, 0, 0);

    return MMSYSERR_NOERROR;
}

OpenKernelDevice()

MMRESULT OpenKernelDevice	(	DeviceType	device_type,
		UINT	device_id,
		DWORD	access,
		HANDLE *	handle
	)

Definition at line 84 of file kernel.c.

{
    MMRESULT result;
    WCHAR device_name[MAX_DEVICE_NAME_LENGTH];
    DWORD open_flags = 0;

    ASSERT(handle);

    /* Glue the base device name and the ID together */

    result = CobbleDeviceName(device_type, device_id, device_name);

    DPRINT("Opening kernel device %ls\n", device_name);

    if ( result != MMSYSERR_NOERROR )
        return result;

    /* We want overlapped I/O when writing */

    if ( access != GENERIC_READ )
        open_flags = FILE_FLAG_OVERLAPPED;

    /* Now try opening... */

    *handle = CreateFile(device_name,
                         access,
                         FILE_SHARE_WRITE,
                         NULL,
                         OPEN_EXISTING,
                         open_flags,
                         NULL);

    if ( *handle == INVALID_HANDLE_VALUE )
        return ErrorToMmResult(GetLastError());

    return MMSYSERR_NOERROR;
}

Referenced by GetDeviceCapabilities(), GetDeviceCount(), and OpenDevice().

PauseDevice()

DWORD PauseDevice

(

DWORD

private_handle

)

PerformWaveIO()

VOID PerformWaveIO

(

SessionInfo *

session_info

)

Definition at line 39 of file wave_io.c.

{

}

Referenced by WaveThread().

QueryWaveFormat()

DWORD QueryWaveFormat	(	DeviceType	device_type,
		PVOID	lpFormat
	)

Definition at line 335 of file wave.c.

{
    /* TODO */
    return WAVERR_BADFORMAT;
}

Referenced by wodMessage().

ResetDevice()

DWORD ResetDevice

(

DWORD

private_handle

)

Referenced by USBSTOR_TimerRoutine().

RestartDevice()

DWORD RestartDevice

(

DWORD

private_handle

)

SetDeviceData()

MMRESULT SetDeviceData	(	HANDLE	device_handle,
		DWORD	ioctl,
		PBYTE	input_buffer,
		DWORD	buffer_size
	)

Definition at line 139 of file kernel.c.

{
    DPRINT("SetDeviceData\n");
    /* TODO */
    return 0;
}

Referenced by ProcessSessionThreadRequest().

StartSessionThread()

MMRESULT StartSessionThread

(

SessionInfo *

session_info

)

Definition at line 154 of file session.c.

{
    LPTASKCALLBACK task;
    MMRESULT result;

    ASSERT(session_info);

    /* This is our "ready" event, sent when the thread is idle */

    session_info->thread.ready_event = CreateEvent(NULL, FALSE, FALSE, NULL);

    if ( ! session_info->thread.ready_event )
    {
        DPRINT("Couldn't create thread_ready event\n");
        return MMSYSERR_NOMEM;
    }

    /* This is our "go" event, sent when we want the thread to do something */

    session_info->thread.go_event = CreateEvent(NULL, FALSE, FALSE, NULL);

    if ( ! session_info->thread.go_event )
    {
        DPRINT("Couldn't create thread_go event\n");
        CloseHandle(session_info->thread.ready_event);
        return MMSYSERR_NOMEM;
    }

    /* TODO - other kinds of devices need attention, too */
    task = ( session_info->device_type == WaveOutDevice )
           ? (LPTASKCALLBACK) WaveThread : NULL;

    ASSERT(task);

    /* Effectively, this is a beefed-up CreateThread */

    result = mmTaskCreate(task,
                          &session_info->thread.handle,
                          (DWORD_PTR)session_info);

    if ( result != MMSYSERR_NOERROR )
    {
        DPRINT("Task creation failed\n");
        CloseHandle(session_info->thread.ready_event);
        CloseHandle(session_info->thread.go_event);
        return result;
    }

    /* Wait for the thread to be ready before completing */

    WaitForSingleObject(session_info->thread.ready_event, INFINITE);

    return MMSYSERR_NOERROR;
}

Referenced by OpenDevice().

WaveThread()

DWORD WaveThread

(

LPVOID

parameter

)

Definition at line 266 of file wave.c.

{
    MMRESULT result = MMSYSERR_ERROR;
    SessionInfo* session_info = (SessionInfo*) parameter;
    BOOL terminate = FALSE;

    /* All your CPU time are belong to us */
    SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);

    DPRINT("Wave processing thread setting ready state\n");

    SetEvent(session_info->thread.ready_event);

    while ( ! terminate )
    {
        /* Wait for GO event, or IO completion notification */
        while ( WaitForSingleObjectEx(session_info->thread.go_event,
                                      INFINITE,
                                      TRUE) == WAIT_IO_COMPLETION )
        {
            /* A buffer has been finished with - pass back to the client */
            ReturnCompletedBuffers(session_info);
        }

        DPRINT("Wave processing thread woken up\n");

        /* Set the terminate flag if that's what the caller wants */
        terminate = (session_info->thread.function == DRVM_TERMINATE);

        /* Process the request */
        DPRINT("Processing thread request\n");
        result = ProcessSessionThreadRequest(session_info);

        /* Store the result code */
        session_info->thread.result = result;

        /* Submit new buffers and continue existing ones */
        DPRINT("Performing wave I/O\n");
        PerformWaveIO(session_info);

        /* Now we're ready for more action */
        DPRINT("Wave processing thread sleeping\n");
        SetEvent(session_info->thread.ready_event);
    }

    return 0;
}

Referenced by StartSessionThread().

WriteWaveBuffer()

DWORD WriteWaveBuffer	(	DWORD_PTR	private_handle,
		PWAVEHDR	wave_header,
		DWORD	wave_header_size
	)

Definition at line 372 of file wave.c.

{
    SessionInfo* session_info = (SessionInfo*) private_handle;
    ASSERT(session_info);

    /* Let the processing thread know that it has work to do */
    return CallSessionThread(session_info, WODM_WRITE, wave_header);
}

Referenced by wodMessage().

Variable Documentation

critical_section

CRITICAL_SECTION critical_section