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     $Id$
  19 */
  20
  21 #include "midi++/port.h"
  22 #include "evoral/midi_events.h"
  23 #include "ardour/ticker.h"
  24 #include "ardour/session.h"
  25 #include "ardour/tempo.h"
  26
  27 #ifdef DEBUG_MIDI_CLOCK
  28 #include <iostream>
  29 using namespace std;
  30 #endif
  31
  32 using namespace ARDOUR;
  33
  34 void Ticker::set_session (Session* s)
  35 {
  36         SessionHandlePtr::set_session (s);
  37
  38         if (_session) {
  39                 _session->tick.connect_same_thread (_session_connections, boost::bind (&Ticker::tick, this, _1, _2, _3));
  40         }
  41 }
  42
  43 void MidiClockTicker::set_session (Session* s)
  44 {
  45          Ticker::set_session (s);
  46
  47          if (_session) {
  48                  _session->MIDIClock_PortChanged.connect_same_thread (_session_connections, boost::bind (&MidiClockTicker::update_midi_clock_port, this));
  49                  _session->TransportStateChange.connect_same_thread (_session_connections, boost::bind (&MidiClockTicker::transport_state_changed, this));
  50                  _session->PositionChanged.connect_same_thread (_session_connections, boost::bind (&MidiClockTicker::position_changed, this, _1));
  51                  _session->TransportLooped.connect_same_thread (_session_connections, boost::bind (&MidiClockTicker::transport_looped, this));
  52                  update_midi_clock_port();
  53          }
  54 }
  55
  56 void
  57 MidiClockTicker::session_going_away ()
  58 {
  59         SessionHandlePtr::session_going_away();
  60         _midi_port = 0;
  61 }
  62
  63 void MidiClockTicker::update_midi_clock_port()
  64 {
  65         _midi_port = _session->midi_clock_port();
  66 }
  67
  68 void MidiClockTicker::transport_state_changed()
  69 {
  70         if (_session->exporting()) {
  71                 /* no midi clock during export, for now */
  72                 return;
  73         }
  74
  75         float     speed    = _session->transport_speed();
  76         nframes_t position = _session->transport_frame();
  77 #ifdef DEBUG_MIDI_CLOCK
  78         cerr << "Transport state change, speed:" << speed << "position:" << position<< " play loop " << _session->get_play_loop() << endl;
  79 #endif
  80         if (speed == 1.0f) {
  81                 _last_tick = position;
  82
  83                 if (!Config->get_send_midi_clock())
  84                         return;
  85
  86                 if (_session->get_play_loop()) {
  87                         assert(_session->locations()->auto_loop_location());
  88                         if (position == _session->locations()->auto_loop_location()->start()) {
  89                                 send_start_event(0);
  90                         } else {
  91                                 send_continue_event(0);
  92                         }
  93                 } else if (position == 0) {
  94                         send_start_event(0);
  95                 } else {
  96                         send_continue_event(0);
  97                 }
  98
  99                 send_midi_clock_event(0);
 100
 101         } else if (speed == 0.0f) {
 102                 if (!Config->get_send_midi_clock())
 103                         return;
 104
 105                 send_stop_event(0);
 106         }
 107
 108         tick(position, *((ARDOUR::BBT_Time *) 0), *((Timecode::Time *)0));
 109 }
 110
 111 void MidiClockTicker::position_changed(nframes_t position)
 112 {
 113 #ifdef DEBUG_MIDI_CLOCK
 114         cerr << "Position changed:" << position << endl;
 115 #endif
 116         _last_tick = position;
 117 }
 118
 119 void MidiClockTicker::transport_looped()
 120 {
 121         Location* loop_location = _session->locations()->auto_loop_location();
 122         assert(loop_location);
 123
 124 #ifdef DEBUG_MIDI_CLOCK
 125         cerr << "Transport looped, position:" <<  _session->transport_frame()
 126              << " loop start " << loop_location->start( )
 127              << " loop end " << loop_location->end( )
 128              << " play loop " << _session->get_play_loop()
 129              <<  endl;
 130 #endif
 131
 132         // adjust _last_tick, so that the next MIDI clock message is sent
 133         // in due time (and the tick interval is still constant)
 134         nframes_t elapsed_since_last_tick = loop_location->end() - _last_tick;
 135         _last_tick = loop_location->start() - elapsed_since_last_tick;
 136 }
 137
 138 void MidiClockTicker::tick(const nframes_t& transport_frames, const BBT_Time& /*transport_bbt*/, const Timecode::Time& /*transport_smpt*/)
 139 {
 140         if (!Config->get_send_midi_clock() || _session == 0 || _session->transport_speed() != 1.0f || _midi_port == 0)
 141                 return;
 142
 143         while (true) {
 144                 double next_tick = _last_tick + one_ppqn_in_frames(transport_frames);
 145                 nframes_t next_tick_offset = nframes_t(next_tick) - transport_frames;
 146
 147 #ifdef DEBUG_MIDI_CLOCK
 148                 cerr << "Transport:" << transport_frames
 149                          << ":Last tick time:" << _last_tick << ":"
 150                          << ":Next tick time:" << next_tick << ":"
 151                          << "Offset:" << next_tick_offset << ":"
 152                          << "cycle length:" << _midi_port->nframes_this_cycle()
 153                          << endl;
 154 #endif
 155
 156                 if (next_tick_offset >= _midi_port->nframes_this_cycle())
 157                         return;
 158
 159                 send_midi_clock_event(next_tick_offset);
 160
 161                 _last_tick = next_tick;
 162         }
 163 }
 164
 165 double MidiClockTicker::one_ppqn_in_frames(nframes_t transport_position)
 166 {
 167         const Tempo& current_tempo = _session->tempo_map().tempo_at(transport_position);
 168         const Meter& current_meter = _session->tempo_map().meter_at(transport_position);
 169         double frames_per_beat =
 170                 current_tempo.frames_per_beat(_session->nominal_frame_rate(),
 171                                               current_meter);
 172
 173         double quarter_notes_per_beat = 4.0 / current_tempo.note_type();
 174         double frames_per_quarter_note = frames_per_beat / quarter_notes_per_beat;
 175
 176         return frames_per_quarter_note / double (_ppqn);
 177 }
 178
 179 void MidiClockTicker::send_midi_clock_event(nframes_t offset)
 180 {
 181         if (!_midi_port) {
 182                 return;
 183         }
 184
 185         assert (MIDI::Port::is_process_thread());
 186 #ifdef DEBUG_MIDI_CLOCK
 187         cerr << "Tick with offset " << offset << endl;
 188 #endif // DEBUG_MIDI_CLOCK
 189         static uint8_t _midi_clock_tick[1] = { MIDI_CMD_COMMON_CLOCK };
 190         _midi_port->write(_midi_clock_tick, 1, offset);
 191 }
 192
 193 void MidiClockTicker::send_start_event(nframes_t offset)
 194 {
 195         if (!_midi_port) {
 196                 return;
 197         }
 198
 199         static uint8_t _midi_clock_tick[1] = { MIDI_CMD_COMMON_START };
 200         _midi_port->write(_midi_clock_tick, 1, offset);
 201 }
 202
 203 void MidiClockTicker::send_continue_event(nframes_t offset)
 204 {
 205         if (!_midi_port) {
 206                 return;
 207         }
 208
 209         static uint8_t _midi_clock_tick[1] = { MIDI_CMD_COMMON_CONTINUE };
 210         _midi_port->write(_midi_clock_tick, 1, offset);
 211 }
 212
 213 void MidiClockTicker::send_stop_event(nframes_t offset)
 214 {
 215         if (!_midi_port) {
 216                 return;
 217         }
 218
 219         static uint8_t _midi_clock_tick[1] = { MIDI_CMD_COMMON_STOP };
 220         _midi_port->write(_midi_clock_tick, 1, offset);
 221 }
 222
 223
 224