drivers/midi/VirtualMidiDevice.cpp

/*
    Copyright (C) 2008 - 2012 Christian Schoenebeck
 */

#include "VirtualMidiDevice.h"

#include "../../common/global_private.h"
#include "../../common/atomic.h"
#include "../../common/RingBuffer.h"

#define MIDI_KEYS               128
#define MIDI_CONTROLLERS        128

// assuming VirtualMidiDevice implementation is only controlled
// by mouse (and the user not being Billy the Kid)
#define MAX_EVENTS  12

namespace LinuxSampler {

    struct VirtualMidiDevice::private_data_t {
        atomic_t notesChanged; // whether some key changed at all
        atomic_t pNoteChanged[MIDI_KEYS]; // which key(s) changed
        atomic_t pNoteIsActive[MIDI_KEYS]; // status of each key (either active or inactive)
        atomic_t pNoteOnVelocity[MIDI_KEYS];
        atomic_t pNoteOffVelocity[MIDI_KEYS];
        atomic_t ccsChanged; // whether some controller changed at all
        atomic_t pCCChanged[MIDI_CONTROLLERS]; // which controller(s) changed
        atomic_t pCCValue[MIDI_CONTROLLERS]; // current value of each controller
        RingBuffer<VirtualMidiDevice::event_t,false> events;

        private_data_t() : events(MAX_EVENTS, 0) {}
    };

    VirtualMidiDevice::VirtualMidiDevice() : p(new private_data_t) {
        atomic_t zero = ATOMIC_INIT(0);
        atomic_t defaultVelocity = ATOMIC_INIT(127);
        atomic_t defaultCCValue = ATOMIC_INIT(0);
        p->notesChanged = zero;
        p->ccsChanged   = zero;
        for (int i = 0; i < MIDI_KEYS; i++) {
            p->pNoteChanged[i]  = zero;
            p->pNoteIsActive[i] = zero;
            p->pNoteOnVelocity[i] = defaultVelocity;
            p->pNoteOffVelocity[i] = defaultVelocity;
            p->pCCChanged[i] = zero;
            p->pCCValue[i]   = defaultCCValue;
        }
    }

    VirtualMidiDevice::~VirtualMidiDevice() {
        delete p;
    }
    
    void VirtualMidiDevice::SetMaxEvents(int n) {
        p->events.resize(n);
    }

    bool VirtualMidiDevice::SendNoteOnToSampler(uint8_t Key, uint8_t Velocity) {
        if (Key >= MIDI_KEYS || Velocity > 127) return false;
        if (Velocity == 0) {
            return SendNoteOffToSampler(Key, Velocity);
        }
        event_t ev = { EVENT_TYPE_NOTEON, Key, Velocity };
        if (p->events.write_space() <= 0) return false;
        p->events.push(&ev);
        return true;
    }

    bool VirtualMidiDevice::SendNoteOffToSampler(uint8_t Key, uint8_t Velocity) {
        if (Key >= MIDI_KEYS || Velocity > 127) return false;
        event_t ev = { EVENT_TYPE_NOTEOFF, Key, Velocity };
        if (p->events.write_space() <= 0) return false;
        p->events.push(&ev);
        return true;
    }
    
    bool VirtualMidiDevice::SendCCToSampler(uint8_t Controller, uint8_t Value) {
        if (Controller >= MIDI_CONTROLLERS || Value > 127) return false;
        event_t ev = { EVENT_TYPE_CC, Controller, Value };
        if (p->events.write_space() <= 0) return false;
        p->events.push(&ev);
        return true;
    }

    bool VirtualMidiDevice::GetMidiEventFromDevice(event_t& Event) {
        return (p->events.pop(&Event) > 0);
    }

    bool VirtualMidiDevice::NotesChanged() {
        int c = atomic_read( &p->notesChanged );
        atomic_sub(c, &p->notesChanged );
        return c;
    }
    
    bool VirtualMidiDevice::ControllersChanged() {
        int c = atomic_read( &p->ccsChanged );
        atomic_sub(c, &p->ccsChanged );
        return c;
    }

    bool VirtualMidiDevice::NoteChanged(uint8_t Key) {
        int c = atomic_read( &(p->pNoteChanged)[Key] );
        atomic_sub(c, &(p->pNoteChanged)[Key] );
        return c;
    }
    
    bool VirtualMidiDevice::ControllerChanged(uint8_t Controller) {
        int c = atomic_read( &(p->pCCChanged)[Controller] );
        atomic_sub(c, &(p->pCCChanged)[Controller] );
        return c;
    }

