X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fmidi_clock_slave.cc;h=ef2d22ab18e61088d43a421084c6a0103fed21d5;hb=2037b9534791377d5feecadea015d5a6927233be;hp=aee640e16e7cc4fabbb33c89668b223dc445f77b;hpb=fd824717a73676e2da3ff05eaba3dd4214239863;p=ardour.git diff --git a/libs/ardour/midi_clock_slave.cc b/libs/ardour/midi_clock_slave.cc index aee640e16e..ef2d22ab18 100644 --- a/libs/ardour/midi_clock_slave.cc +++ b/libs/ardour/midi_clock_slave.cc @@ -1,5 +1,6 @@ /* - Copyright (C) 2002-4 Paul Davis + Copyright (C) 2008 Paul Davis + Author: Hans Baier This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -17,191 +18,267 @@ */ +#include #include #include #include #include -#include -#include -#include +#include "pbd/error.h" +#include "pbd/failed_constructor.h" +#include "pbd/pthread_utils.h" +#include "pbd/convert.h" -#include -#include -#include -#include -#include -#include -#include +#include "midi++/port.h" +#include "ardour/debug.h" +#include "ardour/slave.h" +#include "ardour/tempo.h" #include "i18n.h" +using namespace std; using namespace ARDOUR; -using namespace sigc; using namespace MIDI; using namespace PBD; MIDIClock_Slave::MIDIClock_Slave (Session& s, MIDI::Port& p, int ppqn) - : session (s) - , ppqn (ppqn) - , accumulator_index (0) - , average (0.0) + : ppqn (ppqn) + , bandwidth (1.0 / 60.0) // 1 BpM = 1 / 60 Hz { + session = (ISlaveSessionProxy *) new SlaveSessionProxy(s); rebind (p); reset (); +} - for(int i = 0; i < accumulator_size; i++) - accumulator[i]=0.0; +MIDIClock_Slave::MIDIClock_Slave (ISlaveSessionProxy* session_proxy, int ppqn) + : session(session_proxy) + , ppqn (ppqn) + , bandwidth (1.0 / 60.0) // 1 BpM = 1 / 60 Hz +{ + reset (); } MIDIClock_Slave::~MIDIClock_Slave() { + delete session; } void MIDIClock_Slave::rebind (MIDI::Port& p) { - for (vector::iterator i = connections.begin(); i != connections.end(); ++i) { - (*i).disconnect (); - } + port_connections.drop_connections(); port = &p; - std::cerr << "MIDIClock_Slave: connecting to port " << port->name() << std::endl; + DEBUG_TRACE (DEBUG::MidiClock, string_compose ("MIDIClock_Slave: connecting to port %1\n", port->name())); - connections.push_back (port->input()->timing.connect (mem_fun (*this, &MIDIClock_Slave::update_midi_clock))); - connections.push_back (port->input()->start.connect (mem_fun (*this, &MIDIClock_Slave::start))); - connections.push_back (port->input()->stop.connect (mem_fun (*this, &MIDIClock_Slave::stop))); + port->parser()->timing.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::update_midi_clock, this, _1, _2)); + port->parser()->start.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::start, this, _1, _2)); + port->parser()->contineu.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::contineu, this, _1, _2)); + port->parser()->stop.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::stop, this, _1, _2)); + port->parser()->position.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::position, this, _1, _2, 3)); } void -MIDIClock_Slave::update_midi_clock (Parser& parser, nframes_t timestamp) -{ - nframes_t now = timestamp; - - SafeTime last; - read_current (&last); - - const Tempo& current_tempo = session.tempo_map().tempo_at(now); - const Meter& current_meter = session.tempo_map().meter_at(now); - double frames_per_beat = - current_tempo.frames_per_beat(session.frame_rate(), - current_meter); +MIDIClock_Slave::calculate_one_ppqn_in_frames_at(framepos_t time) +{ + const Tempo& current_tempo = session->tempo_map().tempo_at(time); + double frames_per_beat = current_tempo.frames_per_beat(session->frame_rate()); double quarter_notes_per_beat = 4.0 / current_tempo.note_type(); double frames_per_quarter_note = frames_per_beat / quarter_notes_per_beat; - one_ppqn_in_frames = frames_per_quarter_note / ppqn; - - // for the first MIDI clock event we dont have any past - // data, so we assume a sane tempo - if(last.timestamp == 0) { - midi_clock_frame = one_ppqn_in_frames; - } else { - midi_clock_frame = now - last.timestamp; - } - - // moving average over incoming intervals - accumulator[accumulator_index++] = (float) midi_clock_frame; - if(accumulator_index == accumulator_size) - accumulator_index = 0; - - average = 0.0; - for(int i = 0; i < accumulator_size; i++) - average += accumulator[i]; - average /= accumulator_size; - - JACK_MidiPort *jack_port = dynamic_cast(port); - pthread_t process_thread_id = 0; - if(jack_port) { - process_thread_id = jack_port->get_process_thread(); + one_ppqn_in_frames = frames_per_quarter_note / double (ppqn); + // DEBUG_TRACE (DEBUG::MidiClock, string_compose ("at %1, one ppqn = %2\n", time, one_ppqn_in_frames)); +} + +ARDOUR::framepos_t +MIDIClock_Slave::calculate_song_position(uint16_t song_position_in_sixteenth_notes) +{ + framepos_t song_position_frames = 0; + for (uint16_t i = 1; i <= song_position_in_sixteenth_notes; ++i) { + // one quarter note contains ppqn pulses, so a sixteenth note is ppqn / 4 pulses + calculate_one_ppqn_in_frames_at(song_position_frames); + song_position_frames += one_ppqn_in_frames * (framepos_t)(ppqn / 4); } - - std::cerr << "Thread " << pthread_name() << " with id " << pthread_self() << " process Thread ID: " << process_thread_id - << " got MIDI Clock message at time " << now - << " real delta: " << midi_clock_frame - << " reference: " << one_ppqn_in_frames - << " accu index: " << accumulator_index - << " average: " << average - << " locked: " << locked() - << " frame rate: " << session.frame_rate() << std::endl; - - current.guard1++; - current.position += midi_clock_frame; - current.timestamp = now; - current.guard2++; - - last_inbound_frame = now; + + return song_position_frames; } void -MIDIClock_Slave::start (Parser& parser, nframes_t timestamp) +MIDIClock_Slave::calculate_filter_coefficients() { - - nframes_t now = session.engine().frame_time(); - cerr << "MIDIClock_Slave got start message at time " - << now << endl; + // omega = 2 * PI * Bandwidth / MIDI clock frame frequency in Hz + omega = 2.0 * M_PI * bandwidth * one_ppqn_in_frames / session->frame_rate(); + b = 1.4142135623730950488 * omega; + c = omega * omega; +} - if(!locked()) { - cerr << "Did not start because not locked!" << endl; +void +MIDIClock_Slave::update_midi_clock (Parser& /*parser*/, framepos_t timestamp) +{ + // some pieces of hardware send MIDI Clock all the time + if ( (!_starting) && (!_started) ) { return; } - - midi_clock_frame = 0; - - session.request_transport_speed (1.0); - midi_clock_speed = 1.0; - first_midi_clock_time = now; - - current.guard1++; - current.position = 0; - current.timestamp = now; - current.guard2++; - - _started = true; + + calculate_one_ppqn_in_frames_at(should_be_position); + + framepos_t elapsed_since_start = timestamp - first_timestamp; + double error = 0; + + if (_starting || last_timestamp == 0) { + midi_clock_count = 0; + + first_timestamp = timestamp; + elapsed_since_start = should_be_position; + + // calculate filter coefficients + calculate_filter_coefficients(); + + // initialize DLL + e2 = double(one_ppqn_in_frames) / double(session->frame_rate()); + t0 = double(elapsed_since_start) / double(session->frame_rate()); + t1 = t0 + e2; + + // let ardour go after first MIDI Clock Event + _starting = false; + } else { + midi_clock_count++; + should_be_position += one_ppqn_in_frames; + calculate_filter_coefficients(); + + // calculate loop error + // we use session->audible_frame() instead of t1 here + // because t1 is used to calculate the transport speed, + // so the loop will compensate for accumulating rounding errors + error = (double(should_be_position) - double(session->audible_frame())); + e = error / double(session->frame_rate()); + + // update DLL + t0 = t1; + t1 += b * e + e2; + e2 += c * e; + } + + DEBUG_TRACE (DEBUG::MidiClock, string_compose ("clock #%1 @ %2 arrived %3 (theoretical) audible %4 transport %5 error %6 " + "read delta %7 should-be delta %8 t1-t0 %9 t0 %10 t1 %11 framerate %12 appspeed %13\n", + midi_clock_count, + elapsed_since_start, + should_be_position, + session->audible_frame(), + session->transport_frame(), + error, + timestamp - last_timestamp, + one_ppqn_in_frames, + (t1 -t0) * session->frame_rate(), + t0 * session->frame_rate(), + t1 * session->frame_rate(), + session->frame_rate(), + ((t1 - t0) * session->frame_rate()) / one_ppqn_in_frames)); + + last_timestamp = timestamp; } void -MIDIClock_Slave::stop (Parser& parser, nframes_t timestamp) +MIDIClock_Slave::start (Parser& /*parser*/, framepos_t timestamp) { - std::cerr << "MIDIClock_Slave got stop message" << endl; + DEBUG_TRACE (DEBUG::MidiClock, string_compose ("MIDIClock_Slave got start message at time %1 engine time %2\n", timestamp, session->frame_time())); - session.request_transport_speed (0); - midi_clock_speed = 0.0f; - midi_clock_frame = 0; + if (!_started) { + reset(); - _started = false; - reset(); + _started = true; + _starting = true; + + should_be_position = session->transport_frame(); + } } void -MIDIClock_Slave::read_current (SafeTime *st) const +MIDIClock_Slave::reset () { - int tries = 0; - do { - if (tries == 10) { - error << _("MIDI Clock Slave: atomic read of current time failed, sleeping!") << endmsg; - usleep (20); - tries = 0; - } - - *st = current; - tries++; - - } while (st->guard1 != st->guard2); + should_be_position = session->transport_frame(); + last_timestamp = 0; + + _starting = true; + _started = true; + + // session->request_locate(0, false); + current_delta = 0; +} + +void +MIDIClock_Slave::contineu (Parser& /*parser*/, framepos_t /*timestamp*/) +{ + DEBUG_TRACE (DEBUG::MidiClock, "MIDIClock_Slave got continue message\n"); + + if (!_started) { + _starting = true; + _started = true; + } +} + + +void +MIDIClock_Slave::stop (Parser& /*parser*/, framepos_t /*timestamp*/) +{ + DEBUG_TRACE (DEBUG::MidiClock, "MIDIClock_Slave got stop message\n"); + + if (_started || _starting) { + _starting = false; + _started = false; + // locate to last MIDI clock position + session->request_transport_speed(0.0); + + // we need to go back to the last MIDI beat (6 ppqn) + // and lets hope the tempo didnt change in the meantime :) + + // begin at the should be position, because + // that is the position of the last MIDI Clock + // message and that is probably what the master + // expects where we are right now + framepos_t stop_position = should_be_position; + + // find out the last MIDI beat: go back #midi_clocks mod 6 + // and lets hope the tempo didnt change in those last 6 beats :) + stop_position -= (midi_clock_count % 6) * one_ppqn_in_frames; + + session->request_locate(stop_position, false); + should_be_position = stop_position; + last_timestamp = 0; + } +} + +void +MIDIClock_Slave::position (Parser& /*parser*/, byte* message, size_t size) +{ + // we are note supposed to get position messages while we are running + // so lets be robust and ignore those + if (_started || _starting) { + return; + } + + assert(size == 3); + byte lsb = message[1]; + byte msb = message[2]; + assert((lsb <= 0x7f) && (msb <= 0x7f)); + + uint16_t position_in_sixteenth_notes = (uint16_t(msb) << 7) | uint16_t(lsb); + framepos_t position_in_frames = calculate_song_position(position_in_sixteenth_notes); + + DEBUG_TRACE (DEBUG::MidiClock, string_compose ("Song Position: %1 frames: %2\n", position_in_sixteenth_notes, position_in_frames)); + + session->request_locate(position_in_frames, false); + should_be_position = position_in_frames; + last_timestamp = 0; + } bool MIDIClock_Slave::locked () const { - float rel_error = - ( fabs(one_ppqn_in_frames - average) / one_ppqn_in_frames ); - //cerr << " relative error: " << rel_error << endl; - - return rel_error < 0.01 ? - true - : - false; + return true; } bool @@ -211,63 +288,84 @@ MIDIClock_Slave::ok() const } bool -MIDIClock_Slave::speed_and_position (float& speed, nframes_t& pos) +MIDIClock_Slave::starting() const { - - if(!_started) { - speed = 0.0; - pos = 0; + return false; +} + +bool +MIDIClock_Slave::stop_if_no_more_clock_events(framepos_t& pos, framepos_t now) +{ + /* no timecode for 1/4 second ? conclude that its stopped */ + if (last_timestamp && + now > last_timestamp && + now - last_timestamp > session->frame_rate() / 4) { + DEBUG_TRACE (DEBUG::MidiClock, "No MIDI Clock frames received for some time, stopping!\n"); + pos = should_be_position; + session->request_transport_speed (0); + session->request_locate (should_be_position, false); return true; + } else { + return false; } - - nframes_t now = session.engine().frame_time(); - nframes_t frame_rate = session.frame_rate(); +} - SafeTime last; - read_current (&last); +bool +MIDIClock_Slave::speed_and_position (double& speed, framepos_t& pos) +{ + if (!_started || _starting) { + speed = 0.0; + pos = should_be_position; + return true; + } - /* no timecode for 1/4 second ? conclude that its stopped */ + framepos_t engine_now = session->frame_time(); - if (last_inbound_frame && now > last_inbound_frame && now - last_inbound_frame > frame_rate / 4) { - midi_clock_speed = 0; - pos = last.position; - session.request_locate (pos, false); - session.request_transport_speed (0); - this->stop(*port->input(), now); - reset(); + if (stop_if_no_more_clock_events(pos, engine_now)) { return false; } - midi_clock_speed = average / one_ppqn_in_frames; + // calculate speed + speed = ((t1 - t0) * session->frame_rate()) / one_ppqn_in_frames; + + // provide a 3% deadzone to lock the speed + if (fabs(speed - 1.0) <= 0.03) + speed = 1.0; - nframes_t elapsed = now - last.timestamp; - - pos = last.position + elapsed * speed; + // calculate position + if (engine_now > last_timestamp) { + // we are in between MIDI clock messages + // so we interpolate position according to speed + framecnt_t elapsed = engine_now - last_timestamp; + pos = (framepos_t) (should_be_position + double(elapsed) * speed); + } else { + // A new MIDI clock message has arrived this cycle + pos = should_be_position; + } + + DEBUG_TRACE (DEBUG::MidiClock, string_compose ("speed_and_position: %1 & %2 <-> %3 (transport)\n", speed, pos, session->transport_frame())); + current_delta = pos - session->transport_frame(); - speed = midi_clock_speed; - - cerr << " final speed: " << speed << " elapsed: " << elapsed << " elapsed (scaled) " << elapsed * speed << " position: " << pos - << " Thread ID: " << pthread_self() << endl; return true; } -ARDOUR::nframes_t +ARDOUR::framecnt_t MIDIClock_Slave::resolution() const { - return (nframes_t) one_ppqn_in_frames; + // one beat + return (framecnt_t) one_ppqn_in_frames * ppqn; } -void -MIDIClock_Slave::reset () +std::string +MIDIClock_Slave::approximate_current_delta() const { - - last_inbound_frame = 0; - current.guard1++; - current.position = 0; - current.timestamp = 0; - current.guard2++; - first_midi_clock_frame = 0; - first_midi_clock_time = 0; - - midi_clock_speed = 0; + char delta[80]; + if (last_timestamp == 0 || _starting) { + snprintf(delta, sizeof(delta), "\u2012\u2012\u2012\u2012"); + } else { + snprintf(delta, sizeof(delta), "\u0394%s%s%" PRIi64 " sm", + LEADINGZERO(abs(current_delta)), PLUSMINUS(-current_delta), abs(current_delta)); + } + return std::string(delta); } +