beepmidi.c File Reference

#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <ndk/iofuncs.h>
#include <ndk/obfuncs.h>
#include <ndk/rtlfuncs.h>
#include <ntddbeep.h>
#include <math.h>
#include <mmddk.h>

Include dependency graph for beepmidi.c:

Go to the source code of this file.

Classes
struct	_NoteNode
struct	_DeviceInfo

Macros
#define	TIMESLICE_SIZE   60
#define	ALLOW_DUPLICATE_NOTES
#define	POLYPHONY   3
#define	CONTINUOUS_NOTES
#define	WIN32_NO_STATUS
#define	_INC_WINDOWS
#define	COM_NO_WINDOWS_H
#define	NTOS_MODE_USER
#define	DPRINT   FakePrintf
#define	MIDI_NOTE_OFF   0x80
#define	MIDI_NOTE_ON   0x90
#define	MIDI_CONTROL_CHANGE   0xB0
#define	MIDI_PROGRAM   0xC0
#define	MIDI_PITCH_BEND   0xE0
#define	MIDI_SYSTEM   0xFF
#define	MIDI_RESET   0xFF
#define	PACK_MIDI(b1, b2, b3)    ((b3 * 65536) + (b2 * 256) + b1);

Typedefs
typedef struct _NoteNode	NoteNode
typedef struct _DeviceInfo	DeviceInfo

Functions
void	FakePrintf (char *str,...)
DWORD WINAPI	ProcessPlayingNotes (LPVOID parameter)
MMRESULT	GetDeviceCapabilities (MIDIOUTCAPS *caps)
BOOL	CallClient (DeviceInfo *device_info, DWORD_PTR message, DWORD_PTR parameter1, DWORD_PTR parameter2)
MMRESULT	OpenDevice (DeviceInfo **private_data, MIDIOPENDESC *open_desc, DWORD flags)
MMRESULT	CloseDevice (DeviceInfo *device_info)
MMRESULT	StopNote (DeviceInfo *device_info, UCHAR note)
MMRESULT	PlayNote (DeviceInfo *device_info, UCHAR note, UCHAR velocity)
MMRESULT	ProcessShortMidiMessage (DeviceInfo *device_info, DWORD message)
MMRESULT	ProcessLongMidiMessage (DeviceInfo *device_info, MIDIHDR *header)
MMRESULT FAR PASCAL	modMessage (UINT device_id, UINT message, DWORD_PTR private_data, DWORD_PTR parameter1, DWORD_PTR parameter2)
LONG FAR PASCAL	DriverProc (DWORD driver_id, HDRVR driver_handle, UINT message, LONG parameter1, LONG parameter2)

Variables
DeviceInfo *	the_device
CRITICAL_SECTION	device_lock

Macro Definition Documentation

_INC_WINDOWS

#define _INC_WINDOWS

Definition at line 44 of file beepmidi.c.

ALLOW_DUPLICATE_NOTES

#define ALLOW_DUPLICATE_NOTES

Definition at line 26 of file beepmidi.c.

COM_NO_WINDOWS_H

#define COM_NO_WINDOWS_H

Definition at line 45 of file beepmidi.c.

CONTINUOUS_NOTES

#define CONTINUOUS_NOTES

Definition at line 41 of file beepmidi.c.

DPRINT

#define DPRINT   FakePrintf

Definition at line 58 of file beepmidi.c.

MIDI_CONTROL_CHANGE

#define MIDI_CONTROL_CHANGE   0xB0

Definition at line 63 of file beepmidi.c.

MIDI_NOTE_OFF

#define MIDI_NOTE_OFF   0x80

Definition at line 61 of file beepmidi.c.

MIDI_NOTE_ON

#define MIDI_NOTE_ON   0x90

Definition at line 62 of file beepmidi.c.

MIDI_PITCH_BEND

#define MIDI_PITCH_BEND   0xE0

Definition at line 65 of file beepmidi.c.

MIDI_PROGRAM

#define MIDI_PROGRAM   0xC0

Definition at line 64 of file beepmidi.c.

MIDI_RESET

#define MIDI_RESET   0xFF

Definition at line 69 of file beepmidi.c.

MIDI_SYSTEM

#define MIDI_SYSTEM   0xFF

Definition at line 66 of file beepmidi.c.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 49 of file beepmidi.c.

PACK_MIDI

#define PACK_MIDI	(		b1,
			b2,
			b3
	)		((b3 * 65536) + (b2 * 256) + b1);

Definition at line 654 of file beepmidi.c.

