wave.c File Reference

#include "mmdrv.h"
#include <debug.h>

Include dependency graph for wave.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	MAX_WAVE_BUFFER_SIZE   65536

Functions
MMRESULT	QueueWaveBuffer (SessionInfo *session_info, LPWAVEHDR wave_header)
VOID	ReturnCompletedBuffers (SessionInfo *session_info)
DWORD	ProcessSessionThreadRequest (SessionInfo *session_info)
DWORD	WaveThread (LPVOID parameter)
DWORD	GetWaveFormatExSize (PWAVEFORMATEX format)
DWORD	QueryWaveFormat (DeviceType device_type, PVOID lpFormat)
BOOL	SetWaveFormat (HANDLE device_handle, PWAVEFORMATEX format)
DWORD	WriteWaveBuffer (DWORD_PTR private_handle, PWAVEHDR wave_header, DWORD wave_header_size)

Macro Definition Documentation

MAX_WAVE_BUFFER_SIZE

#define MAX_WAVE_BUFFER_SIZE   65536

Definition at line 18 of file wave.c.

NDEBUG

#define NDEBUG

Definition at line 15 of file wave.c.

Function Documentation

GetWaveFormatExSize()

DWORD GetWaveFormatExSize

(

PWAVEFORMATEX

format

)

Definition at line 320 of file wave.c.

{
    if ( format->wFormatTag == WAVE_FORMAT_PCM )
        return sizeof(PCMWAVEFORMAT);
    else
        return sizeof(WAVEFORMATEX) + format->cbSize;
}

Referenced by SetWaveFormat().

ProcessSessionThreadRequest()

DWORD ProcessSessionThreadRequest

(

SessionInfo *

session_info

)

Definition at line 136 of file wave.c.

{
    MMRESULT result = MMSYSERR_NOERROR;
 
    switch ( session_info->thread.function )
    {
        case WODM_WRITE :
        {
            result = QueueWaveBuffer(session_info,
                                     (LPWAVEHDR) session_info->thread.parameter);
            break;
        }
 
        case WODM_RESET :
        {
            /* TODO */
            break;
        }
 
        case WODM_PAUSE :
        {
            /* TODO */
            break;
        }
 
        case WODM_RESTART :
        {
            /* TODO */
            break;
        }
 
        case WODM_GETPOS :
        {
            /* TODO */
            break;
        }
 
        case WODM_SETPITCH :
        {
            result = SetDeviceData(session_info->kernel_device_handle,
                                   IOCTL_WAVE_SET_PITCH,
                                   (PBYTE) session_info->thread.parameter,
                                   sizeof(DWORD));
            break;
        }
 
        case WODM_GETPITCH :
        {
            result = GetDeviceData(session_info->kernel_device_handle,
                                   IOCTL_WAVE_GET_PITCH,
                                   (PBYTE) session_info->thread.parameter,
                                   sizeof(DWORD));
            break;
        }
 
        case WODM_SETVOLUME :
        {
            break;
        }
 
        case WODM_GETVOLUME :
        {
#if 0
            result = GetDeviceData(session_info->kernel_device_handle,
                                   IOCTL_WAVE_GET_VOLUME,
                                   (PBYTE) session_info->thread.parameter,);
#endif
            break;
        }
 
        case WODM_SETPLAYBACKRATE :
        {
            result = SetDeviceData(session_info->kernel_device_handle,
                                   IOCTL_WAVE_SET_PLAYBACK_RATE,
                                   (PBYTE) session_info->thread.parameter,
                                   sizeof(DWORD));
            break;
        }
 
        case WODM_GETPLAYBACKRATE :
        {
            result = GetDeviceData(session_info->kernel_device_handle,
                                   IOCTL_WAVE_GET_PLAYBACK_RATE,
                                   (PBYTE) session_info->thread.parameter,
                                   sizeof(DWORD));
            break;
        }
 
        case WODM_CLOSE :
        {
            DPRINT("Thread was asked if OK to close device\n");
 
            if ( session_info->wave_queue != NULL )
                result = WAVERR_STILLPLAYING;
            else
                result = MMSYSERR_NOERROR;
 
            break;
        }
 
        case DRVM_TERMINATE :
        {
            DPRINT("Terminating thread...\n");
            result = MMSYSERR_NOERROR;
            break;
        }
 
        default :
        {
            DPRINT("INVALID FUNCTION\n");
            result = MMSYSERR_ERROR;
            break;
        }
    }
 
    /* We're done with the function now */
 
    return result;
}

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

