/[svn]/linuxsampler/trunk/src/drivers/midi/VirtualMidiDevice.cpp
ViewVC logotype

Contents of /linuxsampler/trunk/src/drivers/midi/VirtualMidiDevice.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2385 - (show annotations) (download)
Fri Dec 14 17:41:32 2012 UTC (7 years, 10 months ago) by schoenebeck
File size: 5475 byte(s)
* Bugfix in VirtualMidiDevice: process note on with velocity 0 as note off.

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

  ViewVC Help
Powered by ViewVC