26 #include <jack/statistics.h>
27 #include <jack/jack.h>
28 #include <jack/thread.h>
32 #ifdef HAVE_JACK_SESSION
43 static const char *jack_amp_postfix =
"_amp";
44 static const char *jack_fx_postfix =
"_fx";
47 static const char *default_jack_instancename =
"gx_head";
48 return default_jack_instancename;
56 static unsigned int rt_watchdog_counter;
59 #define SCHED_IDLE SCHED_OTHER // non-linux systems
62 static void *rt_watchdog_run(
void *p) {
63 struct sched_param spar;
64 spar.sched_priority = 0;
65 pthread_setschedparam(pthread_self(),
SCHED_IDLE, &spar);
73 static int rt_watchdog_limit = 0;
75 static void rt_watchdog_start() {
76 if (rt_watchdog_limit > 0) {
78 pthread_attr_init(&attr);
80 if (pthread_create(&pthr, &attr, rt_watchdog_run, 0)) {
83 pthread_attr_destroy(&attr);
87 static inline bool rt_watchdog_check_alive(
unsigned int bs,
unsigned int sr) {
88 if (rt_watchdog_limit > 0) {
107 bypass_insert(false),
108 #ifdef HAVE_JACK_SESSION
110 session_event_ins(0),
111 session_callback_seen(0),
114 connection_changed(),
124 xrun_msg_blocked(false),
129 client_insert_name(),
134 single_client(false) {
135 for(
int i = 0;i<5;i++) mmessage.
send_cc[i] =
false;
136 connection_queue.
new_data.connect(sigc::mem_fun(*
this, &GxJack::fetch_connection_data));
137 client_change_rt.connect(client_change);
139 sigc::mem_fun(*
this, &GxJack::cleanup_slot));
140 xrun.connect(sigc::mem_fun(
this, &GxJack::report_xrun));
148 rt_watchdog_limit = limit;
195 void GxJack::write_jack_port_connections(
200 const char** pl = jack_port_get_connections(pc.
port);
202 for (
const char **p = pl; *p; p++) {
204 w.
write(make_clientvar(*p));
212 for (list<string>::const_iterator i = pc.
conn.begin(); i != pc.
conn.end(); ++i) {
221 write_jack_port_connections(w,
"input",
ports.
input);
222 write_jack_port_connections(w,
"output1",
ports.
output1);
223 write_jack_port_connections(w,
"output2",
ports.
output2);
226 if (!single_client) {
228 write_jack_port_connections(w,
"insert_in",
ports.
insert_in,
true);
237 int GxJack::is_power_of_two (
unsigned int x)
239 return ((x != 0) && ((x & (~x + 1)) == x));
246 int jackopt = (startserver ? JackNullOption : JackNoStartServer);
248 if (client_instance.empty()) {
249 if (!single_client) {
252 client_instance =
"guitarix";
255 jackopt |= JackUseExactName;
266 if (!single_client) {
272 jack_status_t jackstat;
273 #ifdef HAVE_JACK_SESSION
276 client = jack_client_open(
277 client_name.c_str(), JackOptions(jackopt | JackSessionID),
280 if (ServerName.empty()) {
283 client = jack_client_open(
client_name.c_str(), JackOptions(jackopt | JackServerName),
284 &jackstat, ServerName.c_str());
288 if (ServerName.empty()) {
291 client = jack_client_open(
client_name.c_str(), JackOptions(jackopt | JackServerName),
292 &jackstat, ServerName.c_str());
296 if (
client && !single_client) {
300 std::string name = jack_get_client_name(
client);
301 std::string generated_suffix = name.substr(
client_name.size());
302 std::string base = name.substr(0,
client_name.size()-strlen(jack_amp_postfix));
303 client_instance = base + generated_suffix;
306 #ifdef HAVE_JACK_SESSION
310 JackOptions(jackopt | JackSessionID | JackUseExactName),
313 if (ServerName.empty()) {
316 JackOptions(jackopt | JackUseExactName ), &jackstat);
320 JackOptions(jackopt | JackUseExactName | JackServerName),
321 &jackstat, ServerName.c_str());
325 if (ServerName.empty()) {
328 JackOptions(jackopt | JackUseExactName), &jackstat);
332 JackOptions(jackopt | JackUseExactName | JackServerName),
333 &jackstat, ServerName.c_str());
337 jack_client_close(
client);
343 if (!(jackstat & JackServerFailed)) {
344 if ((jackstat & JackServerError) && (jackopt & JackUseExactName)) {
347 boost::format(_(
"can't get requested jack instance name '%1%'"))
352 _(
"unknown jack server communication error"));
361 if (wait_after_connect) {
362 usleep(wait_after_connect);
364 jack_sr = jack_get_sample_rate(
client);
367 boost::format(_(
"The jack sample rate is %1%/sec")) % jack_sr);
369 jack_bs = jack_get_buffer_size(
client);
370 if (!is_power_of_two(jack_bs)) {
373 boost::format(_(
"The jack buffer size is %1%/frames is not power of two, Convolver won't run"))
378 boost::format(_(
"The jack buffer size is %1%/frames ... "))
383 insert_buffer =
new float[jack_bs];
389 gx_jack_init_port_connection(opt);
392 if (jack_sr > 96000) {
395 _(
"Sample rates above 96kHz ain't be supported"));
401 void GxJack::cleanup_slot(
bool otherthread) {
413 jack_client_close(
client);
425 void GxJack::gx_jack_cleanup() {
437 if (!single_client) {
443 #if defined(USE_MIDI_OUT) || defined(USE_MIDI_CC_OUT)
446 if (!single_client) {
451 jack_client_close(
client);
455 delete[] insert_buffer;
456 insert_buffer = NULL;
466 if (!gx_jack_init(startserver, wait_after_connect, opt)) {
487 std::string GxJack::make_clientvar(
const std::string& s) {
488 std::size_t n = s.find(
':');
493 return "%A" + s.substr(n);
496 return "%F" + s.substr(n);
501 std::string GxJack::replace_clientvar(
const std::string& s) {
502 if (s.compare(0, 3,
"%A:") == 0) {
505 if (s.compare(0, 3,
"%F:") == 0) {
519 for (list<string>::iterator i = l.begin(); i != l.end(); ++i) {
530 for (list<string>::iterator i = l.begin(); i != l.end(); ++i) {
535 if (!single_client) {
539 for (list<string>::iterator i = l1.begin(); i != l1.end(); ++i) {
543 for (list<string>::iterator i = l2.begin(); i != l2.end(); ++i) {
563 for (list<string>::iterator i = l1.begin(); i != l1.end(); ++i) {
567 for (list<string>::iterator i = l2.begin(); i != l2.end(); ++i) {
585 #if defined(USE_MIDI_OUT) || defined(USE_MIDI_CC_OUT)
588 for (list<string>::iterator i = lmo.begin(); i != lmo.end(); ++i) {
593 if (!single_client) {
597 bool ifound =
false, ofound =
false;
598 for (list<string>::iterator i = lins_in.begin(); i != lins_in.end(); ++i) {
599 int rc = jack_connect(
client_insert, replace_clientvar(*i).c_str(),
601 if (rc == 0 || rc == EEXIST) {
606 for (list<string>::iterator i = lins_out.begin(); i != lins_out.end(); ++i) {
607 std::string port = replace_clientvar(*i);
608 if (!jack_port_connected_to(port_a, port.c_str())) {
611 if (rc == 0 || rc == EEXIST) {
618 if (!ifound || !ofound) {
631 void GxJack::gx_jack_callbacks() {
633 jack_set_xrun_callback(
client, gx_jack_xrun_callback,
this);
634 jack_set_sample_rate_callback(
client, gx_jack_srate_callback,
this);
635 jack_on_shutdown(
client, shutdown_callback_client,
this);
636 if (!single_client) {
637 jack_on_shutdown(
client_insert, shutdown_callback_client_insert,
this);
639 jack_set_buffer_size_callback(
client, gx_jack_buffersize_callback,
this);
640 jack_set_port_registration_callback(
client, gx_jack_portreg_callback,
this);
641 jack_set_port_connect_callback(
client, gx_jack_portconn_callback,
this);
642 #ifdef HAVE_JACK_SESSION
643 if (jack_set_session_callback_fp) {
644 jack_set_session_callback_fp(
client, gx_jack_session_callback,
this);
645 if (!single_client) jack_set_session_callback_fp(
client_insert, gx_jack_session_callback_ins,
this);
651 client,
"in_0", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
653 client,
"midi_in_1", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
654 if (!single_client) {
656 client,
"out_0", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
659 client,
"out_0", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
661 client,
"out_1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
663 #if defined(USE_MIDI_OUT) || defined(USE_MIDI_CC_OUT)
665 client,
"midi_out_1", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
670 if (!single_client) {
673 client_insert,
"in_0", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
675 client_insert,
"out_0", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
677 client_insert,
"out_1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
680 engine.
init(jack_sr, jack_bs, SCHED_FIFO,
681 jack_client_real_time_priority(
client));
682 jack_set_process_callback(
client, gx_jack_process,
this);
683 if (!single_client) jack_set_process_callback(
client_insert, gx_jack_insert_process,
this);
684 if (jack_activate(
client) != 0) {
686 _(
"Jack Activation"),
687 string(_(
"Can't activate JACK gx_amp client")));
689 if (!single_client) {
692 string(_(
"Can't activate JACK gx_amp_fx client")));
704 for(
int i = 0;i<5;i++) {
706 unsigned char* midi_send = jack_midi_event_reserve(buf, i, mmessage.
me_num[i]);
709 if (mmessage.
me_num[i] == 2) {
711 midi_send[1] = mmessage.
pg_num[i];
713 midi_send[0] = mmessage.
cc_num[i] | 0;
714 }
else if (mmessage.
me_num[i] == 3) {
715 midi_send[2] = mmessage.
bg_num[i];
717 midi_send[1] = mmessage.
pg_num[i];
719 midi_send[0] = mmessage.
cc_num[i] | 0;
734 jack_midi_clear_buffer(midi_port_buf);
736 return midi_port_buf;
739 static inline float *get_float_buf(jack_port_t *port, jack_nframes_t nframes) {
740 return static_cast<float *
>(jack_port_get_buffer(port, nframes));
743 inline void GxJack::check_overload() {
744 if (!rt_watchdog_check_alive(jack_bs, jack_sr)) {
751 int __rt_func GxJack::gx_jack_process(jack_nframes_t nframes,
void *arg) {
756 self.check_overload();
758 self.transport_state = jack_transport_query (
self.
client, &
self.
current);
760 float *obuf =
self.insert_buffer;
761 if (!
self.single_client) {
764 self.engine.mono_chain.process(
769 if (
self.bypass_insert && !
self.single_client) {
770 memcpy(
self.insert_buffer, obuf, nframes*
sizeof(
float));
775 self.engine.controller_map.compute_midi_in(
781 self.old_transport_state =
self.transport_state;
785 void *buf =
self.get_midi_buffer(nframes);
786 self.process_midi_cc(buf, nframes);
789 self.engine.mono_chain.post_rt_finished();
790 if (
self.single_client) {
791 self.gx_jack_insert_process(nframes, arg);
798 int __rt_func GxJack::gx_jack_insert_process(jack_nframes_t nframes,
void *arg) {
803 self.check_overload();
807 if (!
self.bypass_insert && !
self.single_client) {
810 ibuf =
self.insert_buffer;
812 self.engine.stereo_chain.process(
818 self.engine.stereo_chain.post_rt_finished();
828 : ring(jack_ringbuffer_create(20*sizeof(
PortConnData))),
835 _(
"Jack init"), _(
"can't get memory for ringbuffer"));
837 jack_ringbuffer_mlock(ring);
841 jack_ringbuffer_free(ring);
850 size_t sz = jack_ringbuffer_write(ring,
reinterpret_cast<const char*
>(&p),
sizeof(p));
851 if (sz !=
sizeof(p)) {
854 jack_ringbuffer_write_advance(ring, sz);
862 jack_ringbuffer_reset(ring);
867 size_t sz = jack_ringbuffer_read(ring,
reinterpret_cast<char*
>(p),
sizeof(*p));
871 assert(sz ==
sizeof(*p));
872 jack_ringbuffer_read_advance(ring, sz);
876 void GxJack::fetch_connection_data() {
889 bool fetched = connection_queue.
pop(&p);
894 connection_changed(p.name_a, p.name_b, p.connect);
901 void GxJack::gx_jack_portconn_callback(jack_port_id_t a, jack_port_id_t b,
int connect,
void* arg) {
906 jack_port_t* port_a = jack_port_by_id(
self.
client, a);
907 jack_port_t* port_b = jack_port_by_id(
self.
client, b);
908 if (!port_a || !port_b) {
911 self.connection_queue.push(jack_port_name(port_a), jack_port_name(port_b), connect);
920 for(
int i = 0;i<5;i++) {
925 mmessage.
bg_num[i] = _bgn;
926 mmessage.
me_num[i] = _num;
935 void GxJack::gx_jack_portreg_callback(jack_port_id_t pid,
int reg,
void* arg) {
940 jack_port_t* port = jack_port_by_id(
self.
client, pid);
941 if (!port || jack_port_is_mine(
self.
client, port)) {
944 self.connection_queue.portchange();
950 int GxJack::gx_jack_srate_callback(jack_nframes_t samplerate,
void* arg) {
952 if (
self.jack_sr == samplerate) {
956 self.jack_sr = samplerate;
957 self.engine.set_samplerate(samplerate);
964 int GxJack::gx_jack_buffersize_callback(jack_nframes_t nframes,
void* arg) {
966 if (
self.jack_bs == nframes) {
970 self.jack_bs = nframes;
971 self.engine.set_buffersize(nframes);
973 self.buffersize_change();
975 delete[]
self.insert_buffer;
976 self.insert_buffer = NULL;
977 self.insert_buffer =
new float[
self.jack_bs];
982 void GxJack::gx_jack_shutdown_callback() {
988 void GxJack::shutdown_callback_client(
void *arg) {
992 self.client_change_rt();
994 if (!
self.single_client) {
997 self.client_insert = 0;
1000 self.gx_jack_shutdown_callback();
1003 void GxJack::shutdown_callback_client_insert(
void *arg) {
1005 self.client_insert = 0;
1007 jack_client_close(
self.
client);
1009 self.client_change_rt();
1011 self.gx_jack_shutdown_callback();
1014 void GxJack::report_xrun_clear() {
1015 xrun_msg_blocked =
false;
1018 void GxJack::report_xrun() {
1019 if (xrun_msg_blocked) {
1022 xrun_msg_blocked =
true;
1023 Glib::signal_timeout().connect_once(
1024 sigc::mem_fun(
this, &GxJack::report_xrun_clear), 100);
1027 (boost::format(_(
" delay of at least %1% microsecs")) % last_xrun).str());
1031 int GxJack::gx_jack_xrun_callback(
void* arg) {
1036 self.last_xrun = jack_get_xrun_delayed_usecs(
self.
client);
1048 #ifdef HAVE_JACK_SESSION
1049 jack_set_session_callback_type GxJack::jack_set_session_callback_fp =
1050 reinterpret_cast<jack_set_session_callback_type
>(
1051 dlsym(RTLD_DEFAULT,
"jack_set_session_callback"));
1052 jack_get_uuid_for_client_name_type GxJack::jack_get_uuid_for_client_name_fp =
1053 reinterpret_cast<jack_get_uuid_for_client_name_type
>(
1054 dlsym(RTLD_DEFAULT,
"jack_get_uuid_for_client_name"));
1055 jack_client_get_uuid_type GxJack::jack_client_get_uuid_fp =
1056 reinterpret_cast<jack_client_get_uuid_type
>(
1057 dlsym(RTLD_DEFAULT,
"jack_client_get_uuid"));
1059 int GxJack::return_last_session_event() {
1060 jack_session_event_t *
event = get_last_session_event();
1062 session_callback_seen += 1;
1063 jack_session_reply(
client, event);
1064 jack_session_event_free(event);
1067 return session_callback_seen;
1070 int GxJack::return_last_session_event_ins() {
1071 jack_session_event_t *
event = get_last_session_event_ins();
1073 session_callback_seen -= 1;
1075 jack_session_event_free(event);
1078 return session_callback_seen;
1081 string GxJack::get_uuid_insert() {
1084 if (jack_client_get_uuid_fp) {
1086 }
else if (jack_get_uuid_for_client_name_fp) {
1087 uuid = jack_get_uuid_for_client_name_fp(
1099 void GxJack::gx_jack_session_callback(jack_session_event_t *event,
void *arg) {
1101 jack_session_event_t *np = 0;
1109 void GxJack::gx_jack_session_callback_ins(jack_session_event_t *event,
void *arg) {
1111 jack_session_event_t *np = 0;