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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2024 by persson, Mon May 4 18:34:44 2009 UTC revision 2025 by schoenebeck, Sun Nov 1 18:47:59 2009 UTC
# Line 1  Line 1 
1  /*  /*
2      Copyright (C) 2008 Christian Schoenebeck      Copyright (C) 2008 - 2009 Christian Schoenebeck
3   */   */
4    
5  #include "VirtualMidiDevice.h"  #include "VirtualMidiDevice.h"
# Line 8  Line 8 
8  #include "../../common/atomic.h"  #include "../../common/atomic.h"
9  #include "../../common/RingBuffer.h"  #include "../../common/RingBuffer.h"
10    
11  #define MIDI_KEYS       128  #define MIDI_KEYS               128
12    #define MIDI_CONTROLLERS        128
13    
14  // assuming VirtualMidiDevice implementation is only controlled  // assuming VirtualMidiDevice implementation is only controlled
15  // by mouse (and the user not being Billy the Kid)  // by mouse (and the user not being Billy the Kid)
# Line 22  namespace LinuxSampler { Line 23  namespace LinuxSampler {
23          atomic_t pNoteIsActive[MIDI_KEYS]; // status of each key (either active or inactive)          atomic_t pNoteIsActive[MIDI_KEYS]; // status of each key (either active or inactive)
24          atomic_t pNoteOnVelocity[MIDI_KEYS];          atomic_t pNoteOnVelocity[MIDI_KEYS];
25          atomic_t pNoteOffVelocity[MIDI_KEYS];          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;          RingBuffer<VirtualMidiDevice::event_t,false> events;
30    
31          private_data_t() : events(MAX_EVENTS, 0) {}          private_data_t() : events(MAX_EVENTS, 0) {}
# Line 30  namespace LinuxSampler { Line 34  namespace LinuxSampler {
34      VirtualMidiDevice::VirtualMidiDevice() : p(new private_data_t) {      VirtualMidiDevice::VirtualMidiDevice() : p(new private_data_t) {
35          atomic_t zero = ATOMIC_INIT(0);          atomic_t zero = ATOMIC_INIT(0);
36          atomic_t defaultVelocity = ATOMIC_INIT(127);          atomic_t defaultVelocity = ATOMIC_INIT(127);
37            atomic_t defaultCCValue = ATOMIC_INIT(0);
38          p->notesChanged = zero;          p->notesChanged = zero;
39            p->ccsChanged   = zero;
40          for (int i = 0; i < MIDI_KEYS; i++) {          for (int i = 0; i < MIDI_KEYS; i++) {
41              p->pNoteChanged[i]  = zero;              p->pNoteChanged[i]  = zero;
42              p->pNoteIsActive[i] = zero;              p->pNoteIsActive[i] = zero;
43              p->pNoteOnVelocity[i] = defaultVelocity;              p->pNoteOnVelocity[i] = defaultVelocity;
44              p->pNoteOffVelocity[i] = defaultVelocity;              p->pNoteOffVelocity[i] = defaultVelocity;
45                p->pCCChanged[i] = zero;
46                p->pCCValue[i]   = defaultCCValue;
47          }          }
48      }      }
49    
# Line 58  namespace LinuxSampler { Line 66  namespace LinuxSampler {
66          p->events.push(&ev);          p->events.push(&ev);
67          return true;          return true;
68      }      }
69        
70        bool VirtualMidiDevice::SendCCToSampler(uint8_t Controller, uint8_t Value) {
71            if (Controller >= MIDI_CONTROLLERS || Value > 127) return false;
72            event_t ev = { EVENT_TYPE_CC, Controller, Value };
73            if (p->events.write_space() <= 0) return false;
74            p->events.push(&ev);
75            return true;
76        }
77    
78      bool VirtualMidiDevice::GetMidiEventFromDevice(event_t& Event) {      bool VirtualMidiDevice::GetMidiEventFromDevice(event_t& Event) {
79          return (p->events.pop(&Event) > 0);          return (p->events.pop(&Event) > 0);
# Line 68  namespace LinuxSampler { Line 84  namespace LinuxSampler {
84          atomic_sub(c, &p->notesChanged );          atomic_sub(c, &p->notesChanged );
85          return c;          return c;
86      }      }
87        
88        bool VirtualMidiDevice::ControllersChanged() {
89            int c = atomic_read( &p->ccsChanged );
90            atomic_sub(c, &p->ccsChanged );
91            return c;
92        }
93    
94      bool VirtualMidiDevice::NoteChanged(uint8_t Key) {      bool VirtualMidiDevice::NoteChanged(uint8_t Key) {
95          int c = atomic_read( &(p->pNoteChanged)[Key] );          int c = atomic_read( &(p->pNoteChanged)[Key] );
96          atomic_sub(c, &(p->pNoteChanged)[Key] );          atomic_sub(c, &(p->pNoteChanged)[Key] );
97          return c;          return c;
98      }      }
99        
100        bool VirtualMidiDevice::ControllerChanged(uint8_t Controller) {
101            int c = atomic_read( &(p->pCCChanged)[Controller] );
102            atomic_sub(c, &(p->pCCChanged)[Controller] );
103            return c;
104        }
105    
106      bool VirtualMidiDevice::NoteIsActive(uint8_t Key) {      bool VirtualMidiDevice::NoteIsActive(uint8_t Key) {
107          return atomic_read( &(p->pNoteIsActive)[Key] );          return atomic_read( &(p->pNoteIsActive)[Key] );
# Line 86  namespace LinuxSampler { Line 114  namespace LinuxSampler {
114      uint8_t VirtualMidiDevice::NoteOffVelocity(uint8_t Key) {      uint8_t VirtualMidiDevice::NoteOffVelocity(uint8_t Key) {
115          return atomic_read( &(p->pNoteOffVelocity)[Key] );          return atomic_read( &(p->pNoteOffVelocity)[Key] );
116      }      }
117        
118        uint8_t VirtualMidiDevice::ControllerValue(uint8_t Controller) {
119            return atomic_read( &(p->pCCValue)[Controller] );
120        }
121    
122      void VirtualMidiDevice::SendNoteOnToDevice(uint8_t Key, uint8_t Velocity) {      void VirtualMidiDevice::SendNoteOnToDevice(uint8_t Key, uint8_t Velocity) {
123          if (Key >= MIDI_KEYS) return;          if (Key >= MIDI_KEYS) return;
# Line 102  namespace LinuxSampler { Line 134  namespace LinuxSampler {
134          atomic_inc( &(p->pNoteChanged)[Key] );          atomic_inc( &(p->pNoteChanged)[Key] );
135          atomic_inc( &p->notesChanged );          atomic_inc( &p->notesChanged );
136      }      }
137        
138        void VirtualMidiDevice::SendCCToDevice(uint8_t Controller, uint8_t Value) {
139            if (Controller >= MIDI_CONTROLLERS) return;
140            atomic_set( &(p->pCCValue)[Controller], Value );
141            atomic_inc( &(p->pCCChanged)[Controller] );
142            atomic_inc( &p->ccsChanged );
143        }
144    
145  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.2024  
changed lines
  Added in v.2025
  ViewVC Help
Powered by ViewVC