X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fmidi_clock_slave.cc;h=8c95272fde239987e8f13edcec63021fc82bff34;hb=1089f19a4c38fa548451b1371662d5a26051576a;hp=09583ae7c676a5c30545342fd6378d5e34aea9d2;hpb=bb1aa327f8f957628b3580f7650b47f5d2a97f2f;p=ardour.git diff --git a/libs/ardour/midi_clock_slave.cc b/libs/ardour/midi_clock_slave.cc index 09583ae7c6..8c95272fde 100644 --- a/libs/ardour/midi_clock_slave.cc +++ b/libs/ardour/midi_clock_slave.cc @@ -18,246 +18,270 @@ */ +#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/midi_buffer.h" +#include "ardour/midi_port.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) - , bandwidth (30.0 / 60.0) // 1 BpM = 1 / 60 Hz +MIDIClock_Slave::MIDIClock_Slave (Session& s, MidiPort& p, int ppqn) + : ppqn (ppqn) + , bandwidth (2.0 / 60.0) // 1 BpM = 1 / 60 Hz { + session = (ISlaveSessionProxy *) new SlaveSessionProxy(s); rebind (p); reset (); } +MIDIClock_Slave::MIDIClock_Slave (ISlaveSessionProxy* session_proxy, int ppqn) + : session(session_proxy) + , ppqn (ppqn) + , bandwidth (2.0 / 60.0) // 1 BpM = 1 / 60 Hz +{ + reset (); +} + MIDIClock_Slave::~MIDIClock_Slave() { + delete session; } void -MIDIClock_Slave::rebind (MIDI::Port& p) +MIDIClock_Slave::rebind (MidiPort& port) { - for (vector::iterator i = connections.begin(); i != connections.end(); ++i) { - (*i).disconnect (); - } + DEBUG_TRACE (DEBUG::MidiClock, string_compose ("MIDIClock_Slave: connecting to port %1\n", port.name())); - port = &p; + port_connections.drop_connections (); - #ifdef DEBUG_MIDI_CLOCK - std::cerr << "MIDIClock_Slave: connecting to port " << port->name() << std::endl; - #endif + port.self_parser().timing.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::update_midi_clock, this, _1, _2)); + port.self_parser().start.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::start, this, _1, _2)); + port.self_parser().contineu.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::contineu, this, _1, _2)); + port.self_parser().stop.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::stop, this, _1, _2)); + port.self_parser().position.connect_same_thread (port_connections, boost::bind (&MIDIClock_Slave::position, this, _1, _2, 3)); - 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()->contineu.connect (mem_fun (*this, &MIDIClock_Slave::contineu))); - connections.push_back (port->input()->stop.connect (mem_fun (*this, &MIDIClock_Slave::stop))); - connections.push_back (port->input()->position.connect (mem_fun (*this, &MIDIClock_Slave::position))); } -void -MIDIClock_Slave::calculate_one_ppqn_in_frames_at(nframes_t time) +void +MIDIClock_Slave::calculate_one_ppqn_in_frames_at(framepos_t time) { - const Tempo& current_tempo = session.tempo_map().tempo_at(time); - const Meter& current_meter = session.tempo_map().meter_at(time); - double frames_per_beat = - current_tempo.frames_per_beat(session.frame_rate(), - current_meter); + 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 / double (ppqn); + // DEBUG_TRACE (DEBUG::MidiClock, string_compose ("at %1, one ppqn = %2\n", time, one_ppqn_in_frames)); } -ARDOUR::nframes_t +ARDOUR::framepos_t MIDIClock_Slave::calculate_song_position(uint16_t song_position_in_sixteenth_notes) { - nframes_t song_position_frames = 0; + 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 * nframes_t(ppqn / 4); + song_position_frames += one_ppqn_in_frames * (framepos_t)(ppqn / 4); } - + return song_position_frames; } -void +void MIDIClock_Slave::calculate_filter_coefficients() { // omega = 2 * PI * Bandwidth / MIDI clock frame frequency in Hz - omega = 2.0 * 3.14159265358979323846 * bandwidth * one_ppqn_in_frames / session.frame_rate(); + omega = 2.0 * M_PI * bandwidth * one_ppqn_in_frames / session->frame_rate(); b = 1.4142135623730950488 * omega; - c = omega * omega; + c = omega * omega; } void -MIDIClock_Slave::update_midi_clock (Parser& parser, nframes_t timestamp) -{ - // some pieces of hardware send MIDI Clock all the time +MIDIClock_Slave::update_midi_clock (Parser& /*parser*/, framepos_t timestamp) +{ + // some pieces of hardware send MIDI Clock all the time if ( (!_starting) && (!_started) ) { return; } - - // the number of midi clock messages (zero-based) - static long midi_clock_count; - - calculate_one_ppqn_in_frames_at(last_position); - - nframes_t timestamp_relative_to_transport = timestamp - first_timestamp; - + + pframes_t cycle_offset = timestamp - session->sample_time_at_cycle_start(); + + 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; - timestamp_relative_to_transport = last_position; - + elapsed_since_start = should_be_position; + + DEBUG_TRACE (DEBUG::MidiClock, string_compose ("first clock message after start received @ %1\n", timestamp)); + // calculate filter coefficients calculate_filter_coefficients(); - + // initialize DLL - e2 = double(one_ppqn_in_frames) / double(session.frame_rate()); - t0 = double(timestamp_relative_to_transport) / double(session.frame_rate()); + 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 { + } else { midi_clock_count++; - last_position += one_ppqn_in_frames; + should_be_position += one_ppqn_in_frames; calculate_filter_coefficients(); // calculate loop error - // we use session.transport_frame() instead of t1 here + // we use session->transport_frame() instead of t1 here // because t1 is used to calculate the transport speed, // so the loop will compensate for accumulating rounding errors - e = (double(last_position) - double(session.transport_frame())) - / double(session.frame_rate()); - + error = (double(should_be_position) - (double(session->transport_frame()) + double(cycle_offset))); + e = error / double(session->frame_rate()); + current_delta = error; + // update DLL t0 = t1; t1 += b * e + e2; - e2 += c * e; - } - - #ifdef DEBUG_MIDI_CLOCK - std::cerr - << "MIDI Clock #" << midi_clock_count - //<< "@" << timestamp - << " (transport-relative: " << timestamp_relative_to_transport << " should be: " << last_position << ", delta: " << (double(last_position) - double(session.transport_frame())) <<" )" - << " transport: " << session.transport_frame() - //<< " engine: " << session.engine().frame_time() - << " real delta: " << timestamp - last_timestamp - << " reference: " << one_ppqn_in_frames - << " t1-t0: " << (t1 -t0) * session.frame_rate() - << " t0: " << t0 * session.frame_rate() - << " t1: " << t1 * session.frame_rate() - << " frame-rate: " << session.frame_rate() - << std::endl; - #endif // DEBUG_MIDI_CLOCK + e2 += c * e; + } + + DEBUG_TRACE (DEBUG::MidiClock, string_compose ("clock #%1 @ %2 should-be %3 transport %4 error %5 appspeed %6 " + "read-delta %7 should-be delta %8 t1-t0 %9 t0 %10 t1 %11 framerate %12 engine %13\n", + midi_clock_count, // # + elapsed_since_start, // @ + should_be_position, // should-be + session->transport_frame(), // transport + error, // error + ((t1 - t0) * session->frame_rate()) / one_ppqn_in_frames, // appspeed + timestamp - last_timestamp, // read delta + one_ppqn_in_frames, // should-be delta + (t1 - t0) * session->frame_rate(), // t1-t0 + t0 * session->frame_rate(), // t0 + t1 * session->frame_rate(), // t1 + session->frame_rate(), // framerate + session->frame_time() + + )); last_timestamp = timestamp; } void -MIDIClock_Slave::start (Parser& parser, nframes_t timestamp) -{ - #ifdef DEBUG_MIDI_CLOCK - cerr << "MIDIClock_Slave got start message at time " << timestamp << " session time: " << session.engine().frame_time() << endl; - #endif - +MIDIClock_Slave::start (Parser& /*parser*/, framepos_t timestamp) +{ + DEBUG_TRACE (DEBUG::MidiClock, string_compose ("MIDIClock_Slave got start message at time %1 engine time %2 transport_frame %3\n", timestamp, session->frame_time(), session->transport_frame())); + if (!_started) { reset(); - + _started = true; _starting = true; + + should_be_position = session->transport_frame(); } } void MIDIClock_Slave::reset () { + DEBUG_TRACE (DEBUG::MidiClock, string_compose ("MidiClock_Slave reset(): calculated filter bandwidth is %1 for period size %2\n", bandwidth, session->frames_per_cycle())); - last_position = 0; + should_be_position = session->transport_frame(); last_timestamp = 0; - - _starting = false; - _started = false; - - session.request_locate(0, false); + + _starting = true; + _started = true; + + // session->request_locate(0, false); + current_delta = 0; } void -MIDIClock_Slave::contineu (Parser& parser, nframes_t timestamp) +MIDIClock_Slave::contineu (Parser& /*parser*/, framepos_t /*timestamp*/) { - #ifdef DEBUG_MIDI_CLOCK - std::cerr << "MIDIClock_Slave got continue message" << endl; - #endif + DEBUG_TRACE (DEBUG::MidiClock, "MIDIClock_Slave got continue message\n"); + if (!_started) { _starting = true; - _started = true; + _started = true; } } void -MIDIClock_Slave::stop (Parser& parser, nframes_t timestamp) +MIDIClock_Slave::stop (Parser& /*parser*/, framepos_t /*timestamp*/) { - #ifdef DEBUG_MIDI_CLOCK - std::cerr << "MIDIClock_Slave got stop message" << endl; - #endif - + 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); - session.request_locate(last_position, false); + 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) +MIDIClock_Slave::position (Parser& /*parser*/, MIDI::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[0]; - byte msb = message[1]; + MIDI::byte lsb = message[1]; + MIDI::byte msb = message[2]; assert((lsb <= 0x7f) && (msb <= 0x7f)); - + uint16_t position_in_sixteenth_notes = (uint16_t(msb) << 7) | uint16_t(lsb); - nframes_t position_in_frames = calculate_song_position(position_in_sixteenth_notes); - session.request_locate(position_in_frames, false); - last_position = position_in_frames; + 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 @@ -279,18 +303,16 @@ MIDIClock_Slave::starting() const } bool -MIDIClock_Slave::stop_if_no_more_clock_events(nframes_t& pos, nframes_t now) +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) { - #ifdef DEBUG_MIDI_CLOCK - cerr << "No MIDI Clock frames received for some time, stopping!" << endl; - #endif - pos = last_position; - session.request_transport_speed (0); - session.request_locate (last_position, false); + 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; @@ -298,41 +320,60 @@ MIDIClock_Slave::stop_if_no_more_clock_events(nframes_t& pos, nframes_t now) } bool -MIDIClock_Slave::speed_and_position (double& speed, nframes_t& pos) +MIDIClock_Slave::speed_and_position (double& speed, framepos_t& pos) { if (!_started || _starting) { speed = 0.0; - pos = last_position; + pos = should_be_position; return true; } - - nframes_t engine_now = session.engine().frame_time(); + + framepos_t engine_now = session->frame_time(); if (stop_if_no_more_clock_events(pos, engine_now)) { return false; } // calculate speed - speed = ((t1 - t0) * session.frame_rate()) / one_ppqn_in_frames; - + speed = ((t1 - t0) * session->frame_rate()) / one_ppqn_in_frames; + + // provide a 0.1% deadzone to lock the speed + if (fabs(speed - 1.0) <= 0.001) + speed = 1.0; + // calculate position if (engine_now > last_timestamp) { // we are in between MIDI clock messages // so we interpolate position according to speed - nframes_t elapsed = engine_now - last_timestamp; - pos = nframes_t (last_position + double(elapsed) * 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 = last_position; + pos = should_be_position; } + DEBUG_TRACE (DEBUG::MidiClock, string_compose ("speed_and_position: speed %1 should-be %2 transport %3 \n", speed, pos, session->transport_frame())); + return true; } -ARDOUR::nframes_t +ARDOUR::framecnt_t MIDIClock_Slave::resolution() const { // one beat - return (nframes_t) one_ppqn_in_frames * ppqn; + return (framecnt_t) one_ppqn_in_frames * ppqn; +} + +std::string +MIDIClock_Slave::approximate_current_delta() const +{ + 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); }