QueueWaveBuffer()

MMRESULT QueueWaveBuffer	(	SessionInfo *	session_info,
		LPWAVEHDR	wave_header
	)

Definition at line 21 of file wave.c.

{
    PWAVEHDR queue_node, previous_node;
    DPRINT("Queueing wave buffer\n");
 
    if ( ! wave_header )
    {
        return MMSYSERR_INVALPARAM;
    }
 
    if ( ! wave_header->lpData )
    {
        return MMSYSERR_INVALPARAM;
    }
 
    /* Headers must be prepared first */
    if ( ! ( wave_header->dwFlags & WHDR_PREPARED ) )
    {
        DPRINT("I was given a header which hasn't been prepared yet!\n");
        return WAVERR_UNPREPARED;
    }
 
    /* ...and they must not already be in the playing queue! */
    if ( wave_header->dwFlags & WHDR_INQUEUE )
    {
        DPRINT("I was given a header for a buffer which is already playing\n");
        return WAVERR_STILLPLAYING;
    }
 
    /* Initialize */
    wave_header->dwBytesRecorded = 0;
 
    /* Clear the DONE bit, and mark the buffer as queued */
    wave_header->dwFlags &= ~WHDR_DONE;
    wave_header->dwFlags |= WHDR_INQUEUE;
 
    /* Save our handle in the header */
    wave_header->reserved = (DWORD_PTR) session_info;
 
    /* Locate the end of the queue */
    previous_node = NULL;
    queue_node = session_info->wave_queue;
 
    while ( queue_node )
    {
        previous_node = queue_node;
        queue_node = queue_node->lpNext;
    }
 
    /* Go back a step to obtain the previous node (non-NULL) */
    queue_node = previous_node;
 
    /* Append our buffer here, and terminate the queue */
    queue_node->lpNext = wave_header;
    wave_header->lpNext = NULL;
 
    /* When no buffers are playing there's no play queue so we start one */
#if 0
    if ( ! session_info->next_buffer )
    {
        session_info->buffer_position = 0;
        session_info->next_buffer = wave_header;
    }
#endif
 
    /* Pass to the driver - happens automatically during playback */
//    return PerformWaveIO(session_info);
    return MMSYSERR_NOERROR;
}

Referenced by ProcessSessionThreadRequest().

ReturnCompletedBuffers()

VOID ReturnCompletedBuffers

(

SessionInfo *

session_info

)

Definition at line 94 of file wave.c.

{
    PWAVEHDR header = NULL;
 
    /* Set the current header and test to ensure it's not NULL */
    while ( ( header = session_info->wave_queue ) )
    {
        if ( header->dwFlags & WHDR_DONE )
        {
            DWORD message;
 
            /* Mark as done, and unqueued */
            header->dwFlags &= ~WHDR_INQUEUE;
            header->dwFlags |= WHDR_DONE;
 
            /* Trim it from the start of the queue */
            session_info->wave_queue = header->lpNext;
 
            /* Choose appropriate notification */
            message = (session_info->device_type == WaveOutDevice) ? WOM_DONE :
                                                                     WIM_DATA;
 
            DPRINT("Notifying client that buffer 0x%p is done\n", header);
 
            /* Notify the client */
            NotifyClient(session_info, message, (DWORD_PTR) header, 0);
        }
    }
 
    /* TODO: Perform I/O as a new buffer may have arrived */
}

Referenced by WaveThread().

SetWaveFormat()

BOOL SetWaveFormat	(	HANDLE	device_handle,
		PWAVEFORMATEX	format
	)

Definition at line 349 of file wave.c.

{
    DWORD bytes_returned;
    DWORD size;
 
    size = GetWaveFormatExSize(format);
 
    DPRINT("SetWaveFormat\n");
 
    return DeviceIoControl(device_handle,
                           IOCTL_WAVE_SET_FORMAT,
                           (PVOID) format,
                           size,
                           NULL,
                           0,
                           &bytes_returned,
                           NULL);
}

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