POLYPHONY

#define POLYPHONY   3

Definition at line 33 of file beepmidi.c.

TIMESLICE_SIZE

#define TIMESLICE_SIZE   60

Definition at line 18 of file beepmidi.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 43 of file beepmidi.c.

Typedef Documentation

DeviceInfo

typedef struct _DeviceInfo DeviceInfo

NoteNode

typedef struct _NoteNode NoteNode

Function Documentation

CallClient()

BOOL CallClient	(	DeviceInfo *	device_info,
		DWORD_PTR	message,
		DWORD_PTR	parameter1,
		DWORD_PTR	parameter2
	)

Definition at line 240 of file beepmidi.c.

{
    DPRINT("Calling client - callback 0x%x mmhandle 0x%x\n", device_info->callback, device_info->mme_handle);
    return DriverCallback(device_info->callback,
                          HIWORD(device_info->flags),
                          device_info->mme_handle,
                          message,
                          device_info->instance,
                          parameter1,
                          parameter2);
 
}

Referenced by CloseDevice(), OpenDevice(), and ProcessLongMidiMessage().

CloseDevice()

MMRESULT CloseDevice

(

DeviceInfo *

device_info

)

Definition at line 383 of file beepmidi.c.

{
    HANDLE heap = GetProcessHeap();
 
    /* If we're working in threaded mode we need to wait for thread to die */
#ifdef CONTINUOUS_NOTES
    the_device->terminate_thread = TRUE;
    SetEvent(device_info->work_available);
 
    WaitForSingleObject(the_device->thread_handle, INFINITE);
    CloseHandle(the_device->thread_handle);
    CloseHandle(the_device->work_available);
#endif
 
    /* Let the client application know the device is closing */
    DPRINT("Sending MOM_CLOSE\n");
    CallClient(device_info, MOM_CLOSE, 0, 0);
 
    NtClose(device_info->kernel_device);
 
    /* Free resources */
    HeapFree(heap, 0, device_info);
 
    the_device = NULL;
 
    return MMSYSERR_NOERROR;
}

Referenced by modMessage(), and wodMessage().

DriverProc()

LONG FAR PASCAL DriverProc	(	DWORD	driver_id,
		HDRVR	driver_handle,
		UINT	message,
		LONG	parameter1,
		LONG	parameter2
	)

Definition at line 853 of file beepmidi.c.

{
    switch ( message )
    {
        case DRV_LOAD :
            DPRINT("DRV_LOAD\n");
            the_device = NULL;
            return 1L;
 
        case DRV_FREE :
            DPRINT("DRV_FREE\n");
            return 1L;
 
        case DRV_OPEN :
            DPRINT("DRV_OPEN\n");
            InitializeCriticalSection(&device_lock);
            return 1L;
 
        case DRV_CLOSE :
            DPRINT("DRV_CLOSE\n");
            return 1L;
 
        case DRV_ENABLE :
            DPRINT("DRV_ENABLE\n");
            return 1L;
 
        case DRV_DISABLE :
            DPRINT("DRV_DISABLE\n");
            return 1L;
 
        /*
            We don't provide configuration capabilities. This used to be
            for things like I/O port, IRQ, DMA settings, etc.
        */
 
        case DRV_QUERYCONFIGURE :
            DPRINT("DRV_QUERYCONFIGURE\n");
            return 0L;
 
        case DRV_CONFIGURE :
            DPRINT("DRV_CONFIGURE\n");
            return 0L;
 
        case DRV_INSTALL :
            DPRINT("DRV_INSTALL\n");
            return DRVCNF_RESTART;
    };
 
    DPRINT("???\n");
 
    return DefDriverProc(driver_id,
                         driver_handle,
                         message,
                         parameter1,
                         parameter2);
}

FakePrintf()

void FakePrintf	(	char *	str,
			...
	)

Definition at line 105 of file beepmidi.c.

{
    /* Just to shut the compiler up */
}

GetDeviceCapabilities()

MMRESULT GetDeviceCapabilities

(

MIDIOUTCAPS *

caps

)

Definition at line 210 of file beepmidi.c.

{
    /* These are ignored for now */
    caps->wMid = 0;
    caps->wPid = 0;
 
    caps->vDriverVersion = 0x0100;
 
    memset(caps->szPname, 0, sizeof(caps->szPname));
    wcscpy(caps->szPname, L"PC speaker");
 
    caps->wTechnology = MOD_SQSYNTH;
 
    caps->wVoices = 1;              /* We only have one voice */
    caps->wNotes = POLYPHONY;
    caps->wChannelMask = 0xFFBF;    /* Ignore channel 10 */
 
    caps->dwSupport = 0;
 
    return MMSYSERR_NOERROR;
}

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

