2 Copyright (C) 2008 Hans Baier
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.
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.
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.
21 #include "ardour/ticker.h"
22 #include "ardour/session.h"
23 #include "ardour/tempo.h"
25 #ifdef DEBUG_MIDI_CLOCK
34 void Ticker::set_session(Session
& s
)
39 _session
->tick
.connect(mem_fun (*this, &Ticker::tick
));
40 _session
->GoingAway
.connect(mem_fun (*this, &Ticker::going_away
));
44 void MidiClockTicker::set_session(Session
& s
)
46 Ticker::set_session(s
);
49 _session
->MIDIClock_PortChanged
.connect(
50 mem_fun (*this, &MidiClockTicker::update_midi_clock_port
));
51 _session
->TransportStateChange
.connect(
52 mem_fun (*this, &MidiClockTicker::transport_state_changed
));
53 _session
->PositionChanged
.connect(
54 mem_fun (*this, &MidiClockTicker::position_changed
));
55 _session
->TransportLooped
.connect(
56 mem_fun (*this, &MidiClockTicker::transport_looped
));
57 update_midi_clock_port();
61 void MidiClockTicker::update_midi_clock_port()
63 _midi_port
= _session
->midi_clock_port();
66 void MidiClockTicker::transport_state_changed()
68 if (_session
->exporting()) {
69 /* no midi clock during export, for now */
73 float speed
= _session
->transport_speed();
74 nframes_t position
= _session
->transport_frame();
75 #ifdef DEBUG_MIDI_CLOCK
76 cerr
<< "Transport state change, speed:" << speed
<< "position:" << position
<< " play loop " << _session
->get_play_loop() << endl
;
79 _last_tick
= position
;
81 if (!Config
->get_send_midi_clock())
84 if (_session
->get_play_loop()) {
85 assert(_session
->locations()->auto_loop_location());
86 if (position
== _session
->locations()->auto_loop_location()->start()) {
89 send_continue_event(0);
91 } else if (position
== 0) {
94 send_continue_event(0);
97 send_midi_clock_event(0);
99 } else if (speed
== 0.0f
) {
100 if (!Config
->get_send_midi_clock())
106 tick(position
, *((ARDOUR::BBT_Time
*) 0), *((Timecode::Time
*)0));
109 void MidiClockTicker::position_changed(nframes_t position
)
111 #ifdef DEBUG_MIDI_CLOCK
112 cerr
<< "Position changed:" << position
<< endl
;
114 _last_tick
= position
;
117 void MidiClockTicker::transport_looped()
119 Location
* loop_location
= _session
->locations()->auto_loop_location();
120 assert(loop_location
);
122 #ifdef DEBUG_MIDI_CLOCK
123 cerr
<< "Transport looped, position:" << _session
->transport_frame()
124 << " loop start " << loop_location
->start( )
125 << " loop end " << loop_location
->end( )
126 << " play loop " << _session
->get_play_loop()
130 // adjust _last_tick, so that the next MIDI clock message is sent
131 // in due time (and the tick interval is still constant)
132 nframes_t elapsed_since_last_tick
= loop_location
->end() - _last_tick
;
133 _last_tick
= loop_location
->start() - elapsed_since_last_tick
;
136 void MidiClockTicker::tick(const nframes_t
& transport_frames
, const BBT_Time
& /*transport_bbt*/, const Timecode::Time
& /*transport_smpt*/)
138 #ifdef WITH_JACK_MIDI
139 if (!Config
->get_send_midi_clock() || _session
== 0 || _session
->transport_speed() != 1.0f
)
142 MIDI::JACK_MidiPort
* jack_port
= dynamic_cast<MIDI::JACK_MidiPort
*>(_midi_port
);
146 double next_tick
= _last_tick
+ one_ppqn_in_frames(transport_frames
);
147 nframes_t next_tick_offset
= nframes_t(next_tick
) - transport_frames
;
149 #ifdef DEBUG_MIDI_CLOCK
150 cerr
<< "Transport:" << transport_frames
151 << ":Last tick time:" << _last_tick
<< ":"
152 << ":Next tick time:" << next_tick
<< ":"
153 << "Offset:" << next_tick_offset
<< ":"
154 << "cycle length:" << jack_port
->nframes_this_cycle()
158 if (next_tick_offset
>= jack_port
->nframes_this_cycle())
161 send_midi_clock_event(next_tick_offset
);
163 _last_tick
= next_tick
;
165 #endif // WITH_JACK_MIDI
168 double MidiClockTicker::one_ppqn_in_frames(nframes_t transport_position
)
170 const Tempo
& current_tempo
= _session
->tempo_map().tempo_at(transport_position
);
171 const Meter
& current_meter
= _session
->tempo_map().meter_at(transport_position
);
172 double frames_per_beat
=
173 current_tempo
.frames_per_beat(_session
->nominal_frame_rate(),
176 double quarter_notes_per_beat
= 4.0 / current_tempo
.note_type();
177 double frames_per_quarter_note
= frames_per_beat
/ quarter_notes_per_beat
;
179 return frames_per_quarter_note
/ double (_ppqn
);
182 void MidiClockTicker::send_midi_clock_event(nframes_t offset
)
184 #ifdef WITH_JACK_MIDI
185 assert (MIDI::JACK_MidiPort::is_process_thread());
186 #endif // WITH_JACK_MIDI
187 #ifdef DEBUG_MIDI_CLOCK
188 cerr
<< "Tick with offset " << offset
<< endl
;
189 #endif // DEBUG_MIDI_CLOCK
190 static uint8_t _midi_clock_tick
[1] = { MIDI_CMD_COMMON_CLOCK
};
191 _midi_port
->write(_midi_clock_tick
, 1, offset
);
194 void MidiClockTicker::send_start_event(nframes_t offset
)
196 static uint8_t _midi_clock_tick
[1] = { MIDI_CMD_COMMON_START
};
197 _midi_port
->write(_midi_clock_tick
, 1, offset
);
200 void MidiClockTicker::send_continue_event(nframes_t offset
)
202 static uint8_t _midi_clock_tick
[1] = { MIDI_CMD_COMMON_CONTINUE
};
203 _midi_port
->write(_midi_clock_tick
, 1, offset
);
206 void MidiClockTicker::send_stop_event(nframes_t offset
)
208 static uint8_t _midi_clock_tick
[1] = { MIDI_CMD_COMMON_STOP
};
209 _midi_port
->write(_midi_clock_tick
, 1, offset
);