tools/bb/bb.cc

   1 #include <iostream>
   2 #include <cstdio>
   3 #include <cmath>
   4 #include <cstring>
   5
   6 #include <unistd.h>
   7 #include <stdint.h>
   8
   9 #include <jack/jack.h>
  10 #include <jack/midiport.h>
  11
  12 #include "evoral/midi_events.h"
  13
  14 #include "ardour/midi_buffer.h"
  15
  16 #include "bb.h"
  17 #include "gui.h"
  18
  19 using std::cerr;
  20 using std::endl;
  21
  22
  23
  24 BeatBox::BeatBox (int sr)
  25         : _start_requested (false)
  26         , _running (false)
  27         , _measures (2)
  28         , _tempo (120)
  29         , _tempo_request (0)
  30         , _meter_beats (4)
  31         , _meter_beat_type (4)
  32         , _input (0)
  33         , _output (0)
  34         , superclock_cnt (0)
  35         , last_start (0)
  36         , _sample_rate (sr)
  37         , whole_note_superclocks (0)
  38         , beat_superclocks (0)
  39         , measure_superclocks (0)
  40         , _quantize_divisor (4)
  41         , clear_pending (false)
  42 {
  43         for (uint32_t n = 0; n < 1024; ++n) {
  44                 event_pool.push_back (new Event());
  45         }
  46 }
  47
  48 BeatBox::~BeatBox ()
  49 {
  50 }
  51
  52 int
  53 BeatBox::register_ports (jack_client_t* jack)
  54 {
  55         if ((_input = jack_port_register (jack, "midi-in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0)) == 0) {
  56                 cerr << "no input port\n";
  57                 return -1;
  58         }
  59         if ((_output = jack_port_register (jack, "midi-out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0)) == 0) {
  60                 cerr << "no output port\n";
  61                 jack_port_unregister (jack, _input);
  62                 return -1;
  63         }
  64
  65         return 0;
  66 }
  67
  68 void
  69 BeatBox::compute_tempo_clocks ()
  70 {
  71         whole_note_superclocks = (superclock_ticks_per_second * 60) / (_tempo / _meter_beat_type);
  72         beat_superclocks = whole_note_superclocks / _meter_beat_type;
  73         measure_superclocks = beat_superclocks * _meter_beats;
  74 }
  75
  76 void
  77 BeatBox::start ()
  78 {
  79         /* compute tempo, beat steps etc. */
  80
  81         compute_tempo_clocks ();
  82
  83         /* we can start */
  84
  85         _start_requested = true;
  86 }
  87
  88 void
  89 BeatBox::stop ()
  90 {
  91         _start_requested = false;
  92 }
  93
  94 void
  95 BeatBox::set_tempo (float bpm)
  96 {
  97         _tempo_request = bpm;
  98 }
  99
 100 int
 101 BeatBox::process (int nsamples)
 102 {
 103         if (!_running) {
 104                 if (_start_requested) {
 105                         _running = true;
 106                         last_start = superclock_cnt;
 107                 }
 108
 109         } else {
 110                 if (!_start_requested) {
 111                         _running = false;
 112                 }
 113         }
 114
 115         superclock_t superclocks = samples_to_superclock (nsamples, _sample_rate);
 116
 117         if (_tempo_request) {
 118                 double ratio = _tempo / _tempo_request;
 119                 _tempo = _tempo_request;
 120                 _tempo_request = 0;
 121
 122                 compute_tempo_clocks ();
 123
 124                 /* recompute all the event times based on the ratio between the
 125                  * new and old tempo.
 126                  */
 127
 128                 for (Events::iterator ee = _current_events.begin(); ee != _current_events.end(); ++ee) {
 129                         (*ee)->time = llrintf ((*ee)->time * ratio);
 130                 }
 131         }
 132
 133         if (!_running) {
 134                 superclock_cnt += superclocks;
 135                 return 0;
 136         }
 137
 138         superclock_t process_start = superclock_cnt - last_start;
 139         superclock_t process_end = process_start + superclocks;
 140         const superclock_t loop_length = _measures * measure_superclocks;
 141         const superclock_t orig_superclocks = superclocks;
 142
 143         process_start %= loop_length;
 144         process_end   %= loop_length;
 145
 146         bool two_pass_required;
 147         superclock_t offset = 0;
 148
 149         if (process_end < process_start) {
 150                 two_pass_required = true;
 151                 process_end = loop_length;
 152                 superclocks = process_end - process_start;
 153         } else {
 154                 two_pass_required = false;
 155         }
 156
 157         unsigned char* buffer;
 158         void* out_buf;
 159         void* in_buf;
 160         jack_midi_event_t in_event;
 161         jack_nframes_t event_index;
 162
 163         /* do this on the first pass only */
 164         out_buf = jack_port_get_buffer (_output, nsamples);
 165         jack_midi_clear_buffer (out_buf);
 166
 167   second_pass:
 168
 169         /* Output */
 170
 171         if (clear_pending) {
 172
 173                 for (Events::iterator ee = _current_events.begin(); ee != _current_events.end(); ++ee) {
 174                         event_pool.push_back (*ee);
 175                 }
 176                 _current_events.clear ();
 177                 clear_pending = false;
 178         }
 179
 180         for (Events::iterator ee = _current_events.begin(); ee != _current_events.end(); ++ee) {
 181                 Event* e = (*ee);
 182
 183                 if (e->size && (e->time >= process_start && e->time < process_end)) {
 184                         if ((buffer = jack_midi_event_reserve (out_buf, superclock_to_samples (offset + e->time - process_start, _sample_rate), e->size)) != 0) {
 185                                 memcpy (buffer, e->buf, e->size);
 186                                 outbound_tracker.track (e->buf);
 187                         } else {
 188                                 cerr << "Could not reserve space for output event @ " << e << " of size " << e->size << " @ " << offset + e->time - process_start
 189                                      << " (samples: " << superclock_to_samples (offset + e->time - process_start, _sample_rate) << ") offset is " << offset
 190                                      << ")\n";
 191                         }
 192                 }
 193
 194                 if (e->time >= process_end) {
 195                         break;
 196                 }
 197         }
 198
 199         /* input */
 200
 201         in_buf = jack_port_get_buffer (_input, nsamples);
 202         event_index = 0;
 203
 204         while (jack_midi_event_get (&in_event, in_buf, event_index++) == 0) {
 205
 206                 superclock_t event_time = superclock_cnt + samples_to_superclock (in_event.time, _sample_rate);
 207                 superclock_t elapsed_time = event_time - last_start;
 208                 superclock_t in_loop_time = elapsed_time % loop_length;
 209                 superclock_t quantized_time;
 210
 211                 if (_quantize_divisor != 0) {
 212                         const superclock_t time_per_grid_unit = whole_note_superclocks / _quantize_divisor;
 213
 214                         if (in_event.buffer[0] == MIDI_CMD_NOTE_OFF) {
 215
 216                                 /* note off is special - it must be quantized
 217                                  * to at least 1 quantization "spacing" after
 218                                  * the corresponding note on.
 219                                  */
 220
 221                                 /* compute nominal time */
 222
 223                                 quantized_time = (in_loop_time / time_per_grid_unit) * time_per_grid_unit;
 224
 225                                 /* look for the note on */
 226
 227                                 for (Events::iterator ee = _current_events.begin(); ee != _current_events.end(); ++ee) {
 228                                         /* is it a note-on? same note? same  channel? */
 229                                         if ((*ee)->time > quantized_time) {
 230                                                 cerr << "Note off seen without corresponding note on!\n";
 231                                                 /* leave quantized_time alone ... should probably dump the whole event */
 232                                                 break;
 233                                         }
 234
 235                                         if (((*ee)->buf[0] == MIDI_CMD_NOTE_ON) && ((*ee)->buf[1] == in_event.buffer[1]) && ((*ee)->buf[0] & 0xf) == (in_event.buffer[0] & 0xf)) {
 236                                                 quantized_time = (*ee)->time + time_per_grid_unit;
 237                                         }
 238                                 }
 239                         } else {
 240                                 quantized_time = (in_loop_time / time_per_grid_unit) * time_per_grid_unit;
 241                         }
 242
 243                 } else {
 244                         quantized_time = elapsed_time;
 245                 }
 246
 247                 if (in_event.size > 24) {
 248                         cerr << "Ignored large MIDI event\n";
 249                         continue;
 250                 }
 251
 252                 if (event_pool.empty()) {
 253                         cerr << "No more events, grow pool\n";
 254                         continue;
 255                 }
 256
 257                 Event* e = event_pool.back();
 258                 event_pool.pop_back ();
 259
 260                 e->time = quantized_time;
 261                 e->whole_note_superclocks = whole_note_superclocks;
 262                 e->size = in_event.size;
 263                 memcpy (e->buf, in_event.buffer, in_event.size);
 264
 265                 inbound_tracker.track (e->buf);
 266
 267                 _current_events.insert (e);
 268         }
 269
 270         superclock_cnt += superclocks;
 271
 272         if (two_pass_required) {
 273                 offset = superclocks;
 274                 superclocks = orig_superclocks - superclocks;
 275                 process_start = 0;
 276                 process_end = superclocks;
 277                 two_pass_required = false;
 278                 goto second_pass;
 279         }
 280
 281         return 0;
 282 }
 283
 284 void
 285 BeatBox::set_quantize (int divisor)
 286 {
 287         _quantize_divisor = divisor;
 288 }
 289
 290 void
 291 BeatBox::clear ()
 292 {
 293         clear_pending = true;
 294 }
 295
 296 bool
 297 BeatBox::EventComparator::operator() (Event const * a, Event const *b) const
 298 {
 299         if (a->time == b->time) {
 300                 if (a->buf[0] == b->buf[0]) {
 301                         return a < b;
 302                 }
 303                 return !ARDOUR::MidiBuffer::second_simultaneous_midi_byte_is_first (a->buf[0], b->buf[0]);
 304         }
 305         return a->time < b->time;
 306 }
 307
 308 static int
 309 process (jack_nframes_t nsamples, void* arg)
 310 {
 311         BeatBox* bbox = static_cast<BeatBox*> (arg);
 312         return bbox->process (nsamples);
 313 }
 314
 315 int
 316 main (int argc, char* argv[])
 317 {
 318         jack_client_t* jack;
 319         const char *server_name = NULL;
 320         jack_options_t options = JackNullOption;
 321         jack_status_t status;
 322
 323         if ((jack = jack_client_open ("beatbox", options, &status, server_name)) == 0) {
 324                 cerr << "Could not connect to JACK\n";
 325                 return -1;
 326         }
 327
 328         BeatBox* bbox = new BeatBox (jack_get_sample_rate (jack));
 329         BBGUI* gui = new BBGUI (&argc, &argv, jack, bbox);
 330
 331         bbox->register_ports (jack);
 332
 333         jack_set_process_callback (jack, process, bbox);
 334         jack_activate (jack);
 335
 336         bbox->start ();
 337
 338         gui->run ();
 339 }