From e040bf80ae9702725c73e4eedfc8ce8c8c38e0da Mon Sep 17 00:00:00 2001 From: sletz Date: Fri, 19 Jun 2009 11:09:10 +0000 Subject: [PATCH] rebase from trunk 3550:3563 git-svn-id: http://subversion.jackaudio.org/jack/jack2/branches/libjacknet@3564 0c269be4-1314-0410-8aa9-9f06e86f4224 --- ChangeLog | 50 ++++--- common/JackAPI.cpp | 6 +- common/JackEngine.cpp | 29 ++-- common/JackError.cpp | 10 +- common/JackError.h | 10 +- common/JackGraphManager.cpp | 4 +- common/JackGraphManager.h | 2 +- common/JackTransportEngine.cpp | 1 + common/JackWeakAPI.cpp | 168 ++++++++++++++++++++++++ common/Jackdmp.cpp | 13 +- common/jack/jack.h | 5 + common/jack/thread.h | 10 +- common/wscript | 3 - dbus/controller_iface_patchbay.c | 4 +- linux/wscript | 26 ++-- posix/JackFifo.cpp | 12 +- windows/JackWinNamedPipeServerChannel.h | 2 + wscript | 22 ++-- 18 files changed, 294 insertions(+), 83 deletions(-) create mode 100644 common/JackWeakAPI.cpp diff --git a/ChangeLog b/ChangeLog index ff7e9a47..f7cd2b5d 100644 --- a/ChangeLog +++ b/ChangeLog @@ -23,42 +23,58 @@ Paul Davis --------------------------- Jackdmp changes log ---------------------------- - +--------------------------- + +2009-06-19 Stephane Letz + + * Correct JackTransportEngine::MakeAllLocating, sync callback has to be called in this case also. + +2009-06-17 Stephane Letz + + * Move DBus based audio device reservation code in ALSA backend compilation. + +2009-06-16 Stephane Letz + + * Correct JackFifo::TimedWait for EINTR handling. + +2009-06-05 Stephane Letz + + * Correct jack_set_error_function, jack_set_info_function and jack_set_thread_creator functions. + 2009-05-18 Stephane Letz - * Correct wcsript files to create jackdbus only (and not create jackd anymore) when compiled in --dbus mode, add a --classic option. Both options are possible but issue a warning. - + * Correct wcsript files to create jackdbus only (and not create jackd anymore) when compiled in --dbus mode, add a --classic option. Both options are possible but issue a warning. + 2009-05-15 Stephane Letz - * Move InitFrameTime in JackDriver::Start method. - + * Move InitFrameTime in JackDriver::Start method. + 2009-05-13 Stephane Letz - * Reworked Torben Hohn fix for server restart issue on Windows. - + * Reworked Torben Hohn fix for server restart issue on Windows. + 2009-05-11 Stephane Letz - * New jack_free function added in jack.h. - * Torben Hohn fix for InitTime and GetMicroSeconds in JackWinTime.c. - + * New jack_free function added in jack.h. + * Torben Hohn fix for InitTime and GetMicroSeconds in JackWinTime.c. + 2009-05-07 Stephane Letz - * Cleanup "loopback" stuff in server. - + * Cleanup "loopback" stuff in server. + 2009-05-06 Stephane Letz - * Fix transport callback (timebase master, sync) issue when used after jack_activate (RT thread was not running). + * Fix transport callback (timebase master, sync) issue when used after jack_activate (RT thread was not running). * D-Bus access for jackctl_server_add_slave/jackctl_server_remove_slave API. - + 2009-05-05 Stephane Letz * First working version of native MIDI backend (JackCoreMidiDriver, JackWinMMEDriver). - + 2009-04-22 Stephane Letz * jackctl_server_load_master renamed to jackctl_server_switch_master, jackctl_server_unload_master is removed. - + 2009-04-21 Stephane Letz * Add jackctl_server_load_master/jackctl_server_unload_master API. diff --git a/common/JackAPI.cpp b/common/JackAPI.cpp index 3312c9f1..4eadc797 100644 --- a/common/JackAPI.cpp +++ b/common/JackAPI.cpp @@ -278,12 +278,12 @@ static inline void WaitGraphChange() EXPORT void jack_set_error_function (print_function func) { - jack_error_callback = func; + jack_error_callback = (func == NULL) ? &default_jack_error_callback : func; } EXPORT void jack_set_info_function (print_function func) { - jack_info_callback = func; + jack_info_callback = (func == NULL) ? &default_jack_info_callback : func; } EXPORT jack_client_t* jack_client_new(const char* client_name) @@ -1799,7 +1799,7 @@ EXPORT int jack_client_kill_thread(jack_client_t* client, pthread_t thread) #ifndef WIN32 EXPORT void jack_set_thread_creator (jack_thread_creator_t jtc) { - JackGlobals::fJackThreadCreator = jtc; + JackGlobals::fJackThreadCreator = (jtc == NULL) ? pthread_create : jtc; } #endif diff --git a/common/JackEngine.cpp b/common/JackEngine.cpp index 7e94e42f..20b8f16b 100644 --- a/common/JackEngine.cpp +++ b/common/JackEngine.cpp @@ -739,9 +739,10 @@ int JackEngine::PortUnRegister(int refnum, jack_port_id_t port_index) int JackEngine::PortConnect(int refnum, const char* src, const char* dst) { jack_log("JackEngine::PortConnect src = %s dst = %s", src, dst); + AssertRefnum(refnum); jack_port_id_t port_src, port_dst; - return (fGraphManager->CheckPorts(src, dst, &port_src, &port_dst) < 0) + return (fGraphManager->GetTwoPorts(src, dst, &port_src, &port_dst) < 0) ? -1 : PortConnect(refnum, port_src, port_dst); } @@ -788,14 +789,9 @@ int JackEngine::PortDisconnect(int refnum, const char* src, const char* dst) AssertRefnum(refnum); jack_port_id_t port_src, port_dst; - if (fGraphManager->CheckPorts(src, dst, &port_src, &port_dst) < 0) { - return -1; - } else if (fGraphManager->Disconnect(port_src, port_dst) == 0) { - NotifyPortConnect(port_src, port_dst, false); - return 0; - } else { - return -1; - } + return (fGraphManager->GetTwoPorts(src, dst, &port_src, &port_dst) < 0) + ? -1 + : PortDisconnect(refnum, port_src, port_dst); } int JackEngine::PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst) @@ -808,21 +804,23 @@ int JackEngine::PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t ds jack_int_t connections[CONNECTION_NUM_FOR_PORT]; fGraphManager->GetConnections(src, connections); - // Notifications JackPort* port = fGraphManager->GetPort(src); + int ret = 0; if (port->GetFlags() & JackPortIsOutput) { for (int i = 0; (i < CONNECTION_NUM_FOR_PORT) && (connections[i] != EMPTY); i++) { - jack_log("NotifyPortConnect src = %ld dst = %ld false", src, connections[i]); - NotifyPortConnect(src, connections[i], false); + if (PortDisconnect(refnum, src, connections[i]) != 0) { + ret = -1; + } } } else { for (int i = 0; (i < CONNECTION_NUM_FOR_PORT) && (connections[i] != EMPTY); i++) { - jack_log("NotifyPortConnect src = %ld dst = %ld false", connections[i], src); - NotifyPortConnect(connections[i], src, false); + if (PortDisconnect(refnum, connections[i], src) != 0) { + ret = -1; + } } } - return fGraphManager->DisconnectAll(src); + return ret; } else if (fGraphManager->CheckPorts(src, dst) < 0) { return -1; } else if (fGraphManager->Disconnect(src, dst) == 0) { @@ -836,6 +834,7 @@ int JackEngine::PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t ds int JackEngine::PortRename(int refnum, jack_port_id_t port, const char* name) { + AssertRefnum(refnum); fGraphManager->GetPort(port)->SetName(name); NotifyPortRename(port); return 0; diff --git a/common/JackError.cpp b/common/JackError.cpp index 1ed928c0..aad72327 100644 --- a/common/JackError.cpp +++ b/common/JackError.cpp @@ -118,17 +118,23 @@ SERVER_EXPORT void jack_log(const char *fmt,...) } } -static void default_jack_error_callback(const char *desc) +SERVER_EXPORT void default_jack_error_callback(const char *desc) { fprintf(stderr, "%s\n", desc); fflush(stderr); } -static void default_jack_info_callback (const char *desc) +SERVER_EXPORT void default_jack_info_callback(const char *desc) { fprintf(stdout, "%s\n", desc); fflush(stdout); } +SERVER_EXPORT void silent_jack_error_callback(const char *desc) +{} + +SERVER_EXPORT void silent_jack_info_callback(const char *desc) +{} + SERVER_EXPORT void (*jack_error_callback)(const char *desc) = &default_jack_error_callback; SERVER_EXPORT void (*jack_info_callback)(const char *desc) = &default_jack_info_callback; diff --git a/common/JackError.h b/common/JackError.h index 62ad1b92..fca6ec30 100644 --- a/common/JackError.h +++ b/common/JackError.h @@ -45,6 +45,12 @@ extern "C" SERVER_EXPORT extern void (*jack_error_callback)(const char *desc); SERVER_EXPORT extern void (*jack_info_callback)(const char *desc); + + SERVER_EXPORT extern void default_jack_error_callback(const char *desc); + SERVER_EXPORT extern void default_jack_info_callback(const char *desc); + + SERVER_EXPORT extern void silent_jack_error_callback(const char *desc); + SERVER_EXPORT extern void silent_jack_info_callback(const char *desc); typedef void (* jack_log_function_t)(int level, const char *message); @@ -52,8 +58,8 @@ extern "C" void jack_log_function(int level, const char *message); SERVER_EXPORT void set_threaded_log_function(); - - extern int jack_verbose; + + extern int jack_verbose; #ifdef __cplusplus } diff --git a/common/JackGraphManager.cpp b/common/JackGraphManager.cpp index ae5f3351..f6aae030 100644 --- a/common/JackGraphManager.cpp +++ b/common/JackGraphManager.cpp @@ -627,7 +627,7 @@ int JackGraphManager::CheckPorts(jack_port_id_t port_src, jack_port_id_t port_ds return 0; } -int JackGraphManager::CheckPorts(const char* src_name, const char* dst_name, jack_port_id_t* port_src, jack_port_id_t* port_dst) +int JackGraphManager::GetTwoPorts(const char* src_name, const char* dst_name, jack_port_id_t* port_src, jack_port_id_t* port_dst) { jack_log("JackGraphManager::CheckConnect src_name = %s dst_name = %s", src_name, dst_name); @@ -641,7 +641,7 @@ int JackGraphManager::CheckPorts(const char* src_name, const char* dst_name, jac return -1; } - return CheckPorts(*port_src, *port_dst); + return 0; } // Client : port array diff --git a/common/JackGraphManager.h b/common/JackGraphManager.h index 575e3752..0fdd3c82 100644 --- a/common/JackGraphManager.h +++ b/common/JackGraphManager.h @@ -91,7 +91,7 @@ class SERVER_EXPORT JackGraphManager : public JackShmMem, public JackAtomicState void GetConnections(jack_port_id_t port_index, jack_int_t* connections); // TODO const char** GetPorts(const char* port_name_pattern, const char* type_name_pattern, unsigned long flags); - int CheckPorts(const char* src, const char* dst, jack_port_id_t* src_index, jack_port_id_t* dst_index); + int GetTwoPorts(const char* src, const char* dst, jack_port_id_t* src_index, jack_port_id_t* dst_index); int CheckPorts(jack_port_id_t port_src, jack_port_id_t port_dst); void DisconnectAllInput(jack_port_id_t port_index); diff --git a/common/JackTransportEngine.cpp b/common/JackTransportEngine.cpp index 40671af0..418d1180 100644 --- a/common/JackTransportEngine.cpp +++ b/common/JackTransportEngine.cpp @@ -141,6 +141,7 @@ void JackTransportEngine::MakeAllLocating(JackClientInterface** table) if (client) { JackClientControl* control = client->GetClientControl(); control->fTransportState = JackTransportStopped; + control->fTransportSync = true; control->fTransportTimebase = true; jack_log("MakeAllLocating ref = %ld", i); } diff --git a/common/JackWeakAPI.cpp b/common/JackWeakAPI.cpp new file mode 100644 index 00000000..2715922b --- /dev/null +++ b/common/JackWeakAPI.cpp @@ -0,0 +1,168 @@ +/* +Copyright (C) 2009 Grame + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +*/ + +/* + Completed from Julien Pommier (PianoTeq : http://www.pianoteq.com/) code. +*/ + +#include "jack.h" +#include +#include +#include +#include +#include + +/* dynamically load libjack and forward all registered calls to libjack + (similar to what relaytool is trying to do, but more portably..) +*/ + +using std::cerr; + +int libjack_is_present = 0; // public symbol, similar to what relaytool does. +static void *libjack_handle = 0; + +static void __attribute__((constructor)) tryload_libjack() +{ + if (getenv("SKIP_LIBJACK") == 0) { // just in case libjack is causing troubles.. + libjack_handle = dlopen("libjack.so.0", RTLD_LAZY); + } + libjack_is_present = (libjack_handle != 0); +} + +void *load_jack_function(const char *fn_name) +{ + void *fn = 0; + if (!libjack_handle) { + std::cerr << "libjack not found, so do not try to load " << fn_name << " ffs !\n"; + return 0; + } + fn = dlsym(libjack_handle, fn_name); + if (!fn) { + std::cerr << "could not dlsym(" << libjack_handle << "), " << dlerror() << "\n"; + } + return fn; +} + +#define DECL_FUNCTION(return_type, fn_name, arguments_types, arguments) \ + typedef return_type (*fn_name##_ptr_t)arguments_types; \ + return_type fn_name arguments_types { \ + static fn_name##_ptr_t fn = 0; \ + if (fn == 0) { fn = (fn_name##_ptr_t)load_jack_function(#fn_name); } \ + if (fn) return (*fn)arguments; \ + else return 0; \ + } + +#define DECL_VOID_FUNCTION(fn_name, arguments_types, arguments) \ + typedef void (*fn_name##_ptr_t)arguments_types; \ + void fn_name arguments_types { \ + static fn_name##_ptr_t fn = 0; \ + if (fn == 0) { fn = (fn_name##_ptr_t)load_jack_function(#fn_name); } \ + if (fn) (*fn)arguments; \ + } + +DECL_VOID_FUNCTION(jack_get_version, (int *major_ptr, int *minor_ptr, int *micro_ptr, int *proto_ptr), (major_ptr, minor_ptr, micro_ptr, proto_ptr)); +DECL_FUNCTION(const char *, jack_get_version_string, (), ()); +DECL_FUNCTION(jack_client_t *, jack_client_open, (const char *client_name, jack_options_t options, jack_status_t *status, ...), + (client_name, options, status)); +DECL_FUNCTION(int, jack_client_close, (jack_client_t *client), (client)); +DECL_FUNCTION(int, jack_client_new, (const char *client_name), (client_name)); +DECL_FUNCTION(int, jack_client_name_size, (), ()); +DECL_FUNCTION(char*, jack_get_client_name, (jack_client_t *client), (client)); +DECL_FUNCTION(int, jack_internal_client_new, (const char *client_name, + const char *load_name, + const char *load_init), (client_name, load_name, load_init)); +DECL_VOID_FUNCTION(jack_internal_client_close, (const char *client_name), (client_name)); +DECL_FUNCTION(int, jack_is_realtime, (jack_client_t *client), (client)); +DECL_VOID_FUNCTION(jack_on_shutdown, (jack_client_t *client, JackShutdownCallback shutdown_callback, void *arg), (client, function, arg)); +DECL_FUNCTION(int, jack_set_process_callback, (jack_client_t *client, + JackProcessCallback process_callback, + void *arg), (client, process_callback, arg)); +DECL_FUNCTION(jack_nframes_t, jack_thread_wait, (jack_client_t *client, int status), (client, status)); + +// +DECL_FUNCTION(jack_nframes_t, jack_cycle_wait, (jack_client_t *client), (client)); +DECL_VOID_FUNCTION(jack_cycle_signal, (jack_client_t *client, , int status), (client, status)); +DECL_FUNCTION(int, jack_set_process_thread, (jack_client_t *client, + JackThreadCallback fun, + void *arg), (client, fun, arg)); +DECL_FUNCTION(int, jack_set_thread_init_callback, (jack_client_t *client, + JackThreadInitCallback thread_init_callback, + void *arg), (client, thread_init_callback, arg)); +DECL_FUNCTION(int, jack_set_freewheel_callback, (jack_client_t *client, + JackFreewheelCallback freewheel_callback, + void *arg), (client, freewheel_callback, arg)); +DECL_FUNCTION(int, jack_set_freewheel, (jack_client_t *client, int onoff), (client, onoff)); +DECL_FUNCTION(int, jack_set_buffer_size, (jack_client_t *client, jack_nframes_t nframes), (client, nframes)); +DECL_FUNCTION(int, jack_set_buffer_size_callback, (jack_client_t *client, + JackBufferSizeCallback bufsize_callback, + void *arg), (client, bufsize_callback, arg)); +DECL_FUNCTION(int, jack_set_sample_rate_callback, (jack_client_t *client, + JackSampleRateCallback srate_callback, + void *arg), (client, srate_callback, arg)); +DECL_FUNCTION(int, jack_set_client_registration_callback, (jack_client_t *client, + JackClientRegistrationCallback registration_callback, + void *arg), (client, registration_callback, arg)); +DECL_FUNCTION(int, jack_set_port_registration_callback, (jack_client_t *client, + JackPortRegistrationCallback registration_callback, + void *arg), (client, registration_callback, arg)); +DECL_FUNCTION(int, jack_set_port_connect_callback, (jack_client_t *client, + JackPortConnectCallback connect_callback, + void *arg), (client, connect_callback, arg)); +DECL_FUNCTION(int, jack_set_port_rename_callback, (jack_client_t *client, + JackPortRenameCallback rename_callback, + void *arg), (client, rename_callback, arg)); +DECL_FUNCTION(int, jack_set_graph_order_callback, (jack_client_t *client, + JackGraphOrderCallback graph_callback, + void *arg), (client, graph_callback, arg)); +DECL_FUNCTION(int, jack_set_xrun_callback, (jack_client_t *client, + JackXRunCallback xrun_callback, + void *arg), (client, xrun_callback, arg)); +DECL_FUNCTION(int, jack_activate, (jack_client_t *client), (client)); +DECL_FUNCTION(int, jack_deactivate, (jack_client_t *client), (client)); +DECL_FUNCTION(jack_port_t *, jack_port_register, (jack_client_t *client, const char *port_name, const char *port_type, + unsigned long flags, unsigned long buffer_size), + (client, port_name, port_type, flags, buffer_size)); +DECL_FUNCTION(int, jack_port_unregister, (jack_client_t *client, jack_port_t* port), (client, port)); +DECL_FUNCTION(void *, jack_port_get_buffer, (jack_port_t *port, jack_nframes_t nframes), (port, nframes)); +DECL_FUNCTION(const char*, jack_port_name, (const jack_port_t *port), (port)); +DECL_FUNCTION(const char*, jack_port_short_name, (const jack_port_t *port), (port)); +DECL_FUNCTION(int, jack_port_flags, (const jack_port_t *port), (port)); +DECL_FUNCTION(const char*, jack_port_type, (const jack_port_t *port), (port)); +DECL_FUNCTION(jack_port_type_id_t, jack_port_type_id, (const jack_port_t *port), (port)); +DECL_FUNCTION(int, jack_port_is_mine, (const jack_client_t *client, const jack_port_t* port), (client, port)); +DECL_FUNCTION(int, jack_port_connected, (const jack_port_t *port), (port)); +DECL_FUNCTION(int, jack_port_connected_to, (const jack_port_t *port, const char *port_name), (port, port_name)); +DECL_FUNCTION(const char**, jack_port_get_connections, (const jack_port_t *port), (port)); +DECL_FUNCTION(const char**, jack_port_get_all_connections, (const jack_port_t *port), (port)); +DECL_FUNCTION(int, jack_port_tie, (jack_port_t *src, jack_port_t *dst), (src, dst)); +DECL_FUNCTION(int, jack_port_untie, (jack_port_t *port), (port)); + + +DECL_FUNCTION(jack_nframes_t, jack_get_buffer_size, (jack_client_t *client), (client)); +DECL_FUNCTION(jack_nframes_t, jack_get_sample_rate, (jack_client_t *client), (client)); +DECL_FUNCTION(jack_nframes_t, jack_port_get_total_latency, (jack_client_t *client, jack_port_t *port), (client, port)); +DECL_VOID_FUNCTION(jack_set_error_function, (void (*func)(const char *)), (func)); + + +DECL_FUNCTION(const char**, jack_get_ports, (jack_client_t *client, const char *port_name_pattern, const char * type_name_pattern, + unsigned long flags), (client, port_name_pattern, type_name_pattern, flags)); +DECL_FUNCTION(int, jack_connect, (jack_client_t *client, const char *source_port, const char *destination_port), (client, source_port, destination_port)); +DECL_FUNCTION(int, jack_set_port_connect_callback, (jack_client_t *client, JackPortConnectCallback connect_callback, void *arg), + (client, connect_callback, arg)); +DECL_FUNCTION(jack_port_t *, jack_port_by_id, (jack_client_t *client, jack_port_id_t port_id), (client, port_id)); diff --git a/common/Jackdmp.cpp b/common/Jackdmp.cpp index bd6a1230..e2bf6b8f 100644 --- a/common/Jackdmp.cpp +++ b/common/Jackdmp.cpp @@ -76,9 +76,6 @@ static void notify_server_stop(const char* server_name) #endif -static void silent_jack_error_callback(const char *desc) -{} - static void copyright(FILE* file) { fprintf(file, "jackdmp " VERSION "\n" @@ -208,7 +205,7 @@ int main(int argc, char* argv[]) jackctl_parameter_t* param; union jackctl_parameter_value value; - copyright(stdout); + copyright(stdout); server_ctl = jackctl_server_create(); if (server_ctl == NULL) { @@ -359,10 +356,10 @@ int main(int argc, char* argv[]) if (show_version) { printf( "jackdmp version " VERSION - " tmpdir " jack_server_dir - " protocol %d" - "\n", JACK_PROTOCOL_VERSION); - return -1; + " tmpdir " jack_server_dir + " protocol %d" + "\n", JACK_PROTOCOL_VERSION); + return -1; } if (!seen_audio_driver) { diff --git a/common/jack/jack.h b/common/jack/jack.h index f9d8d4e0..2a31cbaf 100644 --- a/common/jack/jack.h +++ b/common/jack/jack.h @@ -1047,6 +1047,7 @@ extern void (*jack_error_callback)(const char *msg); /** * Set the @ref jack_error_callback for error message display. + * Set it to NULL to restore default_jack_error_callback function. * * The JACK library provides two built-in callbacks for this purpose: * default_jack_error_callback() and silent_jack_error_callback(). @@ -1065,6 +1066,10 @@ extern void (*jack_info_callback)(const char *msg); /** * Set the @ref jack_info_callback for info message display. + * Set it to NULL to restore default_jack_info_callback function. + * + * The JACK library provides two built-in callbacks for this purpose: + * default_jack_info_callback() and silent_jack_info_callback(). */ void jack_set_info_function (void (*func)(const char *)); diff --git a/common/jack/thread.h b/common/jack/thread.h index c09c6ca2..48adf084 100644 --- a/common/jack/thread.h +++ b/common/jack/thread.h @@ -116,8 +116,8 @@ int jack_client_stop_thread(jack_client_t* client, pthread_t thread); * @returns 0, if successful; otherwise an error number. */ int jack_client_kill_thread(jack_client_t* client, pthread_t thread); - -#ifndef WIN32 + +#ifndef WIN32 typedef int (*jack_thread_creator_t)(pthread_t*, const pthread_attr_t*, @@ -137,11 +137,13 @@ int jack_client_stop_thread(jack_client_t* client, pthread_t thread); * that all threads that might call win32 functions are known * to Wine. * + * Set it to NULL to restore thread creation function. + * * @param creator a function that creates a new thread * */ -void jack_set_thread_creator (jack_thread_creator_t creator); - +void jack_set_thread_creator (jack_thread_creator_t creator); + #endif /* @} */ diff --git a/common/wscript b/common/wscript index ab59d7fa..2c7aa609 100644 --- a/common/wscript +++ b/common/wscript @@ -141,9 +141,6 @@ def build(bld): '../posix/JackSocketServerNotifyChannel.cpp', '../posix/JackNetUnixSocket.cpp', ] - - if bld.env['IS_LINUX'] and bld.env['BUILD_JACKDBUS']: - serverlib.source += ['../dbus/reserve.c', '../dbus/audio_reserve.c'] if bld.env['IS_SUN']: serverlib.source += [ diff --git a/dbus/controller_iface_patchbay.c b/dbus/controller_iface_patchbay.c index 6c9763a7..e89c7b3b 100644 --- a/dbus/controller_iface_patchbay.c +++ b/dbus/controller_iface_patchbay.c @@ -1352,14 +1352,14 @@ jack_controller_dbus_disconnect_ports_by_id( if (port1_ptr == NULL) { jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port1_id); - return; + goto unlock; } port2_ptr = jack_controller_patchbay_find_port_by_id(patchbay_ptr, port2_id); if (port2_ptr == NULL) { jack_dbus_error(call, JACK_DBUS_ERROR_INVALID_ARGS, "cannot find port %" PRIu64, port2_id); - return; + goto unlock; } if (!jack_controller_patchbay_disconnect( diff --git a/linux/wscript b/linux/wscript index b9383b16..966a8ddf 100644 --- a/linux/wscript +++ b/linux/wscript @@ -36,18 +36,24 @@ def build(bld): jackd.target = 'jackd' create_jack_driver_obj(bld, 'dummy', '../common/JackDummyDriver.cpp') + + alsa_driver_src = ['alsa/JackAlsaDriver.cpp', + 'alsa/alsa_rawmidi.c', + 'alsa/alsa_seqmidi.c', + 'alsa/alsa_midi_jackmp.cpp', + '../common/memops.c', + 'alsa/generic_hw.c', + 'alsa/hdsp.c', + 'alsa/hammerfall.c', + 'alsa/ice1712.c' + ] + + if bld.env['BUILD_JACKDBUS']: + alsa_driver_src += ['../dbus/reserve.c', '../dbus/audio_reserve.c'] + if bld.env['BUILD_DRIVER_ALSA'] == True: - create_jack_driver_obj(bld, 'alsa', ['alsa/JackAlsaDriver.cpp', - 'alsa/alsa_rawmidi.c', - 'alsa/alsa_seqmidi.c', - 'alsa/alsa_midi_jackmp.cpp', - '../common/memops.c', - 'alsa/generic_hw.c', - 'alsa/hdsp.c', - 'alsa/hammerfall.c', - 'alsa/ice1712.c' - ], "ALSA") + create_jack_driver_obj(bld, 'alsa', alsa_driver_src, "ALSA") if bld.env['BUILD_DRIVER_FREEBOB'] == True: create_jack_driver_obj(bld, 'freebob', 'freebob/JackFreebobDriver.cpp', "LIBFREEBOB") diff --git a/posix/JackFifo.cpp b/posix/JackFifo.cpp index 8f927dea..1cd3e5d3 100644 --- a/posix/JackFifo.cpp +++ b/posix/JackFifo.cpp @@ -101,12 +101,16 @@ bool JackFifo::TimedWait(long usec) // Does not work on OSX ?? bool JackFifo::TimedWait(long usec) { - assert(fFifo >= 0); - - if ((poll(&fPoll, 1, usec / 1000) < 0) && (errno != EINTR)) { - jack_error("JackFifo::TimedWait name = %s err = %s", fName, strerror(errno)); + int res; + + if (fFifo < 0) { + jack_error("JackFifo::TimedWait name = %s already desallocated!!", fName); return false; } + + do { + res = poll(&fPoll, 1, usec / 1000); + } while (res < 0 && errno == EINTR); if (fPoll.revents & POLLIN) { return Wait(); diff --git a/windows/JackWinNamedPipeServerChannel.h b/windows/JackWinNamedPipeServerChannel.h index adb6941b..4026b541 100644 --- a/windows/JackWinNamedPipeServerChannel.h +++ b/windows/JackWinNamedPipeServerChannel.h @@ -27,6 +27,8 @@ Copyright (C) 2004-2006 Grame namespace Jack { +class JackServer; + class JackClientPipeThread : public JackRunnableInterface { diff --git a/wscript b/wscript index 68139cdf..c0499682 100644 --- a/wscript +++ b/wscript @@ -61,15 +61,13 @@ def set_options(opt): opt.tool_options('compiler_cc') opt.add_option('--libdir', type='string', help="Library directory [Default: /lib]") - opt.add_option('--classic', action='store_true', default=False, help='Enable standard JACK (jackd)') opt.add_option('--dbus', action='store_true', default=False, help='Enable D-Bus JACK (jackdbus)') + opt.add_option('--classic', action='store_true', default=False, help='Force enable standard JACK (jackd) even if D-Bus JACK (jackdbus) is enabled too') opt.add_option('--doxygen', action='store_true', default=False, help='Enable build of doxygen documentation') opt.add_option('--profile', action='store_true', default=False, help='Build with engine profiling') opt.add_option('--mixed', action='store_true', default=False, help='Build with 32/64 bits mixed mode') opt.add_option('--clients', default=64, type="int", dest="clients", help='Maximum number of JACK clients') opt.add_option('--ports', default=1024, type="int", dest="ports", help='Maximum number of ports') - opt.add_option('--clients', default=64, type="int", dest="clients", help='Maximum number of JACK clients') - opt.add_option('--ports', default=1024, type="int", dest="ports", help='Maximum number of ports') opt.sub_options('dbus') def configure(conf): @@ -124,7 +122,12 @@ def configure(conf): conf.env['BUILD_WITH_PROFILE'] = Options.options.profile conf.env['BUILD_WITH_32_64'] = Options.options.mixed conf.env['BUILD_JACKDBUS'] = Options.options.dbus - conf.env['BUILD_JACKD'] = Options.options.classic + conf.env['BUILD_CLASSIC'] = Options.options.classic + + if conf.env['BUILD_JACKDBUS']: + conf.env['BUILD_JACKD'] = conf.env['BUILD_CLASSIC'] + else: + conf.env['BUILD_JACKD'] = True if Options.options.libdir: conf.env['LIBDIR'] = Options.options.libdir @@ -171,13 +174,12 @@ def configure(conf): display_feature('Build doxygen documentation', conf.env['BUILD_DOXYGEN_DOCS']) display_feature('Build with engine profiling', conf.env['BUILD_WITH_PROFILE']) display_feature('Build with 32/64 bits mixed mode', conf.env['BUILD_WITH_32_64']) + + display_feature('Build standard JACK (jackd)', conf.env['BUILD_JACKD']) + display_feature('Build D-Bus JACK (jackdbus)', conf.env['BUILD_JACKDBUS']) + if conf.env['BUILD_JACKDBUS'] and conf.env['BUILD_JACKD']: - display_feature('Build standard (jackd) and D-Bus JACK (jackdbus) : WARNING !! mixing both program may cause issues...', True) - elif conf.env['BUILD_JACKDBUS']: - display_feature('Build D-Bus JACK (jackdbus)', True) - else: - conf.env['BUILD_JACKD'] = True; # jackd is always built be default - display_feature('Build standard JACK (jackd)', True) + print Logs.colors.RED + 'WARNING !! mixing both jackd and jackdbus may cause issues!' + Logs.colors.NORMAL if conf.env['IS_LINUX']: display_feature('Build with ALSA support', conf.env['BUILD_DRIVER_ALSA'] == True)