smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-12 01:26:31 +01:00
Code Issues Projects Releases Wiki Activity

* fixed jitter problems for midi clock and removed superfluous UI elements

Browse source 
git-svn-id: svn://localhost/ardour2/branches/3.0@4008 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
Hans Baier 2008-10-25 08:28:10 +00:00
parent 33d02c7902
commit fd824717a7
14 changed files with 58 additions and 59 deletions
Download patch file Download diff file Expand all files Collapse all files

1
gtk2_ardour/ardour_ui.h
View file

@ -701,7 +701,6 @@ class ARDOUR_UI : public Gtkmm2ext::UI
void toggle_use_mmc (); void toggle_use_mmc ();
void toggle_send_mmc (); void toggle_send_mmc ();
void toggle_send_mtc (); void toggle_send_mtc ();
void toggle_use_midi_clock ();
void toggle_use_osc (); void toggle_use_osc ();

2
gtk2_ardour/ardour_ui_ed.cc
View file

@ -436,8 +436,6 @@ ARDOUR_UI::install_actions ()
ActionManager::session_sensitive_actions.push_back (act); ActionManager::session_sensitive_actions.push_back (act);
act = ActionManager::register_toggle_action (option_actions, X_("UseMMC"), _("Use MMC"), mem_fun (*this, &ARDOUR_UI::toggle_use_mmc)); act = ActionManager::register_toggle_action (option_actions, X_("UseMMC"), _("Use MMC"), mem_fun (*this, &ARDOUR_UI::toggle_use_mmc));
ActionManager::session_sensitive_actions.push_back (act); ActionManager::session_sensitive_actions.push_back (act);
act = ActionManager::register_toggle_action (option_actions, X_("UseMIDIClock"), _("Use MIDI Clock"), mem_fun (*this, &ARDOUR_UI::toggle_use_midi_clock));
ActionManager::session_sensitive_actions.push_back (act);
act = ActionManager::register_toggle_action (option_actions, X_("SendMIDIfeedback"), _("Send MIDI feedback"), mem_fun (*this, &ARDOUR_UI::toggle_send_midi_feedback)); act = ActionManager::register_toggle_action (option_actions, X_("SendMIDIfeedback"), _("Send MIDI feedback"), mem_fun (*this, &ARDOUR_UI::toggle_send_midi_feedback));
ActionManager::session_sensitive_actions.push_back (act); ActionManager::session_sensitive_actions.push_back (act);

8
gtk2_ardour/ardour_ui_options.cc
View file

