/*
- Copyright (C) 1999-2002 Paul Davis
+ Copyright (C) 1999-2002 Paul Davis
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
#include <fcntl.h>
#include <poll.h>
+#include <boost/shared_ptr.hpp>
+
#include <midi++/mmc.h>
#include <midi++/port.h>
#include <midi++/manager.h>
#include <ardour/audioengine.h>
#include <ardour/session.h>
#include <ardour/audio_track.h>
+#include <ardour/midi_track.h>
#include <ardour/audio_diskstream.h>
#include <ardour/slave.h>
#include <ardour/cycles.h>
MachineControl::CommandSignature MMC_CommandSignature;
MachineControl::ResponseSignature MMC_ResponseSignature;
+
+void
+Session::midi_panic()
+{
+ {
+ boost::shared_ptr<RouteList> r = routes.reader ();
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ MidiTrack *track = dynamic_cast<MidiTrack*>((*i).get());
+ if (track != 0) {
+ track->midi_panic();
+ }
+ }
+ }
+}
+
int
Session::use_config_midi_ports ()
{
set_midi_port ("");
}
+ if (default_midi_clock_port) {
+ set_midi_clock_port (default_midi_clock_port->name());
+ } else {
+ set_midi_clock_port ("");
+ }
+
return 0;
-}
+}
/***********************************************************************
delete mmc;
}
- mmc = new MIDI::MachineControl (*_mmc_port, 1.0,
+ mmc = new MIDI::MachineControl (*_mmc_port, 1.0,
MMC_CommandSignature,
MMC_ResponseSignature);
mmc->set_send_device_id (old_send_device_id);
}
- mmc->Play.connect
+ mmc->Play.connect
(mem_fun (*this, &Session::mmc_deferred_play));
- mmc->DeferredPlay.connect
+ mmc->DeferredPlay.connect
(mem_fun (*this, &Session::mmc_deferred_play));
- mmc->Stop.connect
+ mmc->Stop.connect
(mem_fun (*this, &Session::mmc_stop));
- mmc->FastForward.connect
+ mmc->FastForward.connect
(mem_fun (*this, &Session::mmc_fast_forward));
- mmc->Rewind.connect
+ mmc->Rewind.connect
(mem_fun (*this, &Session::mmc_rewind));
- mmc->Pause.connect
+ mmc->Pause.connect
(mem_fun (*this, &Session::mmc_pause));
- mmc->RecordPause.connect
+ mmc->RecordPause.connect
(mem_fun (*this, &Session::mmc_record_pause));
- mmc->RecordStrobe.connect
+ mmc->RecordStrobe.connect
(mem_fun (*this, &Session::mmc_record_strobe));
- mmc->RecordExit.connect
+ mmc->RecordExit.connect
(mem_fun (*this, &Session::mmc_record_exit));
- mmc->Locate.connect
+ mmc->Locate.connect
(mem_fun (*this, &Session::mmc_locate));
- mmc->Step.connect
+ mmc->Step.connect
(mem_fun (*this, &Session::mmc_step));
- mmc->Shuttle.connect
+ mmc->Shuttle.connect
(mem_fun (*this, &Session::mmc_shuttle));
mmc->TrackRecordStatusChange.connect
(mem_fun (*this, &Session::mmc_record_enable));
_mmc_port->input()->start.connect (mem_fun (*this, &Session::spp_start));
_mmc_port->input()->contineu.connect (mem_fun (*this, &Session::spp_continue));
_mmc_port->input()->stop.connect (mem_fun (*this, &Session::spp_stop));
-
+
Config->set_mmc_port_name (port_tag);
out:
}
_midi_port = port;
-
+
/* XXX need something to forward this to control protocols ? or just
- use the signal below
+ use the signal below
*/
Config->set_midi_port_name (port_tag);
return 0;
}
+int
+Session::set_midi_clock_port (string port_tag)
+{
+ MIDIClock_Slave *ms;
+
+ if (port_tag.length() == 0) {
+
+ if (_slave && ((ms = dynamic_cast<MIDIClock_Slave*> (_slave)) != 0)) {
+ error << _("Ardour is slaved to MIDI Clock - port cannot be reset") << endmsg;
+ return -1;
+ }
+
+ if (_midi_clock_port == 0) {
+ return 0;
+ }
+
+ _midi_clock_port = 0;
+ goto out;
+ }
+
+ MIDI::Port* port;
+
+ if ((port = MIDI::Manager::instance()->port (port_tag)) == 0) {
+ error << string_compose (_("unknown port %1 requested for MIDI Clock"), port_tag) << endl;
+ return -1;
+ }
+
+ _midi_clock_port = port;
+
+ if (_slave && ((ms = dynamic_cast<MIDIClock_Slave*> (_slave)) != 0)) {
+ ms->rebind (*port);
+ }
+
+ Config->set_midi_clock_port_name (port_tag);
+
+ out:
+ MIDIClock_PortChanged(); /* EMIT SIGNAL */
+ change_midi_ports ();
+ set_dirty();
+ return 0;
+}
+
void
Session::set_trace_midi_input (bool yn, MIDI::Port* port)
{
MIDI::Parser* input_parser;
+ cerr << "enabling tracing: " << yn << " for input port " << port->name() << endl;
+
if (port) {
if ((input_parser = port->input()) != 0) {
input_parser->trace (yn, &cout, "input: ");
input_parser->trace (yn, &cout, "input: ");
}
}
-
+
if (_mtc_port && _mtc_port != _mmc_port) {
if ((input_parser = _mtc_port->input()) != 0) {
input_parser->trace (yn, &cout, "input: ");
input_parser->trace (yn, &cout, "input: ");
}
}
+
+ if (_midi_clock_port
+ && _midi_clock_port != _mmc_port
+ && _midi_clock_port != _mtc_port
+ && _midi_clock_port != _midi_port) {
+ if ((input_parser = _midi_clock_port->input()) != 0) {
+ input_parser->trace (yn, &cout, "input: ");
+ }
+ }
}
Config->set_trace_midi_input (yn);
output_parser->trace (yn, &cout, "output: ");
}
}
-
+
if (_mtc_port && _mtc_port != _mmc_port) {
if ((output_parser = _mtc_port->output()) != 0) {
output_parser->trace (yn, &cout, "output: ");
return input_parser->tracing();
}
}
-
+
if (_mtc_port) {
if ((input_parser = _mtc_port->input()) != 0) {
return input_parser->tracing();
return output_parser->tracing();
}
}
-
+
if (_mtc_port) {
if ((output_parser = _mtc_port->output()) != 0) {
return output_parser->tracing();
next_quarter_frame_to_send = 0;
/* setup the MMC buffer */
-
+
mmc_buffer[0] = 0xf0; // SysEx
mmc_buffer[1] = 0x7f; // Real Time SysEx ID for MMC
mmc_buffer[2] = (mmc ? mmc->send_device_id() : 0x7f);
mmc_buffer[3] = 0x6; // MCC
/* Set up the qtr frame message */
-
+
mtc_msg[0] = 0xf1;
mtc_msg[2] = 0xf1;
mtc_msg[4] = 0xf1;
}
void
-Session::spp_start (Parser& ignored)
+Session::spp_start (Parser& ignored, nframes_t timestamp)
{
if (Config->get_mmc_control() && (Config->get_slave_source() != MTC)) {
request_transport_speed (1.0);
}
void
-Session::spp_continue (Parser& ignored)
+Session::spp_continue (Parser& ignored, nframes_t timestamp)
{
- spp_start (ignored);
+ spp_start (ignored, timestamp);
}
void
-Session::spp_stop (Parser& ignored)
+Session::spp_stop (Parser& ignored, nframes_t timestamp)
{
if (Config->get_mmc_control()) {
request_stop ();
}
}
+/*
+void
+Session::midi_clock_start (Parser& ignored, nframes_t timestamp)
+{
+ if (Config->get_slave_source() == MIDIClock) {
+ request_transport_speed (1.0);
+ }
+}
+
+void
+Session::midi_clock_continue (Parser& parser, nframes_t timestamp)
+{
+ midi_clock_start (parser, 0);
+}
+
+void
+Session::midi_clock_stop (Parser& ignored, nframes_t timestamp)
+{
+ if (Config->get_slave_source() == MIDIClock) {
+ request_stop ();
+ }
+}
+*/
void
Session::mmc_deferred_play (MIDI::MachineControl &mmc)
void
Session::mmc_record_strobe (MIDI::MachineControl &mmc)
{
- if (!Config->get_mmc_control())
+ if (!Config->get_mmc_control())
return;
/* record strobe does an implicit "Play" command */
its not the same as maybe_enable_record() though, because
that *can* switch to Recording, which we do not want.
*/
-
+
save_state ("", true);
g_atomic_int_set (&_record_status, Enabled);
RecordStateChanged (); /* EMIT SIGNAL */
-
+
request_transport_speed (1.0);
} else {
struct timeval diff = { 0, 0 };
gettimeofday (&now, 0);
-
+
timersub (&now, &last_mmc_step, &diff);
gettimeofday (&now, 0);
if (last_mmc_step.tv_sec != 0 && (diff.tv_usec + (diff.tv_sec * 1000000)) < _engine.usecs_per_cycle()) {
return;
}
-
+
double diff_secs = diff.tv_sec + (diff.tv_usec / 1000000.0);
double cur_speed = (((steps * 0.5) * smpte_frames_per_second()) / diff_secs) / smpte_frames_per_second();
-
+
if (_transport_speed == 0 || cur_speed * _transport_speed < 0) {
/* change direction */
step_speed = cur_speed;
step_speed *= 0.25;
#if 0
- cerr << "delta = " << diff_secs
+ cerr << "delta = " << diff_secs
<< " ct = " << _transport_speed
<< " steps = " << steps
- << " new speed = " << cur_speed
+ << " new speed = " << cur_speed
<< " speed = " << step_speed
<< endl;
-#endif
+#endif
request_transport_speed (step_speed);
last_mmc_step = now;
smpte.frames = mmc_tc[3];
smpte.rate = smpte_frames_per_second();
smpte.drop = smpte_drop_frames();
-
+
// Also takes smpte offset into account:
smpte_to_sample( smpte, target_frame, true /* use_offset */, false /* use_subframes */ );
-
+
if (target_frame > max_frames) {
target_frame = max_frames;
}
RouteList::iterator i;
boost::shared_ptr<RouteList> r = routes.reader();
-
+
for (i = r->begin(); i != r->end(); ++i) {
AudioTrack *at;
if (_mtc_port == 0 || !session_send_mtc) {
return 0;
}
-
+
// Get smpte time for this transport frame
sample_to_smpte(_transport_frame, smpte, true /* use_offset */, false /* no subframes */);
cerr << "MTC: Sending full time code at " << outbound_mtc_smpte_frame << endl;
// Send message at offset 0, sent time is for the start of this cycle
- if (!_mtc_port->midimsg (msg, sizeof (msg), 0)) {
+ if (_mtc_port->midimsg (msg, sizeof (msg), 0)) {
error << _("Session: could not send full MIDI time code") << endmsg;
return -1;
}
*/
int
Session::send_midi_time_code_for_cycle(nframes_t nframes)
-{
+{
assert (next_quarter_frame_to_send >= 0);
assert (next_quarter_frame_to_send <= 7);
-
- if (next_quarter_frame_to_send < 0)
- {
- printf("Negative????\n");
- }
if (_mtc_port == 0 || !session_send_mtc || transmitting_smpte_time.negative
- /*|| (next_quarter_frame_to_send < 0)*/ ) {
- //printf("(MTC) Not sending MTC\n");
+ /*|| (next_quarter_frame_to_send < 0)*/ ) {
+ // cerr << "(MTC) Not sending MTC\n";
return 0;
}
-
+
/* Duration of one quarter frame */
nframes_t quarter_frame_duration = ((long) _frames_per_smpte_frame) >> 2;
-
- //cerr << "(MTC) TR: " << _transport_frame << " - SF: " << outbound_mtc_smpte_frame
- //<< " - NQ: " << next_quarter_frame_to_send << " - FD" << quarter_frame_duration << endl;
-
+
+ // cerr << "(MTC) TR: " << _transport_frame << " - SF: " << outbound_mtc_smpte_frame
+ // << " - NQ: " << next_quarter_frame_to_send << " - FD" << quarter_frame_duration << endl;
+
// FIXME: this should always be true
//assert((outbound_mtc_smpte_frame + (next_quarter_frame_to_send * quarter_frame_duration))
// > _transport_frame);
-
+
// Send quarter frames for this cycle
while (_transport_frame + nframes > (outbound_mtc_smpte_frame +
(next_quarter_frame_to_send * quarter_frame_duration))) {
- //cerr << "(MTC) Next frame to send: " << next_quarter_frame_to_send << endl;
+ // cerr << "(MTC) Next frame to send: " << next_quarter_frame_to_send << endl;
switch (next_quarter_frame_to_send) {
case 0:
case 7:
mtc_msg[1] = 0x70 | (((mtc_smpte_bits|transmitting_smpte_time.hours) & 0xf0) >> 4);
break;
- }
-
+ }
+
const nframes_t msg_time = (outbound_mtc_smpte_frame
+ (quarter_frame_duration * next_quarter_frame_to_send));
-
+
// This message must fall within this block or something is broken
assert(msg_time >= _transport_frame);
assert(msg_time < _transport_frame + nframes);
nframes_t out_stamp = msg_time - _transport_frame;
assert(out_stamp < nframes);
- if (!_mtc_port->midimsg (mtc_msg, 2, out_stamp)) {
- error << string_compose(_("Session: cannot send quarter-frame MTC message (%1)"), strerror (errno))
- << endmsg;
+ if (_mtc_port->midimsg (mtc_msg, 2, out_stamp)) {
+ error << string_compose(_("Session: cannot send quarter-frame MTC message (%1)"), strerror (errno))
+ << endmsg;
return -1;
}
<< ", qfm = " << next_quarter_frame_to_send
<< ", stamp = " << out_stamp
<< ", delta = " << _transport_frame + out_stamp - last_time << endl;*/
-
+
// Increment quarter frame counter
next_quarter_frame_to_send++;
next_quarter_frame_to_send = 0;
// Increment smpte time twice
SMPTE::increment( transmitting_smpte_time );
- SMPTE::increment( transmitting_smpte_time );
+ SMPTE::increment( transmitting_smpte_time );
// Re-calculate timing of first quarter frame
//smpte_to_sample( transmitting_smpte_time, outbound_mtc_smpte_frame, true /* use_offset */, false );
outbound_mtc_smpte_frame += 8 * quarter_frame_duration;
OUTBOUND MMC STUFF
**********************************************************************/
-/** Send an MMC command at the given absolute timestamp (@a where).
- *
- * This must be called in the process thread, and @a where must fall within
- * this process cycle or horrible things will happen.
- */
void
Session::deliver_mmc (MIDI::MachineControl::Command cmd, nframes_t where)
{
SMPTE::Time smpte;
if (_mmc_port == 0 || !session_send_mmc) {
- //cerr << "Not delivering MMC " << _mmc_port << " - " << send_mmc << endl;
+ // cerr << "Not delivering MMC " << _mmc_port << " - " << session_send_mmc << endl;
return;
}
mmc_buffer[nbytes++] = cmd;
- //cerr << "delivering MMC, cmd = " << hex << (int) cmd << dec << endl;
-
+ // cerr << "delivering MMC, cmd = " << hex << (int) cmd << dec << endl;
+
switch (cmd) {
case MachineControl::cmdLocate:
smpte_time_subframes (where, smpte);
mmc_buffer[nbytes++] = 0xf7; // terminate SysEx/MMC message
- assert(where >= _transport_frame);
-
- if (!_mmc_port->midimsg (mmc_buffer, sizeof (mmc_buffer), 0)) {
+ if (_mmc_port->midimsg (mmc_buffer, nbytes, 0)) {
error << string_compose(_("MMC: cannot send command %1%2%3"), &hex, cmd, &dec) << endmsg;
- } /*else {
- cerr << "Sending MMC\n";
- }*/
+ }
}
}
}
/*---------------------------------------------------------------------------
- MIDI THREAD
+ MIDI THREAD
---------------------------------------------------------------------------*/
int
MIDIRequest* request = new MIDIRequest;
void* status;
-
+
request->type = MIDIRequest::Quit;
-
+
midi_requests.write (&request, 1);
poke_midi_thread ();
bool restart;
vector<MIDI::Port*> ports;
- PBD::ThreadCreatedWithRequestSize (pthread_self(), X_("MIDI"), 2048);
+ PBD::notify_gui_about_thread_creation (pthread_self(), X_("MIDI"), 2048);
memset (&rtparam, 0, sizeof (rtparam));
rtparam.sched_priority = 9; /* XXX should be relative to audio (JACK) thread */
-
+
if ((x = pthread_setschedparam (pthread_self(), SCHED_FIFO, &rtparam)) != 0) {
// do we care? not particularly.
- }
+ }
- /* set up the port vector; 4 is the largest possible size for now */
+ /* set up the port vector; 5 is the largest possible size for now */
- ports.assign (4, (MIDI::Port*) 0);
+ ports.assign (5, (MIDI::Port*) 0);
while (1) {
pfd[nfds].fd = _mmc_port->selectable();
pfd[nfds].events = POLLIN|POLLHUP|POLLERR;
ports[nfds] = _mmc_port;
+ //cerr << "MIDI port " << nfds << " = MMC @ " << _mmc_port << endl;
nfds++;
}
pfd[nfds].fd = _mtc_port->selectable();
pfd[nfds].events = POLLIN|POLLHUP|POLLERR;
ports[nfds] = _mtc_port;
+ //cerr << "MIDI port " << nfds << " = MTC @ " << _mtc_port << endl;
+ nfds++;
+ }
+
+ if (_midi_clock_port && (_midi_clock_port != _mmc_port || !Config->get_mmc_control()) && _midi_clock_port->selectable() >= 0) {
+ pfd[nfds].fd = _midi_clock_port->selectable();
+ pfd[nfds].events = POLLIN|POLLHUP|POLLERR;
+ ports[nfds] = _midi_clock_port;
nfds++;
}
pfd[nfds].fd = _midi_port->selectable();
pfd[nfds].events = POLLIN|POLLHUP|POLLERR;
ports[nfds] = _midi_port;
+ // cerr << "MIDI port " << nfds << " = MIDI @ " << _midi_port << endl;
nfds++;
}
-
+
if (!midi_timeouts.empty()) {
timeout = 100; /* 10msecs */
} else {
if (pfd[0].revents & POLLIN) {
char foo[16];
-
+
// cerr << "MIDI request FIFO ready\n";
fds_ready++;
// cerr << "rebind\n";
restart = true;
break;
-
+
case MIDIRequest::Quit:
delete request;
pthread_exit_pbd (0);
/*NOTREACHED*/
break;
-
+
default:
break;
}
delete request;
}
- }
+ }
if (restart) {
continue;
// error << string_compose(_("Transport: error polling MIDI port %1 (revents =%2%3%4"), p, &hex, pfd[p].revents, &dec) << endmsg;
break;
}
-
+
if (pfd[p].revents & POLLIN) {
fds_ready++;
ports[p]->parse ();
}
/* timeout driven */
-
+
if (fds_ready < 2 && timeout != -1) {
for (MidiTimeoutList::iterator i = midi_timeouts.begin(); i != midi_timeouts.end(); ) {
-
+
MidiTimeoutList::iterator tmp;
tmp = i;
++tmp;
-
+
if (!(*i)()) {
midi_timeouts.erase (i);
}
-
+
i = tmp;
}
}
projects / ardour.git / blobdiff