    bool VirtualMidiDevice::NoteIsActive(uint8_t Key) {
        return atomic_read( &(p->pNoteIsActive)[Key] );
    }

    uint8_t VirtualMidiDevice::NoteOnVelocity(uint8_t Key) {
        return atomic_read( &(p->pNoteOnVelocity)[Key] );
    }

    uint8_t VirtualMidiDevice::NoteOffVelocity(uint8_t Key) {
        return atomic_read( &(p->pNoteOffVelocity)[Key] );
    }
    
    uint8_t VirtualMidiDevice::ControllerValue(uint8_t Controller) {
        return atomic_read( &(p->pCCValue)[Controller] );
    }

    void VirtualMidiDevice::SendNoteOnToDevice(uint8_t Key, uint8_t Velocity) {
        if (Key >= MIDI_KEYS) return;
        if (Velocity == 0) {
            SendNoteOffToDevice(Key, Velocity);
            return;
        }
        atomic_set( &(p->pNoteOnVelocity)[Key], Velocity );
        atomic_inc( &(p->pNoteIsActive)[Key] );
        atomic_inc( &(p->pNoteChanged)[Key] );
        atomic_inc( &p->notesChanged );
    }

    void VirtualMidiDevice::SendNoteOffToDevice(uint8_t Key, uint8_t Velocity) {
        if (Key >= MIDI_KEYS) return;
        atomic_set( &(p->pNoteOffVelocity)[Key], Velocity );
        if (atomic_read( &(p->pNoteIsActive)[Key] )) // only decrement if not zero
            atomic_dec( &(p->pNoteIsActive)[Key] );
        atomic_inc( &(p->pNoteChanged)[Key] );
        atomic_inc( &p->notesChanged );
    }
    