@ -67,12 +67,6 @@ ARDOUR_UI::toggle_use_mmc ()
ActionManager::toggle_config_state ("options", "UseMMC", &Configuration::set_mmc_control, &Configuration::get_mmc_control); ActionManager::toggle_config_state ("options", "UseMMC", &Configuration::set_mmc_control, &Configuration::get_mmc_control);
} }
void
ARDOUR_UI::toggle_use_midi_clock ()
{
ActionManager::toggle_config_state ("options", "UseMIDIClock", &Configuration::set_midi_clock_control, &Configuration::get_midi_clock_control);
}
void void
ARDOUR_UI::toggle_use_osc () ARDOUR_UI::toggle_use_osc ()
{ {
@ -1108,8 +1102,6 @@ ARDOUR_UI::parameter_changed (const char* parameter_name)
} else if (PARAM_IS ("mmc-control")) { } else if (PARAM_IS ("mmc-control")) {
ActionManager::map_some_state ("options", "UseMMC", &Configuration::get_mmc_control); ActionManager::map_some_state ("options", "UseMMC", &Configuration::get_mmc_control);
} else if (PARAM_IS ("midi-clock-control")) {
ActionManager::map_some_state ("options", "UseMIDIClock", &Configuration::get_midi_clock_control);
} else if (PARAM_IS ("midi-feedback")) { } else if (PARAM_IS ("midi-feedback")) {
ActionManager::map_some_state ("options", "SendMIDIfeedback", &Configuration::get_midi_feedback); ActionManager::map_some_state ("options", "SendMIDIfeedback", &Configuration::get_midi_feedback);
} else if (PARAM_IS ("do-not-record-plugins")) { } else if (PARAM_IS ("do-not-record-plugins")) {

1
libs/ardour/ardour/configuration_vars.h
View file

@ -36,7 +36,6 @@ CONFIG_VARIABLE (bool, trace_midi_output, "trace-midi-output", false)
CONFIG_VARIABLE (bool, send_mtc, "send-mtc", false) CONFIG_VARIABLE (bool, send_mtc, "send-mtc", false)
CONFIG_VARIABLE (bool, send_mmc, "send-mmc", true) CONFIG_VARIABLE (bool, send_mmc, "send-mmc", true)
CONFIG_VARIABLE (bool, mmc_control, "mmc-control", true) CONFIG_VARIABLE (bool, mmc_control, "mmc-control", true)
CONFIG_VARIABLE (bool, midi_clock_control, "midi-clock-control", false)
CONFIG_VARIABLE (bool, midi_feedback, "midi-feedback", false) CONFIG_VARIABLE (bool, midi_feedback, "midi-feedback", false)
CONFIG_VARIABLE (uint8_t, mmc_receive_device_id, "mmc-receive-device-id", 0) CONFIG_VARIABLE (uint8_t, mmc_receive_device_id, "mmc-receive-device-id", 0)
CONFIG_VARIABLE (uint8_t, mmc_send_device_id, "mmc-send-device-id", 0) CONFIG_VARIABLE (uint8_t, mmc_send_device_id, "mmc-send-device-id", 0)

10
libs/ardour/ardour/session.h
View file

@ -1306,13 +1306,9 @@ class Session : public PBD::StatefulDestructible
void deliver_mmc (MIDI::MachineControl::Command, nframes_t); void deliver_mmc (MIDI::MachineControl::Command, nframes_t);
void spp_start (MIDI::Parser&); void spp_start (MIDI::Parser&, nframes_t timestamp);
void spp_continue (MIDI::Parser&); void spp_continue (MIDI::Parser&, nframes_t timestamp);
void spp_stop (MIDI::Parser&); void spp_stop (MIDI::Parser&, nframes_t timestamp);
void midi_clock_start (MIDI::Parser&);
void midi_clock_continue (MIDI::Parser&);
void midi_clock_stop (MIDI::Parser&);
void mmc_deferred_play (MIDI::MachineControl &); void mmc_deferred_play (MIDI::MachineControl &);
void mmc_stop (MIDI::MachineControl &); void mmc_stop (MIDI::MachineControl &);

6
libs/ardour/ardour/slave.h
View file

@ -143,9 +143,9 @@ class MIDIClock_Slave : public Slave, public sigc::trackable {
float average; float average;
void reset (); void reset ();
void start (MIDI::Parser& parser); void start (MIDI::Parser& parser, nframes_t timestamp);
void stop (MIDI::Parser& parser); void stop (MIDI::Parser& parser, nframes_t timestamp);
void update_midi_clock (MIDI::Parser& parser); void update_midi_clock (MIDI::Parser& parser, nframes_t timestamp);
void read_current (SafeTime *) const; void read_current (SafeTime *) const;
bool _started; bool _started;

23
libs/ardour/midi_clock_slave.cc
View file

@ -26,12 +26,14 @@
#include <pbd/pthread_utils.h> #include <pbd/pthread_utils.h>
#include <midi++/port.h> #include <midi++/port.h>
#include <midi++/jack.h>
#include <ardour/slave.h> #include <ardour/slave.h>
#include <ardour/session.h> #include <ardour/session.h>
#include <ardour/audioengine.h> #include <ardour/audioengine.h>
#include <ardour/cycles.h> #include <ardour/cycles.h>
#include <ardour/tempo.h> #include <ardour/tempo.h>
#include "i18n.h" #include "i18n.h"
using namespace ARDOUR; using namespace ARDOUR;
@ -73,9 +75,9 @@ MIDIClock_Slave::rebind (MIDI::Port& p)
} }
void void
MIDIClock_Slave::update_midi_clock (Parser& parser) MIDIClock_Slave::update_midi_clock (Parser& parser, nframes_t timestamp)
{ {
nframes_t now = session.engine().frame_time(); nframes_t now = timestamp;
SafeTime last; SafeTime last;
read_current (&last); read_current (&last);
@ -109,8 +111,14 @@ MIDIClock_Slave::update_midi_clock (Parser& parser)
average += accumulator[i]; average += accumulator[i];
average /= accumulator_size; average /= accumulator_size;
JACK_MidiPort *jack_port = dynamic_cast<JACK_MidiPort *>(port);
pthread_t process_thread_id = 0;
if(jack_port) {
process_thread_id = jack_port->get_process_thread();
}
std::cerr << "got MIDI Clock message at time " << now std::cerr << "Thread " << pthread_name() << " with id " << pthread_self() << " process Thread ID: " << process_thread_id
<< " got MIDI Clock message at time " << now
<< " real delta: " << midi_clock_frame << " real delta: " << midi_clock_frame
<< " reference: " << one_ppqn_in_frames << " reference: " << one_ppqn_in_frames
<< " accu index: " << accumulator_index << " accu index: " << accumulator_index
@ -127,7 +135,7 @@ MIDIClock_Slave::update_midi_clock (Parser& parser)
} }
void void
MIDIClock_Slave::start (Parser& parser) MIDIClock_Slave::start (Parser& parser, nframes_t timestamp)
{ {
nframes_t now = session.engine().frame_time(); nframes_t now = session.engine().frame_time();
@ -154,7 +162,7 @@ MIDIClock_Slave::start (Parser& parser)
} }
void void
MIDIClock_Slave::stop (Parser& parser) MIDIClock_Slave::stop (Parser& parser, nframes_t timestamp)
{ {
std::cerr << "MIDIClock_Slave got stop message" << endl; std::cerr << "MIDIClock_Slave got stop message" << endl;
@ -225,7 +233,7 @@ MIDIClock_Slave::speed_and_position (float& speed, nframes_t& pos)
pos = last.position; pos = last.position;
session.request_locate (pos, false); session.request_locate (pos, false);
session.request_transport_speed (0); session.request_transport_speed (0);
this->stop(*port->input()); this->stop(*port->input(), now);
reset(); reset();
return false; return false;
} }
@ -238,7 +246,8 @@ MIDIClock_Slave::speed_and_position (float& speed, nframes_t& pos)
speed = midi_clock_speed; speed = midi_clock_speed;
cerr << " final speed: " << speed << " elapsed: " << elapsed << " elapsed (scaled) " << elapsed * speed << " position: " << pos << endl; cerr << " final speed: " << speed << " elapsed: " << elapsed << " elapsed (scaled) " << elapsed * speed << " position: " << pos
<< " Thread ID: " << pthread_self() << endl;
return true; return true;
} }