modMessage()

MMRESULT FAR PASCAL modMessage	(	UINT	device_id,
		UINT	message,
		DWORD_PTR	private_data,
		DWORD_PTR	parameter1,
		DWORD_PTR	parameter2
	)

Definition at line 771 of file beepmidi.c.

{
    switch ( message )
    {
        case MODM_GETNUMDEVS :
        {
            /* Only one internal PC speaker device (and even that's too much) */
            DPRINT("MODM_GETNUMDEVS\n");
            return 1;
        }
 
        case MODM_GETDEVCAPS :
        {
            DPRINT("MODM_GETDEVCAPS\n");
            return GetDeviceCapabilities((MIDIOUTCAPS*) parameter1);
        }
 
        case MODM_OPEN :
        {
            DPRINT("MODM_OPEN\n");
 
            return OpenDevice((DeviceInfo**) private_data,
                              (MIDIOPENDESC*) parameter1,
                              parameter2);
        }
 
        case MODM_CLOSE :
        {
            DPRINT("MODM_CLOSE\n");
            return CloseDevice((DeviceInfo*) private_data);
        }
 
        case MODM_DATA :
        {
            return ProcessShortMidiMessage((DeviceInfo*) private_data, parameter1);
        }
 
        case MODM_PREPARE :
        {
            /* We don't bother with this */
            MIDIHDR* hdr = (MIDIHDR*) parameter1;
            hdr->dwFlags |= MHDR_PREPARED;
            return MMSYSERR_NOERROR;
        }
 
        case MODM_UNPREPARE :
        {
            MIDIHDR* hdr = (MIDIHDR*) parameter1;
            hdr->dwFlags &= ~MHDR_PREPARED;
            return MMSYSERR_NOERROR;
        }
 
        case MODM_LONGDATA :
        {
            DPRINT("LONGDATA\n");
            return ProcessLongMidiMessage((DeviceInfo*) private_data, (MIDIHDR*) parameter1);
        }
 
        case MODM_RESET :
        {
            /* TODO */
            break;
        }
    }
 
    DPRINT("Not supported %d\n", message);
 
    return MMSYSERR_NOTSUPPORTED;
}

Referenced by MMDRV_Install().

OpenDevice()

MMRESULT OpenDevice	(	DeviceInfo **	private_data,
		MIDIOPENDESC *	open_desc,
		DWORD	flags
	)

Definition at line 264 of file beepmidi.c.

{
    NTSTATUS status;
    HANDLE heap;
    HANDLE kernel_device;
    UNICODE_STRING beep_device_name;
    OBJECT_ATTRIBUTES attribs;
    IO_STATUS_BLOCK status_block;
 
    /* One at a time.. */
    if ( the_device )
    {
        DPRINT("Already allocated\n");
        return MMSYSERR_ALLOCATED;
    }
 
    /* Make the device name into a unicode string and open it */
 
    RtlInitUnicodeString(&beep_device_name,
                            L"\\Device\\Beep");
 
    InitializeObjectAttributes(&attribs,
                                &beep_device_name,
                                0,
                                NULL,
                                NULL);
 
    status = NtCreateFile(&kernel_device,
                            FILE_READ_DATA | FILE_WRITE_DATA,
                            &attribs,
                            &status_block,
                            NULL,
                            0,
                            FILE_SHARE_READ | FILE_SHARE_WRITE,
                            FILE_OPEN_IF,
                            0,
                            NULL,
                            0);
 
    if ( ! NT_SUCCESS(status) )
    {
        DPRINT("Could not connect to BEEP device - %d\n", (int) GetLastError());
        return MMSYSERR_ERROR;
    }
 
    DPRINT("Opened!\n");
 
    /* Allocate and initialize the device info */
 
    heap = GetProcessHeap();
 
    the_device = HeapAlloc(heap, HEAP_ZERO_MEMORY, sizeof(DeviceInfo));
 
    if ( ! the_device )
    {
        DPRINT("Out of memory\n");
        return MMSYSERR_NOMEM;
    }
 
    /* Initialize */
    the_device->kernel_device = kernel_device;
    the_device->playing_notes_count = 0;
    the_device->note_list = NULL;
    the_device->thread_handle = 0;
    the_device->terminate_thread = FALSE;
    the_device->running_status = 0;
 
    // TODO
    the_device->mme_handle = (HDRVR) open_desc->hMidi;
    the_device->callback = open_desc->dwCallback;
    the_device->instance = open_desc->dwInstance;
    the_device->flags = flags;
 
    /* Store the pointer in the user data */
    *private_data = the_device;
 
    /* This is threading-related code */
#ifdef CONTINUOUS_NOTES
    the_device->work_available = CreateEvent(NULL, TRUE, FALSE, NULL);
 
    if ( ! the_device->work_available )
    {
        DPRINT("CreateEvent failed\n");
        HeapFree(heap, 0, the_device);
        return MMSYSERR_NOMEM;
    }
 
    the_device->thread_handle = CreateThread(NULL,
                                             0,
                                             ProcessPlayingNotes,
                                             (PVOID) the_device,
                                             0,
                                             NULL);
 
    if ( ! the_device->thread_handle )
    {
        DPRINT("CreateThread failed\n");
        CloseHandle(the_device->work_available);
        HeapFree(heap, 0, the_device);
        return MMSYSERR_NOMEM;
    }
#endif
 
    /* Now we call the client application to say the device is open */
    DPRINT("Sending MOM_OPEN\n");
    DPRINT("Success? %d\n", (int) CallClient(the_device, MOM_OPEN, 0, 0));
 
    return MMSYSERR_NOERROR;
}

