10 #include <jack/midiport.h>
12 #include "evoral/midi_events.h"
22 second_simultaneous_midi_byte_is_first (uint8_t a, uint8_t b)
26 /* two events at identical times. we need to determine
27 the order in which they should occur.
40 if ((a) >= 0xf0 || (b) >= 0xf0 || ((a & 0xf) != (b & 0xf))) {
42 /* if either message is not a channel message, or if the channels are
43 * different, we don't care about the type.
51 case MIDI_CMD_CONTROL:
55 case MIDI_CMD_PGM_CHANGE:
57 case MIDI_CMD_CONTROL:
59 case MIDI_CMD_PGM_CHANGE:
60 case MIDI_CMD_NOTE_OFF:
61 case MIDI_CMD_NOTE_ON:
62 case MIDI_CMD_NOTE_PRESSURE:
63 case MIDI_CMD_CHANNEL_PRESSURE:
69 case MIDI_CMD_NOTE_OFF:
71 case MIDI_CMD_CONTROL:
72 case MIDI_CMD_PGM_CHANGE:
74 case MIDI_CMD_NOTE_OFF:
75 case MIDI_CMD_NOTE_ON:
76 case MIDI_CMD_NOTE_PRESSURE:
77 case MIDI_CMD_CHANNEL_PRESSURE:
83 case MIDI_CMD_NOTE_ON:
85 case MIDI_CMD_CONTROL:
86 case MIDI_CMD_PGM_CHANGE:
87 case MIDI_CMD_NOTE_OFF:
89 case MIDI_CMD_NOTE_ON:
90 case MIDI_CMD_NOTE_PRESSURE:
91 case MIDI_CMD_CHANNEL_PRESSURE:
96 case MIDI_CMD_NOTE_PRESSURE:
98 case MIDI_CMD_CONTROL:
99 case MIDI_CMD_PGM_CHANGE:
100 case MIDI_CMD_NOTE_OFF:
101 case MIDI_CMD_NOTE_ON:
103 case MIDI_CMD_NOTE_PRESSURE:
104 case MIDI_CMD_CHANNEL_PRESSURE:
105 case MIDI_CMD_BENDER:
110 case MIDI_CMD_CHANNEL_PRESSURE:
112 case MIDI_CMD_CONTROL:
113 case MIDI_CMD_PGM_CHANGE:
114 case MIDI_CMD_NOTE_OFF:
115 case MIDI_CMD_NOTE_ON:
116 case MIDI_CMD_NOTE_PRESSURE:
118 case MIDI_CMD_CHANNEL_PRESSURE:
119 case MIDI_CMD_BENDER:
123 case MIDI_CMD_BENDER:
125 case MIDI_CMD_CONTROL:
126 case MIDI_CMD_PGM_CHANGE:
127 case MIDI_CMD_NOTE_OFF:
128 case MIDI_CMD_NOTE_ON:
129 case MIDI_CMD_NOTE_PRESSURE:
130 case MIDI_CMD_CHANNEL_PRESSURE:
132 case MIDI_CMD_BENDER:
142 BeatBox::BeatBox (int sr)
143 : _start_requested (false)
148 , _meter_beat_type (4)
154 , whole_note_superclocks (0)
155 , beat_superclocks (0)
156 , measure_superclocks (0)
157 , _quantize_divisor (4)
158 , clear_pending (false)
160 for (uint32_t n = 0; n < 1024; ++n) {
161 event_pool.push_back (new Event());
170 BeatBox::register_ports (jack_client_t* jack)
172 if ((_input = jack_port_register (jack, "midi-in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0)) == 0) {
173 cerr << "no input port\n";
176 if ((_output = jack_port_register (jack, "midi-out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0)) == 0) {
177 cerr << "no output port\n";
178 jack_port_unregister (jack, _input);
188 /* compute tempo, beat steps etc. */
191 superclocks_per_minute = superclock_ticks_per_second * 60;
192 beats_per_minute = _tempo;
193 whole_notes_per_minute = beats_per_minute / _meter_beat_type;
196 whole_note_superclocks = (superclock_ticks_per_second * 60) / (_tempo / _meter_beat_type);
197 cerr << "there are " << _tempo / _meter_beat_type << " whole notes per minute, which is " << superclock_ticks_per_second * 60 << " sct, so wns = " << whole_note_superclocks << endl;
198 beat_superclocks = whole_note_superclocks / _meter_beat_type;
199 measure_superclocks = beat_superclocks * _meter_beats;
203 _start_requested = true;
209 _start_requested = false;
213 BeatBox::process (int nsamples)
216 if (_start_requested) {
218 last_start = superclock_cnt;
222 if (!_start_requested) {
227 superclock_t superclocks = samples_to_superclock (nsamples, _sample_rate);
230 superclock_cnt += superclocks;
234 superclock_t process_start = superclock_cnt - last_start;
235 superclock_t process_end = process_start + superclocks;
236 const superclock_t loop_length = _measures * measure_superclocks;
237 const superclock_t orig_superclocks = superclocks;
239 process_start %= loop_length;
240 process_end %= loop_length;
242 bool two_pass_required;
243 superclock_t offset = 0;
245 if (process_end < process_start) {
246 two_pass_required = true;
247 process_end = loop_length;
248 superclocks = process_end - process_start;
250 two_pass_required = false;
253 unsigned char* buffer;
256 jack_midi_event_t in_event;
257 jack_nframes_t event_index;
258 jack_nframes_t event_count;
260 /* do this on the first pass only */
261 out_buf = jack_port_get_buffer (_output, nsamples);
262 jack_midi_clear_buffer (out_buf);
270 for (Events::iterator ee = _current_events.begin(); ee != _current_events.end(); ++ee) {
271 event_pool.push_back (*ee);
273 _current_events.clear ();
274 clear_pending = false;
277 for (Events::iterator ee = _current_events.begin(); ee != _current_events.end(); ++ee) {
280 if (e->size && (e->time >= process_start && e->time < process_end)) {
281 if ((buffer = jack_midi_event_reserve (out_buf, superclock_to_samples (offset + e->time - process_start, _sample_rate), e->size)) != 0) {
282 memcpy (buffer, e->buf, e->size);
284 cerr << "Could not reserve space for output event @ " << e << " of size " << e->size << " @ " << offset + e->time - process_start
285 << " (samples: " << superclock_to_samples (offset + e->time - process_start, _sample_rate) << ") offset is " << offset
290 if (e->time >= process_end) {
297 in_buf = jack_port_get_buffer (_input, nsamples);
300 while (jack_midi_event_get (&in_event, in_buf, event_index++) == 0) {
302 superclock_t event_time = superclock_cnt + samples_to_superclock (in_event.time, _sample_rate);
303 superclock_t elapsed_time = event_time - last_start;
304 superclock_t in_loop_time = elapsed_time % loop_length;
305 superclock_t quantized_time;
307 if (_quantize_divisor != 0) {
308 const superclock_t time_per_beat = whole_note_superclocks / _quantize_divisor;
309 quantized_time = (in_loop_time / time_per_beat) * time_per_beat;
311 quantized_time = elapsed_time;
314 if (in_event.size > 24) {
315 cerr << "Ignored large MIDI event\n";
319 if (event_pool.empty()) {
320 cerr << "No more events, grow pool\n";
324 Event* e = event_pool.back();
325 event_pool.pop_back ();
327 e->time = quantized_time;
328 e->size = in_event.size;
329 memcpy (e->buf, in_event.buffer, in_event.size);
331 _current_events.insert (e);
334 superclock_cnt += superclocks;
336 if (two_pass_required) {
337 offset = superclocks;
338 superclocks = orig_superclocks - superclocks;
340 process_end = superclocks;
341 two_pass_required = false;
342 cerr << "2nd Pass for " << superclocks << " offset = " << offset << endl;
350 BeatBox::set_quantize (int divisor)
352 _quantize_divisor = divisor;
358 clear_pending = true;
362 BeatBox::EventComparator::operator() (Event const * a, Event const *b) const
364 if (a->time == b->time) {
365 if (a->buf[0] == b->buf[0]) {
368 return !second_simultaneous_midi_byte_is_first (a->buf[0], b->buf[0]);
370 return a->time < b->time;
374 process (jack_nframes_t nsamples, void* arg)
376 BeatBox* bbox = static_cast<BeatBox*> (arg);
377 return bbox->process (nsamples);
381 main (int argc, char* argv[])
384 const char *server_name = NULL;
385 jack_options_t options = JackNullOption;
386 jack_status_t status;
388 if ((jack = jack_client_open ("beatbox", options, &status, server_name)) == 0) {
389 cerr << "Could not connect to JACK\n";
393 BeatBox* bbox = new BeatBox (jack_get_sample_rate (jack));
394 BBGUI* gui = new BBGUI (&argc, &argv, jack, bbox);
396 bbox->register_ports (jack);
398 jack_set_process_callback (jack, process, bbox);
399 jack_activate (jack);