27
libs/ardour/session_midi.cc
View file

@ -317,10 +317,6 @@ Session::set_midi_clock_port (string port_tag)
Config->set_midi_clock_port_name (port_tag); Config->set_midi_clock_port_name (port_tag);
_midi_clock_port->input()->start.connect (mem_fun (*this, &Session::midi_clock_start));
_midi_clock_port->input()->contineu.connect (mem_fun (*this, &Session::midi_clock_continue));
_midi_clock_port->input()->stop.connect (mem_fun (*this, &Session::midi_clock_stop));
out: out:
MIDIClock_PortChanged(); /* EMIT SIGNAL */ MIDIClock_PortChanged(); /* EMIT SIGNAL */
change_midi_ports (); change_midi_ports ();
@ -496,7 +492,7 @@ Session::setup_midi_control ()
} }
void void
Session::spp_start (Parser& ignored) Session::spp_start (Parser& ignored, nframes_t timestamp)
{ {
if (Config->get_mmc_control() && (Config->get_slave_source() != MTC)) { if (Config->get_mmc_control() && (Config->get_slave_source() != MTC)) {
request_transport_speed (1.0); request_transport_speed (1.0);
@ -504,40 +500,41 @@ Session::spp_start (Parser& ignored)
} }
void void
Session::spp_continue (Parser& ignored) Session::spp_continue (Parser& ignored, nframes_t timestamp)
{ {
spp_start (ignored); spp_start (ignored, timestamp);
} }
void void
Session::spp_stop (Parser& ignored) Session::spp_stop (Parser& ignored, nframes_t timestamp)
{ {
if (Config->get_mmc_control()) { if (Config->get_mmc_control()) {
request_stop (); request_stop ();
} }
} }
/*
void void
Session::midi_clock_start (Parser& ignored) Session::midi_clock_start (Parser& ignored, nframes_t timestamp)
{ {
if (Config->get_midi_clock_control() && (Config->get_slave_source() == MIDIClock)) { if (Config->get_slave_source() == MIDIClock) {
request_transport_speed (1.0); request_transport_speed (1.0);
} }
} }
void void
Session::midi_clock_continue (Parser& ignored) Session::midi_clock_continue (Parser& parser, nframes_t timestamp)
{ {
midi_clock_start (ignored); midi_clock_start (parser, 0);
} }
void void
Session::midi_clock_stop (Parser& ignored) Session::midi_clock_stop (Parser& ignored, nframes_t timestamp)
{ {
if (Config->get_midi_clock_control()) { if (Config->get_slave_source() == MIDIClock) {
request_stop (); request_stop ();
} }
} }
*/
void void
Session::mmc_deferred_play (MIDI::MachineControl &mmc) Session::mmc_deferred_play (MIDI::MachineControl &mmc)

2
libs/midi++2/jack_midiport.cc
View file

@ -78,6 +78,8 @@ JACK_MidiPort::cycle_start (nframes_t nframes)
if (input_parser) { if (input_parser) {
input_parser->raw_preparse (*input_parser, ev.buffer, ev.size); input_parser->raw_preparse (*input_parser, ev.buffer, ev.size);
for (size_t i = 0; i < ev.size; i++) { for (size_t i = 0; i < ev.size; i++) {
// the midi events here are used for MIDI clock only
input_parser->set_midi_clock_timestamp(ev.time + jack_last_frame_time(_jack_client));
input_parser->scanner (ev.buffer[i]); input_parser->scanner (ev.buffer[i]);
} }
input_parser->raw_postparse (*input_parser, ev.buffer, ev.size); input_parser->raw_postparse (*input_parser, ev.buffer, ev.size);

4
libs/midi++2/midi++/jack.h
View file

@ -60,6 +60,8 @@ public:
virtual void set_state (const XMLNode&); virtual void set_state (const XMLNode&);
static void set_process_thread (pthread_t); static void set_process_thread (pthread_t);
static pthread_t get_process_thread () { return _process_thread; }
static bool is_process_thread();
protected: protected:
std::string get_typestring () const { std::string get_typestring () const {
@ -78,7 +80,7 @@ private:
void flush (void* jack_port_buffer); void flush (void* jack_port_buffer);
static pthread_t _process_thread; static pthread_t _process_thread;
static bool is_process_thread();
RingBuffer<Evoral::Event> non_process_thread_fifo; RingBuffer<Evoral::Event> non_process_thread_fifo;
Glib::Mutex non_process_thread_fifo_lock; Glib::Mutex non_process_thread_fifo_lock;

19
libs/midi++2/midi++/parser.h
View file

@ -74,15 +74,15 @@ class Parser : public sigc::trackable {
Signal position; Signal position;
Signal song; Signal song;
Signal mtc; Signal mtc;
sigc::signal<void,Parser&> mtc_qtr; sigc::signal<void,Parser&> mtc_qtr;
sigc::signal<void, Parser &> all_notes_off; sigc::signal<void, Parser &> all_notes_off;
sigc::signal<void, Parser &> tune; sigc::signal<void, Parser &> tune;
sigc::signal<void, Parser &> timing; sigc::signal<void, Parser &, nframes_t> timing;
sigc::signal<void, Parser &> start; sigc::signal<void, Parser &, nframes_t> start;
sigc::signal<void, Parser &> stop; sigc::signal<void, Parser &, nframes_t> stop;
sigc::signal<void, Parser &> contineu; /* note spelling */ sigc::signal<void, Parser &, nframes_t> contineu; /* note spelling */
sigc::signal<void, Parser &> active_sense; sigc::signal<void, Parser &> active_sense;
sigc::signal<void, Parser &> reset; sigc::signal<void, Parser &> reset;
sigc::signal<void, Parser &> eox; sigc::signal<void, Parser &> eox;
@ -122,6 +122,9 @@ class Parser : public sigc::trackable {
const byte *mtc_current() const { return _mtc_time; } const byte *mtc_current() const { return _mtc_time; }
bool mtc_locked() const { return _mtc_locked; } bool mtc_locked() const { return _mtc_locked; }
const nframes_t get_midi_clock_timestamp() const { return _midi_clock_timestamp; }
void set_midi_clock_timestamp(const nframes_t timestamp) { _midi_clock_timestamp = timestamp; }
sigc::signal<void,MTC_Status> mtc_status; sigc::signal<void,MTC_Status> mtc_status;
sigc::signal<bool> mtc_skipped; sigc::signal<bool> mtc_skipped;
sigc::signal<void,const byte*,bool> mtc_time; sigc::signal<void,const byte*,bool> mtc_time;
@ -169,6 +172,8 @@ class Parser : public sigc::trackable {
bool _mtc_locked; bool _mtc_locked;
byte last_qtr_frame; byte last_qtr_frame;
nframes_t _midi_clock_timestamp;
ParseState pre_variable_state; ParseState pre_variable_state;
MIDI::eventType pre_variable_msgtype; MIDI::eventType pre_variable_msgtype;
byte last_status_byte; byte last_status_byte;

2
libs/midi++2/midi++/port.h
View file

@ -87,7 +87,7 @@ class Port : public sigc::trackable {
int three_byte_msg (byte a, byte b, byte c, timestamp_t timestamp) { int three_byte_msg (byte a, byte b, byte c, timestamp_t timestamp) {
byte msg[3]; byte msg[3];
msg[0] = a; msg[0] = a;
msg[1] = b; msg[1] = b;
msg[2] = c; msg[2] = c;

8
libs/midi++2/midiparser.cc
View file

@ -538,16 +538,16 @@ Parser::realtime_msg(unsigned char inbyte)
switch (inbyte) { switch (inbyte) {
case 0xf8: case 0xf8:
timing (*this); timing (*this, _midi_clock_timestamp);
break; break;
case 0xfa: case 0xfa:
start (*this); start (*this, _midi_clock_timestamp);
break; break;
case 0xfb: case 0xfb:
contineu (*this); contineu (*this, _midi_clock_timestamp);
break; break;
case 0xfc: case 0xfc:
stop (*this); stop (*this, _midi_clock_timestamp);
break; break;
case 0xfe: case 0xfe:
/* !!! active sense message in realtime_msg: should not reach here /* !!! active sense message in realtime_msg: should not reach here

2
libs/pbd/pbd/ringbuffer.h
View file

@ -56,7 +56,7 @@ class RingBuffer
} }
guint read (T *dest, guint cnt); guint read (T *dest, guint cnt);
guint write (T *src, guint cnt); guint write (T *src, guint cnt);
struct rw_vector { struct rw_vector {
T *buf[2]; T *buf[2];