Referenced by AuxGetAudio(), AuxSetAudio(), Enum(), modMessage(), OpenMidiDevice(), SysAudioOpenKMixer(), and wodMessage().

PlayNote()

MMRESULT PlayNote	(	DeviceInfo *	device_info,
		UCHAR	note,
		UCHAR	velocity
	)

Definition at line 484 of file beepmidi.c.

{
    HANDLE heap = GetProcessHeap();
 
    NoteNode* node;
 
    DPRINT("PlayNote\n");
 
    if ( velocity == 0 )
    {
        DPRINT("Zero velocity\n");
 
        /* Velocity zero is effectively a "note off" */
        StopNote(device_info, note);
    }
    else
    {
        /* Start playing the note */
        NoteNode* new_node;
 
        EnterCriticalSection(&device_lock);
 
        node = device_info->note_list;
 
        while ( node != NULL )
        {
#ifndef ALLOW_DUPLICATE_NOTES
            if ( ( node->note == note ) && ( velocity > 0 ) )
            {
                /* The note is already playing - do nothing */
                DPRINT("Duplicate note playback request ignored\n");
                LeaveCriticalSection(&device_lock);
                return MMSYSERR_NOERROR;
            }
#endif
 
            node = node->next;
        }
 
        new_node = HeapAlloc(heap, HEAP_ZERO_MEMORY, sizeof(NoteNode));
 
        if ( ! new_node )
        {
            LeaveCriticalSection(&device_lock);
            return MMSYSERR_NOMEM;
        }
 
        new_node->note = note;
        new_node->velocity = velocity;
 
        /*
            Prepend to the playing notes list. If exceeding polyphony,
            remove the oldest note (which will be at the tail.)
        */
 
        if ( device_info->note_list )
            device_info->note_list->previous = new_node;
 
        new_node->next = device_info->note_list;
        new_node->previous = NULL;
 
        device_info->note_list = new_node;
        device_info->playing_notes_count ++;
 
/*
        if ( device_info->playing_notes_count > POLYPHONY )
        {
            ASSERT(tail_node);
 
            DPRINT("Polyphony exceeded\n");
 
            tail_node->previous->next = NULL;
 
            HeapFree(heap, 0, tail_node);
 
            device_info->playing_notes_count --;
        }
*/
 
#ifdef CONTINUOUS_NOTES
        SetEvent(device_info->work_available);
#endif
 
        LeaveCriticalSection(&device_lock);
 
        DPRINT("Note started - now playing %d notes\n", (int) device_info->playing_notes_count);
        device_info->refresh_notes = TRUE;
    }
 
#ifndef CONTINUOUS_NOTES
    ProcessPlayingNotes((PVOID) device_info);
#endif
 
    return MMSYSERR_NOERROR;
}

Referenced by ProcessShortMidiMessage().

ProcessLongMidiMessage()

MMRESULT ProcessLongMidiMessage	(	DeviceInfo *	device_info,
		MIDIHDR *	header
	)

Definition at line 668 of file beepmidi.c.

