libs/ardour/midi_clock_slave.cc

   1 /*
   2     Copyright (C) 2008 Paul Davis
   3     Author: Hans Baier
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #include <cmath>
  22 #include <errno.h>
  23 #include <sys/types.h>
  24 #include <unistd.h>
  25 #include "pbd/error.h"
  26 #include "pbd/failed_constructor.h"
  27 #include "pbd/pthread_utils.h"
  28 #include "pbd/convert.h"
  29
  30 #include "midi++/port.h"
  31
  32 #include "ardour/audioengine.h"
  33 #include "ardour/debug.h"
  34 #include "ardour/midi_buffer.h"
  35 #include "ardour/midi_port.h"
  36 #include "ardour/session.h"
  37 #include "ardour/tempo.h"
  38 #include "ardour/transport_master.h"
  39
  40 #include "pbd/i18n.h"
  41
  42 using namespace std;
  43 using namespace ARDOUR;
  44 using namespace MIDI;
  45 using namespace PBD;
  46
  47 #define ENGINE AudioEngine::instance()
  48
  49 MIDIClock_TransportMaster::MIDIClock_TransportMaster (std::string const & name, int ppqn)
  50         : TransportMaster (MIDIClock, name)
  51         , ppqn (ppqn)
  52         , midi_clock_count (0)
  53         , _running (false)
  54         , _bpm (0)
  55 {
  56         if ((_port = create_midi_port (string_compose ("%1 in", name))) == 0) {
  57                 throw failed_constructor();
  58         }
  59 }
  60
  61 MIDIClock_TransportMaster::~MIDIClock_TransportMaster()
  62 {
  63         port_connections.drop_connections ();
  64 }
  65
  66 void
  67 MIDIClock_TransportMaster::init ()
  68 {
  69         midi_clock_count = 0;
  70         current.reset ();
  71 }
  72
  73 void
  74 MIDIClock_TransportMaster::set_session (Session *session)
  75 {
  76         port_connections.drop_connections();
  77         _session = session;
  78
  79         /* only connect to signals if we have a proxy, because otherwise we
  80          * cannot interpet incoming data (no tempo map etc.)
  81          */
  82
  83         if (_session) {
  84                 parser.timing.connect_same_thread (port_connections, boost::bind (&MIDIClock_TransportMaster::update_midi_clock, this, _1, _2));
  85                 parser.start.connect_same_thread (port_connections, boost::bind (&MIDIClock_TransportMaster::start, this, _1, _2));
  86                 parser.contineu.connect_same_thread (port_connections, boost::bind (&MIDIClock_TransportMaster::contineu, this, _1, _2));
  87                 parser.stop.connect_same_thread (port_connections, boost::bind (&MIDIClock_TransportMaster::stop, this, _1, _2));
  88                 parser.position.connect_same_thread (port_connections, boost::bind (&MIDIClock_TransportMaster::position, this, _1, _2, _3, _4));
  89
  90                 reset ();
  91         }
  92 }
  93
  94 void
  95 MIDIClock_TransportMaster::pre_process (MIDI::pframes_t nframes, samplepos_t now, boost::optional<samplepos_t> session_pos)
  96 {
  97         /* Read and parse incoming MIDI */
  98
  99         DEBUG_TRACE (DEBUG::MidiClock, string_compose ("preprocess with lt = %1 @ %2, running ? %3\n", current.timestamp, now, _running));
 100
 101         _midi_port->read_and_parse_entire_midi_buffer_with_no_speed_adjustment (nframes, parser, now);
 102
 103         /* no clock messages ever, or no clock messages for 1/4 second ? conclude that its stopped */
 104
 105         if (!last_timestamp || (now > last_timestamp && ((now - last_timestamp) > (ENGINE->sample_rate() / 4)))) {
 106                 current.update (current.position, 0, 0);
 107                 _bpm = 0.0;
 108                 _running = false;
 109                 _current_delta = 0;
 110                 midi_clock_count = 0;
 111
 112                 DEBUG_TRACE (DEBUG::MidiClock, "No MIDI Clock messages received for some time, stopping!\n");
 113                 return;
 114         }
 115
 116         if (!_running && midi_clock_count == 0 && session_pos) {
 117                 current.update (*session_pos, now, current.speed);
 118                 DEBUG_TRACE (DEBUG::MidiClock, string_compose ("set sbp to %1\n", current.position));
 119         }
 120
 121         if (session_pos) {
 122                 const samplepos_t current_pos = current.position + ((now - current.timestamp) * current.speed);
 123                 _current_delta = current_pos - *session_pos;
 124         } else {
 125                 _current_delta = 0;
 126         }
 127
 128         DEBUG_TRACE (DEBUG::MidiClock, string_compose ("speed_and_position: speed %1 should-be %2 transport %3 \n", current.speed, current.position, _session->transport_sample()));
 129 }
 130
 131 void
 132 MIDIClock_TransportMaster::calculate_one_ppqn_in_samples_at(samplepos_t time)
 133 {
 134         const double samples_per_quarter_note = _session->tempo_map().samples_per_quarter_note_at (time, ENGINE->sample_rate());
 135
 136         one_ppqn_in_samples = samples_per_quarter_note / double (ppqn);
 137         // DEBUG_TRACE (DEBUG::MidiClock, string_compose ("at %1, one ppqn = %2\n", time, one_ppqn_in_samples));
 138 }
 139
 140 ARDOUR::samplepos_t
 141 MIDIClock_TransportMaster::calculate_song_position(uint16_t song_position_in_sixteenth_notes)
 142 {
 143         samplepos_t song_position_samples = 0;
 144         for (uint16_t i = 1; i <= song_position_in_sixteenth_notes; ++i) {
 145                 // one quarter note contains ppqn pulses, so a sixteenth note is ppqn / 4 pulses
 146                 calculate_one_ppqn_in_samples_at(song_position_samples);
 147                 song_position_samples += one_ppqn_in_samples * (samplepos_t)(ppqn / 4);
 148         }
 149
 150         return song_position_samples;
 151 }
 152
 153 void
 154 MIDIClock_TransportMaster::calculate_filter_coefficients (double qpm)
 155 {
 156         /* Paul says: I don't understand this computation of bandwidth
 157         */
 158
 159         const double bandwidth = 2.0 / qpm;
 160
 161         /* Frequency of the clock messages is ENGINE->sample_rate() / * one_ppqn_in_samples, per second or in Hz */
 162         const double freq = (double) ENGINE->sample_rate() / one_ppqn_in_samples;
 163
 164         const double omega = 2.0 * M_PI * bandwidth / freq;
 165         b = 1.4142135623730950488 * omega; // sqrt (2.0) * omega
 166         c = omega * omega;
 167
 168         DEBUG_TRACE (DEBUG::MidiClock, string_compose ("DLL coefficients: bw:%1 omega:%2 b:%3 c:%4\n", bandwidth, omega, b, c));
 169 }
 170
 171 void
 172 MIDIClock_TransportMaster::update_midi_clock (Parser& /*parser*/, samplepos_t timestamp)
 173 {
 174         samplepos_t elapsed_since_start = timestamp - first_timestamp;
 175         double e = 0;
 176
 177         calculate_one_ppqn_in_samples_at (current.position);
 178
 179         DEBUG_TRACE (DEBUG::MidiClock, string_compose ("clock count %1, sbp %2\n", midi_clock_count, current.position));
 180
 181         if (midi_clock_count == 0) {
 182                 /* second 0xf8 message after start/reset has arrived */
 183
 184                 first_timestamp = timestamp;
 185                 current.update (0, timestamp, 0);
 186
 187                 DEBUG_TRACE (DEBUG::MidiClock, string_compose ("first clock message after start received @ %1\n", timestamp));
 188
 189                 midi_clock_count++;
 190
 191                 current.position += one_ppqn_in_samples;
 192
 193         } else if (midi_clock_count == 1) {
 194
 195                 /* second 0xf8 message has arrived. we can now estimate QPM
 196                  * (quarters per minute, and fully initialize the DLL
 197                  */
 198
 199                 e  = timestamp - last_timestamp;
 200
 201                 const samplecnt_t samples_per_quarter = e * 24;
 202                 _bpm = (ENGINE->sample_rate() * 60.0) / samples_per_quarter;
 203
 204                 calculate_filter_coefficients (_bpm);
 205
 206                 /* finish DLL initialization */
 207
 208                 t0 = timestamp;
 209                 e2 = e;
 210                 t1 = t0 + e2; /* timestamp we predict for the next 0xf8 clock message */
 211
 212                 midi_clock_count++;
 213                 current.update (one_ppqn_in_samples, timestamp, 0);
 214
 215         } else {
 216
 217                 /* 3rd or later MIDI clock message. We can now compute actual
 218                  * speed (and tempo) with the DLL
 219                  */
 220
 221                 e = timestamp - t1; // error between actual time of arrival of clock message and our predicted time
 222                 t0 = t1;
 223                 t1 += b * e + e2;
 224                 e2 += c * e;
 225
 226                 const double samples_per_quarter = (timestamp - last_timestamp) * 24.0;
 227                 const double instantaneous_bpm = (ENGINE->sample_rate() * 60.0) / samples_per_quarter;
 228                 const double lpf_coeff = 0.05;
 229
 230                 const double predicted_clock_interval_in_samples = (t1 - t0);
 231
 232                 /* _speed is relative to session tempo map */
 233
 234                 double speed = predicted_clock_interval_in_samples / one_ppqn_in_samples;
 235
 236                 /* _bpm (really, _qpm) is absolute */
 237
 238                 /* detect substantial changes in apparent tempo (defined as a
 239                  * change of more than 20% of the current tempo.
 240                  */
 241
 242                 if (fabs (instantaneous_bpm - _bpm) > (0.20 * _bpm)) {
 243                         _bpm = instantaneous_bpm;
 244                 } else {
 245                         _bpm += lpf_coeff * (instantaneous_bpm - _bpm);
 246                 }
 247
 248                 calculate_filter_coefficients (_bpm);
 249
 250                 // need at least two clock events to compute speed
 251
 252                 if (!_running) {
 253                         DEBUG_TRACE (DEBUG::MidiClock, string_compose ("start mclock running with speed = %1\n", (t1 - t0) / one_ppqn_in_samples));
 254                         _running = true;
 255                 }
 256
 257                 midi_clock_count++;
 258                 current.update (current.position + one_ppqn_in_samples, timestamp, speed);
 259         }
 260
 261         DEBUG_TRACE (DEBUG::MidiClock, string_compose ("clock #%1 @ %2 should-be %3 transport %4 error %5 appspeed %6 "
 262                                                        "read-delta %7 should-be delta %8 t1-t0 %9 t0 %10 t1 %11 framerate %12 engine %13 running %14\n",
 263                                                        midi_clock_count,                                          // #
 264                                                        elapsed_since_start,                                       // @
 265                                                        current.position,                                        // should-be
 266                                                        _session->transport_sample(),                                // transport
 267                                                        e,                                                     // error
 268                                                        (t1 - t0) / one_ppqn_in_samples, // appspeed
 269                                                        timestamp - last_timestamp,                                // read delta
 270                                                        one_ppqn_in_samples,                                        // should-be delta
 271                                                        (t1 - t0),                         // t1-t0
 272                                                        t0,                                // t0
 273                                                        t1,                                // t1
 274                                                        ENGINE->sample_rate(),                                      // framerate
 275                                                        ENGINE->sample_time(),
 276                                                        _running
 277
 278         ));
 279
 280         last_timestamp = timestamp;
 281 }
 282
 283 void
 284 MIDIClock_TransportMaster::start (Parser& /*parser*/, samplepos_t timestamp)
 285 {
 286         DEBUG_TRACE (DEBUG::MidiClock, string_compose ("MIDIClock_TransportMaster got start message at time %1 engine time %2 transport_sample %3\n", timestamp, ENGINE->sample_time(), _session->transport_sample()));
 287
 288         if (!_running) {
 289                 reset();
 290                 _running = true;
 291                 current.update (_session->transport_sample(), timestamp, 0);
 292         }
 293 }
 294
 295 void
 296 MIDIClock_TransportMaster::reset ()
 297 {
 298         DEBUG_TRACE (DEBUG::MidiClock, string_compose ("MidiClock Master reset(): calculated filter for period size %2\n", ENGINE->samples_per_cycle()));
 299
 300         current.update (_session->transport_sample(), 0, 0);
 301
 302         _running = false;
 303         _current_delta = 0;
 304 }
 305
 306 void
 307 MIDIClock_TransportMaster::contineu (Parser& /*parser*/, samplepos_t /*timestamp*/)
 308 {
 309         DEBUG_TRACE (DEBUG::MidiClock, "MIDIClock_TransportMaster got continue message\n");
 310
 311         _running = true;
 312 }
 313
 314 void
 315 MIDIClock_TransportMaster::stop (Parser& /*parser*/, samplepos_t timestamp)
 316 {
 317         DEBUG_TRACE (DEBUG::MidiClock, "MIDIClock_TransportMaster got stop message\n");
 318
 319         if (_running) {
 320                 _running = false;
 321                 _speed = 0;
 322                 last_timestamp = 0;
 323
 324                 // we need to go back to the last MIDI beat (6 ppqn)
 325                 // and lets hope the tempo didnt change in the meantime :)
 326
 327                 // begin at the should be position, because
 328                 // that is the position of the last MIDI Clock
 329                 // message and that is probably what the master
 330                 // expects where we are right now
 331                 //
 332                 // find out the last MIDI beat: go back #midi_clocks mod 6
 333                 // and lets hope the tempo didnt change in those last 6 beats :)
 334                 current.update (current.position - (midi_clock_count % 6) * one_ppqn_in_samples, timestamp, current.speed);
 335         }
 336 }
 337
 338 void
 339 MIDIClock_TransportMaster::position (Parser& /*parser*/, MIDI::byte* message, size_t size, samplepos_t timestamp)
 340 {
 341         // we are not supposed to get position messages while we are running
 342         // so lets be robust and ignore those
 343         if (_running) {
 344                 return;
 345         }
 346
 347         assert(size == 3);
 348         MIDI::byte lsb = message[1];
 349         MIDI::byte msb = message[2];
 350         assert((lsb <= 0x7f) && (msb <= 0x7f));
 351
 352         uint16_t position_in_sixteenth_notes = (uint16_t(msb) << 7) | uint16_t(lsb);
 353         samplepos_t position_in_samples = calculate_song_position(position_in_sixteenth_notes);
 354
 355         DEBUG_TRACE (DEBUG::MidiClock, string_compose ("Song Position: %1 samples: %2\n", position_in_sixteenth_notes, position_in_samples));
 356
 357         current.update (position_in_samples, timestamp, current.speed);
 358 }
 359
 360 bool
 361 MIDIClock_TransportMaster::locked () const
 362 {
 363         return true;
 364 }
 365
 366 bool
 367 MIDIClock_TransportMaster::ok() const
 368 {
 369         return true;
 370 }
 371
 372 bool
 373 MIDIClock_TransportMaster::starting() const
 374 {
 375         return false;
 376 }
 377
 378 ARDOUR::samplecnt_t
 379 MIDIClock_TransportMaster::resolution() const
 380 {
 381         // one beat
 382         return (samplecnt_t) one_ppqn_in_samples * ppqn;
 383 }
 384
 385 std::string
 386 MIDIClock_TransportMaster::position_string () const
 387 {
 388         return std::string();
 389 }
 390
 391 std::string
 392 MIDIClock_TransportMaster::delta_string() const
 393 {
 394         char delta[80];
 395         if (last_timestamp == 0 || starting()) {
 396                 snprintf(delta, sizeof(delta), "\u2012\u2012\u2012\u2012");
 397         } else {
 398                 snprintf(delta, sizeof(delta), "\u0394<span foreground=\"green\" face=\"monospace\" >%s%s%" PRIi64 "</span>sm",
 399                                 LEADINGZERO(abs(_current_delta)), PLUSMINUS(-_current_delta), abs(_current_delta));
 400         }
 401         return std::string(delta);
 402 }