    void VirtualMidiDevice::SendCCToDevice(uint8_t Controller, uint8_t Value) {
        if (Controller >= MIDI_CONTROLLERS) return;
        atomic_set( &(p->pCCValue)[Controller], Value );
        atomic_inc( &(p->pCCChanged)[Controller] );
        atomic_inc( &p->ccsChanged );
    }

} // namespace LinuxSampler
1	/*
2	Copyright (C) 2008 - 2012 Christian Schoenebeck
3	*/
4
5	#include "VirtualMidiDevice.h"
6
7	#include "../../common/global_private.h"
8	#include "../../common/atomic.h"
9	#include "../../common/RingBuffer.h"
10
11	#define MIDI_KEYS 128
12	#define MIDI_CONTROLLERS 128
13
14	// assuming VirtualMidiDevice implementation is only controlled
15	// by mouse (and the user not being Billy the Kid)
16	#define MAX_EVENTS 12
17
18	namespace LinuxSampler {
19
20	struct VirtualMidiDevice::private_data_t {
21	atomic_t notesChanged; // whether some key changed at all
22	atomic_t pNoteChanged[MIDI_KEYS]; // which key(s) changed
23	atomic_t pNoteIsActive[MIDI_KEYS]; // status of each key (either active or inactive)
24	atomic_t pNoteOnVelocity[MIDI_KEYS];
25	atomic_t pNoteOffVelocity[MIDI_KEYS];
26	atomic_t ccsChanged; // whether some controller changed at all
27	atomic_t pCCChanged[MIDI_CONTROLLERS]; // which controller(s) changed
28	atomic_t pCCValue[MIDI_CONTROLLERS]; // current value of each controller
29	RingBuffer<VirtualMidiDevice::event_t,false> events;
30
31	private_data_t() : events(MAX_EVENTS, 0) {}
32	};
33
34	VirtualMidiDevice::VirtualMidiDevice() : p(new private_data_t) {
35	atomic_t zero = ATOMIC_INIT(0);
36	atomic_t defaultVelocity = ATOMIC_INIT(127);
37	atomic_t defaultCCValue = ATOMIC_INIT(0);
38	p->notesChanged = zero;
39	p->ccsChanged = zero;
40	for (int i = 0; i < MIDI_KEYS; i++) {
41	p->pNoteChanged[i] = zero;
42	p->pNoteIsActive[i] = zero;
43	p->pNoteOnVelocity[i] = defaultVelocity;
44	p->pNoteOffVelocity[i] = defaultVelocity;
45	p->pCCChanged[i] = zero;
46	p->pCCValue[i] = defaultCCValue;
47	}
48	}
49
50	VirtualMidiDevice::~VirtualMidiDevice() {
51	delete p;
52	}
53
54	void VirtualMidiDevice::SetMaxEvents(int n) {
55	p->events.resize(n);
56	}
57
58	bool VirtualMidiDevice::SendNoteOnToSampler(uint8_t Key, uint8_t Velocity) {
59	if (Key >= MIDI_KEYS \|\| Velocity > 127) return false;
60	if (Velocity == 0) {
61	return SendNoteOffToSampler(Key, Velocity);
62	}
63	event_t ev = { EVENT_TYPE_NOTEON, Key, Velocity };
64	if (p->events.write_space() <= 0) return false;
65	p->events.push(&ev);
66	return true;
67	}
68
69	bool VirtualMidiDevice::SendNoteOffToSampler(uint8_t Key, uint8_t Velocity) {
70	if (Key >= MIDI_KEYS \|\| Velocity > 127) return false;
71	event_t ev = { EVENT_TYPE_NOTEOFF, Key, Velocity };
72	if (p->events.write_space() <= 0) return false;
73	p->events.push(&ev);
74	return true;
75	}
76
77	bool VirtualMidiDevice::SendCCToSampler(uint8_t Controller, uint8_t Value) {
78	if (Controller >= MIDI_CONTROLLERS \|\| Value > 127) return false;
79	event_t ev = { EVENT_TYPE_CC, Controller, Value };
80	if (p->events.write_space() <= 0) return false;
81	p->events.push(&ev);
82	return true;
83	}
84
85	bool VirtualMidiDevice::GetMidiEventFromDevice(event_t& Event) {
86	return (p->events.pop(&Event) > 0);
87	}
88
89	bool VirtualMidiDevice::NotesChanged() {
90	int c = atomic_read( &p->notesChanged );
91	atomic_sub(c, &p->notesChanged );
92	return c;
93	}
94
95	bool VirtualMidiDevice::ControllersChanged() {
96	int c = atomic_read( &p->ccsChanged );
97	atomic_sub(c, &p->ccsChanged );
98	return c;
99	}
100
101	bool VirtualMidiDevice::NoteChanged(uint8_t Key) {
102	int c = atomic_read( &(p->pNoteChanged)[Key] );
103	atomic_sub(c, &(p->pNoteChanged)[Key] );
104	return c;
105	}
106
107	bool VirtualMidiDevice::ControllerChanged(uint8_t Controller) {
108	int c = atomic_read( &(p->pCCChanged)[Controller] );
109	atomic_sub(c, &(p->pCCChanged)[Controller] );
110	return c;
111	}
112
113	bool VirtualMidiDevice::NoteIsActive(uint8_t Key) {
114	return atomic_read( &(p->pNoteIsActive)[Key] );
115	}
116
117	uint8_t VirtualMidiDevice::NoteOnVelocity(uint8_t Key) {
118	return atomic_read( &(p->pNoteOnVelocity)[Key] );
119	}
120
121	uint8_t VirtualMidiDevice::NoteOffVelocity(uint8_t Key) {
122	return atomic_read( &(p->pNoteOffVelocity)[Key] );
123	}
124
125	uint8_t VirtualMidiDevice::ControllerValue(uint8_t Controller) {
126	return atomic_read( &(p->pCCValue)[Controller] );
127	}
128
129	void VirtualMidiDevice::SendNoteOnToDevice(uint8_t Key, uint8_t Velocity) {
130	if (Key >= MIDI_KEYS) return;
131	if (Velocity == 0) {
132	SendNoteOffToDevice(Key, Velocity);
133	return;
134	}
135	atomic_set( &(p->pNoteOnVelocity)[Key], Velocity );
136	atomic_inc( &(p->pNoteIsActive)[Key] );
137	atomic_inc( &(p->pNoteChanged)[Key] );
138	atomic_inc( &p->notesChanged );
139	}
140
141	void VirtualMidiDevice::SendNoteOffToDevice(uint8_t Key, uint8_t Velocity) {
142	if (Key >= MIDI_KEYS) return;
143	atomic_set( &(p->pNoteOffVelocity)[Key], Velocity );
144	if (atomic_read( &(p->pNoteIsActive)[Key] )) // only decrement if not zero
145	atomic_dec( &(p->pNoteIsActive)[Key] );
146	atomic_inc( &(p->pNoteChanged)[Key] );
147	atomic_inc( &p->notesChanged );
148	}
149
150	void VirtualMidiDevice::SendCCToDevice(uint8_t Controller, uint8_t Value) {
151	if (Controller >= MIDI_CONTROLLERS) return;
152	atomic_set( &(p->pCCValue)[Controller], Value );
153	atomic_inc( &(p->pCCChanged)[Controller] );
154	atomic_inc( &p->ccsChanged );
155	}
156
157	} // namespace LinuxSampler