{
    unsigned int index = 0;
    UCHAR* midi_bytes = (UCHAR*) header->lpData;
 
    unsigned int msg_index = 0;
    UCHAR msg[3];
 
    /* Initialize the buffer */
    msg[0] = msg[1] = msg[2] = 0;
 
    if ( ! ( header->dwFlags & MHDR_PREPARED ) )
    {
        DPRINT("Not prepared!\n");
        return MIDIERR_UNPREPARED;
    }
 
    DPRINT("Processing %d bytes of MIDI\n", (int) header->dwBufferLength);
 
    while ( index < header->dwBufferLength )
    {
        /* New status byte? ( = new event) */
        if ( midi_bytes[index] & 0x80 )
        {
            DWORD short_msg;
 
            /* Deal with the existing event */
 
            if ( msg[0] & 0x80 )
            {
                short_msg = PACK_MIDI(msg[0], msg[1], msg[2]);
 
                DPRINT("Complete msg is 0x%x %d %d\n", (int) msg[0], (int) msg[1], (int) msg[2]);
                ProcessShortMidiMessage(device_info, short_msg);
            }
 
            /* Set new running status and start recording the event */
            DPRINT("Set new running status\n");
            device_info->running_status = midi_bytes[index];
            msg[0] = midi_bytes[index];
            msg_index = 1;
        }
 
        /* Unexpected data byte? ( = re-use previous status) */
        else if ( msg_index == 0 )
        {
            if ( device_info->running_status & 0x80 )
            {
                DPRINT("Retrieving running status\n");
                msg[0] = device_info->running_status;
                msg[1] = midi_bytes[index];
                msg_index = 2;
            }
            else
                DPRINT("garbage\n");
        }
 
        /* Expected data ( = append to message until buffer full) */
        else
        {
            DPRINT("Next byte...\n");
            msg[msg_index] = midi_bytes[index];
            msg_index ++;
 
            if ( msg_index > 2 )
            {
                DWORD short_msg;
 
                short_msg = PACK_MIDI(msg[0], msg[1], msg[2]);
 
                DPRINT("Complete msg is 0x%x %d %d\n", (int) msg[0], (int) msg[1], (int) msg[2]);
                ProcessShortMidiMessage(device_info, short_msg);
 
                /* Reinit */
                msg_index = 0;
                msg[0] = msg[1] = msg[2] = 0;
            }
        }
 
        index ++;
    }
 
    /*
        We're meant to clear MHDR_DONE and set MHDR_INQUEUE but since we
        deal with everything here and now we might as well just say so.
    */
    header->dwFlags |= MHDR_DONE;
    header->dwFlags &= ~ MHDR_INQUEUE;
 
    DPRINT("Success? %d\n", CallClient(the_device, MOM_DONE, (DWORD_PTR) header, 0));
 
    return MMSYSERR_NOERROR;
}

Referenced by modMessage().

ProcessPlayingNotes()

DWORD WINAPI ProcessPlayingNotes

(

LPVOID

parameter

)

Definition at line 117 of file beepmidi.c.

{
    DeviceInfo* device_info = (DeviceInfo*) parameter;
    NTSTATUS status;
    IO_STATUS_BLOCK io_status_block;
    DWORD arp_notes;
 
    DPRINT("Note processing started\n");
 
    /* We lock the note list only while accessing it */
 
#ifdef CONTINUOUS_NOTES
    while ( WaitForSingleObject(the_device->work_available, INFINITE), !device_info->terminate_thread )
#endif
    {
        NoteNode* node;
 
        /* Number of notes being arpeggiated */
        arp_notes = 1;
 
        EnterCriticalSection(&device_lock);
 
        /* Calculate how much time to allocate to each playing note */
 
        DPRINT("%d notes active\n", (int) device_info->playing_notes_count);
 
        node = device_info->note_list;
 
        while ( ( node != NULL ) && ( arp_notes <= POLYPHONY ) )
        {
            BEEP_SET_PARAMETERS beep_data;
            DWORD actually_playing = 0;
 
            double frequency = node->note;
 
            DPRINT("playing..\n");
 
            frequency = frequency / 12;
            frequency = pow(2, frequency);
            frequency = 8.1758 * frequency;
 
            if (device_info->playing_notes_count > POLYPHONY)
                actually_playing = POLYPHONY;
            else
                actually_playing = device_info->playing_notes_count;
 
            DPRINT("Frequency %f\n", frequency);
 
            // TODO
            beep_data.Frequency = (DWORD) frequency;
            beep_data.Duration = TIMESLICE_SIZE / actually_playing; /* device_info->playing_notes_count; */
 
            status = NtDeviceIoControlFile(device_info->kernel_device,
                                           NULL,
                                           NULL,
                                           NULL,
                                           &io_status_block,
                                           IOCTL_BEEP_SET,
                                           &beep_data,
                                           sizeof(BEEP_SET_PARAMETERS),
                                           NULL,
                                           0);
 
            if ( ! NT_SUCCESS(status) )
            {
                DPRINT("ERROR %d\n", (int) GetLastError());
            }
 
            SleepEx(beep_data.Duration, TRUE);
 
            if ( device_info->refresh_notes )
            {
                device_info->refresh_notes = FALSE;
                break;
            }
 
            arp_notes ++;
            node = node->next;
        }
 
        LeaveCriticalSection(&device_lock);
    }
 
    return 0;
}

