1 //=============================================================================
3 // jackWeakAPI partly based on Julien Pommier (PianoTeq : http://www.pianoteq.com/) code.
5 // Copyright (C) 2002-2007 Werner Schweer and others
6 // Copyright (C) 2009 Grame
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU Lesser General Public License as published by
10 // the Free Software Foundation; either version 2.1 of the License, or
11 // (at your option) any later version.
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU Lesser General Public License for more details.
18 // You should have received a copy of the GNU Lesser General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 #include <jack/jack.h>
23 #include <jack/session.h>
24 #include <jack/thread.h>
25 #include <jack/midiport.h>
33 /* dynamically load libjack and forward all registered calls to libjack
34 (similar to what relaytool is trying to do, but more portably..)
37 typedef void (*print_function
)(const char *);
38 typedef void *(*thread_routine
)(void*);
40 static int libjack_is_present
= 0; // public symbol, similar to what relaytool does.
43 static HMODULE libjack_handle
= 0;
45 static void *libjack_handle
= 0;
48 static void __attribute__((constructor
)) tryload_libjack()
50 void tryload_libjack()
53 if (getenv("SKIP_LIBJACK") == 0) { // just in case libjack is causing troubles..
55 libjack_handle
= dlopen("libjack.0.dylib", RTLD_LAZY
);
56 if (!libjack_handle
) {
57 fprintf(stderr
, "dlopen error : %s \n", dlerror());
59 libjack_handle
= dlopen("/usr/local/lib/libjack.0.dylib", RTLD_LAZY
);
60 if (!libjack_handle
) {
61 fprintf(stderr
, "dlopen error : %s \n", dlerror());
65 libjack_handle
= LoadLibrary("libjack64.dll");
67 libjack_handle
= LoadLibrary("libjack.dll");
70 libjack_handle
= dlopen("libjack.so.0", RTLD_LAZY
);
73 libjack_is_present
= (libjack_handle
!= 0);
76 void *load_jack_function(const char *fn_name
)
79 if (!libjack_handle
) {
80 fprintf (stderr
, "libjack not found, so do not try to load %s ffs !\n", fn_name
);
84 fn
= (void*)GetProcAddress(libjack_handle
, fn_name
);
86 fn
= dlsym(libjack_handle
, fn_name
);
91 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_SYSTEM
| FORMAT_MESSAGE_IGNORE_INSERTS
,NULL
,GetLastError(),MAKELANGID(LANG_NEUTRAL
, SUBLANG_DEFAULT
),(LPTSTR
) &lpMsgBuf
,0,NULL
);
92 fprintf(stderr
, "could not GetProcAddress( %s ), %s \n", fn_name
, lpMsgBuf
);
94 fprintf(stderr
, "could not dlsym( %s ), %s \n", fn_name
, dlerror());
100 #define DECL_FUNCTION(return_type, fn_name, arguments_types, arguments) \
101 typedef return_type (*fn_name##_ptr_t)arguments_types; \
102 return_type fn_name arguments_types { \
103 static fn_name##_ptr_t fn = 0; \
104 if (fn == 0) { fn = (fn_name##_ptr_t)load_jack_function(#fn_name); } \
105 if (fn) return (*fn)arguments; \
106 else return (return_type)-1; \
109 #define DECL_FUNCTION_NULL(return_type, fn_name, arguments_types, arguments) \
110 typedef return_type (*fn_name##_ptr_t)arguments_types; \
111 return_type fn_name arguments_types { \
112 static fn_name##_ptr_t fn = 0; \
113 if (fn == 0) { fn = (fn_name##_ptr_t)load_jack_function(#fn_name); } \
114 if (fn) return (*fn)arguments; \
115 else return (return_type)0; \
118 #define DECL_VOID_FUNCTION(fn_name, arguments_types, arguments) \
119 typedef void (*fn_name##_ptr_t)arguments_types; \
120 void fn_name arguments_types { \
121 static fn_name##_ptr_t fn = 0; \
122 if (fn == 0) { fn = (fn_name##_ptr_t)load_jack_function(#fn_name); } \
123 if (fn) (*fn)arguments; \
127 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
));
128 DECL_FUNCTION_NULL(const char *, jack_get_version_string
, (), ());
129 DECL_FUNCTION_NULL(jack_client_t
*, jack_client_open
, (const char *client_name
, jack_options_t options
, jack_status_t
*status
, ...),
130 (client_name
, options
, status
));
131 DECL_FUNCTION(int, jack_client_close
, (jack_client_t
*client
), (client
));
132 DECL_FUNCTION_NULL(jack_client_t
*, jack_client_new
, (const char *client_name
), (client_name
));
133 DECL_FUNCTION(int, jack_client_name_size
, (), ());
134 DECL_FUNCTION_NULL(char*, jack_get_client_name
, (jack_client_t
*client
), (client
));
135 DECL_FUNCTION(int, jack_internal_client_new
, (const char *client_name
,
136 const char *load_name
,
137 const char *load_init
), (client_name
, load_name
, load_init
));
138 DECL_VOID_FUNCTION(jack_internal_client_close
, (const char *client_name
), (client_name
));
139 DECL_FUNCTION(int, jack_is_realtime
, (jack_client_t
*client
), (client
));
140 DECL_VOID_FUNCTION(jack_on_shutdown
, (jack_client_t
*client
, JackShutdownCallback shutdown_callback
, void *arg
), (client
, shutdown_callback
, arg
));
141 DECL_VOID_FUNCTION(jack_on_info_shutdown
, (jack_client_t
* client
, JackInfoShutdownCallback shutdown_callback
, void* arg
), (client
, shutdown_callback
, arg
));
142 DECL_FUNCTION(int, jack_set_process_callback
, (jack_client_t
*client
,
143 JackProcessCallback process_callback
,
144 void *arg
), (client
, process_callback
, arg
));
145 DECL_FUNCTION(jack_nframes_t
, jack_thread_wait
, (jack_client_t
*client
, int status
), (client
, status
));
148 DECL_FUNCTION(jack_nframes_t
, jack_cycle_wait
, (jack_client_t
*client
), (client
));
149 DECL_VOID_FUNCTION(jack_cycle_signal
, (jack_client_t
*client
, int status
), (client
, status
));
150 DECL_FUNCTION(int, jack_set_process_thread
, (jack_client_t
*client
,
151 JackThreadCallback fun
,
152 void *arg
), (client
, fun
, arg
));
153 DECL_FUNCTION(int, jack_set_thread_init_callback
, (jack_client_t
*client
,
154 JackThreadInitCallback thread_init_callback
,
155 void *arg
), (client
, thread_init_callback
, arg
));
156 DECL_FUNCTION(int, jack_set_freewheel_callback
, (jack_client_t
*client
,
157 JackFreewheelCallback freewheel_callback
,
158 void *arg
), (client
, freewheel_callback
, arg
));
159 DECL_FUNCTION(int, jack_set_freewheel
, (jack_client_t
*client
, int onoff
), (client
, onoff
));
160 DECL_FUNCTION(int, jack_set_buffer_size
, (jack_client_t
*client
, jack_nframes_t nframes
), (client
, nframes
));
161 DECL_FUNCTION(int, jack_set_buffer_size_callback
, (jack_client_t
*client
,
162 JackBufferSizeCallback bufsize_callback
,
163 void *arg
), (client
, bufsize_callback
, arg
));
164 DECL_FUNCTION(int, jack_set_sample_rate_callback
, (jack_client_t
*client
,
165 JackSampleRateCallback srate_callback
,
166 void *arg
), (client
, srate_callback
, arg
));
167 DECL_FUNCTION(int, jack_set_client_registration_callback
, (jack_client_t
*client
,
168 JackClientRegistrationCallback registration_callback
,
169 void *arg
), (client
, registration_callback
, arg
));
170 DECL_FUNCTION(int, jack_set_port_registration_callback
, (jack_client_t
*client
,
171 JackPortRegistrationCallback registration_callback
,
172 void *arg
), (client
, registration_callback
, arg
));
173 DECL_FUNCTION(int, jack_set_port_connect_callback
, (jack_client_t
*client
,
174 JackPortConnectCallback connect_callback
,
175 void *arg
), (client
, connect_callback
, arg
));
176 DECL_FUNCTION(int, jack_set_port_rename_callback
, (jack_client_t
*client
,
177 JackPortRenameCallback rename_callback
,
178 void *arg
), (client
, rename_callback
, arg
));
179 DECL_FUNCTION(int, jack_set_graph_order_callback
, (jack_client_t
*client
,
180 JackGraphOrderCallback graph_callback
,
181 void *arg
), (client
, graph_callback
, arg
));
182 DECL_FUNCTION(int, jack_set_xrun_callback
, (jack_client_t
*client
,
183 JackXRunCallback xrun_callback
,
184 void *arg
), (client
, xrun_callback
, arg
));
185 DECL_FUNCTION(int, jack_set_latency_callback
, (jack_client_t
*client
,
186 JackLatencyCallback latency_callback
,
187 void *arg
), (client
, latency_callback
, arg
));
188 DECL_FUNCTION(int, jack_activate
, (jack_client_t
*client
), (client
));
189 DECL_FUNCTION(int, jack_deactivate
, (jack_client_t
*client
), (client
));
190 DECL_FUNCTION_NULL(jack_port_t
*, jack_port_register
, (jack_client_t
*client
, const char *port_name
, const char *port_type
,
191 unsigned long flags
, unsigned long buffer_size
),
192 (client
, port_name
, port_type
, flags
, buffer_size
));
193 DECL_FUNCTION(int, jack_port_unregister
, (jack_client_t
*client
, jack_port_t
* port
), (client
, port
));
194 DECL_FUNCTION_NULL(void *, jack_port_get_buffer
, (jack_port_t
*port
, jack_nframes_t nframes
), (port
, nframes
));
195 DECL_FUNCTION_NULL(const char*, jack_port_name
, (const jack_port_t
*port
), (port
));
196 DECL_FUNCTION_NULL(const char*, jack_port_short_name
, (const jack_port_t
*port
), (port
));
197 DECL_FUNCTION(int, jack_port_flags
, (const jack_port_t
*port
), (port
));
198 DECL_FUNCTION_NULL(const char*, jack_port_type
, (const jack_port_t
*port
), (port
));
199 DECL_FUNCTION(jack_port_type_id_t
, jack_port_type_id
, (const jack_port_t
*port
), (port
));
200 DECL_FUNCTION(int, jack_port_is_mine
, (const jack_client_t
*client
, const jack_port_t
* port
), (client
, port
));
201 DECL_FUNCTION(int, jack_port_connected
, (const jack_port_t
*port
), (port
));
202 DECL_FUNCTION(int, jack_port_connected_to
, (const jack_port_t
*port
, const char *port_name
), (port
, port_name
));
203 DECL_FUNCTION_NULL(const char**, jack_port_get_connections
, (const jack_port_t
*port
), (port
));
204 DECL_FUNCTION_NULL(const char**, jack_port_get_all_connections
, (const jack_client_t
*client
,const jack_port_t
*port
), (client
, port
));
205 DECL_FUNCTION(int, jack_port_tie
, (jack_port_t
*src
, jack_port_t
*dst
), (src
, dst
));
206 DECL_FUNCTION(int, jack_port_untie
, (jack_port_t
*port
), (port
));
207 DECL_FUNCTION(jack_nframes_t
, jack_port_get_latency
, (jack_port_t
*port
), (port
));
208 DECL_FUNCTION(jack_nframes_t
, jack_port_get_total_latency
,(jack_client_t
* client
, jack_port_t
*port
), (client
, port
));
209 DECL_VOID_FUNCTION(jack_port_set_latency
, (jack_port_t
* port
, jack_nframes_t frames
), (port
, frames
));
210 DECL_FUNCTION(int, jack_recompute_total_latency
, (jack_client_t
* client
, jack_port_t
* port
), (client
, port
));
211 DECL_VOID_FUNCTION(jack_port_get_latency_range
, (jack_port_t
*port
, jack_latency_callback_mode_t mode
, jack_latency_range_t
*range
), (port
, mode
, range
));
212 DECL_VOID_FUNCTION(jack_port_set_latency_range
, (jack_port_t
*port
, jack_latency_callback_mode_t mode
, jack_latency_range_t
*range
), (port
, mode
, range
));
213 DECL_FUNCTION(int, jack_recompute_total_latencies
, (jack_client_t
* client
),(client
));
215 DECL_FUNCTION(int, jack_port_set_name
, (jack_port_t
*port
, const char *port_name
), (port
, port_name
));
216 DECL_FUNCTION(int, jack_port_rename
, (jack_client_t
*client
, jack_port_t
*port
, const char *port_name
), (client
, port
, port_name
));
217 DECL_FUNCTION(int, jack_port_set_alias
, (jack_port_t
*port
, const char *alias
), (port
, alias
));
218 DECL_FUNCTION(int, jack_port_unset_alias
, (jack_port_t
*port
, const char *alias
), (port
, alias
));
219 DECL_FUNCTION(int, jack_port_get_aliases
, (const jack_port_t
*port
, char* const aliases
[2]), (port
,aliases
));
220 DECL_FUNCTION(int, jack_port_request_monitor
, (jack_port_t
*port
, int onoff
), (port
, onoff
));
221 DECL_FUNCTION(int, jack_port_request_monitor_by_name
, (jack_client_t
*client
, const char *port_name
, int onoff
), (client
, port_name
, onoff
));
222 DECL_FUNCTION(int, jack_port_ensure_monitor
, (jack_port_t
*port
, int onoff
), (port
, onoff
));
223 DECL_FUNCTION(int, jack_port_monitoring_input
, (jack_port_t
*port
) ,(port
));
224 DECL_FUNCTION(int, jack_connect
, (jack_client_t
* client
, const char *source_port
, const char *destination_port
), (client
, source_port
, destination_port
));
225 DECL_FUNCTION(int, jack_disconnect
, (jack_client_t
* client
, const char *source_port
, const char *destination_port
), (client
, source_port
, destination_port
));
226 DECL_FUNCTION(int, jack_port_disconnect
, (jack_client_t
* client
, jack_port_t
* port
), (client
, port
));
227 DECL_FUNCTION(int, jack_port_name_size
,(),());
228 DECL_FUNCTION(int, jack_port_type_size
,(),());
229 DECL_FUNCTION(size_t, jack_port_type_get_buffer_size
, (jack_client_t
*client
, const char* port_type
), (client
, port_type
));
231 DECL_FUNCTION(jack_nframes_t
, jack_get_sample_rate
, (jack_client_t
*client
), (client
));
232 DECL_FUNCTION(jack_nframes_t
, jack_get_buffer_size
, (jack_client_t
*client
), (client
));
233 DECL_FUNCTION_NULL(const char**, jack_get_ports
, (jack_client_t
*client
, const char *port_name_pattern
, const char * type_name_pattern
,
234 unsigned long flags
), (client
, port_name_pattern
, type_name_pattern
, flags
));
235 DECL_FUNCTION_NULL(jack_port_t
*, jack_port_by_name
, (jack_client_t
* client
, const char *port_name
), (client
, port_name
));
236 DECL_FUNCTION_NULL(jack_port_t
*, jack_port_by_id
, (jack_client_t
*client
, jack_port_id_t port_id
), (client
, port_id
));
238 DECL_FUNCTION(int, jack_engine_takeover_timebase
, (jack_client_t
* client
), (client
));
239 DECL_FUNCTION(jack_nframes_t
, jack_frames_since_cycle_start
, (const jack_client_t
* client
), (client
));
240 DECL_FUNCTION(jack_time_t
, jack_get_time
, (), ());
241 DECL_FUNCTION(jack_nframes_t
, jack_time_to_frames
, (const jack_client_t
*client
, jack_time_t time
), (client
, time
));
242 DECL_FUNCTION(jack_time_t
, jack_frames_to_time
, (const jack_client_t
*client
, jack_nframes_t frames
), (client
, frames
));
243 DECL_FUNCTION(jack_nframes_t
, jack_frame_time
, (const jack_client_t
*client
), (client
));
244 DECL_FUNCTION(jack_nframes_t
, jack_last_frame_time
, (const jack_client_t
*client
), (client
));
245 DECL_FUNCTION(float, jack_cpu_load
, (jack_client_t
*client
), (client
));
246 DECL_FUNCTION_NULL(jack_native_thread_t
, jack_client_thread_id
, (jack_client_t
*client
), (client
));
247 DECL_VOID_FUNCTION(jack_set_error_function
, (print_function fun
), (fun
));
248 DECL_VOID_FUNCTION(jack_set_info_function
, (print_function fun
), (fun
));
250 DECL_FUNCTION(float, jack_get_max_delayed_usecs
, (jack_client_t
*client
), (client
));
251 DECL_FUNCTION(float, jack_get_xrun_delayed_usecs
, (jack_client_t
*client
), (client
));
252 DECL_VOID_FUNCTION(jack_reset_max_delayed_usecs
, (jack_client_t
*client
), (client
));
254 DECL_FUNCTION(int, jack_release_timebase
, (jack_client_t
*client
), (client
));
255 DECL_FUNCTION(int, jack_set_sync_callback
, (jack_client_t
*client
, JackSyncCallback sync_callback
, void *arg
), (client
, sync_callback
, arg
));
256 DECL_FUNCTION(int, jack_set_sync_timeout
, (jack_client_t
*client
, jack_time_t timeout
), (client
, timeout
));
257 DECL_FUNCTION(int, jack_set_timebase_callback
, (jack_client_t
*client
,
259 JackTimebaseCallback timebase_callback
,
260 void *arg
), (client
, conditional
, timebase_callback
, arg
));
261 DECL_FUNCTION(int, jack_transport_locate
, (jack_client_t
*client
, jack_nframes_t frame
), (client
, frame
));
262 DECL_FUNCTION(jack_transport_state_t
, jack_transport_query
, (const jack_client_t
*client
, jack_position_t
*pos
), (client
, pos
));
263 DECL_FUNCTION(jack_nframes_t
, jack_get_current_transport_frame
, (const jack_client_t
*client
), (client
));
264 DECL_FUNCTION(int, jack_transport_reposition
, (jack_client_t
*client
, const jack_position_t
*pos
), (client
, pos
));
265 DECL_VOID_FUNCTION(jack_transport_start
, (jack_client_t
*client
), (client
));
266 DECL_VOID_FUNCTION(jack_transport_stop
, (jack_client_t
*client
), (client
));
267 DECL_VOID_FUNCTION(jack_get_transport_info
, (jack_client_t
*client
, jack_transport_info_t
*tinfo
), (client
,tinfo
));
268 DECL_VOID_FUNCTION(jack_set_transport_info
, (jack_client_t
*client
, jack_transport_info_t
*tinfo
), (client
,tinfo
));
270 DECL_FUNCTION(int, jack_client_real_time_priority
, (jack_client_t
* client
), (client
));
271 DECL_FUNCTION(int, jack_client_max_real_time_priority
, (jack_client_t
* client
), (client
));
272 DECL_FUNCTION(int, jack_acquire_real_time_scheduling
, (jack_native_thread_t thread
, int priority
), (thread
, priority
));
273 DECL_FUNCTION(int, jack_client_create_thread
, (jack_client_t
* client
,
274 jack_native_thread_t
*thread
,
276 int realtime
, // boolean
277 thread_routine routine
,
278 void *arg
), (client
, thread
, priority
, realtime
, routine
, arg
));
279 DECL_FUNCTION(int, jack_drop_real_time_scheduling
, (jack_native_thread_t thread
), (thread
));
281 DECL_FUNCTION(int, jack_client_stop_thread
, (jack_client_t
* client
, jack_native_thread_t thread
), (client
, thread
));
282 DECL_FUNCTION(int, jack_client_kill_thread
, (jack_client_t
* client
, jack_native_thread_t thread
), (client
, thread
));
284 DECL_VOID_FUNCTION(jack_set_thread_creator
, (jack_thread_creator_t jtc
), (jtc
));
286 DECL_FUNCTION(char *, jack_get_internal_client_name
, (jack_client_t
*client
, jack_intclient_t intclient
), (client
, intclient
));
287 DECL_FUNCTION(jack_intclient_t
, jack_internal_client_handle
, (jack_client_t
*client
, const char *client_name
, jack_status_t
*status
), (client
, client_name
, status
));
289 DECL_FUNCTION(jack_intclient_t, jack_internal_client_load, (jack_client_t *client,
290 const char *client_name,
291 jack_options_t options,
292 jack_status_t *status
293 , ...), (client, client_name, options, status, ...));
295 DECL_FUNCTION(jack_status_t
, jack_internal_client_unload
, (jack_client_t
*client
, jack_intclient_t intclient
), (client
, intclient
));
296 DECL_VOID_FUNCTION(jack_free
, (void* ptr
), (ptr
));
299 DECL_FUNCTION(int, jack_set_session_callback
, (jack_client_t
* ext_client
, JackSessionCallback session_callback
, void* arg
), (ext_client
, session_callback
, arg
));
300 DECL_FUNCTION(jack_session_command_t
*, jack_session_notify
, (jack_client_t
* ext_client
, const char* target
, jack_session_event_type_t ev_type
, const char* path
), (ext_client
, target
, ev_type
, path
));
301 DECL_FUNCTION(int, jack_session_reply
, (jack_client_t
* ext_client
, jack_session_event_t
*event
), (ext_client
, event
));
302 DECL_VOID_FUNCTION(jack_session_event_free
, (jack_session_event_t
* ev
), (ev
));
303 DECL_FUNCTION(char*, jack_client_get_uuid
, (jack_client_t
* ext_client
),(ext_client
));
304 DECL_FUNCTION(char*, jack_get_uuid_for_client_name
, (jack_client_t
* ext_client
, const char* client_name
),(ext_client
, client_name
));
305 DECL_FUNCTION(char*, jack_get_client_name_by_uuid
, (jack_client_t
* ext_client
, const char* client_uuid
),(ext_client
, client_uuid
));
306 DECL_FUNCTION(int, jack_reserve_client_name
, (jack_client_t
* ext_client
, const char* name
, const char* uuid
),(ext_client
, name
, uuid
));
307 DECL_VOID_FUNCTION(jack_session_commands_free
, (jack_session_command_t
*cmds
),(cmds
));
308 DECL_FUNCTION(int, jack_client_has_session_callback
, (jack_client_t
*client
, const char* client_name
),(client
, client_name
));
311 DECL_FUNCTION(jack_nframes_t
, jack_midi_get_event_count
, (void* port_buffer
), (port_buffer
));
312 DECL_FUNCTION(int, jack_midi_event_get
, (jack_midi_event_t
* event
, void* port_buffer
, jack_nframes_t event_index
), (event
, port_buffer
, event_index
)) ;
313 DECL_VOID_FUNCTION(jack_midi_clear_buffer
, (void* port_buffer
), (port_buffer
));
314 DECL_FUNCTION(size_t, jack_midi_max_event_size
, (void* port_buffer
), (port_buffer
));
315 DECL_FUNCTION_NULL(jack_midi_data_t
*, jack_midi_event_reserve
, (void* port_buffer
, jack_nframes_t time
, size_t data_size
), (port_buffer
, time
, data_size
));
316 DECL_FUNCTION(int, jack_midi_event_write
, (void* port_buffer
, jack_nframes_t time
, const jack_midi_data_t
* data
, size_t data_size
), (port_buffer
, time
, data
, data_size
));
317 DECL_FUNCTION(jack_nframes_t
, jack_midi_get_lost_event_count
, (void* port_buffer
), (port_buffer
));