libs/ardour/ticker.cc

   1 /*
   2     Copyright (C) 2008 Hans Baier
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17 */
  18
  19 #include "pbd/compose.h"
  20 #include "pbd/stacktrace.h"
  21
  22 #include "midi++/port.h"
  23 #include "midi++/jack_midi_port.h"
  24 #include "midi++/manager.h"
  25
  26 #include "evoral/midi_events.h"
  27
  28 #include "ardour/audioengine.h"
  29 #include "ardour/ticker.h"
  30 #include "ardour/session.h"
  31 #include "ardour/tempo.h"
  32 #include "ardour/debug.h"
  33
  34 using namespace ARDOUR;
  35 using namespace PBD;
  36
  37 /** MIDI Clock Position tracking */
  38 class MidiClockTicker::Position : public Timecode::BBT_Time
  39 {
  40 public:
  41
  42         Position() : speed(0.0f), frame(0) { }
  43         ~Position() { }
  44
  45         /** Sync timing information taken from the given Session
  46                 @return True if timings differed */
  47         bool sync (Session* s) {
  48
  49                 bool didit = false;
  50
  51                 double     sp = s->transport_speed();
  52                 framecnt_t fr = s->transport_frame();
  53
  54                 if (speed != sp) {
  55                         speed = sp;
  56                         didit = true;
  57                 }
  58
  59                 if (frame != fr) {
  60                         frame = fr;
  61
  62                         s->bbt_time (this->frame, *this);
  63
  64                         const TempoMap& tempo = s->tempo_map();
  65
  66                         const double divisions   = tempo.meter_at(frame).divisions_per_bar();
  67                         const double divisor     = tempo.meter_at(frame).note_divisor();
  68                         const double qnote_scale = divisor * 0.25f;
  69
  70                         /* Midi Beats in terms of Song Position Pointer is equivalent to total
  71                            sixteenth notes at 'time' */
  72
  73                         midi_beats  = (((bars - 1) * divisions) + beats - 1);
  74                         midi_beats += (double)ticks / (double)Position::ticks_per_beat * qnote_scale;
  75                         midi_beats *= 16.0f / divisor;
  76
  77                         midi_clocks = midi_beats * 6.0f;
  78
  79                         didit = true;
  80                 }
  81
  82                 return didit;
  83         }
  84
  85         double      speed;
  86         framecnt_t  frame;
  87         double      midi_beats;
  88         double      midi_clocks;
  89
  90         void print (std::ostream& s) {
  91                 s << "frames: " << frame << " midi beats: " << midi_beats << " speed: " << speed;
  92         }
  93 };
  94
  95
  96 MidiClockTicker::MidiClockTicker ()
  97         : _midi_port (0)
  98         , _ppqn (24)
  99         , _last_tick (0.0)
 100 {
 101         _pos = new Position();
 102 }
 103
 104 MidiClockTicker::~MidiClockTicker()
 105 {
 106         _midi_port = 0;
 107         if (_pos) {
 108                 delete _pos;
 109                 _pos = 0;
 110         }
 111 }
 112
 113 void
 114 MidiClockTicker::set_session (Session* s)
 115 {
 116         SessionHandlePtr::set_session (s);
 117
 118          if (_session) {
 119                  _session->TransportStateChange.connect_same_thread (_session_connections, boost::bind (&MidiClockTicker::transport_state_changed, this));
 120                  _session->PositionChanged.connect_same_thread (_session_connections, boost::bind (&MidiClockTicker::position_changed, this, _1));
 121                  _session->TransportLooped.connect_same_thread (_session_connections, boost::bind (&MidiClockTicker::transport_looped, this));
 122                  _session->Located.connect_same_thread (_session_connections, boost::bind (&MidiClockTicker::session_located, this));
 123
 124                  update_midi_clock_port();
 125                  _pos->sync (_session);
 126          }
 127 }
 128
 129 void
 130 MidiClockTicker::session_located()
 131 {
 132         DEBUG_TRACE (DEBUG::MidiClock, string_compose ("Session Located: %1, speed: %2\n", _session->transport_frame(), _session->transport_speed()));
 133
 134         if (0 == _session || ! _pos->sync (_session)) {
 135                 return;
 136         }
 137
 138         _last_tick = _pos->frame;
 139
 140         if (_pos->speed == 0.0f && Config->get_send_midi_clock()) {
 141                 uint32_t where = std::floor (_pos->midi_beats);
 142                 send_position_event (where, 0);
 143                 return;
 144         }
 145 }
 146
 147 void
 148 MidiClockTicker::session_going_away ()
 149 {
 150         SessionHandlePtr::session_going_away();
 151         _midi_port = 0;
 152 }
 153
 154 void
 155 MidiClockTicker::update_midi_clock_port()
 156 {
 157         _midi_port = MIDI::Manager::instance()->midi_clock_output_port();
 158 }
 159
 160 void
 161 MidiClockTicker::transport_state_changed()
 162 {
 163         if (_session->exporting()) {
 164                 /* no midi clock during export, for now */
 165                 return;
 166         }
 167
 168         if (!_session->engine().running()) {
 169                 /* Engine stopped, we can't do anything */
 170                 return;
 171         }
 172
 173         if (! _pos->sync (_session)) {
 174                 return;
 175         }
 176
 177         DEBUG_TRACE (PBD::DEBUG::MidiClock,
 178                  string_compose ("Transport state change @ %4, speed: %1 position: %2 play loop: %3\n",
 179                                                         _pos->speed, _pos->frame, _session->get_play_loop(), _pos->frame)
 180         );
 181
 182         _last_tick = _pos->frame;
 183
 184         if (! Config->get_send_midi_clock()) {
 185                 return;
 186         }
 187
 188         if (_pos->speed == 1.0f) {
 189
 190                 if (_session->get_play_loop()) {
 191                         assert(_session->locations()->auto_loop_location());
 192
 193                         if (_pos->frame == _session->locations()->auto_loop_location()->start()) {
 194                                 send_start_event(0);
 195                         } else {
 196                                 send_continue_event(0);
 197                         }
 198
 199                 } else if (_pos->frame == 0) {
 200                         send_start_event(0);
 201                 } else {
 202                         send_continue_event(0);
 203                 }
 204
 205                 // send_midi_clock_event (0);
 206
 207         } else if (_pos->speed == 0.0f) {
 208                 send_stop_event (0);
 209                 send_position_event (std::floor (_pos->midi_beats), 0);
 210         }
 211
 212         // tick (_pos->frame);
 213 }
 214
 215 void
 216 MidiClockTicker::position_changed (framepos_t)
 217 {
 218 #if 0
 219         const double speed = _session->transport_speed();
 220         DEBUG_TRACE (PBD::DEBUG::MidiClock, string_compose ("Transport Position Change: %1, speed: %2\n", position, speed));
 221
 222         if (speed == 0.0f && Config->get_send_midi_clock()) {
 223                 send_position_event (position, 0);
 224         }
 225
 226         _last_tick = position;
 227 #endif
 228 }
 229
 230 void
 231 MidiClockTicker::transport_looped()
 232 {
 233         Location* loop_location = _session->locations()->auto_loop_location();
 234         assert(loop_location);
 235
 236         DEBUG_TRACE (PBD::DEBUG::MidiClock,
 237                      string_compose ("Transport looped, position: %1, loop start: %2, loop end: %3, play loop: %4\n",
 238                                      _session->transport_frame(), loop_location->start(), loop_location->end(), _session->get_play_loop())
 239                 );
 240
 241         // adjust _last_tick, so that the next MIDI clock message is sent
 242         // in due time (and the tick interval is still constant)
 243
 244         framecnt_t elapsed_since_last_tick = loop_location->end() - _last_tick;
 245
 246         if (loop_location->start() > elapsed_since_last_tick) {
 247                 _last_tick = loop_location->start() - elapsed_since_last_tick;
 248         } else {
 249                 _last_tick = 0;
 250         }
 251 }
 252
 253 void
 254 MidiClockTicker::tick (const framepos_t& transport_frame)
 255 {
 256
 257         if (!Config->get_send_midi_clock() || _session == 0 || _session->transport_speed() != 1.0f || _midi_port == 0) {
 258                 return;
 259         }
 260
 261         while (true) {
 262                 double next_tick = _last_tick + one_ppqn_in_frames (transport_frame);
 263                 frameoffset_t next_tick_offset = llrint (next_tick) - transport_frame;
 264
 265
 266                 MIDI::JackMIDIPort* mp = dynamic_cast<MIDI::JackMIDIPort*> (_midi_port);
 267
 268
 269                 DEBUG_TRACE (PBD::DEBUG::MidiClock,
 270                              string_compose ("Transport: %1, last tick time: %2, next tick time: %3, offset: %4, cycle length: %5\n",
 271                                              transport_frame, _last_tick, next_tick, next_tick_offset, mp ? mp->nframes_this_cycle() : 0));
 272
 273
 274                 if (!mp || (next_tick_offset >= mp->nframes_this_cycle())) {
 275                         break;
 276                 }
 277
 278                 if (next_tick_offset >= 0) {
 279                         send_midi_clock_event (next_tick_offset);
 280                 }
 281
 282                 _pos->frame = _last_tick = next_tick;
 283         }
 284 }
 285
 286 double
 287 MidiClockTicker::one_ppqn_in_frames (framepos_t transport_position)
 288 {
 289         const Tempo& current_tempo = _session->tempo_map().tempo_at (transport_position);
 290         double frames_per_beat = current_tempo.frames_per_beat (_session->nominal_frame_rate());
 291
 292         double quarter_notes_per_beat = 4.0 / current_tempo.note_type();
 293         double frames_per_quarter_note = frames_per_beat / quarter_notes_per_beat;
 294
 295         return frames_per_quarter_note / double (_ppqn);
 296 }
 297
 298 void
 299 MidiClockTicker::send_midi_clock_event (pframes_t offset)
 300 {
 301         if (!_midi_port) {
 302                 return;
 303         }
 304
 305         // DEBUG_TRACE (PBD::DEBUG::MidiClock, string_compose ("Tick with offset %1\n", offset));
 306
 307         static uint8_t _midi_clock_tick[1] = { MIDI_CMD_COMMON_CLOCK };
 308         _midi_port->write (_midi_clock_tick, 1, offset);
 309 }
 310
 311 void
 312 MidiClockTicker::send_start_event (pframes_t offset)
 313 {
 314         if (!_midi_port) {
 315                 return;
 316         }
 317
 318         DEBUG_TRACE (PBD::DEBUG::MidiClock, string_compose ("Start %1\n", _last_tick));
 319
 320         static uint8_t _midi_clock_tick[1] = { MIDI_CMD_COMMON_START };
 321         _midi_port->write (_midi_clock_tick, 1, offset);
 322 }
 323
 324 void
 325 MidiClockTicker::send_continue_event (pframes_t offset)
 326 {
 327         if (!_midi_port) {
 328                 return;
 329         }
 330
 331         DEBUG_TRACE (PBD::DEBUG::MidiClock, string_compose ("Continue %1\n", _last_tick));
 332
 333         static uint8_t _midi_clock_tick[1] = { MIDI_CMD_COMMON_CONTINUE };
 334         _midi_port->write (_midi_clock_tick, 1, offset);
 335 }
 336
 337 void
 338 MidiClockTicker::send_stop_event (pframes_t offset)
 339 {
 340         if (!_midi_port) {
 341                 return;
 342         }
 343
 344         DEBUG_TRACE (PBD::DEBUG::MidiClock, string_compose ("Stop %1\n", _last_tick));
 345
 346         static uint8_t _midi_clock_tick[1] = { MIDI_CMD_COMMON_STOP };
 347         _midi_port->write (_midi_clock_tick, 1, offset);
 348 }
 349
 350 void
 351 MidiClockTicker::send_position_event (uint32_t midi_beats, pframes_t offset)
 352 {
 353         if (!_midi_port) {
 354                 return;
 355         }
 356
 357         /* can only use 14bits worth */
 358         if (midi_beats > 0x3fff) {
 359                 return;
 360         }
 361
 362         /* split midi beats into a 14bit value */
 363         MIDI::byte msg[3] = {
 364                 MIDI_CMD_COMMON_SONG_POS,
 365                 midi_beats & 0x007f,
 366                 midi_beats & 0x3f80
 367         };
 368
 369         _midi_port->midimsg (msg, sizeof (msg), offset);
 370
 371         DEBUG_TRACE (PBD::DEBUG::MidiClock, string_compose ("Song Position Sent: %1\n", midi_beats));
 372 }