libs/ardour/midi_clock_slave.cc

   1 /*
   2     Copyright (C) 2002-4 Paul Davis
   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
  20 #include <errno.h>
  21 #include <poll.h>
  22 #include <sys/types.h>
  23 #include <unistd.h>
  24 #include <pbd/error.h>
  25 #include <pbd/failed_constructor.h>
  26 #include <pbd/pthread_utils.h>
  27
  28 #include <midi++/port.h>
  29 #include <midi++/jack.h>
  30 #include <ardour/slave.h>
  31 #include <ardour/session.h>
  32 #include <ardour/audioengine.h>
  33 #include <ardour/cycles.h>
  34 #include <ardour/tempo.h>
  35
  36
  37 #include "i18n.h"
  38
  39 using namespace ARDOUR;
  40 using namespace sigc;
  41 using namespace MIDI;
  42 using namespace PBD;
  43
  44 MIDIClock_Slave::MIDIClock_Slave (Session& s, MIDI::Port& p, int ppqn)
  45         : session (s)
  46         , ppqn (ppqn)
  47         , accumulator_index (0)
  48         , average_midi_clock_frame_duration (0.0)
  49 {
  50         rebind (p);
  51         reset ();
  52
  53         for(int i = 0; i < accumulator_size; i++)
  54                 accumulator[i]=0.0;
  55 }
  56
  57 MIDIClock_Slave::~MIDIClock_Slave()
  58 {
  59 }
  60
  61 void
  62 MIDIClock_Slave::rebind (MIDI::Port& p)
  63 {
  64         for (vector<sigc::connection>::iterator i = connections.begin(); i != connections.end(); ++i) {
  65                 (*i).disconnect ();
  66         }
  67
  68         port = &p;
  69
  70         std::cerr << "MIDIClock_Slave: connecting to port " << port->name() << std::endl;
  71
  72         connections.push_back (port->input()->timing.connect (mem_fun (*this, &MIDIClock_Slave::update_midi_clock)));
  73         connections.push_back (port->input()->start.connect  (mem_fun (*this, &MIDIClock_Slave::start)));
  74         connections.push_back (port->input()->stop.connect   (mem_fun (*this, &MIDIClock_Slave::stop)));
  75 }
  76
  77 void
  78 MIDIClock_Slave::update_midi_clock (Parser& parser, nframes_t timestamp)
  79 {
  80         nframes_t now = timestamp;
  81
  82         SafeTime last;
  83         read_current (&last);
  84
  85         const Tempo& current_tempo = session.tempo_map().tempo_at(now);
  86         const Meter& current_meter = session.tempo_map().meter_at(now);
  87         double frames_per_beat =
  88                 current_tempo.frames_per_beat(session.nominal_frame_rate(),
  89                                               current_meter);
  90
  91         double quarter_notes_per_beat = 4.0 / current_tempo.note_type();
  92         double frames_per_quarter_note = frames_per_beat / quarter_notes_per_beat;
  93
  94         one_ppqn_in_frames = frames_per_quarter_note / double (ppqn);
  95
  96         // for the first MIDI clock event we dont have any past
  97         // data, so we assume a sane tempo
  98         if(last.timestamp == 0) {
  99                 current_midi_clock_frame_duration = one_ppqn_in_frames;
 100         } else {
 101                 current_midi_clock_frame_duration = now - last.timestamp;
 102         }
 103
 104         // moving average over incoming intervals
 105         accumulator[accumulator_index++] = current_midi_clock_frame_duration;
 106         if(accumulator_index == accumulator_size)
 107                 accumulator_index = 0;
 108
 109         average_midi_clock_frame_duration = 0.0;
 110         for(int i = 0; i < accumulator_size; i++)
 111                 average_midi_clock_frame_duration += accumulator[i];
 112         average_midi_clock_frame_duration /= double(accumulator_size);
 113
 114 #if 1
 115         JACK_MidiPort *jack_port = dynamic_cast<JACK_MidiPort *>(port);
 116         pthread_t process_thread_id = 0;
 117         if(jack_port) {
 118                 process_thread_id = jack_port->get_process_thread();
 119         }
 120
 121         std::cerr
 122                   << " got MIDI Clock message at time " << now
 123                   << " session time: " << session.engine().frame_time()
 124                   << " transport position: " << session.transport_frame()
 125                   << " real delta: " << current_midi_clock_frame_duration
 126                   << " reference: " << one_ppqn_in_frames
 127                   << " average: " << average_midi_clock_frame_duration
 128                   << std::endl;
 129 #endif
 130
 131         current.guard1++;
 132         current.position += one_ppqn_in_frames;
 133         current_position += one_ppqn_in_frames;
 134         current.timestamp = now;
 135         current.guard2++;
 136
 137         last_inbound_frame = now;
 138 }
 139
 140 void
 141 MIDIClock_Slave::start (Parser& parser, nframes_t timestamp)
 142 {
 143
 144         nframes_t now = timestamp;
 145
 146         cerr << "MIDIClock_Slave got start message at time "  <<  now << " session time: " << session.engine().frame_time() << endl;
 147
 148         if(!locked()) {
 149                 cerr << "Did not start because not locked!" << endl;
 150                 return;
 151         }
 152
 153         current_midi_clock_frame_duration = 0;
 154
 155         session.request_transport_speed(one_ppqn_in_frames / double(average_midi_clock_frame_duration));
 156         current.guard1++;
 157         current.position = 0;
 158         current_position = 0;
 159         current.timestamp = now;
 160         current.guard2++;
 161
 162         _started = true;
 163         _starting = true;
 164 }
 165
 166 void
 167 MIDIClock_Slave::stop (Parser& parser, nframes_t timestamp)
 168 {
 169         std::cerr << "MIDIClock_Slave got stop message" << endl;
 170
 171         current_midi_clock_frame_duration = 0;
 172
 173         current.guard1++;
 174         current.position = 0;
 175         current_position = 0;
 176         current.timestamp = 0;
 177         current.guard2++;
 178
 179         _started = false;
 180         reset();
 181 }
 182
 183 void
 184 MIDIClock_Slave::read_current (SafeTime *st) const
 185 {
 186         int tries = 0;
 187         do {
 188                 if (tries == 10) {
 189                         error << _("MIDI Clock Slave: atomic read of current time failed, sleeping!") << endmsg;
 190                         usleep (20);
 191                         tries = 0;
 192                 }
 193
 194                 *st = current;
 195                 tries++;
 196
 197         } while (st->guard1 != st->guard2);
 198 }
 199
 200 bool
 201 MIDIClock_Slave::locked () const
 202 {
 203         return true;
 204 }
 205
 206 bool
 207 MIDIClock_Slave::ok() const
 208 {
 209         return true;
 210 }
 211
 212 bool
 213 MIDIClock_Slave::speed_and_position (float& speed, nframes_t& pos)
 214 {
 215         if (!_started) {
 216                 speed = 0.0;
 217                 pos = 0;
 218                 return true;
 219         }
 220
 221         nframes_t now = session.engine().frame_time();
 222         SafeTime last;
 223         read_current (&last);
 224
 225         /* no timecode for 1/4 second ? conclude that its stopped */
 226         if (last_inbound_frame &&
 227             now > last_inbound_frame &&
 228             now - last_inbound_frame > session.frame_rate() / 4) {
 229                 //cerr << "No MIDI Clock frames received for some time, stopping!" << endl;
 230                 pos = last.position;
 231                 session.request_locate (pos, false);
 232                 session.request_transport_speed (0);
 233                 this->stop(*port->input(), now);
 234                 reset();
 235                 return false;
 236         }
 237
 238         //cerr << " now: " << now << " last: " << last.timestamp;
 239
 240         // calculate speed
 241         double speed_double = one_ppqn_in_frames / average_midi_clock_frame_duration;
 242         speed = float(speed_double);
 243         //cerr << " final speed: " << speed;
 244
 245         // calculate position
 246         if (now > last.timestamp) {
 247                 // we are in between MIDI clock messages
 248                 // so we interpolate position according to speed
 249                 nframes_t elapsed = now - last.timestamp;
 250                 pos = nframes_t (current_position + double(elapsed) * speed_double);
 251         } else {
 252                 // A new MIDI clock message has arrived this cycle
 253                 pos = current_position;
 254         }
 255
 256         /*
 257    cerr << " transport position now: " <<  session.transport_frame();
 258    cerr << " calculated position: " << pos;
 259    cerr << endl;
 260    */
 261
 262    // we want start on frame 0 on the first call after a MIDI start
 263    if (_starting) {
 264            pos = 0;
 265            _starting = false;
 266    }
 267
 268         return true;
 269 }
 270
 271 ARDOUR::nframes_t
 272 MIDIClock_Slave::resolution() const
 273 {
 274         return (nframes_t) one_ppqn_in_frames * 24;
 275 }
 276
 277 void
 278 MIDIClock_Slave::reset ()
 279 {
 280
 281         last_inbound_frame = 0;
 282         current.guard1++;
 283         current.position = 0;
 284         current_position = 0;
 285         current.timestamp = 0;
 286         current.guard2++;
 287
 288         session.request_locate(0, false);
 289 }