Referenced by OpenDevice(), PlayNote(), and StopNote().

ProcessShortMidiMessage()

MMRESULT ProcessShortMidiMessage	(	DeviceInfo *	device_info,
		DWORD	message
	)

Definition at line 590 of file beepmidi.c.

{
    DWORD status;
 
    DWORD category;
    DWORD channel;
    DWORD data1, data2;
 
    status = message & 0x000000FF;
 
    /* Deal with running status */
 
    if ( status < MIDI_NOTE_OFF )
    {
        status = device_info->running_status;
    }
 
    /* Ensure the status is sane! */
 
    if ( status < MIDI_NOTE_OFF )
    {
        /* It's garbage, ignore it */
        return MMSYSERR_NOERROR;
    }
 
    /* Figure out the message category and channel */
 
    category = status & 0xF0;
    channel = status & 0x0F;    /* we don't use this */
 
    data1 = (message & 0x0000FF00) >> 8;
    data2 = (message & 0x00FF0000) >> 16;
 
    DPRINT("0x%x, %d, %d\n", (int) status, (int) data1, (int) data2);
 
    /* Filter drums (which are *usually* on channel 10) */
    if ( channel == 10 )
    {
        return MMSYSERR_NOERROR;
    }
 
    /* Pass to the appropriate message handler */
 
    switch ( category )
    {
        case MIDI_NOTE_ON :
        {
            PlayNote(device_info, data1, data2);
            break;
        }
 
        case MIDI_NOTE_OFF :
        {
            StopNote(device_info, data1);
            break;
        }
    }
 
    return MMSYSERR_NOERROR;
}

Referenced by modMessage(), and ProcessLongMidiMessage().

StopNote()

MMRESULT StopNote	(	DeviceInfo *	device_info,
		UCHAR	note
	)

Definition at line 418 of file beepmidi.c.

{
    HANDLE heap = GetProcessHeap();
    NoteNode* node;
    NoteNode* prev_node = NULL;
 
    DPRINT("StopNote\n");
 
    EnterCriticalSection(&device_lock);
 
    node = device_info->note_list;
 
    while ( node != NULL )
    {
        if ( node->note == note )
        {
            /* Found the note - just remove the node from the list */
 
            DPRINT("Stopping note %d\n", (int) node->note);
 
            if ( prev_node != NULL )
                prev_node->next = node->next;
            else
                device_info->note_list = node->next;
 
            HeapFree(heap, 0, node);
 
            device_info->playing_notes_count --;
 
            DPRINT("Note stopped - now playing %d notes\n", (int) device_info->playing_notes_count);
 
#ifdef CONTINUOUS_NOTES
            if (device_info->playing_notes_count == 0)
                ResetEvent(device_info->work_available);
#endif
 
            LeaveCriticalSection(&device_lock);
            device_info->refresh_notes = TRUE;
 
            return MMSYSERR_NOERROR;
        }
 
        prev_node = node;
        node = node->next;
    }
 
    LeaveCriticalSection(&device_lock);
 
    /* Hmm, a good idea? */
#ifndef CONTINUOUS_NOTES
    ProcessPlayingNotes((PVOID) device_info);
#endif
 
    return MMSYSERR_NOERROR;
}

Referenced by PlayNote(), and ProcessShortMidiMessage().

Variable Documentation

device_lock

CRITICAL_SECTION device_lock

Definition at line 102 of file beepmidi.c.

Referenced by DriverProc(), PlayNote(), ProcessPlayingNotes(), and StopNote().

the_device

DeviceInfo* the_device

Definition at line 101 of file beepmidi.c.

Referenced by CloseDevice(), DriverProc(), OpenDevice(), ProcessLongMidiMessage(), and ProcessPlayingNotes().