diff --git a/jack-sys/build.rs b/jack-sys/build.rs index 835d2f0c4..e66c38602 100644 --- a/jack-sys/build.rs +++ b/jack-sys/build.rs @@ -1,2077 +1,7 @@ -bitflags::bitflags! { - struct FunctionFlags: u8 { - const NONE = 0b00000000; - const WEAK = 0b00000001; - } -} - fn main() { - let out_dir = std::env::var_os("OUT_DIR").unwrap(); let target_os = std::env::var("CARGO_CFG_TARGET_OS"); let library_found = pkg_config::find_library("jack"); if target_os.as_ref().map(|s| s.as_str()) == Ok("linux") { library_found.unwrap(); } - let dest_path = std::path::Path::new(&out_dir).join("functions.rs"); - let mut out = std::fs::File::create(&dest_path).unwrap(); - wrap_in_module( - "dynamic_loading", - "#[cfg(feature = \"dynamic_loading\")]", - write_dynamic_loading_src, - &mut out, - ) - .unwrap(); - wrap_in_module( - "dynamic_linking", - "#[cfg(not(feature = \"dynamic_loading\"))]", - write_dynamic_linking_src, - &mut out, - ) - .unwrap(); - println!("cargo:rerun-if-changed=build.rs"); -} - -type WriterFn = fn(&mut W) -> Result<(), std::io::Error>; - -fn wrap_in_module( - module: &str, - feature_guard: &str, - inner: WriterFn, - out: &mut W, -) -> Result<(), std::io::Error> { - writeln!(out, "{}", feature_guard)?; - writeln!(out, "pub mod {} {{", module)?; - inner(out)?; - writeln!(out, "}}")?; - Ok(()) -} - -fn write_dynamic_linking_src(out: &mut W) -> Result<(), std::io::Error> { - writeln!(out, "use crate::types::*;")?; - for f in FUNCTIONS - .iter() - .filter(|f| f.flags.contains(FunctionFlags::WEAK)) - { - writeln!( - out, - "pub unsafe fn {}({}) -> Option<{}> {{ None }}", - f.name, - f.args_full(true), - f.ret - )?; - } - writeln!(out, "#[link(name=\"jack\")]")?; - writeln!(out, "extern \"C\" {{")?; - for f in FUNCTIONS - .iter() - .filter(|f| !f.flags.contains(FunctionFlags::WEAK)) - { - writeln!( - out, - " pub fn {}({}) -> {};", - f.name, - f.args_full(false), - f.ret - )?; - } - writeln!(out, "}}")?; - Ok(()) -} - -fn write_dynamic_loading_src(out: &mut W) -> Result<(), std::io::Error> { - writeln!(out, "use crate::types::*;")?; - writeln!(out, "use lazy_static::lazy_static;")?; - writeln!(out, "pub struct JackFunctions {{")?; - for f in FUNCTIONS.iter() { - if f.flags.contains(FunctionFlags::WEAK) { - writeln!( - out, - " {}_impl: Option {}>,", - f.name, - f.arg_types(), - f.ret - )?; - } else { - writeln!( - out, - " {}_impl: unsafe extern \"C\" fn({}) -> {},", - f.name, - f.arg_types(), - f.ret - )?; - } - } - writeln!(out, "}}\n")?; - - writeln!(out, "lazy_static! {{")?; - writeln!(out, " static ref FUNCTIONS: JackFunctions = unsafe {{")?; - writeln!(out, " let library = crate::library().unwrap();")?; - for f in FUNCTIONS.iter() { - if f.flags.contains(FunctionFlags::WEAK) { - writeln!(out, - " let {}_impl = library.get:: {}>(b\"{}\").ok();", - f.name, - f.args_full(false), - f.ret, - f.name, - )?; - writeln!( - out, - " let {}_impl = {}_impl.map(|sym| sym.into_raw());", - f.name, f.name - )?; - writeln!( - out, - " let {}_impl = {}_impl.map(|sym| *sym.deref() as {});", - f.name, - f.name, - f.type_name() - )?; - } else { - writeln!(out, - " let {}_impl = library.get:: {}>(b\"{}\").unwrap();", - f.name, - f.args_full(false), - f.ret, - f.name, - )?; - writeln!( - out, - " let {}_impl = {}_impl.into_raw();", - f.name, f.name - )?; - writeln!( - out, - " let {}_impl = *{}_impl.deref() as {};", - f.name, - f.name, - f.type_name() - )?; - } - } - writeln!(out, " JackFunctions {{")?; - for f in FUNCTIONS.iter() { - writeln!(out, " {}_impl,", f.name)?; - } - writeln!(out, " }}")?; - writeln!(out, " }};\n")?; - writeln!(out, "}}\n")?; - - for f in FUNCTIONS.iter() { - if f.flags.contains(FunctionFlags::WEAK) { - writeln!( - out, - "pub unsafe fn {}({}) -> Option<{}> {{", - f.name, - f.args_full(false), - f.ret - )?; - writeln!(out, " let f = FUNCTIONS.{}_impl?;", f.name)?; - writeln!(out, " Some(f({}))", f.arg_names())?; - } else { - writeln!( - out, - "pub unsafe fn {}({}) -> {} {{", - f.name, - f.args_full(false), - f.ret - )?; - writeln!(out, " let f = FUNCTIONS.{}_impl;", f.name)?; - writeln!(out, " f({})", f.arg_names())?; - } - writeln!(out, "}}")?; - } - Ok(()) -} - -struct Function { - name: &'static str, - args: &'static [(&'static str, &'static str)], - ret: &'static str, - flags: FunctionFlags, -} - -impl Function { - fn args_full(&self, prefix_with_underscore: bool) -> String { - let mut args = String::new(); - for &(name, ty) in self.args.iter() { - if !args.is_empty() { - args.push_str(", "); - } - if !name.is_empty() { - if prefix_with_underscore { - args.push_str("_"); - } - args.push_str(name); - args.push_str(": "); - } - args.push_str(ty); - } - args - } - - fn arg_types(&self) -> String { - let mut args = String::new(); - for &(_, ty) in self.args.iter() { - if !args.is_empty() { - args.push_str(", "); - } - args.push_str(ty); - } - args - } - - fn arg_names(&self) -> String { - let mut args = String::new(); - for &(name, _) in self.args.iter() { - if !args.is_empty() { - args.push_str(", "); - } - args.push_str(name); - } - args - } - - fn type_name(&self) -> String { - format!( - "unsafe extern \"C\" fn({}) -> {}", - self.args_full(false), - self.ret - ) - } } - -const FUNCTIONS: &[Function] = &[ - Function { - name: "jack_release_timebase", - args: &[("client", "*mut jack_client_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_get_cycle_times", - args: &[ - ("client", "*const jack_client_t"), - ("current_frames", "*mut jack_nframes_t"), - ("current_usecs", "*mut jack_time_t"), - ("next_usecs", "*mut jack_time_t"), - ("period_usecs", "*mut ::libc::c_float"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::WEAK, - }, - Function { - name: "jack_set_sync_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("sync_callback", "JackSyncCallback"), - ("sync_arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_sync_timeout", - args: &[("client", "*mut jack_client_t"), ("timeout", "jack_time_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_timebase_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("conditional", "::libc::c_int"), - ("timebase_callback", "TimebaseCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_transport_locate", - args: &[ - ("client", "*mut jack_client_t"), - ("frame", "jack_nframes_t"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_transport_query", - args: &[ - ("client", "*const jack_client_t"), - ("pos", "*mut jack_position_t"), - ], - ret: "jack_transport_state_t", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_get_current_transport_frame", - args: &[("client", "*const jack_client_t")], - ret: "jack_nframes_t", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_transport_reposition", - args: &[ - ("client", "*mut jack_client_t"), - ("pos", "*const jack_position_t"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_transport_start", - args: &[("client", "*mut jack_client_t")], - ret: "()", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_transport_stop", - args: &[("client", "*mut jack_client_t")], - ret: "()", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_get_transport_info", - args: &[ - ("client", "*mut jack_client_t"), - ("tinfo", "*mut jack_transport_info_t"), - ], - ret: "()", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_transport_info", - args: &[ - ("client", "*mut jack_client_t"), - ("tinfo", "*mut jack_transport_info_t"), - ], - ret: "()", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_client_open", - args: &[ - ("client_name", "*const ::libc::c_char"), - ("options", "jack_options_t"), - ("status", "*mut jack_status_t"), - // Varargs not supported - // ("", "..."), - ], - ret: "*mut jack_client_t", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_client_new", - args: &[("client_name", "*const ::libc::c_char")], - ret: "*mut jack_client_t", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_client_close", - args: &[("client", "*mut jack_client_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_client_name_size", - args: &[], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_get_client_name", - args: &[("client", "*mut jack_client_t")], - ret: "*mut ::libc::c_char", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_get_uuid_for_client_name", - args: &[ - ("client", "*mut jack_client_t"), - ("client_name", "*const ::libc::c_char"), - ], - ret: "*mut ::libc::c_char", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_get_client_name_by_uuid", - args: &[ - ("client", "*mut jack_client_t"), - ("client_uuid", "*const ::libc::c_char"), - ], - ret: "*mut ::libc::c_char", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_internal_client_new", - args: &[ - ("client_name", "*const ::libc::c_char"), - ("load_name", "*const ::libc::c_char"), - ("load_init", "*const ::libc::c_char"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::WEAK, - }, - Function { - name: "jack_internal_client_close", - args: &[("client_name", "*const ::libc::c_char")], - ret: "()", - flags: FunctionFlags::WEAK, - }, - Function { - name: "jack_activate", - args: &[("client", "*mut jack_client_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_deactivate", - args: &[("client", "*mut jack_client_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_get_client_pid", - args: &[("name", "*const ::libc::c_char")], - ret: "::libc::c_int", - flags: FunctionFlags::WEAK, - }, - // #[cfg(not(target_os = "windows"))] - // pub fn jack_client_thread_id(client: *mut jack_client_t) -> jack_native_thread_t; - Function { - name: "jack_is_realtime", - args: &[("client", "*mut jack_client_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_thread_wait", - args: &[ - ("client", "*mut jack_client_t"), - ("status", "::libc::c_int"), - ], - ret: "jack_nframes_t", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_cycle_wait", - args: &[("client", "*mut jack_client_t")], - ret: "jack_nframes_t", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_cycle_signal", - args: &[ - ("client", "*mut jack_client_t"), - ("status", "::libc::c_int"), - ], - ret: "()", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_process_thread", - args: &[ - ("client", "*mut jack_client_t"), - ("thread_callback", "JackThreadCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_thread_init_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("thread_init_callback", "JackThreadInitCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_on_shutdown", - args: &[ - ("client", "*mut jack_client_t"), - ("callback", "JackShutdownCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "()", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_on_info_shutdown", - args: &[ - ("client", "*mut jack_client_t"), - ("callback", "JackInfoShutdownCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "()", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_process_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("process_callback", "JackProcessCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_freewheel_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("freewheel_callback", "JackFreewheelCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_buffer_size_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("bufsize_callback", "JackBufferSizeCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_get_sample_rate", - args: &[ - ("client", "*mut jack_client_t"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_sample_rate_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("srate_callback", "JackSampleRateCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_client_registration_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("registration_callback", "JackClientRegistrationCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_port_registration_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("registration_callback", "JackPortRegistrationCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_port_connect_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("connect_callback", "JackPortConnectCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_port_rename_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("rename_callback", "JackPortRenameCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_graph_order_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("graph_callback", "JackGraphOrderCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_xrun_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("xrun_callback", "JackXRunCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_latency_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("latency_callback", "JackLatencyCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_freewheel", - args: &[("client", "*mut jack_client_t"), ("onoff", "::libc::c_int")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_set_buffer_size", - args: &[ - ("client", "*mut jack_client_t"), - ("nframes", "jack_nframes_t"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_get_buffer_size", - args: &[("client", "*mut jack_client_t")], - ret: "jack_nframes_t", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_engine_takeover_timebase", - args: &[("client", "*mut jack_client_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_cpu_load", - args: &[("client", "*mut jack_client_t")], - ret: "::libc::c_float", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_register", - args: &[ - ("client", "*mut jack_client_t"), - ("port_name", "*const ::libc::c_char"), - ("port_type", "*const ::libc::c_char"), - ("flags", "::libc::c_ulong"), - ("buffer_size", "::libc::c_ulong"), - ], - ret: "*mut jack_port_t", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_unregister", - args: &[ - ("client", "*mut jack_client_t"), - ("port", "*mut jack_port_t"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_get_buffer", - args: &[("port", "*mut jack_port_t"), ("nframes", "jack_nframes_t")], - ret: "*mut ::libc::c_void", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_uuid", - args: &[("port", "*mut jack_port_t")], - ret: "jack_uuid_t", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_name", - args: &[("port", "*mut jack_port_t")], - ret: "*const ::libc::c_char", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_short_name", - args: &[("port", "*mut jack_port_t")], - ret: "*const ::libc::c_char", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_flags", - args: &[("port", "*mut jack_port_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_type", - args: &[("port", "*const jack_port_t")], - ret: "*const ::libc::c_char", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_type_id", - args: &[("port", "*const jack_port_t")], - ret: "jack_port_type_id_t", - flags: FunctionFlags::WEAK, - }, - Function { - name: "jack_port_is_mine", - args: &[ - ("client", "*const jack_client_t"), - ("port", "*const jack_port_t"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_connected", - args: &[("port", "*const jack_port_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_connected_to", - args: &[ - ("port", "*const jack_port_t"), - ("port_name", "*const ::libc::c_char"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_get_connections", - args: &[("port", "*const jack_port_t")], - ret: "*mut *const ::libc::c_char", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_get_all_connections", - args: &[ - ("client", "*const jack_client_t"), - ("port", "*const jack_port_t"), - ], - ret: "*mut *const ::libc::c_char", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_tie", - args: &[("src", "*mut jack_port_t"), ("dst", "*mut jack_port_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_untie", - args: &[("port", "*mut jack_port_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_set_name", - args: &[ - ("port", "*mut jack_port_t"), - ("port_name", "*const ::libc::c_char"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_set_alias", - args: &[ - ("port", "*mut jack_port_t"), - ("alias", "*const ::libc::c_char"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_unset_alias", - args: &[ - ("port", "*mut jack_port_t"), - ("alias", "*const ::libc::c_char"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_get_aliases", - args: &[ - ("port", "*const jack_port_t"), - ("aliases", "*mut *mut ::libc::c_char"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_request_monitor", - args: &[("port", "*mut jack_port_t"), ("onoff", "::libc::c_int")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_request_monitor_by_name", - args: &[ - ("client", "*mut jack_client_t"), - ("port_name", "*const ::libc::c_char"), - ("onoff", "::libc::c_int"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_ensure_monitor", - args: &[("port", "*mut jack_port_t"), ("onoff", "::libc::c_int")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_port_monitoring_input", - args: &[("port", "*mut jack_port_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_connect", - args: &[ - ("client", "*mut jack_client_t"), - ("source_port", "*const ::libc::c_char"), - ("destination_port", "*const ::libc::c_char"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_disconnect( - // client: *mut jack_client_t, - // source_port: *const ::libc::c_char, - // destination_port: *const ::libc::c_char, - // ) -> ::libc::c_int; - Function { - name: "jack_disconnect", - args: &[ - ("client", "*mut jack_client_t"), - ("source_port", "*const ::libc::c_char"), - ("destination_port", "*const ::libc::c_char"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_port_disconnect(client: *mut jack_client_t, port: *mut jack_port_t) -> ::libc::c_int; - Function { - name: "jack_port_disconnect", - args: &[ - ("client", "*mut jack_client_t"), - ("port", "*mut jack_port_t"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_port_name_size() -> ::libc::c_int; - Function { - name: "jack_port_name_size", - args: &[], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_port_type_size() -> ::libc::c_int; - Function { - name: "jack_port_type_size", - args: &[], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_port_type_get_buffer_size( - // client: *mut jack_client_t, - // port_type: *const ::libc::c_char, - // ) -> ::libc::size_t; - Function { - name: "jack_port_type_get_buffer_size", - args: &[ - ("client", "*mut jack_client_t"), - ("port_type", "*const ::libc::c_char"), - ], - ret: "::libc::size_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_port_set_latency(port: *mut jack_port_t, arg1: jack_nframes_t) -> (); - Function { - name: "jack_port_set_latency", - args: &[("port", "*mut jack_port_t"), ("arg1", "jack_nframes_t")], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_port_get_latency_range( - // port: *mut jack_port_t, - // mode: jack_latency_callback_mode_t, - // range: *mut jack_latency_range_t, - // ) -> (); - Function { - name: "jack_port_get_latency_range", - args: &[ - ("port", "*mut jack_port_t"), - ("mode", "jack_latency_callback_mode_t"), - ("range", "*mut jack_latency_range_t"), - ], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_port_set_latency_range( - // port: *mut jack_port_t, - // mode: jack_latency_callback_mode_t, - // range: *mut jack_latency_range_t, - // ) -> (); - Function { - name: "jack_port_set_latency_range", - args: &[ - ("port", "*mut jack_port_t"), - ("mode", "jack_latency_callback_mode_t"), - ("range", "*mut jack_latency_range_t"), - ], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_recompute_total_latencies(client: *mut jack_client_t) -> ::libc::c_int; - Function { - name: "jack_recompute_total_latencies", - args: &[("client", "*mut jack_client_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_port_get_latency(port: *mut jack_port_t) -> jack_nframes_t; - Function { - name: "jack_port_get_latency", - args: &[("port", "*mut jack_port_t")], - ret: "jack_nframes_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_port_get_total_latency( - // client: *mut jack_client_t, - // port: *mut jack_port_t, - // ) -> jack_nframes_t; - Function { - name: "jack_port_get_total_latency", - args: &[ - ("client", "*mut jack_client_t"), - ("port", "*mut jack_port_t"), - ], - ret: "jack_nframes_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_recompute_total_latency( - // arg1: *mut jack_client_t, - // port: *mut jack_port_t, - // ) -> ::libc::c_int; - Function { - name: "jack_recompute_total_latency", - args: &[("arg1", "*mut jack_client_t"), ("port", "*mut jack_port_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_get_ports( - // client: *mut jack_client_t, - // port_name_pattern: *const ::libc::c_char, - // type_name_pattern: *const ::libc::c_char, - // flags: ::libc::c_ulong, - // ) -> *mut *const ::libc::c_char; - Function { - name: "jack_get_ports", - args: &[ - ("client", "*mut jack_client_t"), - ("port_name_pattern", "*const ::libc::c_char"), - ("type_name_pattern", "*const ::libc::c_char"), - ("flags", "::libc::c_ulong"), - ], - ret: "*mut *const ::libc::c_char", - flags: FunctionFlags::NONE, - }, - // pub fn jack_port_by_name( - // client: *mut jack_client_t, - // port_name: *const ::libc::c_char, - // ) -> *mut jack_port_t; - Function { - name: "jack_port_by_name", - args: &[ - ("client", "*mut jack_client_t"), - ("port_name", "*const ::libc::c_char"), - ], - ret: "*mut jack_port_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_port_by_id(client: *mut jack_client_t, port_id: jack_port_id_t) -> *mut jack_port_t; - Function { - name: "jack_port_by_id", - args: &[ - ("client", "*mut jack_client_t"), - ("port_id", "jack_port_id_t"), - ], - ret: "*mut jack_port_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_frames_since_cycle_start(arg1: *const jack_client_t) -> jack_nframes_t; - Function { - name: "jack_frames_since_cycle_start", - args: &[("arg1", "*const jack_client_t")], - ret: "jack_nframes_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_frame_time(arg1: *const jack_client_t) -> jack_nframes_t; - Function { - name: "jack_frame_time", - args: &[("arg1", "*const jack_client_t")], - ret: "jack_nframes_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_last_frame_time(client: *const jack_client_t) -> jack_nframes_t; - Function { - name: "jack_last_frame_time", - args: &[("client", "*const jack_client_t")], - ret: "jack_nframes_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_frames_to_time(client: *const jack_client_t, arg1: jack_nframes_t) -> jack_time_t; - Function { - name: "jack_frames_to_time", - args: &[ - ("client", "*const jack_client_t"), - ("arg1", "jack_nframes_t"), - ], - ret: "jack_time_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_time_to_frames(client: *const jack_client_t, arg1: jack_time_t) -> jack_nframes_t; - Function { - name: "jack_time_to_frames", - args: &[("client", "*const jack_client_t"), ("arg1", "jack_time_t")], - ret: "jack_nframes_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_get_time() -> jack_time_t; - Function { - name: "jack_get_time", - args: &[], - ret: "jack_time_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_set_error_function( - // func: ::std::option::Option ()>, - // ) -> (); - Function { - name: "jack_set_error_function", - args: &[( - "func", - "::std::option::Option ()>", - )], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_set_info_function( - // func: ::std::option::Option ()>, - // ) -> (); - Function { - name: "jack_set_info_function", - args: &[( - "func", - "::std::option::Option ()>", - )], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_free(ptr: *mut ::libc::c_void) -> (); - Function { - name: "jack_free", - args: &[("ptr", "*mut ::libc::c_void")], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_client_real_time_priority(arg1: *mut jack_client_t) -> ::libc::c_int; - Function { - name: "jack_client_real_time_priority", - args: &[("arg1", "*mut jack_client_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_client_max_real_time_priority(arg1: *mut jack_client_t) -> ::libc::c_int; - Function { - name: "jack_client_max_real_time_priority", - args: &[("arg1", "*mut jack_client_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // #[cfg(not(target_os = "windows"))] - // pub fn jack_acquire_real_time_scheduling( - // thread: jack_native_thread_t, - // priority: ::libc::c_int, - // ) -> ::libc::c_int; - // #[cfg(not(target_os = "windows"))] - // pub fn jack_client_create_thread( - // client: *mut jack_client_t, - // thread: *mut jack_native_thread_t, - // priority: ::libc::c_int, - // realtime: ::libc::c_int, - // start_routine: ::std::option::Option< - // unsafe extern "C" fn(arg1: *mut ::libc::c_void) -> *mut ::libc::c_void, - // >, - // arg: *mut ::libc::c_void, - // ) -> ::libc::c_int; - // #[cfg(not(target_os = "windows"))] - // pub fn jack_drop_real_time_scheduling(thread: jack_native_thread_t) -> ::libc::c_int; - // #[cfg(not(target_os = "windows"))] - // pub fn jack_client_stop_thread( - // client: *mut jack_client_t, - // thread: jack_native_thread_t, - // ) -> ::libc::c_int; - // #[cfg(not(target_os = "windows"))] - // pub fn jack_client_kill_thread( - // client: *mut jack_client_t, - // thread: jack_native_thread_t, - // ) -> ::libc::c_int; - // #[cfg(not(target_os = "windows"))] - // pub fn jack_set_thread_creator(creator: jack_thread_creator_t) -> (); - // pub fn jack_set_session_callback( - // client: *mut jack_client_t, - // session_callback: JackSessionCallback, - // arg: *mut ::libc::c_void, - // ) -> ::libc::c_int; - Function { - name: "jack_set_session_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("session_callback", "JackSessionCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_session_reply( - // client: *mut jack_client_t, - // event: *mut jack_session_event_t, - // ) -> ::libc::c_int; - Function { - name: "jack_session_reply", - args: &[ - ("client", "*mut jack_client_t"), - ("event", "*mut jack_session_event_t"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_session_event_free(event: *mut jack_session_event_t) -> (); - Function { - name: "jack_session_event_free", - args: &[("event", "*mut jack_session_event_t")], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_client_get_uuid(client: *mut jack_client_t) -> *mut ::libc::c_char; - Function { - name: "jack_client_get_uuid", - args: &[("client", "*mut jack_client_t")], - ret: "*mut ::libc::c_char", - flags: FunctionFlags::NONE, - }, - // pub fn jack_session_notify( - // client: *mut jack_client_t, - // target: *const ::libc::c_char, - // _type: jack_session_event_type_t, - // path: *const ::libc::c_char, - // ) -> *mut jack_session_command_t; - Function { - name: "jack_session_notify", - args: &[ - ("client", "*mut jack_client_t"), - ("target", "*const ::libc::c_char"), - ("_type", "jack_session_event_type_t"), - ("path", "*const ::libc::c_char"), - ], - ret: "*mut jack_session_command_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_session_commands_free(cmds: *mut jack_session_command_t) -> (); - Function { - name: "jack_session_commands_free", - args: &[("cmds", "*mut jack_session_command_t")], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_reserve_client_name( - // client: *mut jack_client_t, - // name: *const ::libc::c_char, - // uuid: *const ::libc::c_char, - // ) -> ::libc::c_int; - Function { - name: "jack_reserve_client_name", - args: &[ - ("client", "*mut jack_client_t"), - ("name", "*const ::libc::c_char"), - ("uuid", "*const ::libc::c_char"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_client_has_session_callback( - // client: *mut jack_client_t, - // client_name: *const ::libc::c_char, - // ) -> ::libc::c_int; - Function { - name: "jack_client_has_session_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("client_name", "*const ::libc::c_char"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jackctl_setup_signals(flags: ::libc::c_uint) -> *mut jackctl_sigmask_t; - Function { - name: "jackctl_setup_signals", - args: &[("flags", "::libc::c_uint")], - ret: "*mut jackctl_sigmask_t", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_wait_signals(signals: *mut jackctl_sigmask_t) -> (); - Function { - name: "jackctl_wait_signals", - args: &[("signals", "*mut jackctl_sigmask_t")], - ret: "()", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_server_create( - // on_device_acquire: ::std::option::Option< - // unsafe extern "C" fn(device_name: *const ::libc::c_char) -> u8, - // >, - // on_device_release: ::std::option::Option< - // unsafe extern "C" fn(device_name: *const ::libc::c_char) -> (), - // >, - // ) -> *mut jackctl_server_t; - Function { - name: "jackctl_server_create", - args: &[ - ("on_device_acquire", "::std::option::Option u8>"), - ("on_device_release", "::std::option::Option ()>"), - ], - ret: "*mut jackctl_server_t", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_server_destroy(server: *mut jackctl_server_t) -> (); - Function { - name: "jackctl_server_destroy", - args: &[("server", "*mut jackctl_server_t")], - ret: "()", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_server_open(server: *mut jackctl_server_t, driver: *mut jackctl_driver_t) -> u8; - Function { - name: "jackctl_server_open", - args: &[ - ("server", "*mut jackctl_server_t"), - ("driver", "*mut jackctl_driver_t"), - ], - ret: "u8", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_server_start(server: *mut jackctl_server_t) -> u8; - Function { - name: "jackctl_server_start", - args: &[("server", "*mut jackctl_server_t")], - ret: "u8", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_server_stop(server: *mut jackctl_server_t) -> u8; - Function { - name: "jackctl_server_stop", - args: &[("server", "*mut jackctl_server_t")], - ret: "u8", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_server_close(server: *mut jackctl_server_t) -> u8; - Function { - name: "jackctl_server_close", - args: &[("server", "*mut jackctl_server_t")], - ret: "u8", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_server_get_drivers_list(server: *mut jackctl_server_t) -> *const JSList; - Function { - name: "jackctl_server_get_drivers_list", - args: &[("server", "*mut jackctl_server_t")], - ret: "*const JSList", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_server_get_parameters(server: *mut jackctl_server_t) -> *const JSList; - Function { - name: "jackctl_server_get_parameters", - args: &[("server", "*mut jackctl_server_t")], - ret: "*const JSList", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_server_get_internals_list(server: *mut jackctl_server_t) -> *const JSList; - Function { - name: "jackctl_server_get_internals_list", - args: &[("server", "*mut jackctl_server_t")], - ret: "*const JSList", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_server_load_internal( - // server: *mut jackctl_server_t, - // internal: *mut jackctl_internal_t, - // ) -> u8; - Function { - name: "jackctl_server_load_internal", - args: &[ - ("server", "*mut jackctl_server_t"), - ("internal", "*mut jackctl_internal_t"), - ], - ret: "u8", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_server_unload_internal( - // server: *mut jackctl_server_t, - // internal: *mut jackctl_internal_t, - // ) -> u8; - Function { - name: "jackctl_server_unload_internal", - args: &[ - ("server", "*mut jackctl_server_t"), - ("internal", "*mut jackctl_internal_t"), - ], - ret: "u8", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_server_add_slave(server: *mut jackctl_server_t, driver: *mut jackctl_driver_t) - // -> u8; - Function { - name: "jackctl_server_add_slave", - args: &[ - ("server", "*mut jackctl_server_t"), - ("driver", "*mut jackctl_driver_t"), - ], - ret: "u8", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_server_remove_slave( - // server: *mut jackctl_server_t, - // driver: *mut jackctl_driver_t, - // ) -> u8; - Function { - name: "jackctl_server_remove_slave", - args: &[ - ("server", "*mut jackctl_server_t"), - ("driver", "*mut jackctl_driver_t"), - ], - ret: "u8", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_server_switch_master( - // server: *mut jackctl_server_t, - // driver: *mut jackctl_driver_t, - // ) -> u8; - Function { - name: "jackctl_server_switch_master", - args: &[ - ("server", "*mut jackctl_server_t"), - ("driver", "*mut jackctl_driver_t"), - ], - ret: "u8", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_driver_get_name(driver: *mut jackctl_driver_t) -> *const ::libc::c_char; - Function { - name: "jackctl_driver_get_name", - args: &[("driver", "*mut jackctl_driver_t")], - ret: "*const ::libc::c_char", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_driver_get_type(driver: *mut jackctl_driver_t) -> jackctl_driver_type_t; - Function { - name: "jackctl_driver_get_type", - args: &[("driver", "*mut jackctl_driver_t")], - ret: "jackctl_driver_type_t", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_driver_get_parameters(driver: *mut jackctl_driver_t) -> *const JSList; - Function { - name: "jackctl_driver_get_parameters", - args: &[("driver", "*mut jackctl_driver_t")], - ret: "*const JSList", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_driver_params_parse( - // driver: *mut jackctl_driver_t, - // argc: ::libc::c_int, - // argv: *mut *mut ::libc::c_char, - // ) -> ::libc::c_int; - Function { - name: "jackctl_driver_params_parse", - args: &[ - ("driver", "*mut jackctl_driver_t"), - ("argc", "::libc::c_int"), - ("argv", "*mut *mut ::libc::c_char"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_internal_get_name(internal: *mut jackctl_internal_t) -> *const ::libc::c_char; - Function { - name: "jackctl_internal_get_name", - args: &[("internal", "*mut jackctl_internal_t")], - ret: "*const ::libc::c_char", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_internal_get_parameters(internal: *mut jackctl_internal_t) -> *const JSList; - Function { - name: "jackctl_internal_get_parameters", - args: &[("internal", "*mut jackctl_internal_t")], - ret: "*const JSList", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_get_name(parameter: *mut jackctl_parameter_t) -> *const ::libc::c_char; - Function { - name: "jackctl_parameter_get_name", - args: &[("parameter", "*mut jackctl_parameter_t")], - ret: "*const ::libc::c_char", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_get_short_description( - // parameter: *mut jackctl_parameter_t, - // ) -> *const ::libc::c_char; - Function { - name: "jackctl_parameter_get_short_description", - args: &[("parameter", "*mut jackctl_parameter_t")], - ret: "*const ::libc::c_char", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_get_long_description( - // parameter: *mut jackctl_parameter_t, - // ) -> *const ::libc::c_char; - Function { - name: "jackctl_parameter_get_long_description", - args: &[("parameter", "*mut jackctl_parameter_t")], - ret: "*const ::libc::c_char", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_get_type(parameter: *mut jackctl_parameter_t) -> jackctl_param_type_t; - Function { - name: "jackctl_parameter_get_type", - args: &[("parameter", "*mut jackctl_parameter_t")], - ret: "jackctl_param_type_t", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_get_id(parameter: *mut jackctl_parameter_t) -> ::libc::c_char; - Function { - name: "jackctl_parameter_get_id", - args: &[("parameter", "*mut jackctl_parameter_t")], - ret: "::libc::c_char", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_is_set(parameter: *mut jackctl_parameter_t) -> u8; - Function { - name: "jackctl_parameter_is_set", - args: &[("parameter", "*mut jackctl_parameter_t")], - ret: "u8", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_reset(parameter: *mut jackctl_parameter_t) -> u8; - Function { - name: "jackctl_parameter_reset", - args: &[("parameter", "*mut jackctl_parameter_t")], - ret: "u8", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_get_value( - // parameter: *mut jackctl_parameter_t, - // ) -> Union_jackctl_parameter_value; - Function { - name: "jackctl_parameter_get_value", - args: &[("parameter", "*mut jackctl_parameter_t")], - ret: "Union_jackctl_parameter_value", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_set_value( - // parameter: *mut jackctl_parameter_t, - // value_ptr: *const Union_jackctl_parameter_value, - // ) -> u8; - Function { - name: "jackctl_parameter_set_value", - args: &[ - ("parameter", "*mut jackctl_parameter_t"), - ("value_ptr", "*const Union_jackctl_parameter_value"), - ], - ret: "u8", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_get_default_value( - // parameter: *mut jackctl_parameter_t, - // ) -> Union_jackctl_parameter_value; - Function { - name: "jackctl_parameter_get_default_value", - args: &[("parameter", "*mut jackctl_parameter_t")], - ret: "Union_jackctl_parameter_value", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_has_range_constraint(parameter: *mut jackctl_parameter_t) -> u8; - Function { - name: "jackctl_parameter_has_range_constraint", - args: &[("parameter", "*mut jackctl_parameter_t")], - ret: "u8", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_has_enum_constraint(parameter: *mut jackctl_parameter_t) -> u8; - Function { - name: "jackctl_parameter_has_enum_constraint", - args: &[("parameter", "*mut jackctl_parameter_t")], - ret: "u8", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_get_enum_constraints_count(parameter: *mut jackctl_parameter_t) -> u32; - Function { - name: "jackctl_parameter_get_enum_constraints_count", - args: &[("parameter", "*mut jackctl_parameter_t")], - ret: "u32", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_get_enum_constraint_value( - // parameter: *mut jackctl_parameter_t, - // index: u32, - // ) -> Union_jackctl_parameter_value; - Function { - name: "jackctl_parameter_get_enum_constraint_value", - args: &[ - ("parameter", "*mut jackctl_parameter_t"), - ("index", "u32"), - ], - ret: "Union_jackctl_parameter_value", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_get_enum_constraint_description( - // parameter: *mut jackctl_parameter_t, - // index: u32, - // ) -> *const ::libc::c_char; - Function { - name: "jackctl_parameter_get_enum_constraint_description", - args: &[ - ("parameter", "*mut jackctl_parameter_t"), - ("index", "u32"), - ], - ret: "*const ::libc::c_char", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_get_range_constraint( - // parameter: *mut jackctl_parameter_t, - // min_ptr: *mut Union_jackctl_parameter_value, - // max_ptr: *mut Union_jackctl_parameter_value, - // ) -> (); - Function { - name: "jackctl_parameter_get_range_constraint", - args: &[ - ("parameter", "*mut jackctl_parameter_t"), - ("min_ptr", "*mut Union_jackctl_parameter_value"), - ("max_ptr", "*mut Union_jackctl_parameter_value"), - ], - ret: "()", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_constraint_is_strict(parameter: *mut jackctl_parameter_t) -> u8; - Function { - name: "jackctl_parameter_constraint_is_strict", - args: &[("parameter", "*mut jackctl_parameter_t")], - ret: "u8", - flags: FunctionFlags::WEAK, - }, - // pub fn jackctl_parameter_constraint_is_fake_value(parameter: *mut jackctl_parameter_t) -> u8; - Function { - name: "jackctl_parameter_constraint_is_fake_value", - args: &[("parameter", "*mut jackctl_parameter_t")], - ret: "u8", - flags: FunctionFlags::WEAK, - }, - // pub fn jack_error(format: *const ::libc::c_char, ...) -> (); - // Function { - // name: "jack_error", - // args: &[ - // ("format", "*const ::libc::c_char"), - // // Varargs not yet supported. - // // (""..."), - // ], - // ret: "()", - // flags: FunctionFlags::NONE, - // }, - // pub fn jack_info(format: *const ::libc::c_char, ...) -> (); - // Function { - // name: "jack_info", - // args: &[ - // ("format", "*const ::libc::c_char"), - // // Varargs not yet supported. - // // ("", "..."), - // ], - // ret: "()", - // flags: FunctionFlags::NONE, - // }, - // pub fn jack_log(format: *const ::libc::c_char, ...) -> (); - // Function { - // name: "jack_log", - // args: &[ - // ("format", "*const ::libc::c_char"), - // // Varargs not yet supported. - // // ("", "..."), - // ], - // ret: "()", - // flags: FunctionFlags::NONE, - // }, - // pub fn jack_set_property( - // arg1: *mut jack_client_t, - // subject: jack_uuid_t, - // key: *const ::libc::c_char, - // value: *const ::libc::c_char, - // _type: *const ::libc::c_char, - // ) -> ::libc::c_int; - Function { - name: "jack_set_property", - args: &[ - ("arg1", "*mut jack_client_t"), - ("subject", "jack_uuid_t"), - ("key", "*const ::libc::c_char"), - ("value", "*const ::libc::c_char"), - ("_type", "*const ::libc::c_char"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_get_property( - // subject: jack_uuid_t, - // key: *const ::libc::c_char, - // value: *mut *mut ::libc::c_char, - // _type: *mut *mut ::libc::c_char, - // ) -> ::libc::c_int; - Function { - name: "jack_get_property", - args: &[ - ("subject", "jack_uuid_t"), - ("key", "*const ::libc::c_char"), - ("value", "*mut *mut ::libc::c_char"), - ("_type", "*mut *mut ::libc::c_char"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_free_description( - // desc: *mut jack_description_t, - // free_description_itself: ::libc::c_int, - // ) -> (); - Function { - name: "jack_free_description", - args: &[ - ("desc", "*mut jack_description_t"), - ("free_description_itself", "::libc::c_int"), - ], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_get_properties(subject: jack_uuid_t, desc: *mut jack_description_t) -> ::libc::c_int; - Function { - name: "jack_get_properties", - args: &[ - ("subject", "jack_uuid_t"), - ("desc", "*mut jack_description_t"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_get_all_properties(descs: *mut *mut jack_description_t) -> ::libc::c_int; - Function { - name: "jack_get_all_properties", - args: &[("descs", "*mut *mut jack_description_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_remove_property( - // client: *mut jack_client_t, - // subject: jack_uuid_t, - // key: *const ::libc::c_char, - // ) -> ::libc::c_int; - Function { - name: "jack_remove_property", - args: &[ - ("client", "*mut jack_client_t"), - ("subject", "jack_uuid_t"), - ("key", "*const ::libc::c_char"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_remove_properties(client: *mut jack_client_t, subject: jack_uuid_t) -> ::libc::c_int; - Function { - name: "jack_remove_properties", - args: &[("client", "*mut jack_client_t"), ("subject", "jack_uuid_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_remove_all_properties(client: *mut jack_client_t) -> ::libc::c_int; - Function { - name: "jack_remove_all_properties", - args: &[("client", "*mut jack_client_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_set_property_change_callback( - // client: *mut jack_client_t, - // callback: JackPropertyChangeCallback, - // arg: *mut ::libc::c_void, - // ) -> ::libc::c_int; - Function { - name: "jack_set_property_change_callback", - args: &[ - ("client", "*mut jack_client_t"), - ("callback", "JackPropertyChangeCallback"), - ("arg", "*mut ::libc::c_void"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_get_internal_client_name( - // client: *mut jack_client_t, - // intclient: jack_intclient_t, - // ) -> *mut ::libc::c_char; - Function { - name: "jack_get_internal_client_name", - args: &[ - ("client", "*mut jack_client_t"), - ("intclient", "jack_intclient_t"), - ], - ret: "*mut ::libc::c_char", - flags: FunctionFlags::WEAK, - }, - // pub fn jack_internal_client_handle( - // client: *mut jack_client_t, - // client_name: *const ::libc::c_char, - // status: *mut jack_status_t, - // ) -> jack_intclient_t; - Function { - name: "jack_internal_client_handle", - args: &[ - ("client", "*mut jack_client_t"), - ("client_name", "*const ::libc::c_char"), - ("status", "*mut jack_status_t"), - ], - ret: "jack_intclient_t", - flags: FunctionFlags::WEAK, - }, - // pub fn jack_internal_client_load( - // client: *mut jack_client_t, - // client_name: *const ::libc::c_char, - // options: jack_options_t, - // status: *mut jack_status_t, - // ... - // ) -> jack_intclient_t; - Function { - name: "jack_internal_client_load", - args: &[ - ("client", "*mut jack_client_t"), - ("client_name", "*const ::libc::c_char"), - ("options", "jack_options_t"), - ("status", "*mut jack_status_t"), - ("load_name", "*const ::libc::c_char"), - ("load_init", "*const ::libc::c_char"), - // Varargs not supported. - // ("", "..."), - ], - ret: "jack_intclient_t", - flags: FunctionFlags::WEAK, - }, - // pub fn jack_internal_client_unload( - // client: *mut jack_client_t, - // intclient: jack_intclient_t, - // ) -> jack_status_t; - Function { - name: "jack_internal_client_unload", - args: &[ - ("client", "*mut jack_client_t"), - ("intclient", "jack_intclient_t"), - ], - ret: "jack_status_t", - flags: FunctionFlags::WEAK, - }, - // pub fn jack_get_max_delayed_usecs(client: *mut jack_client_t) -> ::libc::c_float; - Function { - name: "jack_get_max_delayed_usecs", - args: &[("client", "*mut jack_client_t")], - ret: "::libc::c_float", - flags: FunctionFlags::NONE, - }, - // pub fn jack_get_xrun_delayed_usecs(client: *mut jack_client_t) -> ::libc::c_float; - Function { - name: "jack_get_xrun_delayed_usecs", - args: &[("client", "*mut jack_client_t")], - ret: "::libc::c_float", - flags: FunctionFlags::NONE, - }, - // pub fn jack_reset_max_delayed_usecs(client: *mut jack_client_t) -> (); - Function { - name: "jack_reset_max_delayed_usecs", - args: &[("client", "*mut jack_client_t")], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_midi_get_event_count(port_buffer: *mut ::libc::c_void) -> u32; - Function { - name: "jack_midi_get_event_count", - args: &[("port_buffer", "*mut ::libc::c_void")], - ret: "u32", - flags: FunctionFlags::NONE, - }, - // pub fn jack_midi_event_get( - // event: *mut jack_midi_event_t, - // port_buffer: *mut ::libc::c_void, - // event_index: u32, - // ) -> ::libc::c_int; - Function { - name: "jack_midi_event_get", - args: &[ - ("event", "*mut jack_midi_event_t"), - ("port_buffer", "*mut ::libc::c_void"), - ("event_index", "u32"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_midi_clear_buffer(port_buffer: *mut ::libc::c_void) -> (); - Function { - name: "jack_midi_clear_buffer", - args: &[("port_buffer", "*mut ::libc::c_void")], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_midi_max_event_size(port_buffer: *mut ::libc::c_void) -> ::libc::size_t; - Function { - name: "jack_midi_max_event_size", - args: &[("port_buffer", "*mut ::libc::c_void")], - ret: "::libc::size_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_midi_event_reserve( - // port_buffer: *mut ::libc::c_void, - // time: jack_nframes_t, - // data_size: ::libc::size_t, - // ) -> *mut jack_midi_data_t; - Function { - name: "jack_midi_event_reserve", - args: &[ - ("port_buffer", "*mut ::libc::c_void"), - ("time", "jack_nframes_t"), - ("data_size", "::libc::size_t"), - ], - ret: "*mut jack_midi_data_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_midi_event_write( - // port_buffer: *mut ::libc::c_void, - // time: jack_nframes_t, - // data: *const jack_midi_data_t, - // data_size: ::libc::size_t, - // ) -> ::libc::c_int; - Function { - name: "jack_midi_event_write", - args: &[ - ("port_buffer", "*mut ::libc::c_void"), - ("time", "jack_nframes_t"), - ("data", "*const jack_midi_data_t"), - ("data_size", "::libc::size_t"), - ], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_midi_get_lost_event_count(port_buffer: *mut ::libc::c_void) -> u32; - Function { - name: "jack_midi_get_lost_event_count", - args: &[("port_buffer", "*mut ::libc::c_void")], - ret: "u32", - flags: FunctionFlags::NONE, - }, - // pub fn jack_ringbuffer_create(sz: ::libc::size_t) -> *mut jack_ringbuffer_t; - Function { - name: "jack_ringbuffer_create", - args: &[("sz", "::libc::size_t")], - ret: "*mut jack_ringbuffer_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_ringbuffer_free(rb: *mut jack_ringbuffer_t) -> (); - Function { - name: "jack_ringbuffer_free", - args: &[("rb", "*mut jack_ringbuffer_t")], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_ringbuffer_get_read_vector( - // rb: *const jack_ringbuffer_t, - // vec: *mut jack_ringbuffer_data_t, - // ) -> (); - Function { - name: "jack_ringbuffer_get_read_vector", - args: &[ - ("rb", "*const jack_ringbuffer_t"), - ("vec", "*mut jack_ringbuffer_data_t"), - ], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_ringbuffer_get_write_vector( - // rb: *const jack_ringbuffer_t, - // vec: *mut jack_ringbuffer_data_t, - // ) -> (); - Function { - name: "jack_ringbuffer_get_write_vector", - args: &[ - ("rb", "*const jack_ringbuffer_t"), - ("vec", "*mut jack_ringbuffer_data_t"), - ], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_ringbuffer_read( - // rb: *mut jack_ringbuffer_t, - // dest: *mut ::libc::c_char, - // cnt: ::libc::size_t, - // ) -> ::libc::size_t; - Function { - name: "jack_ringbuffer_read", - args: &[ - ("rb", "*mut jack_ringbuffer_t"), - ("dest", "*mut ::libc::c_char"), - ("cnt", "::libc::size_t"), - ], - ret: "::libc::size_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_ringbuffer_peek( - // rb: *mut jack_ringbuffer_t, - // dest: *mut ::libc::c_char, - // cnt: ::libc::size_t, - // ) -> ::libc::size_t; - Function { - name: "jack_ringbuffer_peek", - args: &[ - ("rb", "*mut jack_ringbuffer_t"), - ("dest", "*mut ::libc::c_char"), - ("cnt", "::libc::size_t"), - ], - ret: "::libc::size_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_ringbuffer_read_advance(rb: *mut jack_ringbuffer_t, cnt: ::libc::size_t) -> (); - Function { - name: "jack_ringbuffer_read_advance", - args: &[("rb", "*mut jack_ringbuffer_t"), ("cnt", "::libc::size_t")], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_ringbuffer_read_space(rb: *const jack_ringbuffer_t) -> ::libc::size_t; - Function { - name: "jack_ringbuffer_read_space", - args: &[("rb", "*const jack_ringbuffer_t")], - ret: "::libc::size_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_ringbuffer_mlock(rb: *mut jack_ringbuffer_t) -> ::libc::c_int; - Function { - name: "jack_ringbuffer_mlock", - args: &[("rb", "*mut jack_ringbuffer_t")], - ret: "::libc::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_ringbuffer_reset(rb: *mut jack_ringbuffer_t) -> (); - Function { - name: "jack_ringbuffer_reset", - args: &[("rb", "*mut jack_ringbuffer_t")], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_ringbuffer_write( - // rb: *mut jack_ringbuffer_t, - // src: *const ::libc::c_char, - // cnt: ::libc::size_t, - // ) -> ::libc::size_t; - Function { - name: "jack_ringbuffer_write", - args: &[ - ("rb", "*mut jack_ringbuffer_t"), - ("src", "*const ::libc::c_char"), - ("cnt", "::libc::size_t"), - ], - ret: "::libc::size_t", - flags: FunctionFlags::NONE, - }, - // pub fn jack_ringbuffer_write_advance(rb: *mut jack_ringbuffer_t, cnt: ::libc::size_t) -> (); - Function { - name: "jack_ringbuffer_write_advance", - args: &[("rb", "*mut jack_ringbuffer_t"), ("cnt", "::libc::size_t")], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_ringbuffer_write_space(rb: *const jack_ringbuffer_t) -> ::libc::size_t; - Function { - name: "jack_ringbuffer_write_space", - args: &[("rb", "*const jack_ringbuffer_t")], - ret: "::libc::size_t", - flags: FunctionFlags::NONE, - }, - - // pub fn jack_uuid_to_index(arg1: jack_uuid_t) -> u32; - Function { - name: "jack_uuid_to_index", - args: &[("arg1", "jack_uuid_t")], - ret: "u32", - flags: FunctionFlags::NONE, - }, - // pub fn jack_uuid_compare(arg1: jack_uuid_t, arg2: jack_uuid_t) -> ::std::os::raw::c_int; - Function { - name: "jack_uuid_compare", - args: &[("arg1", "jack_uuid_t"), ("arg2", "jack_uuid_t")], - ret: "::std::os::raw::c_int", - flags: FunctionFlags::NONE, - }, - // pub fn jack_uuid_copy(dst: *mut jack_uuid_t, src: jack_uuid_t); - Function { - name: "jack_uuid_copy", - args: &[("dst", "*mut jack_uuid_t"), ("src", "jack_uuid_t")], - ret: "()", - flags: FunctionFlags::NONE, - }, - // pub fn jack_uuid_clear(arg1: *mut jack_uuid_t); - Function { - name: "jack_uuid_clear", - args: &[("arg1", "*mut jack_uuid_t")], - ret: "()", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_uuid_parse", - args: &[ - ("buf", "*const ::std::os::raw::c_char"), - ("arg1", "*mut jack_uuid_t"), - ], - ret: "::std::os::raw::c_int", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_uuid_unparse", - args: &[ - ("arg1", "jack_uuid_t"), - ("buf", "*mut ::std::os::raw::c_char"), - ], - ret: "()", - flags: FunctionFlags::NONE, - }, - Function { - name: "jack_uuid_empty", - args: &[("arg1", "jack_uuid_t")], - ret: "::std::os::raw::c_int", - flags: FunctionFlags::NONE, - }, -]; diff --git a/jack-sys/src/functions/dynamic_linking.rs b/jack-sys/src/functions/dynamic_linking.rs new file mode 100644 index 000000000..61fe13f59 --- /dev/null +++ b/jack-sys/src/functions/dynamic_linking.rs @@ -0,0 +1,661 @@ +use crate::types::*; +pub unsafe fn jack_get_cycle_times( + _client: *const jack_client_t, + _current_frames: *mut jack_nframes_t, + _current_usecs: *mut jack_time_t, + _next_usecs: *mut jack_time_t, + _period_usecs: *mut ::libc::c_float, +) -> Option<::libc::c_int> { + None +} +pub unsafe fn jack_internal_client_new( + _client_name: *const ::libc::c_char, + _load_name: *const ::libc::c_char, + _load_init: *const ::libc::c_char, +) -> Option<::libc::c_int> { + None +} +pub unsafe fn jack_internal_client_close(_client_name: *const ::libc::c_char) -> Option<()> { + None +} +pub unsafe fn jack_get_client_pid(_name: *const ::libc::c_char) -> Option<::libc::c_int> { + None +} +pub unsafe fn jack_port_type_id(_port: *const jack_port_t) -> Option { + None +} +pub unsafe fn jackctl_setup_signals(_flags: ::libc::c_uint) -> Option<*mut jackctl_sigmask_t> { + None +} +pub unsafe fn jackctl_wait_signals(_signals: *mut jackctl_sigmask_t) -> Option<()> { + None +} +pub unsafe fn jackctl_server_create( + _on_device_acquire: ::std::option::Option< + unsafe extern "C" fn(device_name: *const ::libc::c_char) -> u8, + >, + _on_device_release: ::std::option::Option< + unsafe extern "C" fn(device_name: *const ::libc::c_char) -> (), + >, +) -> Option<*mut jackctl_server_t> { + None +} +pub unsafe fn jackctl_server_destroy(_server: *mut jackctl_server_t) -> Option<()> { + None +} +pub unsafe fn jackctl_server_open( + _server: *mut jackctl_server_t, + _driver: *mut jackctl_driver_t, +) -> Option { + None +} +pub unsafe fn jackctl_server_start(_server: *mut jackctl_server_t) -> Option { + None +} +pub unsafe fn jackctl_server_stop(_server: *mut jackctl_server_t) -> Option { + None +} +pub unsafe fn jackctl_server_close(_server: *mut jackctl_server_t) -> Option { + None +} +pub unsafe fn jackctl_server_get_drivers_list( + _server: *mut jackctl_server_t, +) -> Option<*const JSList> { + None +} +pub unsafe fn jackctl_server_get_parameters( + _server: *mut jackctl_server_t, +) -> Option<*const JSList> { + None +} +pub unsafe fn jackctl_server_get_internals_list( + _server: *mut jackctl_server_t, +) -> Option<*const JSList> { + None +} +pub unsafe fn jackctl_server_load_internal( + _server: *mut jackctl_server_t, + _internal: *mut jackctl_internal_t, +) -> Option { + None +} +pub unsafe fn jackctl_server_unload_internal( + _server: *mut jackctl_server_t, + _internal: *mut jackctl_internal_t, +) -> Option { + None +} +pub unsafe fn jackctl_server_add_slave( + _server: *mut jackctl_server_t, + _driver: *mut jackctl_driver_t, +) -> Option { + None +} +pub unsafe fn jackctl_server_remove_slave( + _server: *mut jackctl_server_t, + _driver: *mut jackctl_driver_t, +) -> Option { + None +} +pub unsafe fn jackctl_server_switch_master( + _server: *mut jackctl_server_t, + _driver: *mut jackctl_driver_t, +) -> Option { + None +} +pub unsafe fn jackctl_driver_get_name( + _driver: *mut jackctl_driver_t, +) -> Option<*const ::libc::c_char> { + None +} +pub unsafe fn jackctl_driver_get_type( + _driver: *mut jackctl_driver_t, +) -> Option { + None +} +pub unsafe fn jackctl_driver_get_parameters( + _driver: *mut jackctl_driver_t, +) -> Option<*const JSList> { + None +} +pub unsafe fn jackctl_driver_params_parse( + _driver: *mut jackctl_driver_t, + _argc: ::libc::c_int, + _argv: *mut *mut ::libc::c_char, +) -> Option<::libc::c_int> { + None +} +pub unsafe fn jackctl_internal_get_name( + _internal: *mut jackctl_internal_t, +) -> Option<*const ::libc::c_char> { + None +} +pub unsafe fn jackctl_internal_get_parameters( + _internal: *mut jackctl_internal_t, +) -> Option<*const JSList> { + None +} +pub unsafe fn jackctl_parameter_get_name( + _parameter: *mut jackctl_parameter_t, +) -> Option<*const ::libc::c_char> { + None +} +pub unsafe fn jackctl_parameter_get_short_description( + _parameter: *mut jackctl_parameter_t, +) -> Option<*const ::libc::c_char> { + None +} +pub unsafe fn jackctl_parameter_get_long_description( + _parameter: *mut jackctl_parameter_t, +) -> Option<*const ::libc::c_char> { + None +} +pub unsafe fn jackctl_parameter_get_type( + _parameter: *mut jackctl_parameter_t, +) -> Option { + None +} +pub unsafe fn jackctl_parameter_get_id( + _parameter: *mut jackctl_parameter_t, +) -> Option<::libc::c_char> { + None +} +pub unsafe fn jackctl_parameter_is_set(_parameter: *mut jackctl_parameter_t) -> Option { + None +} +pub unsafe fn jackctl_parameter_reset(_parameter: *mut jackctl_parameter_t) -> Option { + None +} +pub unsafe fn jackctl_parameter_get_value( + _parameter: *mut jackctl_parameter_t, +) -> Option { + None +} +pub unsafe fn jackctl_parameter_set_value( + _parameter: *mut jackctl_parameter_t, + _value_ptr: *const Union_jackctl_parameter_value, +) -> Option { + None +} +pub unsafe fn jackctl_parameter_get_default_value( + _parameter: *mut jackctl_parameter_t, +) -> Option { + None +} +pub unsafe fn jackctl_parameter_has_range_constraint( + _parameter: *mut jackctl_parameter_t, +) -> Option { + None +} +pub unsafe fn jackctl_parameter_has_enum_constraint( + _parameter: *mut jackctl_parameter_t, +) -> Option { + None +} +pub unsafe fn jackctl_parameter_get_enum_constraints_count( + _parameter: *mut jackctl_parameter_t, +) -> Option { + None +} +pub unsafe fn jackctl_parameter_get_enum_constraint_value( + _parameter: *mut jackctl_parameter_t, + _index: u32, +) -> Option { + None +} +pub unsafe fn jackctl_parameter_get_enum_constraint_description( + _parameter: *mut jackctl_parameter_t, + _index: u32, +) -> Option<*const ::libc::c_char> { + None +} +pub unsafe fn jackctl_parameter_get_range_constraint( + _parameter: *mut jackctl_parameter_t, + _min_ptr: *mut Union_jackctl_parameter_value, + _max_ptr: *mut Union_jackctl_parameter_value, +) -> Option<()> { + None +} +pub unsafe fn jackctl_parameter_constraint_is_strict( + _parameter: *mut jackctl_parameter_t, +) -> Option { + None +} +pub unsafe fn jackctl_parameter_constraint_is_fake_value( + _parameter: *mut jackctl_parameter_t, +) -> Option { + None +} +pub unsafe fn jack_get_internal_client_name( + _client: *mut jack_client_t, + _intclient: jack_intclient_t, +) -> Option<*mut ::libc::c_char> { + None +} +pub unsafe fn jack_internal_client_handle( + _client: *mut jack_client_t, + _client_name: *const ::libc::c_char, + _status: *mut jack_status_t, +) -> Option { + None +} +pub unsafe fn jack_internal_client_load( + _client: *mut jack_client_t, + _client_name: *const ::libc::c_char, + _options: jack_options_t, + _status: *mut jack_status_t, + _load_name: *const ::libc::c_char, + _load_init: *const ::libc::c_char, +) -> Option { + None +} +pub unsafe fn jack_internal_client_unload( + _client: *mut jack_client_t, + _intclient: jack_intclient_t, +) -> Option { + None +} +#[link(name = "jack")] +extern "C" { + pub fn jack_release_timebase(client: *mut jack_client_t) -> ::libc::c_int; + pub fn jack_set_sync_callback( + client: *mut jack_client_t, + sync_callback: JackSyncCallback, + sync_arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_set_sync_timeout(client: *mut jack_client_t, timeout: jack_time_t) + -> ::libc::c_int; + pub fn jack_set_timebase_callback( + client: *mut jack_client_t, + conditional: ::libc::c_int, + timebase_callback: TimebaseCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_transport_locate( + client: *mut jack_client_t, + frame: jack_nframes_t, + ) -> ::libc::c_int; + pub fn jack_transport_query( + client: *const jack_client_t, + pos: *mut jack_position_t, + ) -> jack_transport_state_t; + pub fn jack_get_current_transport_frame(client: *const jack_client_t) -> jack_nframes_t; + pub fn jack_transport_reposition( + client: *mut jack_client_t, + pos: *const jack_position_t, + ) -> ::libc::c_int; + pub fn jack_transport_start(client: *mut jack_client_t) -> (); + pub fn jack_transport_stop(client: *mut jack_client_t) -> (); + pub fn jack_get_transport_info( + client: *mut jack_client_t, + tinfo: *mut jack_transport_info_t, + ) -> (); + pub fn jack_set_transport_info( + client: *mut jack_client_t, + tinfo: *mut jack_transport_info_t, + ) -> (); + pub fn jack_client_open( + client_name: *const ::libc::c_char, + options: jack_options_t, + status: *mut jack_status_t, + ) -> *mut jack_client_t; + pub fn jack_client_new(client_name: *const ::libc::c_char) -> *mut jack_client_t; + pub fn jack_client_close(client: *mut jack_client_t) -> ::libc::c_int; + pub fn jack_client_name_size() -> ::libc::c_int; + pub fn jack_get_client_name(client: *mut jack_client_t) -> *mut ::libc::c_char; + pub fn jack_get_uuid_for_client_name( + client: *mut jack_client_t, + client_name: *const ::libc::c_char, + ) -> *mut ::libc::c_char; + pub fn jack_get_client_name_by_uuid( + client: *mut jack_client_t, + client_uuid: *const ::libc::c_char, + ) -> *mut ::libc::c_char; + pub fn jack_activate(client: *mut jack_client_t) -> ::libc::c_int; + pub fn jack_deactivate(client: *mut jack_client_t) -> ::libc::c_int; + pub fn jack_is_realtime(client: *mut jack_client_t) -> ::libc::c_int; + pub fn jack_thread_wait(client: *mut jack_client_t, status: ::libc::c_int) -> jack_nframes_t; + pub fn jack_cycle_wait(client: *mut jack_client_t) -> jack_nframes_t; + pub fn jack_cycle_signal(client: *mut jack_client_t, status: ::libc::c_int) -> (); + pub fn jack_set_process_thread( + client: *mut jack_client_t, + thread_callback: JackThreadCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_set_thread_init_callback( + client: *mut jack_client_t, + thread_init_callback: JackThreadInitCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_on_shutdown( + client: *mut jack_client_t, + callback: JackShutdownCallback, + arg: *mut ::libc::c_void, + ) -> (); + pub fn jack_on_info_shutdown( + client: *mut jack_client_t, + callback: JackInfoShutdownCallback, + arg: *mut ::libc::c_void, + ) -> (); + pub fn jack_set_process_callback( + client: *mut jack_client_t, + process_callback: JackProcessCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_set_freewheel_callback( + client: *mut jack_client_t, + freewheel_callback: JackFreewheelCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_set_buffer_size_callback( + client: *mut jack_client_t, + bufsize_callback: JackBufferSizeCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_get_sample_rate(client: *mut jack_client_t) -> ::libc::c_int; + pub fn jack_set_sample_rate_callback( + client: *mut jack_client_t, + srate_callback: JackSampleRateCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_set_client_registration_callback( + client: *mut jack_client_t, + registration_callback: JackClientRegistrationCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_set_port_registration_callback( + client: *mut jack_client_t, + registration_callback: JackPortRegistrationCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_set_port_connect_callback( + client: *mut jack_client_t, + connect_callback: JackPortConnectCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_set_port_rename_callback( + client: *mut jack_client_t, + rename_callback: JackPortRenameCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_set_graph_order_callback( + client: *mut jack_client_t, + graph_callback: JackGraphOrderCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_set_xrun_callback( + client: *mut jack_client_t, + xrun_callback: JackXRunCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_set_latency_callback( + client: *mut jack_client_t, + latency_callback: JackLatencyCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_set_freewheel(client: *mut jack_client_t, onoff: ::libc::c_int) -> ::libc::c_int; + pub fn jack_set_buffer_size( + client: *mut jack_client_t, + nframes: jack_nframes_t, + ) -> ::libc::c_int; + pub fn jack_get_buffer_size(client: *mut jack_client_t) -> jack_nframes_t; + pub fn jack_engine_takeover_timebase(client: *mut jack_client_t) -> ::libc::c_int; + pub fn jack_cpu_load(client: *mut jack_client_t) -> ::libc::c_float; + pub fn jack_port_register( + client: *mut jack_client_t, + port_name: *const ::libc::c_char, + port_type: *const ::libc::c_char, + flags: ::libc::c_ulong, + buffer_size: ::libc::c_ulong, + ) -> *mut jack_port_t; + pub fn jack_port_unregister( + client: *mut jack_client_t, + port: *mut jack_port_t, + ) -> ::libc::c_int; + pub fn jack_port_get_buffer( + port: *mut jack_port_t, + nframes: jack_nframes_t, + ) -> *mut ::libc::c_void; + pub fn jack_port_uuid(port: *mut jack_port_t) -> jack_uuid_t; + pub fn jack_port_name(port: *mut jack_port_t) -> *const ::libc::c_char; + pub fn jack_port_short_name(port: *mut jack_port_t) -> *const ::libc::c_char; + pub fn jack_port_flags(port: *mut jack_port_t) -> ::libc::c_int; + pub fn jack_port_type(port: *const jack_port_t) -> *const ::libc::c_char; + pub fn jack_port_is_mine( + client: *const jack_client_t, + port: *const jack_port_t, + ) -> ::libc::c_int; + pub fn jack_port_connected(port: *const jack_port_t) -> ::libc::c_int; + pub fn jack_port_connected_to( + port: *const jack_port_t, + port_name: *const ::libc::c_char, + ) -> ::libc::c_int; + pub fn jack_port_get_connections(port: *const jack_port_t) -> *mut *const ::libc::c_char; + pub fn jack_port_get_all_connections( + client: *const jack_client_t, + port: *const jack_port_t, + ) -> *mut *const ::libc::c_char; + pub fn jack_port_tie(src: *mut jack_port_t, dst: *mut jack_port_t) -> ::libc::c_int; + pub fn jack_port_untie(port: *mut jack_port_t) -> ::libc::c_int; + pub fn jack_port_set_name( + port: *mut jack_port_t, + port_name: *const ::libc::c_char, + ) -> ::libc::c_int; + pub fn jack_port_set_alias( + port: *mut jack_port_t, + alias: *const ::libc::c_char, + ) -> ::libc::c_int; + pub fn jack_port_unset_alias( + port: *mut jack_port_t, + alias: *const ::libc::c_char, + ) -> ::libc::c_int; + pub fn jack_port_get_aliases( + port: *const jack_port_t, + aliases: *mut *mut ::libc::c_char, + ) -> ::libc::c_int; + pub fn jack_port_request_monitor(port: *mut jack_port_t, onoff: ::libc::c_int) + -> ::libc::c_int; + pub fn jack_port_request_monitor_by_name( + client: *mut jack_client_t, + port_name: *const ::libc::c_char, + onoff: ::libc::c_int, + ) -> ::libc::c_int; + pub fn jack_port_ensure_monitor(port: *mut jack_port_t, onoff: ::libc::c_int) -> ::libc::c_int; + pub fn jack_port_monitoring_input(port: *mut jack_port_t) -> ::libc::c_int; + pub fn jack_connect( + client: *mut jack_client_t, + source_port: *const ::libc::c_char, + destination_port: *const ::libc::c_char, + ) -> ::libc::c_int; + pub fn jack_disconnect( + client: *mut jack_client_t, + source_port: *const ::libc::c_char, + destination_port: *const ::libc::c_char, + ) -> ::libc::c_int; + pub fn jack_port_disconnect( + client: *mut jack_client_t, + port: *mut jack_port_t, + ) -> ::libc::c_int; + pub fn jack_port_name_size() -> ::libc::c_int; + pub fn jack_port_type_size() -> ::libc::c_int; + pub fn jack_port_type_get_buffer_size( + client: *mut jack_client_t, + port_type: *const ::libc::c_char, + ) -> ::libc::size_t; + pub fn jack_port_set_latency(port: *mut jack_port_t, arg1: jack_nframes_t) -> (); + pub fn jack_port_get_latency_range( + port: *mut jack_port_t, + mode: jack_latency_callback_mode_t, + range: *mut jack_latency_range_t, + ) -> (); + pub fn jack_port_set_latency_range( + port: *mut jack_port_t, + mode: jack_latency_callback_mode_t, + range: *mut jack_latency_range_t, + ) -> (); + pub fn jack_recompute_total_latencies(client: *mut jack_client_t) -> ::libc::c_int; + pub fn jack_port_get_latency(port: *mut jack_port_t) -> jack_nframes_t; + pub fn jack_port_get_total_latency( + client: *mut jack_client_t, + port: *mut jack_port_t, + ) -> jack_nframes_t; + pub fn jack_recompute_total_latency( + arg1: *mut jack_client_t, + port: *mut jack_port_t, + ) -> ::libc::c_int; + pub fn jack_get_ports( + client: *mut jack_client_t, + port_name_pattern: *const ::libc::c_char, + type_name_pattern: *const ::libc::c_char, + flags: ::libc::c_ulong, + ) -> *mut *const ::libc::c_char; + pub fn jack_port_by_name( + client: *mut jack_client_t, + port_name: *const ::libc::c_char, + ) -> *mut jack_port_t; + pub fn jack_port_by_id(client: *mut jack_client_t, port_id: jack_port_id_t) + -> *mut jack_port_t; + pub fn jack_frames_since_cycle_start(arg1: *const jack_client_t) -> jack_nframes_t; + pub fn jack_frame_time(arg1: *const jack_client_t) -> jack_nframes_t; + pub fn jack_last_frame_time(client: *const jack_client_t) -> jack_nframes_t; + pub fn jack_frames_to_time(client: *const jack_client_t, arg1: jack_nframes_t) -> jack_time_t; + pub fn jack_time_to_frames(client: *const jack_client_t, arg1: jack_time_t) -> jack_nframes_t; + pub fn jack_get_time() -> jack_time_t; + pub fn jack_set_error_function( + func: ::std::option::Option ()>, + ) -> (); + pub fn jack_set_info_function( + func: ::std::option::Option ()>, + ) -> (); + pub fn jack_free(ptr: *mut ::libc::c_void) -> (); + pub fn jack_client_real_time_priority(arg1: *mut jack_client_t) -> ::libc::c_int; + pub fn jack_client_max_real_time_priority(arg1: *mut jack_client_t) -> ::libc::c_int; + pub fn jack_set_session_callback( + client: *mut jack_client_t, + session_callback: JackSessionCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_session_reply( + client: *mut jack_client_t, + event: *mut jack_session_event_t, + ) -> ::libc::c_int; + pub fn jack_session_event_free(event: *mut jack_session_event_t) -> (); + pub fn jack_client_get_uuid(client: *mut jack_client_t) -> *mut ::libc::c_char; + pub fn jack_session_notify( + client: *mut jack_client_t, + target: *const ::libc::c_char, + _type: jack_session_event_type_t, + path: *const ::libc::c_char, + ) -> *mut jack_session_command_t; + pub fn jack_session_commands_free(cmds: *mut jack_session_command_t) -> (); + pub fn jack_reserve_client_name( + client: *mut jack_client_t, + name: *const ::libc::c_char, + uuid: *const ::libc::c_char, + ) -> ::libc::c_int; + pub fn jack_client_has_session_callback( + client: *mut jack_client_t, + client_name: *const ::libc::c_char, + ) -> ::libc::c_int; + pub fn jack_set_property( + arg1: *mut jack_client_t, + subject: jack_uuid_t, + key: *const ::libc::c_char, + value: *const ::libc::c_char, + _type: *const ::libc::c_char, + ) -> ::libc::c_int; + pub fn jack_get_property( + subject: jack_uuid_t, + key: *const ::libc::c_char, + value: *mut *mut ::libc::c_char, + _type: *mut *mut ::libc::c_char, + ) -> ::libc::c_int; + pub fn jack_free_description( + desc: *mut jack_description_t, + free_description_itself: ::libc::c_int, + ) -> (); + pub fn jack_get_properties( + subject: jack_uuid_t, + desc: *mut jack_description_t, + ) -> ::libc::c_int; + pub fn jack_get_all_properties(descs: *mut *mut jack_description_t) -> ::libc::c_int; + pub fn jack_remove_property( + client: *mut jack_client_t, + subject: jack_uuid_t, + key: *const ::libc::c_char, + ) -> ::libc::c_int; + pub fn jack_remove_properties( + client: *mut jack_client_t, + subject: jack_uuid_t, + ) -> ::libc::c_int; + pub fn jack_remove_all_properties(client: *mut jack_client_t) -> ::libc::c_int; + pub fn jack_set_property_change_callback( + client: *mut jack_client_t, + callback: JackPropertyChangeCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + pub fn jack_get_max_delayed_usecs(client: *mut jack_client_t) -> ::libc::c_float; + pub fn jack_get_xrun_delayed_usecs(client: *mut jack_client_t) -> ::libc::c_float; + pub fn jack_reset_max_delayed_usecs(client: *mut jack_client_t) -> (); + pub fn jack_midi_get_event_count(port_buffer: *mut ::libc::c_void) -> u32; + pub fn jack_midi_event_get( + event: *mut jack_midi_event_t, + port_buffer: *mut ::libc::c_void, + event_index: u32, + ) -> ::libc::c_int; + pub fn jack_midi_clear_buffer(port_buffer: *mut ::libc::c_void) -> (); + pub fn jack_midi_max_event_size(port_buffer: *mut ::libc::c_void) -> ::libc::size_t; + pub fn jack_midi_event_reserve( + port_buffer: *mut ::libc::c_void, + time: jack_nframes_t, + data_size: ::libc::size_t, + ) -> *mut jack_midi_data_t; + pub fn jack_midi_event_write( + port_buffer: *mut ::libc::c_void, + time: jack_nframes_t, + data: *const jack_midi_data_t, + data_size: ::libc::size_t, + ) -> ::libc::c_int; + pub fn jack_midi_get_lost_event_count(port_buffer: *mut ::libc::c_void) -> u32; + pub fn jack_ringbuffer_create(sz: ::libc::size_t) -> *mut jack_ringbuffer_t; + pub fn jack_ringbuffer_free(rb: *mut jack_ringbuffer_t) -> (); + pub fn jack_ringbuffer_get_read_vector( + rb: *const jack_ringbuffer_t, + vec: *mut jack_ringbuffer_data_t, + ) -> (); + pub fn jack_ringbuffer_get_write_vector( + rb: *const jack_ringbuffer_t, + vec: *mut jack_ringbuffer_data_t, + ) -> (); + pub fn jack_ringbuffer_read( + rb: *mut jack_ringbuffer_t, + dest: *mut ::libc::c_char, + cnt: ::libc::size_t, + ) -> ::libc::size_t; + pub fn jack_ringbuffer_peek( + rb: *mut jack_ringbuffer_t, + dest: *mut ::libc::c_char, + cnt: ::libc::size_t, + ) -> ::libc::size_t; + pub fn jack_ringbuffer_read_advance(rb: *mut jack_ringbuffer_t, cnt: ::libc::size_t) -> (); + pub fn jack_ringbuffer_read_space(rb: *const jack_ringbuffer_t) -> ::libc::size_t; + pub fn jack_ringbuffer_mlock(rb: *mut jack_ringbuffer_t) -> ::libc::c_int; + pub fn jack_ringbuffer_reset(rb: *mut jack_ringbuffer_t) -> (); + pub fn jack_ringbuffer_write( + rb: *mut jack_ringbuffer_t, + src: *const ::libc::c_char, + cnt: ::libc::size_t, + ) -> ::libc::size_t; + pub fn jack_ringbuffer_write_advance(rb: *mut jack_ringbuffer_t, cnt: ::libc::size_t) -> (); + pub fn jack_ringbuffer_write_space(rb: *const jack_ringbuffer_t) -> ::libc::size_t; + pub fn jack_uuid_to_index(arg1: jack_uuid_t) -> u32; + pub fn jack_uuid_compare(arg1: jack_uuid_t, arg2: jack_uuid_t) -> ::std::os::raw::c_int; + pub fn jack_uuid_copy(dst: *mut jack_uuid_t, src: jack_uuid_t) -> (); + pub fn jack_uuid_clear(arg1: *mut jack_uuid_t) -> (); + pub fn jack_uuid_parse( + buf: *const ::std::os::raw::c_char, + arg1: *mut jack_uuid_t, + ) -> ::std::os::raw::c_int; + pub fn jack_uuid_unparse(arg1: jack_uuid_t, buf: *mut ::std::os::raw::c_char) -> (); + pub fn jack_uuid_empty(arg1: jack_uuid_t) -> ::std::os::raw::c_int; +} diff --git a/jack-sys/src/functions/dynamic_loading.rs b/jack-sys/src/functions/dynamic_loading.rs new file mode 100644 index 000000000..3a266ab98 --- /dev/null +++ b/jack-sys/src/functions/dynamic_loading.rs @@ -0,0 +1,3988 @@ +use crate::types::*; +use lazy_static::lazy_static; + +pub struct JackFunctions { + jack_release_timebase_impl: unsafe extern "C" fn(*mut jack_client_t) -> ::libc::c_int, + jack_get_cycle_times_impl: Option< + unsafe extern "C" fn( + *const jack_client_t, + *mut jack_nframes_t, + *mut jack_time_t, + *mut jack_time_t, + *mut ::libc::c_float, + ) -> ::libc::c_int, + >, + jack_set_sync_callback_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackSyncCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_set_sync_timeout_impl: + unsafe extern "C" fn(*mut jack_client_t, jack_time_t) -> ::libc::c_int, + jack_set_timebase_callback_impl: unsafe extern "C" fn( + *mut jack_client_t, + ::libc::c_int, + TimebaseCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_transport_locate_impl: + unsafe extern "C" fn(*mut jack_client_t, jack_nframes_t) -> ::libc::c_int, + jack_transport_query_impl: + unsafe extern "C" fn(*const jack_client_t, *mut jack_position_t) -> jack_transport_state_t, + jack_get_current_transport_frame_impl: + unsafe extern "C" fn(*const jack_client_t) -> jack_nframes_t, + jack_transport_reposition_impl: + unsafe extern "C" fn(*mut jack_client_t, *const jack_position_t) -> ::libc::c_int, + jack_transport_start_impl: unsafe extern "C" fn(*mut jack_client_t) -> (), + jack_transport_stop_impl: unsafe extern "C" fn(*mut jack_client_t) -> (), + jack_get_transport_info_impl: + unsafe extern "C" fn(*mut jack_client_t, *mut jack_transport_info_t) -> (), + jack_set_transport_info_impl: + unsafe extern "C" fn(*mut jack_client_t, *mut jack_transport_info_t) -> (), + jack_client_open_impl: unsafe extern "C" fn( + *const ::libc::c_char, + jack_options_t, + *mut jack_status_t, + ) -> *mut jack_client_t, + jack_client_new_impl: unsafe extern "C" fn(*const ::libc::c_char) -> *mut jack_client_t, + jack_client_close_impl: unsafe extern "C" fn(*mut jack_client_t) -> ::libc::c_int, + jack_client_name_size_impl: unsafe extern "C" fn() -> ::libc::c_int, + jack_get_client_name_impl: unsafe extern "C" fn(*mut jack_client_t) -> *mut ::libc::c_char, + jack_get_uuid_for_client_name_impl: + unsafe extern "C" fn(*mut jack_client_t, *const ::libc::c_char) -> *mut ::libc::c_char, + jack_get_client_name_by_uuid_impl: + unsafe extern "C" fn(*mut jack_client_t, *const ::libc::c_char) -> *mut ::libc::c_char, + jack_internal_client_new_impl: Option< + unsafe extern "C" fn( + *const ::libc::c_char, + *const ::libc::c_char, + *const ::libc::c_char, + ) -> ::libc::c_int, + >, + jack_internal_client_close_impl: Option ()>, + jack_activate_impl: unsafe extern "C" fn(*mut jack_client_t) -> ::libc::c_int, + jack_deactivate_impl: unsafe extern "C" fn(*mut jack_client_t) -> ::libc::c_int, + jack_get_client_pid_impl: Option ::libc::c_int>, + jack_is_realtime_impl: unsafe extern "C" fn(*mut jack_client_t) -> ::libc::c_int, + jack_thread_wait_impl: + unsafe extern "C" fn(*mut jack_client_t, ::libc::c_int) -> jack_nframes_t, + jack_cycle_wait_impl: unsafe extern "C" fn(*mut jack_client_t) -> jack_nframes_t, + jack_cycle_signal_impl: unsafe extern "C" fn(*mut jack_client_t, ::libc::c_int) -> (), + jack_set_process_thread_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackThreadCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_set_thread_init_callback_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackThreadInitCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_on_shutdown_impl: + unsafe extern "C" fn(*mut jack_client_t, JackShutdownCallback, *mut ::libc::c_void) -> (), + jack_on_info_shutdown_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackInfoShutdownCallback, + *mut ::libc::c_void, + ) -> (), + jack_set_process_callback_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackProcessCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_set_freewheel_callback_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackFreewheelCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_set_buffer_size_callback_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackBufferSizeCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_get_sample_rate_impl: unsafe extern "C" fn(*mut jack_client_t) -> ::libc::c_int, + jack_set_sample_rate_callback_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackSampleRateCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_set_client_registration_callback_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackClientRegistrationCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_set_port_registration_callback_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackPortRegistrationCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_set_port_connect_callback_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackPortConnectCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_set_port_rename_callback_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackPortRenameCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_set_graph_order_callback_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackGraphOrderCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_set_xrun_callback_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackXRunCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_set_latency_callback_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackLatencyCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_set_freewheel_impl: + unsafe extern "C" fn(*mut jack_client_t, ::libc::c_int) -> ::libc::c_int, + jack_set_buffer_size_impl: + unsafe extern "C" fn(*mut jack_client_t, jack_nframes_t) -> ::libc::c_int, + jack_get_buffer_size_impl: unsafe extern "C" fn(*mut jack_client_t) -> jack_nframes_t, + jack_engine_takeover_timebase_impl: unsafe extern "C" fn(*mut jack_client_t) -> ::libc::c_int, + jack_cpu_load_impl: unsafe extern "C" fn(*mut jack_client_t) -> ::libc::c_float, + jack_port_register_impl: unsafe extern "C" fn( + *mut jack_client_t, + *const ::libc::c_char, + *const ::libc::c_char, + ::libc::c_ulong, + ::libc::c_ulong, + ) -> *mut jack_port_t, + jack_port_unregister_impl: + unsafe extern "C" fn(*mut jack_client_t, *mut jack_port_t) -> ::libc::c_int, + jack_port_get_buffer_impl: + unsafe extern "C" fn(*mut jack_port_t, jack_nframes_t) -> *mut ::libc::c_void, + jack_port_uuid_impl: unsafe extern "C" fn(*mut jack_port_t) -> jack_uuid_t, + jack_port_name_impl: unsafe extern "C" fn(*mut jack_port_t) -> *const ::libc::c_char, + jack_port_short_name_impl: unsafe extern "C" fn(*mut jack_port_t) -> *const ::libc::c_char, + jack_port_flags_impl: unsafe extern "C" fn(*mut jack_port_t) -> ::libc::c_int, + jack_port_type_impl: unsafe extern "C" fn(*const jack_port_t) -> *const ::libc::c_char, + jack_port_type_id_impl: Option jack_port_type_id_t>, + jack_port_is_mine_impl: + unsafe extern "C" fn(*const jack_client_t, *const jack_port_t) -> ::libc::c_int, + jack_port_connected_impl: unsafe extern "C" fn(*const jack_port_t) -> ::libc::c_int, + jack_port_connected_to_impl: + unsafe extern "C" fn(*const jack_port_t, *const ::libc::c_char) -> ::libc::c_int, + jack_port_get_connections_impl: + unsafe extern "C" fn(*const jack_port_t) -> *mut *const ::libc::c_char, + jack_port_get_all_connections_impl: unsafe extern "C" fn( + *const jack_client_t, + *const jack_port_t, + ) -> *mut *const ::libc::c_char, + jack_port_tie_impl: unsafe extern "C" fn(*mut jack_port_t, *mut jack_port_t) -> ::libc::c_int, + jack_port_untie_impl: unsafe extern "C" fn(*mut jack_port_t) -> ::libc::c_int, + jack_port_set_name_impl: + unsafe extern "C" fn(*mut jack_port_t, *const ::libc::c_char) -> ::libc::c_int, + jack_port_set_alias_impl: + unsafe extern "C" fn(*mut jack_port_t, *const ::libc::c_char) -> ::libc::c_int, + jack_port_unset_alias_impl: + unsafe extern "C" fn(*mut jack_port_t, *const ::libc::c_char) -> ::libc::c_int, + jack_port_get_aliases_impl: + unsafe extern "C" fn(*const jack_port_t, *mut *mut ::libc::c_char) -> ::libc::c_int, + jack_port_request_monitor_impl: + unsafe extern "C" fn(*mut jack_port_t, ::libc::c_int) -> ::libc::c_int, + jack_port_request_monitor_by_name_impl: unsafe extern "C" fn( + *mut jack_client_t, + *const ::libc::c_char, + ::libc::c_int, + ) -> ::libc::c_int, + jack_port_ensure_monitor_impl: + unsafe extern "C" fn(*mut jack_port_t, ::libc::c_int) -> ::libc::c_int, + jack_port_monitoring_input_impl: unsafe extern "C" fn(*mut jack_port_t) -> ::libc::c_int, + jack_connect_impl: unsafe extern "C" fn( + *mut jack_client_t, + *const ::libc::c_char, + *const ::libc::c_char, + ) -> ::libc::c_int, + jack_disconnect_impl: unsafe extern "C" fn( + *mut jack_client_t, + *const ::libc::c_char, + *const ::libc::c_char, + ) -> ::libc::c_int, + jack_port_disconnect_impl: + unsafe extern "C" fn(*mut jack_client_t, *mut jack_port_t) -> ::libc::c_int, + jack_port_name_size_impl: unsafe extern "C" fn() -> ::libc::c_int, + jack_port_type_size_impl: unsafe extern "C" fn() -> ::libc::c_int, + jack_port_type_get_buffer_size_impl: + unsafe extern "C" fn(*mut jack_client_t, *const ::libc::c_char) -> ::libc::size_t, + jack_port_set_latency_impl: unsafe extern "C" fn(*mut jack_port_t, jack_nframes_t) -> (), + jack_port_get_latency_range_impl: unsafe extern "C" fn( + *mut jack_port_t, + jack_latency_callback_mode_t, + *mut jack_latency_range_t, + ) -> (), + jack_port_set_latency_range_impl: unsafe extern "C" fn( + *mut jack_port_t, + jack_latency_callback_mode_t, + *mut jack_latency_range_t, + ) -> (), + jack_recompute_total_latencies_impl: unsafe extern "C" fn(*mut jack_client_t) -> ::libc::c_int, + jack_port_get_latency_impl: unsafe extern "C" fn(*mut jack_port_t) -> jack_nframes_t, + jack_port_get_total_latency_impl: + unsafe extern "C" fn(*mut jack_client_t, *mut jack_port_t) -> jack_nframes_t, + jack_recompute_total_latency_impl: + unsafe extern "C" fn(*mut jack_client_t, *mut jack_port_t) -> ::libc::c_int, + jack_get_ports_impl: unsafe extern "C" fn( + *mut jack_client_t, + *const ::libc::c_char, + *const ::libc::c_char, + ::libc::c_ulong, + ) -> *mut *const ::libc::c_char, + jack_port_by_name_impl: + unsafe extern "C" fn(*mut jack_client_t, *const ::libc::c_char) -> *mut jack_port_t, + jack_port_by_id_impl: + unsafe extern "C" fn(*mut jack_client_t, jack_port_id_t) -> *mut jack_port_t, + jack_frames_since_cycle_start_impl: + unsafe extern "C" fn(*const jack_client_t) -> jack_nframes_t, + jack_frame_time_impl: unsafe extern "C" fn(*const jack_client_t) -> jack_nframes_t, + jack_last_frame_time_impl: unsafe extern "C" fn(*const jack_client_t) -> jack_nframes_t, + jack_frames_to_time_impl: + unsafe extern "C" fn(*const jack_client_t, jack_nframes_t) -> jack_time_t, + jack_time_to_frames_impl: + unsafe extern "C" fn(*const jack_client_t, jack_time_t) -> jack_nframes_t, + jack_get_time_impl: unsafe extern "C" fn() -> jack_time_t, + jack_set_error_function_impl: unsafe extern "C" fn( + ::std::option::Option ()>, + ) -> (), + jack_set_info_function_impl: unsafe extern "C" fn( + ::std::option::Option ()>, + ) -> (), + jack_free_impl: unsafe extern "C" fn(*mut ::libc::c_void) -> (), + jack_client_real_time_priority_impl: unsafe extern "C" fn(*mut jack_client_t) -> ::libc::c_int, + jack_client_max_real_time_priority_impl: + unsafe extern "C" fn(*mut jack_client_t) -> ::libc::c_int, + jack_set_session_callback_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackSessionCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_session_reply_impl: + unsafe extern "C" fn(*mut jack_client_t, *mut jack_session_event_t) -> ::libc::c_int, + jack_session_event_free_impl: unsafe extern "C" fn(*mut jack_session_event_t) -> (), + jack_client_get_uuid_impl: unsafe extern "C" fn(*mut jack_client_t) -> *mut ::libc::c_char, + jack_session_notify_impl: unsafe extern "C" fn( + *mut jack_client_t, + *const ::libc::c_char, + jack_session_event_type_t, + *const ::libc::c_char, + ) -> *mut jack_session_command_t, + jack_session_commands_free_impl: unsafe extern "C" fn(*mut jack_session_command_t) -> (), + jack_reserve_client_name_impl: unsafe extern "C" fn( + *mut jack_client_t, + *const ::libc::c_char, + *const ::libc::c_char, + ) -> ::libc::c_int, + jack_client_has_session_callback_impl: + unsafe extern "C" fn(*mut jack_client_t, *const ::libc::c_char) -> ::libc::c_int, + jackctl_setup_signals_impl: + Option *mut jackctl_sigmask_t>, + jackctl_wait_signals_impl: Option ()>, + jackctl_server_create_impl: Option< + unsafe extern "C" fn( + ::std::option::Option u8>, + ::std::option::Option ()>, + ) -> *mut jackctl_server_t, + >, + jackctl_server_destroy_impl: Option ()>, + jackctl_server_open_impl: + Option u8>, + jackctl_server_start_impl: Option u8>, + jackctl_server_stop_impl: Option u8>, + jackctl_server_close_impl: Option u8>, + jackctl_server_get_drivers_list_impl: + Option *const JSList>, + jackctl_server_get_parameters_impl: + Option *const JSList>, + jackctl_server_get_internals_list_impl: + Option *const JSList>, + jackctl_server_load_internal_impl: + Option u8>, + jackctl_server_unload_internal_impl: + Option u8>, + jackctl_server_add_slave_impl: + Option u8>, + jackctl_server_remove_slave_impl: + Option u8>, + jackctl_server_switch_master_impl: + Option u8>, + jackctl_driver_get_name_impl: + Option *const ::libc::c_char>, + jackctl_driver_get_type_impl: + Option jackctl_driver_type_t>, + jackctl_driver_get_parameters_impl: + Option *const JSList>, + jackctl_driver_params_parse_impl: Option< + unsafe extern "C" fn( + *mut jackctl_driver_t, + ::libc::c_int, + *mut *mut ::libc::c_char, + ) -> ::libc::c_int, + >, + jackctl_internal_get_name_impl: + Option *const ::libc::c_char>, + jackctl_internal_get_parameters_impl: + Option *const JSList>, + jackctl_parameter_get_name_impl: + Option *const ::libc::c_char>, + jackctl_parameter_get_short_description_impl: + Option *const ::libc::c_char>, + jackctl_parameter_get_long_description_impl: + Option *const ::libc::c_char>, + jackctl_parameter_get_type_impl: + Option jackctl_param_type_t>, + jackctl_parameter_get_id_impl: + Option ::libc::c_char>, + jackctl_parameter_is_set_impl: Option u8>, + jackctl_parameter_reset_impl: Option u8>, + jackctl_parameter_get_value_impl: + Option Union_jackctl_parameter_value>, + jackctl_parameter_set_value_impl: Option< + unsafe extern "C" fn(*mut jackctl_parameter_t, *const Union_jackctl_parameter_value) -> u8, + >, + jackctl_parameter_get_default_value_impl: + Option Union_jackctl_parameter_value>, + jackctl_parameter_has_range_constraint_impl: + Option u8>, + jackctl_parameter_has_enum_constraint_impl: + Option u8>, + jackctl_parameter_get_enum_constraints_count_impl: + Option u32>, + jackctl_parameter_get_enum_constraint_value_impl: Option< + unsafe extern "C" fn(*mut jackctl_parameter_t, u32) -> Union_jackctl_parameter_value, + >, + jackctl_parameter_get_enum_constraint_description_impl: + Option *const ::libc::c_char>, + jackctl_parameter_get_range_constraint_impl: Option< + unsafe extern "C" fn( + *mut jackctl_parameter_t, + *mut Union_jackctl_parameter_value, + *mut Union_jackctl_parameter_value, + ) -> (), + >, + jackctl_parameter_constraint_is_strict_impl: + Option u8>, + jackctl_parameter_constraint_is_fake_value_impl: + Option u8>, + jack_set_property_impl: unsafe extern "C" fn( + *mut jack_client_t, + jack_uuid_t, + *const ::libc::c_char, + *const ::libc::c_char, + *const ::libc::c_char, + ) -> ::libc::c_int, + jack_get_property_impl: unsafe extern "C" fn( + jack_uuid_t, + *const ::libc::c_char, + *mut *mut ::libc::c_char, + *mut *mut ::libc::c_char, + ) -> ::libc::c_int, + jack_free_description_impl: unsafe extern "C" fn(*mut jack_description_t, ::libc::c_int) -> (), + jack_get_properties_impl: + unsafe extern "C" fn(jack_uuid_t, *mut jack_description_t) -> ::libc::c_int, + jack_get_all_properties_impl: + unsafe extern "C" fn(*mut *mut jack_description_t) -> ::libc::c_int, + jack_remove_property_impl: unsafe extern "C" fn( + *mut jack_client_t, + jack_uuid_t, + *const ::libc::c_char, + ) -> ::libc::c_int, + jack_remove_properties_impl: + unsafe extern "C" fn(*mut jack_client_t, jack_uuid_t) -> ::libc::c_int, + jack_remove_all_properties_impl: unsafe extern "C" fn(*mut jack_client_t) -> ::libc::c_int, + jack_set_property_change_callback_impl: unsafe extern "C" fn( + *mut jack_client_t, + JackPropertyChangeCallback, + *mut ::libc::c_void, + ) -> ::libc::c_int, + jack_get_internal_client_name_impl: + Option *mut ::libc::c_char>, + jack_internal_client_handle_impl: Option< + unsafe extern "C" fn( + *mut jack_client_t, + *const ::libc::c_char, + *mut jack_status_t, + ) -> jack_intclient_t, + >, + jack_internal_client_load_impl: Option< + unsafe extern "C" fn( + *mut jack_client_t, + *const ::libc::c_char, + jack_options_t, + *mut jack_status_t, + *const ::libc::c_char, + *const ::libc::c_char, + ) -> jack_intclient_t, + >, + jack_internal_client_unload_impl: + Option jack_status_t>, + jack_get_max_delayed_usecs_impl: unsafe extern "C" fn(*mut jack_client_t) -> ::libc::c_float, + jack_get_xrun_delayed_usecs_impl: unsafe extern "C" fn(*mut jack_client_t) -> ::libc::c_float, + jack_reset_max_delayed_usecs_impl: unsafe extern "C" fn(*mut jack_client_t) -> (), + jack_midi_get_event_count_impl: unsafe extern "C" fn(*mut ::libc::c_void) -> u32, + jack_midi_event_get_impl: + unsafe extern "C" fn(*mut jack_midi_event_t, *mut ::libc::c_void, u32) -> ::libc::c_int, + jack_midi_clear_buffer_impl: unsafe extern "C" fn(*mut ::libc::c_void) -> (), + jack_midi_max_event_size_impl: unsafe extern "C" fn(*mut ::libc::c_void) -> ::libc::size_t, + jack_midi_event_reserve_impl: unsafe extern "C" fn( + *mut ::libc::c_void, + jack_nframes_t, + ::libc::size_t, + ) -> *mut jack_midi_data_t, + jack_midi_event_write_impl: unsafe extern "C" fn( + *mut ::libc::c_void, + jack_nframes_t, + *const jack_midi_data_t, + ::libc::size_t, + ) -> ::libc::c_int, + jack_midi_get_lost_event_count_impl: unsafe extern "C" fn(*mut ::libc::c_void) -> u32, + jack_ringbuffer_create_impl: unsafe extern "C" fn(::libc::size_t) -> *mut jack_ringbuffer_t, + jack_ringbuffer_free_impl: unsafe extern "C" fn(*mut jack_ringbuffer_t) -> (), + jack_ringbuffer_get_read_vector_impl: + unsafe extern "C" fn(*const jack_ringbuffer_t, *mut jack_ringbuffer_data_t) -> (), + jack_ringbuffer_get_write_vector_impl: + unsafe extern "C" fn(*const jack_ringbuffer_t, *mut jack_ringbuffer_data_t) -> (), + jack_ringbuffer_read_impl: unsafe extern "C" fn( + *mut jack_ringbuffer_t, + *mut ::libc::c_char, + ::libc::size_t, + ) -> ::libc::size_t, + jack_ringbuffer_peek_impl: unsafe extern "C" fn( + *mut jack_ringbuffer_t, + *mut ::libc::c_char, + ::libc::size_t, + ) -> ::libc::size_t, + jack_ringbuffer_read_advance_impl: + unsafe extern "C" fn(*mut jack_ringbuffer_t, ::libc::size_t) -> (), + jack_ringbuffer_read_space_impl: + unsafe extern "C" fn(*const jack_ringbuffer_t) -> ::libc::size_t, + jack_ringbuffer_mlock_impl: unsafe extern "C" fn(*mut jack_ringbuffer_t) -> ::libc::c_int, + jack_ringbuffer_reset_impl: unsafe extern "C" fn(*mut jack_ringbuffer_t) -> (), + jack_ringbuffer_write_impl: unsafe extern "C" fn( + *mut jack_ringbuffer_t, + *const ::libc::c_char, + ::libc::size_t, + ) -> ::libc::size_t, + jack_ringbuffer_write_advance_impl: + unsafe extern "C" fn(*mut jack_ringbuffer_t, ::libc::size_t) -> (), + jack_ringbuffer_write_space_impl: + unsafe extern "C" fn(*const jack_ringbuffer_t) -> ::libc::size_t, + jack_uuid_to_index_impl: unsafe extern "C" fn(jack_uuid_t) -> u32, + jack_uuid_compare_impl: unsafe extern "C" fn(jack_uuid_t, jack_uuid_t) -> ::std::os::raw::c_int, + jack_uuid_copy_impl: unsafe extern "C" fn(*mut jack_uuid_t, jack_uuid_t) -> (), + jack_uuid_clear_impl: unsafe extern "C" fn(*mut jack_uuid_t) -> (), + jack_uuid_parse_impl: unsafe extern "C" fn( + *const ::std::os::raw::c_char, + *mut jack_uuid_t, + ) -> ::std::os::raw::c_int, + jack_uuid_unparse_impl: unsafe extern "C" fn(jack_uuid_t, *mut ::std::os::raw::c_char) -> (), + jack_uuid_empty_impl: unsafe extern "C" fn(jack_uuid_t) -> ::std::os::raw::c_int, +} + +lazy_static! { + static ref FUNCTIONS: JackFunctions = unsafe { + let library = crate::library().unwrap(); + let jack_release_timebase_impl = library + .get:: ::libc::c_int>( + b"jack_release_timebase", + ) + .unwrap(); + let jack_release_timebase_impl = jack_release_timebase_impl.into_raw(); + let jack_release_timebase_impl = *jack_release_timebase_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> ::libc::c_int; + let jack_get_cycle_times_impl = library + .get:: ::libc::c_int>(b"jack_get_cycle_times") + .ok(); + let jack_get_cycle_times_impl = jack_get_cycle_times_impl.map(|sym| sym.into_raw()); + let jack_get_cycle_times_impl = jack_get_cycle_times_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + client: *const jack_client_t, + current_frames: *mut jack_nframes_t, + current_usecs: *mut jack_time_t, + next_usecs: *mut jack_time_t, + period_usecs: *mut ::libc::c_float, + ) -> ::libc::c_int + }); + let jack_set_sync_callback_impl = library + .get:: ::libc::c_int>(b"jack_set_sync_callback") + .unwrap(); + let jack_set_sync_callback_impl = jack_set_sync_callback_impl.into_raw(); + let jack_set_sync_callback_impl = *jack_set_sync_callback_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + sync_callback: JackSyncCallback, + sync_arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_set_sync_timeout_impl = + library + .get:: ::libc::c_int>(b"jack_set_sync_timeout") + .unwrap(); + let jack_set_sync_timeout_impl = jack_set_sync_timeout_impl.into_raw(); + let jack_set_sync_timeout_impl = *jack_set_sync_timeout_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + timeout: jack_time_t, + ) -> ::libc::c_int; + let jack_set_timebase_callback_impl = library + .get:: ::libc::c_int>(b"jack_set_timebase_callback") + .unwrap(); + let jack_set_timebase_callback_impl = jack_set_timebase_callback_impl.into_raw(); + let jack_set_timebase_callback_impl = *jack_set_timebase_callback_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + conditional: ::libc::c_int, + timebase_callback: TimebaseCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_transport_locate_impl = + library + .get:: ::libc::c_int>(b"jack_transport_locate") + .unwrap(); + let jack_transport_locate_impl = jack_transport_locate_impl.into_raw(); + let jack_transport_locate_impl = *jack_transport_locate_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + frame: jack_nframes_t, + ) -> ::libc::c_int; + let jack_transport_query_impl = library + .get:: jack_transport_state_t>(b"jack_transport_query") + .unwrap(); + let jack_transport_query_impl = jack_transport_query_impl.into_raw(); + let jack_transport_query_impl = *jack_transport_query_impl.deref() + as unsafe extern "C" fn( + client: *const jack_client_t, + pos: *mut jack_position_t, + ) -> jack_transport_state_t; + let jack_get_current_transport_frame_impl = library + .get:: jack_nframes_t>( + b"jack_get_current_transport_frame", + ) + .unwrap(); + let jack_get_current_transport_frame_impl = + jack_get_current_transport_frame_impl.into_raw(); + let jack_get_current_transport_frame_impl = *jack_get_current_transport_frame_impl.deref() + as unsafe extern "C" fn(client: *const jack_client_t) -> jack_nframes_t; + let jack_transport_reposition_impl = library + .get:: ::libc::c_int>(b"jack_transport_reposition") + .unwrap(); + let jack_transport_reposition_impl = jack_transport_reposition_impl.into_raw(); + let jack_transport_reposition_impl = *jack_transport_reposition_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + pos: *const jack_position_t, + ) -> ::libc::c_int; + let jack_transport_start_impl = library + .get:: ()>(b"jack_transport_start") + .unwrap(); + let jack_transport_start_impl = jack_transport_start_impl.into_raw(); + let jack_transport_start_impl = *jack_transport_start_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> (); + let jack_transport_stop_impl = library + .get:: ()>(b"jack_transport_stop") + .unwrap(); + let jack_transport_stop_impl = jack_transport_stop_impl.into_raw(); + let jack_transport_stop_impl = *jack_transport_stop_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> (); + let jack_get_transport_info_impl = library + .get:: ()>(b"jack_get_transport_info") + .unwrap(); + let jack_get_transport_info_impl = jack_get_transport_info_impl.into_raw(); + let jack_get_transport_info_impl = *jack_get_transport_info_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + tinfo: *mut jack_transport_info_t, + ) -> (); + let jack_set_transport_info_impl = library + .get:: ()>(b"jack_set_transport_info") + .unwrap(); + let jack_set_transport_info_impl = jack_set_transport_info_impl.into_raw(); + let jack_set_transport_info_impl = *jack_set_transport_info_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + tinfo: *mut jack_transport_info_t, + ) -> (); + let jack_client_open_impl = library + .get:: *mut jack_client_t>(b"jack_client_open") + .unwrap(); + let jack_client_open_impl = jack_client_open_impl.into_raw(); + let jack_client_open_impl = *jack_client_open_impl.deref() + as unsafe extern "C" fn( + client_name: *const ::libc::c_char, + options: jack_options_t, + status: *mut jack_status_t, + ) -> *mut jack_client_t; + let jack_client_new_impl = library + .get:: *mut jack_client_t>( + b"jack_client_new", + ) + .unwrap(); + let jack_client_new_impl = jack_client_new_impl.into_raw(); + let jack_client_new_impl = *jack_client_new_impl.deref() + as unsafe extern "C" fn(client_name: *const ::libc::c_char) -> *mut jack_client_t; + let jack_client_close_impl = library + .get:: ::libc::c_int>( + b"jack_client_close", + ) + .unwrap(); + let jack_client_close_impl = jack_client_close_impl.into_raw(); + let jack_client_close_impl = *jack_client_close_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> ::libc::c_int; + let jack_client_name_size_impl = library + .get:: ::libc::c_int>(b"jack_client_name_size") + .unwrap(); + let jack_client_name_size_impl = jack_client_name_size_impl.into_raw(); + let jack_client_name_size_impl = + *jack_client_name_size_impl.deref() as unsafe extern "C" fn() -> ::libc::c_int; + let jack_get_client_name_impl = library + .get:: *mut ::libc::c_char>( + b"jack_get_client_name", + ) + .unwrap(); + let jack_get_client_name_impl = jack_get_client_name_impl.into_raw(); + let jack_get_client_name_impl = *jack_get_client_name_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> *mut ::libc::c_char; + let jack_get_uuid_for_client_name_impl = library + .get:: *mut ::libc::c_char>(b"jack_get_uuid_for_client_name") + .unwrap(); + let jack_get_uuid_for_client_name_impl = jack_get_uuid_for_client_name_impl.into_raw(); + let jack_get_uuid_for_client_name_impl = *jack_get_uuid_for_client_name_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + client_name: *const ::libc::c_char, + ) -> *mut ::libc::c_char; + let jack_get_client_name_by_uuid_impl = library + .get:: *mut ::libc::c_char>(b"jack_get_client_name_by_uuid") + .unwrap(); + let jack_get_client_name_by_uuid_impl = jack_get_client_name_by_uuid_impl.into_raw(); + let jack_get_client_name_by_uuid_impl = *jack_get_client_name_by_uuid_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + client_uuid: *const ::libc::c_char, + ) -> *mut ::libc::c_char; + let jack_internal_client_new_impl = library + .get:: ::libc::c_int>(b"jack_internal_client_new") + .ok(); + let jack_internal_client_new_impl = jack_internal_client_new_impl.map(|sym| sym.into_raw()); + let jack_internal_client_new_impl = jack_internal_client_new_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + client_name: *const ::libc::c_char, + load_name: *const ::libc::c_char, + load_init: *const ::libc::c_char, + ) -> ::libc::c_int + }); + let jack_internal_client_close_impl = library + .get:: ()>( + b"jack_internal_client_close", + ) + .ok(); + let jack_internal_client_close_impl = + jack_internal_client_close_impl.map(|sym| sym.into_raw()); + let jack_internal_client_close_impl = jack_internal_client_close_impl.map(|sym| { + *sym.deref() as unsafe extern "C" fn(client_name: *const ::libc::c_char) -> () + }); + let jack_activate_impl = library + .get:: ::libc::c_int>( + b"jack_activate", + ) + .unwrap(); + let jack_activate_impl = jack_activate_impl.into_raw(); + let jack_activate_impl = *jack_activate_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> ::libc::c_int; + let jack_deactivate_impl = library + .get:: ::libc::c_int>( + b"jack_deactivate", + ) + .unwrap(); + let jack_deactivate_impl = jack_deactivate_impl.into_raw(); + let jack_deactivate_impl = *jack_deactivate_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> ::libc::c_int; + let jack_get_client_pid_impl = library + .get:: ::libc::c_int>( + b"jack_get_client_pid", + ) + .ok(); + let jack_get_client_pid_impl = jack_get_client_pid_impl.map(|sym| sym.into_raw()); + let jack_get_client_pid_impl = jack_get_client_pid_impl.map(|sym| { + *sym.deref() as unsafe extern "C" fn(name: *const ::libc::c_char) -> ::libc::c_int + }); + let jack_is_realtime_impl = library + .get:: ::libc::c_int>( + b"jack_is_realtime", + ) + .unwrap(); + let jack_is_realtime_impl = jack_is_realtime_impl.into_raw(); + let jack_is_realtime_impl = *jack_is_realtime_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> ::libc::c_int; + let jack_thread_wait_impl = library + .get:: jack_nframes_t>(b"jack_thread_wait") + .unwrap(); + let jack_thread_wait_impl = jack_thread_wait_impl.into_raw(); + let jack_thread_wait_impl = *jack_thread_wait_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + status: ::libc::c_int, + ) -> jack_nframes_t; + let jack_cycle_wait_impl = library + .get:: jack_nframes_t>( + b"jack_cycle_wait", + ) + .unwrap(); + let jack_cycle_wait_impl = jack_cycle_wait_impl.into_raw(); + let jack_cycle_wait_impl = *jack_cycle_wait_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> jack_nframes_t; + let jack_cycle_signal_impl = library + .get:: ()>( + b"jack_cycle_signal", + ) + .unwrap(); + let jack_cycle_signal_impl = jack_cycle_signal_impl.into_raw(); + let jack_cycle_signal_impl = *jack_cycle_signal_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t, status: ::libc::c_int) -> (); + let jack_set_process_thread_impl = library + .get:: ::libc::c_int>(b"jack_set_process_thread") + .unwrap(); + let jack_set_process_thread_impl = jack_set_process_thread_impl.into_raw(); + let jack_set_process_thread_impl = *jack_set_process_thread_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + thread_callback: JackThreadCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_set_thread_init_callback_impl = library + .get:: ::libc::c_int>(b"jack_set_thread_init_callback") + .unwrap(); + let jack_set_thread_init_callback_impl = jack_set_thread_init_callback_impl.into_raw(); + let jack_set_thread_init_callback_impl = *jack_set_thread_init_callback_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + thread_init_callback: JackThreadInitCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_on_shutdown_impl = library + .get:: ()>(b"jack_on_shutdown") + .unwrap(); + let jack_on_shutdown_impl = jack_on_shutdown_impl.into_raw(); + let jack_on_shutdown_impl = *jack_on_shutdown_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + callback: JackShutdownCallback, + arg: *mut ::libc::c_void, + ) -> (); + let jack_on_info_shutdown_impl = library + .get:: ()>(b"jack_on_info_shutdown") + .unwrap(); + let jack_on_info_shutdown_impl = jack_on_info_shutdown_impl.into_raw(); + let jack_on_info_shutdown_impl = *jack_on_info_shutdown_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + callback: JackInfoShutdownCallback, + arg: *mut ::libc::c_void, + ) -> (); + let jack_set_process_callback_impl = library + .get:: ::libc::c_int>(b"jack_set_process_callback") + .unwrap(); + let jack_set_process_callback_impl = jack_set_process_callback_impl.into_raw(); + let jack_set_process_callback_impl = *jack_set_process_callback_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + process_callback: JackProcessCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_set_freewheel_callback_impl = library + .get:: ::libc::c_int>(b"jack_set_freewheel_callback") + .unwrap(); + let jack_set_freewheel_callback_impl = jack_set_freewheel_callback_impl.into_raw(); + let jack_set_freewheel_callback_impl = *jack_set_freewheel_callback_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + freewheel_callback: JackFreewheelCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_set_buffer_size_callback_impl = library + .get:: ::libc::c_int>(b"jack_set_buffer_size_callback") + .unwrap(); + let jack_set_buffer_size_callback_impl = jack_set_buffer_size_callback_impl.into_raw(); + let jack_set_buffer_size_callback_impl = *jack_set_buffer_size_callback_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + bufsize_callback: JackBufferSizeCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_get_sample_rate_impl = library + .get:: ::libc::c_int>( + b"jack_get_sample_rate", + ) + .unwrap(); + let jack_get_sample_rate_impl = jack_get_sample_rate_impl.into_raw(); + let jack_get_sample_rate_impl = *jack_get_sample_rate_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> ::libc::c_int; + let jack_set_sample_rate_callback_impl = library + .get:: ::libc::c_int>(b"jack_set_sample_rate_callback") + .unwrap(); + let jack_set_sample_rate_callback_impl = jack_set_sample_rate_callback_impl.into_raw(); + let jack_set_sample_rate_callback_impl = *jack_set_sample_rate_callback_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + srate_callback: JackSampleRateCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_set_client_registration_callback_impl = library + .get:: ::libc::c_int>(b"jack_set_client_registration_callback") + .unwrap(); + let jack_set_client_registration_callback_impl = + jack_set_client_registration_callback_impl.into_raw(); + let jack_set_client_registration_callback_impl = *jack_set_client_registration_callback_impl + .deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + registration_callback: JackClientRegistrationCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_set_port_registration_callback_impl = library + .get:: ::libc::c_int>(b"jack_set_port_registration_callback") + .unwrap(); + let jack_set_port_registration_callback_impl = + jack_set_port_registration_callback_impl.into_raw(); + let jack_set_port_registration_callback_impl = *jack_set_port_registration_callback_impl + .deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + registration_callback: JackPortRegistrationCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_set_port_connect_callback_impl = library + .get:: ::libc::c_int>(b"jack_set_port_connect_callback") + .unwrap(); + let jack_set_port_connect_callback_impl = jack_set_port_connect_callback_impl.into_raw(); + let jack_set_port_connect_callback_impl = *jack_set_port_connect_callback_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + connect_callback: JackPortConnectCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_set_port_rename_callback_impl = library + .get:: ::libc::c_int>(b"jack_set_port_rename_callback") + .unwrap(); + let jack_set_port_rename_callback_impl = jack_set_port_rename_callback_impl.into_raw(); + let jack_set_port_rename_callback_impl = *jack_set_port_rename_callback_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + rename_callback: JackPortRenameCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_set_graph_order_callback_impl = library + .get:: ::libc::c_int>(b"jack_set_graph_order_callback") + .unwrap(); + let jack_set_graph_order_callback_impl = jack_set_graph_order_callback_impl.into_raw(); + let jack_set_graph_order_callback_impl = *jack_set_graph_order_callback_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + graph_callback: JackGraphOrderCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_set_xrun_callback_impl = library + .get:: ::libc::c_int>(b"jack_set_xrun_callback") + .unwrap(); + let jack_set_xrun_callback_impl = jack_set_xrun_callback_impl.into_raw(); + let jack_set_xrun_callback_impl = *jack_set_xrun_callback_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + xrun_callback: JackXRunCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_set_latency_callback_impl = library + .get:: ::libc::c_int>(b"jack_set_latency_callback") + .unwrap(); + let jack_set_latency_callback_impl = jack_set_latency_callback_impl.into_raw(); + let jack_set_latency_callback_impl = *jack_set_latency_callback_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + latency_callback: JackLatencyCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_set_freewheel_impl = + library + .get:: ::libc::c_int>(b"jack_set_freewheel") + .unwrap(); + let jack_set_freewheel_impl = jack_set_freewheel_impl.into_raw(); + let jack_set_freewheel_impl = *jack_set_freewheel_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + onoff: ::libc::c_int, + ) -> ::libc::c_int; + let jack_set_buffer_size_impl = library + .get:: ::libc::c_int>(b"jack_set_buffer_size") + .unwrap(); + let jack_set_buffer_size_impl = jack_set_buffer_size_impl.into_raw(); + let jack_set_buffer_size_impl = *jack_set_buffer_size_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + nframes: jack_nframes_t, + ) -> ::libc::c_int; + let jack_get_buffer_size_impl = library + .get:: jack_nframes_t>( + b"jack_get_buffer_size", + ) + .unwrap(); + let jack_get_buffer_size_impl = jack_get_buffer_size_impl.into_raw(); + let jack_get_buffer_size_impl = *jack_get_buffer_size_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> jack_nframes_t; + let jack_engine_takeover_timebase_impl = library + .get:: ::libc::c_int>( + b"jack_engine_takeover_timebase", + ) + .unwrap(); + let jack_engine_takeover_timebase_impl = jack_engine_takeover_timebase_impl.into_raw(); + let jack_engine_takeover_timebase_impl = *jack_engine_takeover_timebase_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> ::libc::c_int; + let jack_cpu_load_impl = library + .get:: ::libc::c_float>( + b"jack_cpu_load", + ) + .unwrap(); + let jack_cpu_load_impl = jack_cpu_load_impl.into_raw(); + let jack_cpu_load_impl = *jack_cpu_load_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> ::libc::c_float; + let jack_port_register_impl = library + .get:: *mut jack_port_t>(b"jack_port_register") + .unwrap(); + let jack_port_register_impl = jack_port_register_impl.into_raw(); + let jack_port_register_impl = *jack_port_register_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + port_name: *const ::libc::c_char, + port_type: *const ::libc::c_char, + flags: ::libc::c_ulong, + buffer_size: ::libc::c_ulong, + ) -> *mut jack_port_t; + let jack_port_unregister_impl = library + .get:: ::libc::c_int>(b"jack_port_unregister") + .unwrap(); + let jack_port_unregister_impl = jack_port_unregister_impl.into_raw(); + let jack_port_unregister_impl = *jack_port_unregister_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + port: *mut jack_port_t, + ) -> ::libc::c_int; + let jack_port_get_buffer_impl = library + .get:: *mut ::libc::c_void>(b"jack_port_get_buffer") + .unwrap(); + let jack_port_get_buffer_impl = jack_port_get_buffer_impl.into_raw(); + let jack_port_get_buffer_impl = *jack_port_get_buffer_impl.deref() + as unsafe extern "C" fn( + port: *mut jack_port_t, + nframes: jack_nframes_t, + ) -> *mut ::libc::c_void; + let jack_port_uuid_impl = library + .get:: jack_uuid_t>(b"jack_port_uuid") + .unwrap(); + let jack_port_uuid_impl = jack_port_uuid_impl.into_raw(); + let jack_port_uuid_impl = *jack_port_uuid_impl.deref() + as unsafe extern "C" fn(port: *mut jack_port_t) -> jack_uuid_t; + let jack_port_name_impl = library + .get:: *const ::libc::c_char>( + b"jack_port_name", + ) + .unwrap(); + let jack_port_name_impl = jack_port_name_impl.into_raw(); + let jack_port_name_impl = *jack_port_name_impl.deref() + as unsafe extern "C" fn(port: *mut jack_port_t) -> *const ::libc::c_char; + let jack_port_short_name_impl = library + .get:: *const ::libc::c_char>( + b"jack_port_short_name", + ) + .unwrap(); + let jack_port_short_name_impl = jack_port_short_name_impl.into_raw(); + let jack_port_short_name_impl = *jack_port_short_name_impl.deref() + as unsafe extern "C" fn(port: *mut jack_port_t) -> *const ::libc::c_char; + let jack_port_flags_impl = library + .get:: ::libc::c_int>( + b"jack_port_flags", + ) + .unwrap(); + let jack_port_flags_impl = jack_port_flags_impl.into_raw(); + let jack_port_flags_impl = *jack_port_flags_impl.deref() + as unsafe extern "C" fn(port: *mut jack_port_t) -> ::libc::c_int; + let jack_port_type_impl = library + .get:: *const ::libc::c_char>( + b"jack_port_type", + ) + .unwrap(); + let jack_port_type_impl = jack_port_type_impl.into_raw(); + let jack_port_type_impl = *jack_port_type_impl.deref() + as unsafe extern "C" fn(port: *const jack_port_t) -> *const ::libc::c_char; + let jack_port_type_id_impl = library + .get:: jack_port_type_id_t>( + b"jack_port_type_id", + ) + .ok(); + let jack_port_type_id_impl = jack_port_type_id_impl.map(|sym| sym.into_raw()); + let jack_port_type_id_impl = jack_port_type_id_impl.map(|sym| { + *sym.deref() as unsafe extern "C" fn(port: *const jack_port_t) -> jack_port_type_id_t + }); + let jack_port_is_mine_impl = library + .get:: ::libc::c_int>(b"jack_port_is_mine") + .unwrap(); + let jack_port_is_mine_impl = jack_port_is_mine_impl.into_raw(); + let jack_port_is_mine_impl = *jack_port_is_mine_impl.deref() + as unsafe extern "C" fn( + client: *const jack_client_t, + port: *const jack_port_t, + ) -> ::libc::c_int; + let jack_port_connected_impl = library + .get:: ::libc::c_int>( + b"jack_port_connected", + ) + .unwrap(); + let jack_port_connected_impl = jack_port_connected_impl.into_raw(); + let jack_port_connected_impl = *jack_port_connected_impl.deref() + as unsafe extern "C" fn(port: *const jack_port_t) -> ::libc::c_int; + let jack_port_connected_to_impl = library + .get:: ::libc::c_int>(b"jack_port_connected_to") + .unwrap(); + let jack_port_connected_to_impl = jack_port_connected_to_impl.into_raw(); + let jack_port_connected_to_impl = *jack_port_connected_to_impl.deref() + as unsafe extern "C" fn( + port: *const jack_port_t, + port_name: *const ::libc::c_char, + ) -> ::libc::c_int; + let jack_port_get_connections_impl = library + .get:: *mut *const ::libc::c_char>( + b"jack_port_get_connections", + ) + .unwrap(); + let jack_port_get_connections_impl = jack_port_get_connections_impl.into_raw(); + let jack_port_get_connections_impl = *jack_port_get_connections_impl.deref() + as unsafe extern "C" fn(port: *const jack_port_t) -> *mut *const ::libc::c_char; + let jack_port_get_all_connections_impl = library + .get:: *mut *const ::libc::c_char>(b"jack_port_get_all_connections") + .unwrap(); + let jack_port_get_all_connections_impl = jack_port_get_all_connections_impl.into_raw(); + let jack_port_get_all_connections_impl = *jack_port_get_all_connections_impl.deref() + as unsafe extern "C" fn( + client: *const jack_client_t, + port: *const jack_port_t, + ) -> *mut *const ::libc::c_char; + let jack_port_tie_impl = library.get:: ::libc::c_int>(b"jack_port_tie").unwrap(); + let jack_port_tie_impl = jack_port_tie_impl.into_raw(); + let jack_port_tie_impl = *jack_port_tie_impl.deref() + as unsafe extern "C" fn(src: *mut jack_port_t, dst: *mut jack_port_t) -> ::libc::c_int; + let jack_port_untie_impl = library + .get:: ::libc::c_int>( + b"jack_port_untie", + ) + .unwrap(); + let jack_port_untie_impl = jack_port_untie_impl.into_raw(); + let jack_port_untie_impl = *jack_port_untie_impl.deref() + as unsafe extern "C" fn(port: *mut jack_port_t) -> ::libc::c_int; + let jack_port_set_name_impl = library + .get:: ::libc::c_int>(b"jack_port_set_name") + .unwrap(); + let jack_port_set_name_impl = jack_port_set_name_impl.into_raw(); + let jack_port_set_name_impl = *jack_port_set_name_impl.deref() + as unsafe extern "C" fn( + port: *mut jack_port_t, + port_name: *const ::libc::c_char, + ) -> ::libc::c_int; + let jack_port_set_alias_impl = library + .get:: ::libc::c_int>(b"jack_port_set_alias") + .unwrap(); + let jack_port_set_alias_impl = jack_port_set_alias_impl.into_raw(); + let jack_port_set_alias_impl = *jack_port_set_alias_impl.deref() + as unsafe extern "C" fn( + port: *mut jack_port_t, + alias: *const ::libc::c_char, + ) -> ::libc::c_int; + let jack_port_unset_alias_impl = library + .get:: ::libc::c_int>(b"jack_port_unset_alias") + .unwrap(); + let jack_port_unset_alias_impl = jack_port_unset_alias_impl.into_raw(); + let jack_port_unset_alias_impl = *jack_port_unset_alias_impl.deref() + as unsafe extern "C" fn( + port: *mut jack_port_t, + alias: *const ::libc::c_char, + ) -> ::libc::c_int; + let jack_port_get_aliases_impl = library + .get:: ::libc::c_int>(b"jack_port_get_aliases") + .unwrap(); + let jack_port_get_aliases_impl = jack_port_get_aliases_impl.into_raw(); + let jack_port_get_aliases_impl = *jack_port_get_aliases_impl.deref() + as unsafe extern "C" fn( + port: *const jack_port_t, + aliases: *mut *mut ::libc::c_char, + ) -> ::libc::c_int; + let jack_port_request_monitor_impl = library.get:: ::libc::c_int>(b"jack_port_request_monitor").unwrap(); + let jack_port_request_monitor_impl = jack_port_request_monitor_impl.into_raw(); + let jack_port_request_monitor_impl = *jack_port_request_monitor_impl.deref() + as unsafe extern "C" fn(port: *mut jack_port_t, onoff: ::libc::c_int) -> ::libc::c_int; + let jack_port_request_monitor_by_name_impl = library + .get:: ::libc::c_int>(b"jack_port_request_monitor_by_name") + .unwrap(); + let jack_port_request_monitor_by_name_impl = + jack_port_request_monitor_by_name_impl.into_raw(); + let jack_port_request_monitor_by_name_impl = *jack_port_request_monitor_by_name_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + port_name: *const ::libc::c_char, + onoff: ::libc::c_int, + ) -> ::libc::c_int; + let jack_port_ensure_monitor_impl = library.get:: ::libc::c_int>(b"jack_port_ensure_monitor").unwrap(); + let jack_port_ensure_monitor_impl = jack_port_ensure_monitor_impl.into_raw(); + let jack_port_ensure_monitor_impl = *jack_port_ensure_monitor_impl.deref() + as unsafe extern "C" fn(port: *mut jack_port_t, onoff: ::libc::c_int) -> ::libc::c_int; + let jack_port_monitoring_input_impl = library + .get:: ::libc::c_int>( + b"jack_port_monitoring_input", + ) + .unwrap(); + let jack_port_monitoring_input_impl = jack_port_monitoring_input_impl.into_raw(); + let jack_port_monitoring_input_impl = *jack_port_monitoring_input_impl.deref() + as unsafe extern "C" fn(port: *mut jack_port_t) -> ::libc::c_int; + let jack_connect_impl = library + .get:: ::libc::c_int>(b"jack_connect") + .unwrap(); + let jack_connect_impl = jack_connect_impl.into_raw(); + let jack_connect_impl = *jack_connect_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + source_port: *const ::libc::c_char, + destination_port: *const ::libc::c_char, + ) -> ::libc::c_int; + let jack_disconnect_impl = library + .get:: ::libc::c_int>(b"jack_disconnect") + .unwrap(); + let jack_disconnect_impl = jack_disconnect_impl.into_raw(); + let jack_disconnect_impl = *jack_disconnect_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + source_port: *const ::libc::c_char, + destination_port: *const ::libc::c_char, + ) -> ::libc::c_int; + let jack_port_disconnect_impl = library + .get:: ::libc::c_int>(b"jack_port_disconnect") + .unwrap(); + let jack_port_disconnect_impl = jack_port_disconnect_impl.into_raw(); + let jack_port_disconnect_impl = *jack_port_disconnect_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + port: *mut jack_port_t, + ) -> ::libc::c_int; + let jack_port_name_size_impl = library + .get:: ::libc::c_int>(b"jack_port_name_size") + .unwrap(); + let jack_port_name_size_impl = jack_port_name_size_impl.into_raw(); + let jack_port_name_size_impl = + *jack_port_name_size_impl.deref() as unsafe extern "C" fn() -> ::libc::c_int; + let jack_port_type_size_impl = library + .get:: ::libc::c_int>(b"jack_port_type_size") + .unwrap(); + let jack_port_type_size_impl = jack_port_type_size_impl.into_raw(); + let jack_port_type_size_impl = + *jack_port_type_size_impl.deref() as unsafe extern "C" fn() -> ::libc::c_int; + let jack_port_type_get_buffer_size_impl = library + .get:: ::libc::size_t>(b"jack_port_type_get_buffer_size") + .unwrap(); + let jack_port_type_get_buffer_size_impl = jack_port_type_get_buffer_size_impl.into_raw(); + let jack_port_type_get_buffer_size_impl = *jack_port_type_get_buffer_size_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + port_type: *const ::libc::c_char, + ) -> ::libc::size_t; + let jack_port_set_latency_impl = library + .get:: ()>( + b"jack_port_set_latency", + ) + .unwrap(); + let jack_port_set_latency_impl = jack_port_set_latency_impl.into_raw(); + let jack_port_set_latency_impl = *jack_port_set_latency_impl.deref() + as unsafe extern "C" fn(port: *mut jack_port_t, arg1: jack_nframes_t) -> (); + let jack_port_get_latency_range_impl = library + .get:: ()>(b"jack_port_get_latency_range") + .unwrap(); + let jack_port_get_latency_range_impl = jack_port_get_latency_range_impl.into_raw(); + let jack_port_get_latency_range_impl = *jack_port_get_latency_range_impl.deref() + as unsafe extern "C" fn( + port: *mut jack_port_t, + mode: jack_latency_callback_mode_t, + range: *mut jack_latency_range_t, + ) -> (); + let jack_port_set_latency_range_impl = library + .get:: ()>(b"jack_port_set_latency_range") + .unwrap(); + let jack_port_set_latency_range_impl = jack_port_set_latency_range_impl.into_raw(); + let jack_port_set_latency_range_impl = *jack_port_set_latency_range_impl.deref() + as unsafe extern "C" fn( + port: *mut jack_port_t, + mode: jack_latency_callback_mode_t, + range: *mut jack_latency_range_t, + ) -> (); + let jack_recompute_total_latencies_impl = library + .get:: ::libc::c_int>( + b"jack_recompute_total_latencies", + ) + .unwrap(); + let jack_recompute_total_latencies_impl = jack_recompute_total_latencies_impl.into_raw(); + let jack_recompute_total_latencies_impl = *jack_recompute_total_latencies_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> ::libc::c_int; + let jack_port_get_latency_impl = library + .get:: jack_nframes_t>( + b"jack_port_get_latency", + ) + .unwrap(); + let jack_port_get_latency_impl = jack_port_get_latency_impl.into_raw(); + let jack_port_get_latency_impl = *jack_port_get_latency_impl.deref() + as unsafe extern "C" fn(port: *mut jack_port_t) -> jack_nframes_t; + let jack_port_get_total_latency_impl = library + .get:: jack_nframes_t>(b"jack_port_get_total_latency") + .unwrap(); + let jack_port_get_total_latency_impl = jack_port_get_total_latency_impl.into_raw(); + let jack_port_get_total_latency_impl = *jack_port_get_total_latency_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + port: *mut jack_port_t, + ) -> jack_nframes_t; + let jack_recompute_total_latency_impl = + library + .get:: ::libc::c_int>(b"jack_recompute_total_latency") + .unwrap(); + let jack_recompute_total_latency_impl = jack_recompute_total_latency_impl.into_raw(); + let jack_recompute_total_latency_impl = *jack_recompute_total_latency_impl.deref() + as unsafe extern "C" fn( + arg1: *mut jack_client_t, + port: *mut jack_port_t, + ) -> ::libc::c_int; + let jack_get_ports_impl = library + .get:: *mut *const ::libc::c_char>(b"jack_get_ports") + .unwrap(); + let jack_get_ports_impl = jack_get_ports_impl.into_raw(); + let jack_get_ports_impl = *jack_get_ports_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + port_name_pattern: *const ::libc::c_char, + type_name_pattern: *const ::libc::c_char, + flags: ::libc::c_ulong, + ) -> *mut *const ::libc::c_char; + let jack_port_by_name_impl = library + .get:: *mut jack_port_t>(b"jack_port_by_name") + .unwrap(); + let jack_port_by_name_impl = jack_port_by_name_impl.into_raw(); + let jack_port_by_name_impl = *jack_port_by_name_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + port_name: *const ::libc::c_char, + ) -> *mut jack_port_t; + let jack_port_by_id_impl = library + .get:: *mut jack_port_t>(b"jack_port_by_id") + .unwrap(); + let jack_port_by_id_impl = jack_port_by_id_impl.into_raw(); + let jack_port_by_id_impl = *jack_port_by_id_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + port_id: jack_port_id_t, + ) -> *mut jack_port_t; + let jack_frames_since_cycle_start_impl = library + .get:: jack_nframes_t>( + b"jack_frames_since_cycle_start", + ) + .unwrap(); + let jack_frames_since_cycle_start_impl = jack_frames_since_cycle_start_impl.into_raw(); + let jack_frames_since_cycle_start_impl = *jack_frames_since_cycle_start_impl.deref() + as unsafe extern "C" fn(arg1: *const jack_client_t) -> jack_nframes_t; + let jack_frame_time_impl = library + .get:: jack_nframes_t>( + b"jack_frame_time", + ) + .unwrap(); + let jack_frame_time_impl = jack_frame_time_impl.into_raw(); + let jack_frame_time_impl = *jack_frame_time_impl.deref() + as unsafe extern "C" fn(arg1: *const jack_client_t) -> jack_nframes_t; + let jack_last_frame_time_impl = library + .get:: jack_nframes_t>( + b"jack_last_frame_time", + ) + .unwrap(); + let jack_last_frame_time_impl = jack_last_frame_time_impl.into_raw(); + let jack_last_frame_time_impl = *jack_last_frame_time_impl.deref() + as unsafe extern "C" fn(client: *const jack_client_t) -> jack_nframes_t; + let jack_frames_to_time_impl = + library + .get:: jack_time_t>(b"jack_frames_to_time") + .unwrap(); + let jack_frames_to_time_impl = jack_frames_to_time_impl.into_raw(); + let jack_frames_to_time_impl = *jack_frames_to_time_impl.deref() + as unsafe extern "C" fn( + client: *const jack_client_t, + arg1: jack_nframes_t, + ) -> jack_time_t; + let jack_time_to_frames_impl = + library + .get:: jack_nframes_t>(b"jack_time_to_frames") + .unwrap(); + let jack_time_to_frames_impl = jack_time_to_frames_impl.into_raw(); + let jack_time_to_frames_impl = *jack_time_to_frames_impl.deref() + as unsafe extern "C" fn( + client: *const jack_client_t, + arg1: jack_time_t, + ) -> jack_nframes_t; + let jack_get_time_impl = library + .get:: jack_time_t>(b"jack_get_time") + .unwrap(); + let jack_get_time_impl = jack_get_time_impl.into_raw(); + let jack_get_time_impl = + *jack_get_time_impl.deref() as unsafe extern "C" fn() -> jack_time_t; + let jack_set_error_function_impl = + library + .get:: (), + >, + ) -> ()>(b"jack_set_error_function") + .unwrap(); + let jack_set_error_function_impl = jack_set_error_function_impl.into_raw(); + let jack_set_error_function_impl = *jack_set_error_function_impl.deref() + as unsafe extern "C" fn( + func: ::std::option::Option ()>, + ) -> (); + let jack_set_info_function_impl = + library + .get:: (), + >, + ) -> ()>(b"jack_set_info_function") + .unwrap(); + let jack_set_info_function_impl = jack_set_info_function_impl.into_raw(); + let jack_set_info_function_impl = *jack_set_info_function_impl.deref() + as unsafe extern "C" fn( + func: ::std::option::Option ()>, + ) -> (); + let jack_free_impl = library + .get:: ()>(b"jack_free") + .unwrap(); + let jack_free_impl = jack_free_impl.into_raw(); + let jack_free_impl = + *jack_free_impl.deref() as unsafe extern "C" fn(ptr: *mut ::libc::c_void) -> (); + let jack_client_real_time_priority_impl = library + .get:: ::libc::c_int>( + b"jack_client_real_time_priority", + ) + .unwrap(); + let jack_client_real_time_priority_impl = jack_client_real_time_priority_impl.into_raw(); + let jack_client_real_time_priority_impl = *jack_client_real_time_priority_impl.deref() + as unsafe extern "C" fn(arg1: *mut jack_client_t) -> ::libc::c_int; + let jack_client_max_real_time_priority_impl = library + .get:: ::libc::c_int>( + b"jack_client_max_real_time_priority", + ) + .unwrap(); + let jack_client_max_real_time_priority_impl = + jack_client_max_real_time_priority_impl.into_raw(); + let jack_client_max_real_time_priority_impl = *jack_client_max_real_time_priority_impl + .deref() + as unsafe extern "C" fn(arg1: *mut jack_client_t) -> ::libc::c_int; + let jack_set_session_callback_impl = library + .get:: ::libc::c_int>(b"jack_set_session_callback") + .unwrap(); + let jack_set_session_callback_impl = jack_set_session_callback_impl.into_raw(); + let jack_set_session_callback_impl = *jack_set_session_callback_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + session_callback: JackSessionCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_session_reply_impl = library + .get:: ::libc::c_int>(b"jack_session_reply") + .unwrap(); + let jack_session_reply_impl = jack_session_reply_impl.into_raw(); + let jack_session_reply_impl = *jack_session_reply_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + event: *mut jack_session_event_t, + ) -> ::libc::c_int; + let jack_session_event_free_impl = library + .get:: ()>( + b"jack_session_event_free", + ) + .unwrap(); + let jack_session_event_free_impl = jack_session_event_free_impl.into_raw(); + let jack_session_event_free_impl = *jack_session_event_free_impl.deref() + as unsafe extern "C" fn(event: *mut jack_session_event_t) -> (); + let jack_client_get_uuid_impl = library + .get:: *mut ::libc::c_char>( + b"jack_client_get_uuid", + ) + .unwrap(); + let jack_client_get_uuid_impl = jack_client_get_uuid_impl.into_raw(); + let jack_client_get_uuid_impl = *jack_client_get_uuid_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> *mut ::libc::c_char; + let jack_session_notify_impl = library + .get:: *mut jack_session_command_t>(b"jack_session_notify") + .unwrap(); + let jack_session_notify_impl = jack_session_notify_impl.into_raw(); + let jack_session_notify_impl = *jack_session_notify_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + target: *const ::libc::c_char, + _type: jack_session_event_type_t, + path: *const ::libc::c_char, + ) -> *mut jack_session_command_t; + let jack_session_commands_free_impl = library + .get:: ()>( + b"jack_session_commands_free", + ) + .unwrap(); + let jack_session_commands_free_impl = jack_session_commands_free_impl.into_raw(); + let jack_session_commands_free_impl = *jack_session_commands_free_impl.deref() + as unsafe extern "C" fn(cmds: *mut jack_session_command_t) -> (); + let jack_reserve_client_name_impl = library + .get:: ::libc::c_int>(b"jack_reserve_client_name") + .unwrap(); + let jack_reserve_client_name_impl = jack_reserve_client_name_impl.into_raw(); + let jack_reserve_client_name_impl = *jack_reserve_client_name_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + name: *const ::libc::c_char, + uuid: *const ::libc::c_char, + ) -> ::libc::c_int; + let jack_client_has_session_callback_impl = library + .get:: ::libc::c_int>(b"jack_client_has_session_callback") + .unwrap(); + let jack_client_has_session_callback_impl = + jack_client_has_session_callback_impl.into_raw(); + let jack_client_has_session_callback_impl = *jack_client_has_session_callback_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + client_name: *const ::libc::c_char, + ) -> ::libc::c_int; + let jackctl_setup_signals_impl = library + .get:: *mut jackctl_sigmask_t>( + b"jackctl_setup_signals", + ) + .ok(); + let jackctl_setup_signals_impl = jackctl_setup_signals_impl.map(|sym| sym.into_raw()); + let jackctl_setup_signals_impl = jackctl_setup_signals_impl.map(|sym| { + *sym.deref() as unsafe extern "C" fn(flags: ::libc::c_uint) -> *mut jackctl_sigmask_t + }); + let jackctl_wait_signals_impl = library + .get:: ()>( + b"jackctl_wait_signals", + ) + .ok(); + let jackctl_wait_signals_impl = jackctl_wait_signals_impl.map(|sym| sym.into_raw()); + let jackctl_wait_signals_impl = jackctl_wait_signals_impl + .map(|sym| *sym.deref() as unsafe extern "C" fn(signals: *mut jackctl_sigmask_t) -> ()); + let jackctl_server_create_impl = library + .get:: u8, + >, + on_device_release: ::std::option::Option< + unsafe extern "C" fn(device_name: *const ::libc::c_char) -> (), + >, + ) -> *mut jackctl_server_t>(b"jackctl_server_create") + .ok(); + let jackctl_server_create_impl = jackctl_server_create_impl.map(|sym| sym.into_raw()); + let jackctl_server_create_impl = jackctl_server_create_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + on_device_acquire: ::std::option::Option< + unsafe extern "C" fn(device_name: *const ::libc::c_char) -> u8, + >, + on_device_release: ::std::option::Option< + unsafe extern "C" fn(device_name: *const ::libc::c_char) -> (), + >, + ) -> *mut jackctl_server_t + }); + let jackctl_server_destroy_impl = library + .get:: ()>( + b"jackctl_server_destroy", + ) + .ok(); + let jackctl_server_destroy_impl = jackctl_server_destroy_impl.map(|sym| sym.into_raw()); + let jackctl_server_destroy_impl = jackctl_server_destroy_impl + .map(|sym| *sym.deref() as unsafe extern "C" fn(server: *mut jackctl_server_t) -> ()); + let jackctl_server_open_impl = + library + .get:: u8>(b"jackctl_server_open") + .ok(); + let jackctl_server_open_impl = jackctl_server_open_impl.map(|sym| sym.into_raw()); + let jackctl_server_open_impl = jackctl_server_open_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + server: *mut jackctl_server_t, + driver: *mut jackctl_driver_t, + ) -> u8 + }); + let jackctl_server_start_impl = library + .get:: u8>( + b"jackctl_server_start", + ) + .ok(); + let jackctl_server_start_impl = jackctl_server_start_impl.map(|sym| sym.into_raw()); + let jackctl_server_start_impl = jackctl_server_start_impl + .map(|sym| *sym.deref() as unsafe extern "C" fn(server: *mut jackctl_server_t) -> u8); + let jackctl_server_stop_impl = library + .get:: u8>( + b"jackctl_server_stop", + ) + .ok(); + let jackctl_server_stop_impl = jackctl_server_stop_impl.map(|sym| sym.into_raw()); + let jackctl_server_stop_impl = jackctl_server_stop_impl + .map(|sym| *sym.deref() as unsafe extern "C" fn(server: *mut jackctl_server_t) -> u8); + let jackctl_server_close_impl = library + .get:: u8>( + b"jackctl_server_close", + ) + .ok(); + let jackctl_server_close_impl = jackctl_server_close_impl.map(|sym| sym.into_raw()); + let jackctl_server_close_impl = jackctl_server_close_impl + .map(|sym| *sym.deref() as unsafe extern "C" fn(server: *mut jackctl_server_t) -> u8); + let jackctl_server_get_drivers_list_impl = library + .get:: *const JSList>( + b"jackctl_server_get_drivers_list", + ) + .ok(); + let jackctl_server_get_drivers_list_impl = + jackctl_server_get_drivers_list_impl.map(|sym| sym.into_raw()); + let jackctl_server_get_drivers_list_impl = + jackctl_server_get_drivers_list_impl.map(|sym| { + *sym.deref() as unsafe extern "C" fn(server: *mut jackctl_server_t) -> *const JSList + }); + let jackctl_server_get_parameters_impl = library + .get:: *const JSList>( + b"jackctl_server_get_parameters", + ) + .ok(); + let jackctl_server_get_parameters_impl = + jackctl_server_get_parameters_impl.map(|sym| sym.into_raw()); + let jackctl_server_get_parameters_impl = jackctl_server_get_parameters_impl.map(|sym| { + *sym.deref() as unsafe extern "C" fn(server: *mut jackctl_server_t) -> *const JSList + }); + let jackctl_server_get_internals_list_impl = library + .get:: *const JSList>( + b"jackctl_server_get_internals_list", + ) + .ok(); + let jackctl_server_get_internals_list_impl = + jackctl_server_get_internals_list_impl.map(|sym| sym.into_raw()); + let jackctl_server_get_internals_list_impl = + jackctl_server_get_internals_list_impl.map(|sym| { + *sym.deref() as unsafe extern "C" fn(server: *mut jackctl_server_t) -> *const JSList + }); + let jackctl_server_load_internal_impl = library + .get:: u8>(b"jackctl_server_load_internal") + .ok(); + let jackctl_server_load_internal_impl = + jackctl_server_load_internal_impl.map(|sym| sym.into_raw()); + let jackctl_server_load_internal_impl = jackctl_server_load_internal_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + server: *mut jackctl_server_t, + internal: *mut jackctl_internal_t, + ) -> u8 + }); + let jackctl_server_unload_internal_impl = library + .get:: u8>(b"jackctl_server_unload_internal") + .ok(); + let jackctl_server_unload_internal_impl = + jackctl_server_unload_internal_impl.map(|sym| sym.into_raw()); + let jackctl_server_unload_internal_impl = jackctl_server_unload_internal_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + server: *mut jackctl_server_t, + internal: *mut jackctl_internal_t, + ) -> u8 + }); + let jackctl_server_add_slave_impl = + library + .get:: u8>(b"jackctl_server_add_slave") + .ok(); + let jackctl_server_add_slave_impl = jackctl_server_add_slave_impl.map(|sym| sym.into_raw()); + let jackctl_server_add_slave_impl = jackctl_server_add_slave_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + server: *mut jackctl_server_t, + driver: *mut jackctl_driver_t, + ) -> u8 + }); + let jackctl_server_remove_slave_impl = + library + .get:: u8>(b"jackctl_server_remove_slave") + .ok(); + let jackctl_server_remove_slave_impl = + jackctl_server_remove_slave_impl.map(|sym| sym.into_raw()); + let jackctl_server_remove_slave_impl = jackctl_server_remove_slave_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + server: *mut jackctl_server_t, + driver: *mut jackctl_driver_t, + ) -> u8 + }); + let jackctl_server_switch_master_impl = + library + .get:: u8>(b"jackctl_server_switch_master") + .ok(); + let jackctl_server_switch_master_impl = + jackctl_server_switch_master_impl.map(|sym| sym.into_raw()); + let jackctl_server_switch_master_impl = jackctl_server_switch_master_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + server: *mut jackctl_server_t, + driver: *mut jackctl_driver_t, + ) -> u8 + }); + let jackctl_driver_get_name_impl = library + .get:: *const ::libc::c_char>( + b"jackctl_driver_get_name", + ) + .ok(); + let jackctl_driver_get_name_impl = jackctl_driver_get_name_impl.map(|sym| sym.into_raw()); + let jackctl_driver_get_name_impl = jackctl_driver_get_name_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn(driver: *mut jackctl_driver_t) -> *const ::libc::c_char + }); + let jackctl_driver_get_type_impl = library + .get:: jackctl_driver_type_t>( + b"jackctl_driver_get_type", + ) + .ok(); + let jackctl_driver_get_type_impl = jackctl_driver_get_type_impl.map(|sym| sym.into_raw()); + let jackctl_driver_get_type_impl = jackctl_driver_get_type_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn(driver: *mut jackctl_driver_t) -> jackctl_driver_type_t + }); + let jackctl_driver_get_parameters_impl = library + .get:: *const JSList>( + b"jackctl_driver_get_parameters", + ) + .ok(); + let jackctl_driver_get_parameters_impl = + jackctl_driver_get_parameters_impl.map(|sym| sym.into_raw()); + let jackctl_driver_get_parameters_impl = jackctl_driver_get_parameters_impl.map(|sym| { + *sym.deref() as unsafe extern "C" fn(driver: *mut jackctl_driver_t) -> *const JSList + }); + let jackctl_driver_params_parse_impl = library + .get:: ::libc::c_int>(b"jackctl_driver_params_parse") + .ok(); + let jackctl_driver_params_parse_impl = + jackctl_driver_params_parse_impl.map(|sym| sym.into_raw()); + let jackctl_driver_params_parse_impl = jackctl_driver_params_parse_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + driver: *mut jackctl_driver_t, + argc: ::libc::c_int, + argv: *mut *mut ::libc::c_char, + ) -> ::libc::c_int + }); + let jackctl_internal_get_name_impl = library.get:: *const ::libc::c_char>(b"jackctl_internal_get_name").ok(); + let jackctl_internal_get_name_impl = + jackctl_internal_get_name_impl.map(|sym| sym.into_raw()); + let jackctl_internal_get_name_impl = jackctl_internal_get_name_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn(internal: *mut jackctl_internal_t) -> *const ::libc::c_char + }); + let jackctl_internal_get_parameters_impl = library + .get:: *const JSList>( + b"jackctl_internal_get_parameters", + ) + .ok(); + let jackctl_internal_get_parameters_impl = + jackctl_internal_get_parameters_impl.map(|sym| sym.into_raw()); + let jackctl_internal_get_parameters_impl = + jackctl_internal_get_parameters_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn(internal: *mut jackctl_internal_t) -> *const JSList + }); + let jackctl_parameter_get_name_impl = library.get:: *const ::libc::c_char>(b"jackctl_parameter_get_name").ok(); + let jackctl_parameter_get_name_impl = + jackctl_parameter_get_name_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_get_name_impl = jackctl_parameter_get_name_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + parameter: *mut jackctl_parameter_t, + ) -> *const ::libc::c_char + }); + let jackctl_parameter_get_short_description_impl = library.get:: *const ::libc::c_char>(b"jackctl_parameter_get_short_description").ok(); + let jackctl_parameter_get_short_description_impl = + jackctl_parameter_get_short_description_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_get_short_description_impl = + jackctl_parameter_get_short_description_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + parameter: *mut jackctl_parameter_t, + ) -> *const ::libc::c_char + }); + let jackctl_parameter_get_long_description_impl = library.get:: *const ::libc::c_char>(b"jackctl_parameter_get_long_description").ok(); + let jackctl_parameter_get_long_description_impl = + jackctl_parameter_get_long_description_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_get_long_description_impl = + jackctl_parameter_get_long_description_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + parameter: *mut jackctl_parameter_t, + ) -> *const ::libc::c_char + }); + let jackctl_parameter_get_type_impl = library.get:: jackctl_param_type_t>(b"jackctl_parameter_get_type").ok(); + let jackctl_parameter_get_type_impl = + jackctl_parameter_get_type_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_get_type_impl = jackctl_parameter_get_type_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn(parameter: *mut jackctl_parameter_t) -> jackctl_param_type_t + }); + let jackctl_parameter_get_id_impl = library + .get:: ::libc::c_char>( + b"jackctl_parameter_get_id", + ) + .ok(); + let jackctl_parameter_get_id_impl = jackctl_parameter_get_id_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_get_id_impl = jackctl_parameter_get_id_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn(parameter: *mut jackctl_parameter_t) -> ::libc::c_char + }); + let jackctl_parameter_is_set_impl = library + .get:: u8>( + b"jackctl_parameter_is_set", + ) + .ok(); + let jackctl_parameter_is_set_impl = jackctl_parameter_is_set_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_is_set_impl = jackctl_parameter_is_set_impl.map(|sym| { + *sym.deref() as unsafe extern "C" fn(parameter: *mut jackctl_parameter_t) -> u8 + }); + let jackctl_parameter_reset_impl = library + .get:: u8>( + b"jackctl_parameter_reset", + ) + .ok(); + let jackctl_parameter_reset_impl = jackctl_parameter_reset_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_reset_impl = jackctl_parameter_reset_impl.map(|sym| { + *sym.deref() as unsafe extern "C" fn(parameter: *mut jackctl_parameter_t) -> u8 + }); + let jackctl_parameter_get_value_impl = library + .get:: Union_jackctl_parameter_value>(b"jackctl_parameter_get_value") + .ok(); + let jackctl_parameter_get_value_impl = + jackctl_parameter_get_value_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_get_value_impl = jackctl_parameter_get_value_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + parameter: *mut jackctl_parameter_t, + ) -> Union_jackctl_parameter_value + }); + let jackctl_parameter_set_value_impl = library + .get:: u8>(b"jackctl_parameter_set_value") + .ok(); + let jackctl_parameter_set_value_impl = + jackctl_parameter_set_value_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_set_value_impl = jackctl_parameter_set_value_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + parameter: *mut jackctl_parameter_t, + value_ptr: *const Union_jackctl_parameter_value, + ) -> u8 + }); + let jackctl_parameter_get_default_value_impl = library + .get:: Union_jackctl_parameter_value>(b"jackctl_parameter_get_default_value") + .ok(); + let jackctl_parameter_get_default_value_impl = + jackctl_parameter_get_default_value_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_get_default_value_impl = jackctl_parameter_get_default_value_impl + .map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + parameter: *mut jackctl_parameter_t, + ) -> Union_jackctl_parameter_value + }); + let jackctl_parameter_has_range_constraint_impl = library + .get:: u8>( + b"jackctl_parameter_has_range_constraint", + ) + .ok(); + let jackctl_parameter_has_range_constraint_impl = + jackctl_parameter_has_range_constraint_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_has_range_constraint_impl = + jackctl_parameter_has_range_constraint_impl.map(|sym| { + *sym.deref() as unsafe extern "C" fn(parameter: *mut jackctl_parameter_t) -> u8 + }); + let jackctl_parameter_has_enum_constraint_impl = library + .get:: u8>( + b"jackctl_parameter_has_enum_constraint", + ) + .ok(); + let jackctl_parameter_has_enum_constraint_impl = + jackctl_parameter_has_enum_constraint_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_has_enum_constraint_impl = jackctl_parameter_has_enum_constraint_impl + .map(|sym| { + *sym.deref() as unsafe extern "C" fn(parameter: *mut jackctl_parameter_t) -> u8 + }); + let jackctl_parameter_get_enum_constraints_count_impl = library + .get:: u32>( + b"jackctl_parameter_get_enum_constraints_count", + ) + .ok(); + let jackctl_parameter_get_enum_constraints_count_impl = + jackctl_parameter_get_enum_constraints_count_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_get_enum_constraints_count_impl = + jackctl_parameter_get_enum_constraints_count_impl.map(|sym| { + *sym.deref() as unsafe extern "C" fn(parameter: *mut jackctl_parameter_t) -> u32 + }); + let jackctl_parameter_get_enum_constraint_value_impl = library + .get:: Union_jackctl_parameter_value>( + b"jackctl_parameter_get_enum_constraint_value" + ) + .ok(); + let jackctl_parameter_get_enum_constraint_value_impl = + jackctl_parameter_get_enum_constraint_value_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_get_enum_constraint_value_impl = + jackctl_parameter_get_enum_constraint_value_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + parameter: *mut jackctl_parameter_t, + index: u32, + ) -> Union_jackctl_parameter_value + }); + let jackctl_parameter_get_enum_constraint_description_impl = library + .get:: *const ::libc::c_char>( + b"jackctl_parameter_get_enum_constraint_description" + ) + .ok(); + let jackctl_parameter_get_enum_constraint_description_impl = + jackctl_parameter_get_enum_constraint_description_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_get_enum_constraint_description_impl = + jackctl_parameter_get_enum_constraint_description_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + parameter: *mut jackctl_parameter_t, + index: u32, + ) -> *const ::libc::c_char + }); + let jackctl_parameter_get_range_constraint_impl = library + .get:: ()>(b"jackctl_parameter_get_range_constraint") + .ok(); + let jackctl_parameter_get_range_constraint_impl = + jackctl_parameter_get_range_constraint_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_get_range_constraint_impl = + jackctl_parameter_get_range_constraint_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + parameter: *mut jackctl_parameter_t, + min_ptr: *mut Union_jackctl_parameter_value, + max_ptr: *mut Union_jackctl_parameter_value, + ) -> () + }); + let jackctl_parameter_constraint_is_strict_impl = library + .get:: u8>( + b"jackctl_parameter_constraint_is_strict", + ) + .ok(); + let jackctl_parameter_constraint_is_strict_impl = + jackctl_parameter_constraint_is_strict_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_constraint_is_strict_impl = + jackctl_parameter_constraint_is_strict_impl.map(|sym| { + *sym.deref() as unsafe extern "C" fn(parameter: *mut jackctl_parameter_t) -> u8 + }); + let jackctl_parameter_constraint_is_fake_value_impl = library + .get:: u8>( + b"jackctl_parameter_constraint_is_fake_value", + ) + .ok(); + let jackctl_parameter_constraint_is_fake_value_impl = + jackctl_parameter_constraint_is_fake_value_impl.map(|sym| sym.into_raw()); + let jackctl_parameter_constraint_is_fake_value_impl = + jackctl_parameter_constraint_is_fake_value_impl.map(|sym| { + *sym.deref() as unsafe extern "C" fn(parameter: *mut jackctl_parameter_t) -> u8 + }); + let jack_set_property_impl = library + .get:: ::libc::c_int>(b"jack_set_property") + .unwrap(); + let jack_set_property_impl = jack_set_property_impl.into_raw(); + let jack_set_property_impl = *jack_set_property_impl.deref() + as unsafe extern "C" fn( + arg1: *mut jack_client_t, + subject: jack_uuid_t, + key: *const ::libc::c_char, + value: *const ::libc::c_char, + _type: *const ::libc::c_char, + ) -> ::libc::c_int; + let jack_get_property_impl = library + .get:: ::libc::c_int>(b"jack_get_property") + .unwrap(); + let jack_get_property_impl = jack_get_property_impl.into_raw(); + let jack_get_property_impl = *jack_get_property_impl.deref() + as unsafe extern "C" fn( + subject: jack_uuid_t, + key: *const ::libc::c_char, + value: *mut *mut ::libc::c_char, + _type: *mut *mut ::libc::c_char, + ) -> ::libc::c_int; + let jack_free_description_impl = library + .get:: ()>(b"jack_free_description") + .unwrap(); + let jack_free_description_impl = jack_free_description_impl.into_raw(); + let jack_free_description_impl = *jack_free_description_impl.deref() + as unsafe extern "C" fn( + desc: *mut jack_description_t, + free_description_itself: ::libc::c_int, + ) -> (); + let jack_get_properties_impl = library + .get:: ::libc::c_int>(b"jack_get_properties") + .unwrap(); + let jack_get_properties_impl = jack_get_properties_impl.into_raw(); + let jack_get_properties_impl = *jack_get_properties_impl.deref() + as unsafe extern "C" fn( + subject: jack_uuid_t, + desc: *mut jack_description_t, + ) -> ::libc::c_int; + let jack_get_all_properties_impl = library + .get:: ::libc::c_int>( + b"jack_get_all_properties", + ) + .unwrap(); + let jack_get_all_properties_impl = jack_get_all_properties_impl.into_raw(); + let jack_get_all_properties_impl = *jack_get_all_properties_impl.deref() + as unsafe extern "C" fn(descs: *mut *mut jack_description_t) -> ::libc::c_int; + let jack_remove_property_impl = library + .get:: ::libc::c_int>(b"jack_remove_property") + .unwrap(); + let jack_remove_property_impl = jack_remove_property_impl.into_raw(); + let jack_remove_property_impl = *jack_remove_property_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + subject: jack_uuid_t, + key: *const ::libc::c_char, + ) -> ::libc::c_int; + let jack_remove_properties_impl = + library + .get:: ::libc::c_int>(b"jack_remove_properties") + .unwrap(); + let jack_remove_properties_impl = jack_remove_properties_impl.into_raw(); + let jack_remove_properties_impl = *jack_remove_properties_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + subject: jack_uuid_t, + ) -> ::libc::c_int; + let jack_remove_all_properties_impl = library + .get:: ::libc::c_int>( + b"jack_remove_all_properties", + ) + .unwrap(); + let jack_remove_all_properties_impl = jack_remove_all_properties_impl.into_raw(); + let jack_remove_all_properties_impl = *jack_remove_all_properties_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> ::libc::c_int; + let jack_set_property_change_callback_impl = library + .get:: ::libc::c_int>(b"jack_set_property_change_callback") + .unwrap(); + let jack_set_property_change_callback_impl = + jack_set_property_change_callback_impl.into_raw(); + let jack_set_property_change_callback_impl = *jack_set_property_change_callback_impl.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + callback: JackPropertyChangeCallback, + arg: *mut ::libc::c_void, + ) -> ::libc::c_int; + let jack_get_internal_client_name_impl = library + .get:: *mut ::libc::c_char>(b"jack_get_internal_client_name") + .ok(); + let jack_get_internal_client_name_impl = + jack_get_internal_client_name_impl.map(|sym| sym.into_raw()); + let jack_get_internal_client_name_impl = jack_get_internal_client_name_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + intclient: jack_intclient_t, + ) -> *mut ::libc::c_char + }); + let jack_internal_client_handle_impl = library + .get:: jack_intclient_t>(b"jack_internal_client_handle") + .ok(); + let jack_internal_client_handle_impl = + jack_internal_client_handle_impl.map(|sym| sym.into_raw()); + let jack_internal_client_handle_impl = jack_internal_client_handle_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + client_name: *const ::libc::c_char, + status: *mut jack_status_t, + ) -> jack_intclient_t + }); + let jack_internal_client_load_impl = library + .get:: jack_intclient_t>(b"jack_internal_client_load") + .ok(); + let jack_internal_client_load_impl = + jack_internal_client_load_impl.map(|sym| sym.into_raw()); + let jack_internal_client_load_impl = jack_internal_client_load_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + client_name: *const ::libc::c_char, + options: jack_options_t, + status: *mut jack_status_t, + load_name: *const ::libc::c_char, + load_init: *const ::libc::c_char, + ) -> jack_intclient_t + }); + let jack_internal_client_unload_impl = library + .get:: jack_status_t>(b"jack_internal_client_unload") + .ok(); + let jack_internal_client_unload_impl = + jack_internal_client_unload_impl.map(|sym| sym.into_raw()); + let jack_internal_client_unload_impl = jack_internal_client_unload_impl.map(|sym| { + *sym.deref() + as unsafe extern "C" fn( + client: *mut jack_client_t, + intclient: jack_intclient_t, + ) -> jack_status_t + }); + let jack_get_max_delayed_usecs_impl = library + .get:: ::libc::c_float>( + b"jack_get_max_delayed_usecs", + ) + .unwrap(); + let jack_get_max_delayed_usecs_impl = jack_get_max_delayed_usecs_impl.into_raw(); + let jack_get_max_delayed_usecs_impl = *jack_get_max_delayed_usecs_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> ::libc::c_float; + let jack_get_xrun_delayed_usecs_impl = library + .get:: ::libc::c_float>( + b"jack_get_xrun_delayed_usecs", + ) + .unwrap(); + let jack_get_xrun_delayed_usecs_impl = jack_get_xrun_delayed_usecs_impl.into_raw(); + let jack_get_xrun_delayed_usecs_impl = *jack_get_xrun_delayed_usecs_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> ::libc::c_float; + let jack_reset_max_delayed_usecs_impl = library + .get:: ()>( + b"jack_reset_max_delayed_usecs", + ) + .unwrap(); + let jack_reset_max_delayed_usecs_impl = jack_reset_max_delayed_usecs_impl.into_raw(); + let jack_reset_max_delayed_usecs_impl = *jack_reset_max_delayed_usecs_impl.deref() + as unsafe extern "C" fn(client: *mut jack_client_t) -> (); + let jack_midi_get_event_count_impl = library + .get:: u32>( + b"jack_midi_get_event_count", + ) + .unwrap(); + let jack_midi_get_event_count_impl = jack_midi_get_event_count_impl.into_raw(); + let jack_midi_get_event_count_impl = *jack_midi_get_event_count_impl.deref() + as unsafe extern "C" fn(port_buffer: *mut ::libc::c_void) -> u32; + let jack_midi_event_get_impl = library + .get:: ::libc::c_int>(b"jack_midi_event_get") + .unwrap(); + let jack_midi_event_get_impl = jack_midi_event_get_impl.into_raw(); + let jack_midi_event_get_impl = *jack_midi_event_get_impl.deref() + as unsafe extern "C" fn( + event: *mut jack_midi_event_t, + port_buffer: *mut ::libc::c_void, + event_index: u32, + ) -> ::libc::c_int; + let jack_midi_clear_buffer_impl = library + .get:: ()>( + b"jack_midi_clear_buffer", + ) + .unwrap(); + let jack_midi_clear_buffer_impl = jack_midi_clear_buffer_impl.into_raw(); + let jack_midi_clear_buffer_impl = *jack_midi_clear_buffer_impl.deref() + as unsafe extern "C" fn(port_buffer: *mut ::libc::c_void) -> (); + let jack_midi_max_event_size_impl = library + .get:: ::libc::size_t>( + b"jack_midi_max_event_size", + ) + .unwrap(); + let jack_midi_max_event_size_impl = jack_midi_max_event_size_impl.into_raw(); + let jack_midi_max_event_size_impl = *jack_midi_max_event_size_impl.deref() + as unsafe extern "C" fn(port_buffer: *mut ::libc::c_void) -> ::libc::size_t; + let jack_midi_event_reserve_impl = library + .get:: *mut jack_midi_data_t>(b"jack_midi_event_reserve") + .unwrap(); + let jack_midi_event_reserve_impl = jack_midi_event_reserve_impl.into_raw(); + let jack_midi_event_reserve_impl = *jack_midi_event_reserve_impl.deref() + as unsafe extern "C" fn( + port_buffer: *mut ::libc::c_void, + time: jack_nframes_t, + data_size: ::libc::size_t, + ) -> *mut jack_midi_data_t; + let jack_midi_event_write_impl = library + .get:: ::libc::c_int>(b"jack_midi_event_write") + .unwrap(); + let jack_midi_event_write_impl = jack_midi_event_write_impl.into_raw(); + let jack_midi_event_write_impl = *jack_midi_event_write_impl.deref() + as unsafe extern "C" fn( + port_buffer: *mut ::libc::c_void, + time: jack_nframes_t, + data: *const jack_midi_data_t, + data_size: ::libc::size_t, + ) -> ::libc::c_int; + let jack_midi_get_lost_event_count_impl = library + .get:: u32>( + b"jack_midi_get_lost_event_count", + ) + .unwrap(); + let jack_midi_get_lost_event_count_impl = jack_midi_get_lost_event_count_impl.into_raw(); + let jack_midi_get_lost_event_count_impl = *jack_midi_get_lost_event_count_impl.deref() + as unsafe extern "C" fn(port_buffer: *mut ::libc::c_void) -> u32; + let jack_ringbuffer_create_impl = library + .get:: *mut jack_ringbuffer_t>( + b"jack_ringbuffer_create", + ) + .unwrap(); + let jack_ringbuffer_create_impl = jack_ringbuffer_create_impl.into_raw(); + let jack_ringbuffer_create_impl = *jack_ringbuffer_create_impl.deref() + as unsafe extern "C" fn(sz: ::libc::size_t) -> *mut jack_ringbuffer_t; + let jack_ringbuffer_free_impl = library + .get:: ()>(b"jack_ringbuffer_free") + .unwrap(); + let jack_ringbuffer_free_impl = jack_ringbuffer_free_impl.into_raw(); + let jack_ringbuffer_free_impl = *jack_ringbuffer_free_impl.deref() + as unsafe extern "C" fn(rb: *mut jack_ringbuffer_t) -> (); + let jack_ringbuffer_get_read_vector_impl = library + .get:: ()>(b"jack_ringbuffer_get_read_vector") + .unwrap(); + let jack_ringbuffer_get_read_vector_impl = jack_ringbuffer_get_read_vector_impl.into_raw(); + let jack_ringbuffer_get_read_vector_impl = *jack_ringbuffer_get_read_vector_impl.deref() + as unsafe extern "C" fn( + rb: *const jack_ringbuffer_t, + vec: *mut jack_ringbuffer_data_t, + ) -> (); + let jack_ringbuffer_get_write_vector_impl = library + .get:: ()>(b"jack_ringbuffer_get_write_vector") + .unwrap(); + let jack_ringbuffer_get_write_vector_impl = + jack_ringbuffer_get_write_vector_impl.into_raw(); + let jack_ringbuffer_get_write_vector_impl = *jack_ringbuffer_get_write_vector_impl.deref() + as unsafe extern "C" fn( + rb: *const jack_ringbuffer_t, + vec: *mut jack_ringbuffer_data_t, + ) -> (); + let jack_ringbuffer_read_impl = library + .get:: ::libc::size_t>(b"jack_ringbuffer_read") + .unwrap(); + let jack_ringbuffer_read_impl = jack_ringbuffer_read_impl.into_raw(); + let jack_ringbuffer_read_impl = *jack_ringbuffer_read_impl.deref() + as unsafe extern "C" fn( + rb: *mut jack_ringbuffer_t, + dest: *mut ::libc::c_char, + cnt: ::libc::size_t, + ) -> ::libc::size_t; + let jack_ringbuffer_peek_impl = library + .get:: ::libc::size_t>(b"jack_ringbuffer_peek") + .unwrap(); + let jack_ringbuffer_peek_impl = jack_ringbuffer_peek_impl.into_raw(); + let jack_ringbuffer_peek_impl = *jack_ringbuffer_peek_impl.deref() + as unsafe extern "C" fn( + rb: *mut jack_ringbuffer_t, + dest: *mut ::libc::c_char, + cnt: ::libc::size_t, + ) -> ::libc::size_t; + let jack_ringbuffer_read_advance_impl = library + .get:: ()>( + b"jack_ringbuffer_read_advance", + ) + .unwrap(); + let jack_ringbuffer_read_advance_impl = jack_ringbuffer_read_advance_impl.into_raw(); + let jack_ringbuffer_read_advance_impl = *jack_ringbuffer_read_advance_impl.deref() + as unsafe extern "C" fn(rb: *mut jack_ringbuffer_t, cnt: ::libc::size_t) -> (); + let jack_ringbuffer_read_space_impl = library + .get:: ::libc::size_t>( + b"jack_ringbuffer_read_space", + ) + .unwrap(); + let jack_ringbuffer_read_space_impl = jack_ringbuffer_read_space_impl.into_raw(); + let jack_ringbuffer_read_space_impl = *jack_ringbuffer_read_space_impl.deref() + as unsafe extern "C" fn(rb: *const jack_ringbuffer_t) -> ::libc::size_t; + let jack_ringbuffer_mlock_impl = library + .get:: ::libc::c_int>( + b"jack_ringbuffer_mlock", + ) + .unwrap(); + let jack_ringbuffer_mlock_impl = jack_ringbuffer_mlock_impl.into_raw(); + let jack_ringbuffer_mlock_impl = *jack_ringbuffer_mlock_impl.deref() + as unsafe extern "C" fn(rb: *mut jack_ringbuffer_t) -> ::libc::c_int; + let jack_ringbuffer_reset_impl = library + .get:: ()>(b"jack_ringbuffer_reset") + .unwrap(); + let jack_ringbuffer_reset_impl = jack_ringbuffer_reset_impl.into_raw(); + let jack_ringbuffer_reset_impl = *jack_ringbuffer_reset_impl.deref() + as unsafe extern "C" fn(rb: *mut jack_ringbuffer_t) -> (); + let jack_ringbuffer_write_impl = library + .get:: ::libc::size_t>(b"jack_ringbuffer_write") + .unwrap(); + let jack_ringbuffer_write_impl = jack_ringbuffer_write_impl.into_raw(); + let jack_ringbuffer_write_impl = *jack_ringbuffer_write_impl.deref() + as unsafe extern "C" fn( + rb: *mut jack_ringbuffer_t, + src: *const ::libc::c_char, + cnt: ::libc::size_t, + ) -> ::libc::size_t; + let jack_ringbuffer_write_advance_impl = library + .get:: ()>( + b"jack_ringbuffer_write_advance", + ) + .unwrap(); + let jack_ringbuffer_write_advance_impl = jack_ringbuffer_write_advance_impl.into_raw(); + let jack_ringbuffer_write_advance_impl = *jack_ringbuffer_write_advance_impl.deref() + as unsafe extern "C" fn(rb: *mut jack_ringbuffer_t, cnt: ::libc::size_t) -> (); + let jack_ringbuffer_write_space_impl = library + .get:: ::libc::size_t>( + b"jack_ringbuffer_write_space", + ) + .unwrap(); + let jack_ringbuffer_write_space_impl = jack_ringbuffer_write_space_impl.into_raw(); + let jack_ringbuffer_write_space_impl = *jack_ringbuffer_write_space_impl.deref() + as unsafe extern "C" fn(rb: *const jack_ringbuffer_t) -> ::libc::size_t; + let jack_uuid_to_index_impl = library + .get:: u32>(b"jack_uuid_to_index") + .unwrap(); + let jack_uuid_to_index_impl = jack_uuid_to_index_impl.into_raw(); + let jack_uuid_to_index_impl = + *jack_uuid_to_index_impl.deref() as unsafe extern "C" fn(arg1: jack_uuid_t) -> u32; + let jack_uuid_compare_impl = library.get:: ::std::os::raw::c_int>(b"jack_uuid_compare").unwrap(); + let jack_uuid_compare_impl = jack_uuid_compare_impl.into_raw(); + let jack_uuid_compare_impl = *jack_uuid_compare_impl.deref() + as unsafe extern "C" fn(arg1: jack_uuid_t, arg2: jack_uuid_t) -> ::std::os::raw::c_int; + let jack_uuid_copy_impl = library + .get:: ()>( + b"jack_uuid_copy", + ) + .unwrap(); + let jack_uuid_copy_impl = jack_uuid_copy_impl.into_raw(); + let jack_uuid_copy_impl = *jack_uuid_copy_impl.deref() + as unsafe extern "C" fn(dst: *mut jack_uuid_t, src: jack_uuid_t) -> (); + let jack_uuid_clear_impl = library + .get:: ()>(b"jack_uuid_clear") + .unwrap(); + let jack_uuid_clear_impl = jack_uuid_clear_impl.into_raw(); + let jack_uuid_clear_impl = + *jack_uuid_clear_impl.deref() as unsafe extern "C" fn(arg1: *mut jack_uuid_t) -> (); + let jack_uuid_parse_impl = library + .get:: ::std::os::raw::c_int>(b"jack_uuid_parse") + .unwrap(); + let jack_uuid_parse_impl = jack_uuid_parse_impl.into_raw(); + let jack_uuid_parse_impl = *jack_uuid_parse_impl.deref() + as unsafe extern "C" fn( + buf: *const ::std::os::raw::c_char, + arg1: *mut jack_uuid_t, + ) -> ::std::os::raw::c_int; + let jack_uuid_unparse_impl = library + .get:: ()>( + b"jack_uuid_unparse", + ) + .unwrap(); + let jack_uuid_unparse_impl = jack_uuid_unparse_impl.into_raw(); + let jack_uuid_unparse_impl = *jack_uuid_unparse_impl.deref() + as unsafe extern "C" fn(arg1: jack_uuid_t, buf: *mut ::std::os::raw::c_char) -> (); + let jack_uuid_empty_impl = library + .get:: ::std::os::raw::c_int>( + b"jack_uuid_empty", + ) + .unwrap(); + let jack_uuid_empty_impl = jack_uuid_empty_impl.into_raw(); + let jack_uuid_empty_impl = *jack_uuid_empty_impl.deref() + as unsafe extern "C" fn(arg1: jack_uuid_t) -> ::std::os::raw::c_int; + JackFunctions { + jack_release_timebase_impl, + jack_get_cycle_times_impl, + jack_set_sync_callback_impl, + jack_set_sync_timeout_impl, + jack_set_timebase_callback_impl, + jack_transport_locate_impl, + jack_transport_query_impl, + jack_get_current_transport_frame_impl, + jack_transport_reposition_impl, + jack_transport_start_impl, + jack_transport_stop_impl, + jack_get_transport_info_impl, + jack_set_transport_info_impl, + jack_client_open_impl, + jack_client_new_impl, + jack_client_close_impl, + jack_client_name_size_impl, + jack_get_client_name_impl, + jack_get_uuid_for_client_name_impl, + jack_get_client_name_by_uuid_impl, + jack_internal_client_new_impl, + jack_internal_client_close_impl, + jack_activate_impl, + jack_deactivate_impl, + jack_get_client_pid_impl, + jack_is_realtime_impl, + jack_thread_wait_impl, + jack_cycle_wait_impl, + jack_cycle_signal_impl, + jack_set_process_thread_impl, + jack_set_thread_init_callback_impl, + jack_on_shutdown_impl, + jack_on_info_shutdown_impl, + jack_set_process_callback_impl, + jack_set_freewheel_callback_impl, + jack_set_buffer_size_callback_impl, + jack_get_sample_rate_impl, + jack_set_sample_rate_callback_impl, + jack_set_client_registration_callback_impl, + jack_set_port_registration_callback_impl, + jack_set_port_connect_callback_impl, + jack_set_port_rename_callback_impl, + jack_set_graph_order_callback_impl, + jack_set_xrun_callback_impl, + jack_set_latency_callback_impl, + jack_set_freewheel_impl, + jack_set_buffer_size_impl, + jack_get_buffer_size_impl, + jack_engine_takeover_timebase_impl, + jack_cpu_load_impl, + jack_port_register_impl, + jack_port_unregister_impl, + jack_port_get_buffer_impl, + jack_port_uuid_impl, + jack_port_name_impl, + jack_port_short_name_impl, + jack_port_flags_impl, + jack_port_type_impl, + jack_port_type_id_impl, + jack_port_is_mine_impl, + jack_port_connected_impl, + jack_port_connected_to_impl, + jack_port_get_connections_impl, + jack_port_get_all_connections_impl, + jack_port_tie_impl, + jack_port_untie_impl, + jack_port_set_name_impl, + jack_port_set_alias_impl, + jack_port_unset_alias_impl, + jack_port_get_aliases_impl, + jack_port_request_monitor_impl, + jack_port_request_monitor_by_name_impl, + jack_port_ensure_monitor_impl, + jack_port_monitoring_input_impl, + jack_connect_impl, + jack_disconnect_impl, + jack_port_disconnect_impl, + jack_port_name_size_impl, + jack_port_type_size_impl, + jack_port_type_get_buffer_size_impl, + jack_port_set_latency_impl, + jack_port_get_latency_range_impl, + jack_port_set_latency_range_impl, + jack_recompute_total_latencies_impl, + jack_port_get_latency_impl, + jack_port_get_total_latency_impl, + jack_recompute_total_latency_impl, + jack_get_ports_impl, + jack_port_by_name_impl, + jack_port_by_id_impl, + jack_frames_since_cycle_start_impl, + jack_frame_time_impl, + jack_last_frame_time_impl, + jack_frames_to_time_impl, + jack_time_to_frames_impl, + jack_get_time_impl, + jack_set_error_function_impl, + jack_set_info_function_impl, + jack_free_impl, + jack_client_real_time_priority_impl, + jack_client_max_real_time_priority_impl, + jack_set_session_callback_impl, + jack_session_reply_impl, + jack_session_event_free_impl, + jack_client_get_uuid_impl, + jack_session_notify_impl, + jack_session_commands_free_impl, + jack_reserve_client_name_impl, + jack_client_has_session_callback_impl, + jackctl_setup_signals_impl, + jackctl_wait_signals_impl, + jackctl_server_create_impl, + jackctl_server_destroy_impl, + jackctl_server_open_impl, + jackctl_server_start_impl, + jackctl_server_stop_impl, + jackctl_server_close_impl, + jackctl_server_get_drivers_list_impl, + jackctl_server_get_parameters_impl, + jackctl_server_get_internals_list_impl, + jackctl_server_load_internal_impl, + jackctl_server_unload_internal_impl, + jackctl_server_add_slave_impl, + jackctl_server_remove_slave_impl, + jackctl_server_switch_master_impl, + jackctl_driver_get_name_impl, + jackctl_driver_get_type_impl, + jackctl_driver_get_parameters_impl, + jackctl_driver_params_parse_impl, + jackctl_internal_get_name_impl, + jackctl_internal_get_parameters_impl, + jackctl_parameter_get_name_impl, + jackctl_parameter_get_short_description_impl, + jackctl_parameter_get_long_description_impl, + jackctl_parameter_get_type_impl, + jackctl_parameter_get_id_impl, + jackctl_parameter_is_set_impl, + jackctl_parameter_reset_impl, + jackctl_parameter_get_value_impl, + jackctl_parameter_set_value_impl, + jackctl_parameter_get_default_value_impl, + jackctl_parameter_has_range_constraint_impl, + jackctl_parameter_has_enum_constraint_impl, + jackctl_parameter_get_enum_constraints_count_impl, + jackctl_parameter_get_enum_constraint_value_impl, + jackctl_parameter_get_enum_constraint_description_impl, + jackctl_parameter_get_range_constraint_impl, + jackctl_parameter_constraint_is_strict_impl, + jackctl_parameter_constraint_is_fake_value_impl, + jack_set_property_impl, + jack_get_property_impl, + jack_free_description_impl, + jack_get_properties_impl, + jack_get_all_properties_impl, + jack_remove_property_impl, + jack_remove_properties_impl, + jack_remove_all_properties_impl, + jack_set_property_change_callback_impl, + jack_get_internal_client_name_impl, + jack_internal_client_handle_impl, + jack_internal_client_load_impl, + jack_internal_client_unload_impl, + jack_get_max_delayed_usecs_impl, + jack_get_xrun_delayed_usecs_impl, + jack_reset_max_delayed_usecs_impl, + jack_midi_get_event_count_impl, + jack_midi_event_get_impl, + jack_midi_clear_buffer_impl, + jack_midi_max_event_size_impl, + jack_midi_event_reserve_impl, + jack_midi_event_write_impl, + jack_midi_get_lost_event_count_impl, + jack_ringbuffer_create_impl, + jack_ringbuffer_free_impl, + jack_ringbuffer_get_read_vector_impl, + jack_ringbuffer_get_write_vector_impl, + jack_ringbuffer_read_impl, + jack_ringbuffer_peek_impl, + jack_ringbuffer_read_advance_impl, + jack_ringbuffer_read_space_impl, + jack_ringbuffer_mlock_impl, + jack_ringbuffer_reset_impl, + jack_ringbuffer_write_impl, + jack_ringbuffer_write_advance_impl, + jack_ringbuffer_write_space_impl, + jack_uuid_to_index_impl, + jack_uuid_compare_impl, + jack_uuid_copy_impl, + jack_uuid_clear_impl, + jack_uuid_parse_impl, + jack_uuid_unparse_impl, + jack_uuid_empty_impl, + } + }; +} + +pub unsafe fn jack_release_timebase(client: *mut jack_client_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_release_timebase_impl; + f(client) +} +pub unsafe fn jack_get_cycle_times( + client: *const jack_client_t, + current_frames: *mut jack_nframes_t, + current_usecs: *mut jack_time_t, + next_usecs: *mut jack_time_t, + period_usecs: *mut ::libc::c_float, +) -> Option<::libc::c_int> { + let f = FUNCTIONS.jack_get_cycle_times_impl?; + Some(f( + client, + current_frames, + current_usecs, + next_usecs, + period_usecs, + )) +} +pub unsafe fn jack_set_sync_callback( + client: *mut jack_client_t, + sync_callback: JackSyncCallback, + sync_arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_sync_callback_impl; + f(client, sync_callback, sync_arg) +} +pub unsafe fn jack_set_sync_timeout( + client: *mut jack_client_t, + timeout: jack_time_t, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_sync_timeout_impl; + f(client, timeout) +} +pub unsafe fn jack_set_timebase_callback( + client: *mut jack_client_t, + conditional: ::libc::c_int, + timebase_callback: TimebaseCallback, + arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_timebase_callback_impl; + f(client, conditional, timebase_callback, arg) +} +pub unsafe fn jack_transport_locate( + client: *mut jack_client_t, + frame: jack_nframes_t, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_transport_locate_impl; + f(client, frame) +} +pub unsafe fn jack_transport_query( + client: *const jack_client_t, + pos: *mut jack_position_t, +) -> jack_transport_state_t { + let f = FUNCTIONS.jack_transport_query_impl; + f(client, pos) +} +pub unsafe fn jack_get_current_transport_frame(client: *const jack_client_t) -> jack_nframes_t { + let f = FUNCTIONS.jack_get_current_transport_frame_impl; + f(client) +} +pub unsafe fn jack_transport_reposition( + client: *mut jack_client_t, + pos: *const jack_position_t, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_transport_reposition_impl; + f(client, pos) +} +pub unsafe fn jack_transport_start(client: *mut jack_client_t) -> () { + let f = FUNCTIONS.jack_transport_start_impl; + f(client) +} +pub unsafe fn jack_transport_stop(client: *mut jack_client_t) -> () { + let f = FUNCTIONS.jack_transport_stop_impl; + f(client) +} +pub unsafe fn jack_get_transport_info( + client: *mut jack_client_t, + tinfo: *mut jack_transport_info_t, +) -> () { + let f = FUNCTIONS.jack_get_transport_info_impl; + f(client, tinfo) +} +pub unsafe fn jack_set_transport_info( + client: *mut jack_client_t, + tinfo: *mut jack_transport_info_t, +) -> () { + let f = FUNCTIONS.jack_set_transport_info_impl; + f(client, tinfo) +} +pub unsafe fn jack_client_open( + client_name: *const ::libc::c_char, + options: jack_options_t, + status: *mut jack_status_t, +) -> *mut jack_client_t { + let f = FUNCTIONS.jack_client_open_impl; + f(client_name, options, status) +} +pub unsafe fn jack_client_new(client_name: *const ::libc::c_char) -> *mut jack_client_t { + let f = FUNCTIONS.jack_client_new_impl; + f(client_name) +} +pub unsafe fn jack_client_close(client: *mut jack_client_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_client_close_impl; + f(client) +} +pub unsafe fn jack_client_name_size() -> ::libc::c_int { + let f = FUNCTIONS.jack_client_name_size_impl; + f() +} +pub unsafe fn jack_get_client_name(client: *mut jack_client_t) -> *mut ::libc::c_char { + let f = FUNCTIONS.jack_get_client_name_impl; + f(client) +} +pub unsafe fn jack_get_uuid_for_client_name( + client: *mut jack_client_t, + client_name: *const ::libc::c_char, +) -> *mut ::libc::c_char { + let f = FUNCTIONS.jack_get_uuid_for_client_name_impl; + f(client, client_name) +} +pub unsafe fn jack_get_client_name_by_uuid( + client: *mut jack_client_t, + client_uuid: *const ::libc::c_char, +) -> *mut ::libc::c_char { + let f = FUNCTIONS.jack_get_client_name_by_uuid_impl; + f(client, client_uuid) +} +pub unsafe fn jack_internal_client_new( + client_name: *const ::libc::c_char, + load_name: *const ::libc::c_char, + load_init: *const ::libc::c_char, +) -> Option<::libc::c_int> { + let f = FUNCTIONS.jack_internal_client_new_impl?; + Some(f(client_name, load_name, load_init)) +} +pub unsafe fn jack_internal_client_close(client_name: *const ::libc::c_char) -> Option<()> { + let f = FUNCTIONS.jack_internal_client_close_impl?; + Some(f(client_name)) +} +pub unsafe fn jack_activate(client: *mut jack_client_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_activate_impl; + f(client) +} +pub unsafe fn jack_deactivate(client: *mut jack_client_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_deactivate_impl; + f(client) +} +pub unsafe fn jack_get_client_pid(name: *const ::libc::c_char) -> Option<::libc::c_int> { + let f = FUNCTIONS.jack_get_client_pid_impl?; + Some(f(name)) +} +pub unsafe fn jack_is_realtime(client: *mut jack_client_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_is_realtime_impl; + f(client) +} +pub unsafe fn jack_thread_wait( + client: *mut jack_client_t, + status: ::libc::c_int, +) -> jack_nframes_t { + let f = FUNCTIONS.jack_thread_wait_impl; + f(client, status) +} +pub unsafe fn jack_cycle_wait(client: *mut jack_client_t) -> jack_nframes_t { + let f = FUNCTIONS.jack_cycle_wait_impl; + f(client) +} +pub unsafe fn jack_cycle_signal(client: *mut jack_client_t, status: ::libc::c_int) -> () { + let f = FUNCTIONS.jack_cycle_signal_impl; + f(client, status) +} +pub unsafe fn jack_set_process_thread( + client: *mut jack_client_t, + thread_callback: JackThreadCallback, + arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_process_thread_impl; + f(client, thread_callback, arg) +} +pub unsafe fn jack_set_thread_init_callback( + client: *mut jack_client_t, + thread_init_callback: JackThreadInitCallback, + arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_thread_init_callback_impl; + f(client, thread_init_callback, arg) +} +pub unsafe fn jack_on_shutdown( + client: *mut jack_client_t, + callback: JackShutdownCallback, + arg: *mut ::libc::c_void, +) -> () { + let f = FUNCTIONS.jack_on_shutdown_impl; + f(client, callback, arg) +} +pub unsafe fn jack_on_info_shutdown( + client: *mut jack_client_t, + callback: JackInfoShutdownCallback, + arg: *mut ::libc::c_void, +) -> () { + let f = FUNCTIONS.jack_on_info_shutdown_impl; + f(client, callback, arg) +} +pub unsafe fn jack_set_process_callback( + client: *mut jack_client_t, + process_callback: JackProcessCallback, + arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_process_callback_impl; + f(client, process_callback, arg) +} +pub unsafe fn jack_set_freewheel_callback( + client: *mut jack_client_t, + freewheel_callback: JackFreewheelCallback, + arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_freewheel_callback_impl; + f(client, freewheel_callback, arg) +} +pub unsafe fn jack_set_buffer_size_callback( + client: *mut jack_client_t, + bufsize_callback: JackBufferSizeCallback, + arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_buffer_size_callback_impl; + f(client, bufsize_callback, arg) +} +pub unsafe fn jack_get_sample_rate(client: *mut jack_client_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_get_sample_rate_impl; + f(client) +} +pub unsafe fn jack_set_sample_rate_callback( + client: *mut jack_client_t, + srate_callback: JackSampleRateCallback, + arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_sample_rate_callback_impl; + f(client, srate_callback, arg) +} +pub unsafe fn jack_set_client_registration_callback( + client: *mut jack_client_t, + registration_callback: JackClientRegistrationCallback, + arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_client_registration_callback_impl; + f(client, registration_callback, arg) +} +pub unsafe fn jack_set_port_registration_callback( + client: *mut jack_client_t, + registration_callback: JackPortRegistrationCallback, + arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_port_registration_callback_impl; + f(client, registration_callback, arg) +} +pub unsafe fn jack_set_port_connect_callback( + client: *mut jack_client_t, + connect_callback: JackPortConnectCallback, + arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_port_connect_callback_impl; + f(client, connect_callback, arg) +} +pub unsafe fn jack_set_port_rename_callback( + client: *mut jack_client_t, + rename_callback: JackPortRenameCallback, + arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_port_rename_callback_impl; + f(client, rename_callback, arg) +} +pub unsafe fn jack_set_graph_order_callback( + client: *mut jack_client_t, + graph_callback: JackGraphOrderCallback, + arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_graph_order_callback_impl; + f(client, graph_callback, arg) +} +pub unsafe fn jack_set_xrun_callback( + client: *mut jack_client_t, + xrun_callback: JackXRunCallback, + arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_xrun_callback_impl; + f(client, xrun_callback, arg) +} +pub unsafe fn jack_set_latency_callback( + client: *mut jack_client_t, + latency_callback: JackLatencyCallback, + arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_latency_callback_impl; + f(client, latency_callback, arg) +} +pub unsafe fn jack_set_freewheel( + client: *mut jack_client_t, + onoff: ::libc::c_int, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_freewheel_impl; + f(client, onoff) +} +pub unsafe fn jack_set_buffer_size( + client: *mut jack_client_t, + nframes: jack_nframes_t, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_buffer_size_impl; + f(client, nframes) +} +pub unsafe fn jack_get_buffer_size(client: *mut jack_client_t) -> jack_nframes_t { + let f = FUNCTIONS.jack_get_buffer_size_impl; + f(client) +} +pub unsafe fn jack_engine_takeover_timebase(client: *mut jack_client_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_engine_takeover_timebase_impl; + f(client) +} +pub unsafe fn jack_cpu_load(client: *mut jack_client_t) -> ::libc::c_float { + let f = FUNCTIONS.jack_cpu_load_impl; + f(client) +} +pub unsafe fn jack_port_register( + client: *mut jack_client_t, + port_name: *const ::libc::c_char, + port_type: *const ::libc::c_char, + flags: ::libc::c_ulong, + buffer_size: ::libc::c_ulong, +) -> *mut jack_port_t { + let f = FUNCTIONS.jack_port_register_impl; + f(client, port_name, port_type, flags, buffer_size) +} +pub unsafe fn jack_port_unregister( + client: *mut jack_client_t, + port: *mut jack_port_t, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_port_unregister_impl; + f(client, port) +} +pub unsafe fn jack_port_get_buffer( + port: *mut jack_port_t, + nframes: jack_nframes_t, +) -> *mut ::libc::c_void { + let f = FUNCTIONS.jack_port_get_buffer_impl; + f(port, nframes) +} +pub unsafe fn jack_port_uuid(port: *mut jack_port_t) -> jack_uuid_t { + let f = FUNCTIONS.jack_port_uuid_impl; + f(port) +} +pub unsafe fn jack_port_name(port: *mut jack_port_t) -> *const ::libc::c_char { + let f = FUNCTIONS.jack_port_name_impl; + f(port) +} +pub unsafe fn jack_port_short_name(port: *mut jack_port_t) -> *const ::libc::c_char { + let f = FUNCTIONS.jack_port_short_name_impl; + f(port) +} +pub unsafe fn jack_port_flags(port: *mut jack_port_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_port_flags_impl; + f(port) +} +pub unsafe fn jack_port_type(port: *const jack_port_t) -> *const ::libc::c_char { + let f = FUNCTIONS.jack_port_type_impl; + f(port) +} +pub unsafe fn jack_port_type_id(port: *const jack_port_t) -> Option { + let f = FUNCTIONS.jack_port_type_id_impl?; + Some(f(port)) +} +pub unsafe fn jack_port_is_mine( + client: *const jack_client_t, + port: *const jack_port_t, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_port_is_mine_impl; + f(client, port) +} +pub unsafe fn jack_port_connected(port: *const jack_port_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_port_connected_impl; + f(port) +} +pub unsafe fn jack_port_connected_to( + port: *const jack_port_t, + port_name: *const ::libc::c_char, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_port_connected_to_impl; + f(port, port_name) +} +pub unsafe fn jack_port_get_connections(port: *const jack_port_t) -> *mut *const ::libc::c_char { + let f = FUNCTIONS.jack_port_get_connections_impl; + f(port) +} +pub unsafe fn jack_port_get_all_connections( + client: *const jack_client_t, + port: *const jack_port_t, +) -> *mut *const ::libc::c_char { + let f = FUNCTIONS.jack_port_get_all_connections_impl; + f(client, port) +} +pub unsafe fn jack_port_tie(src: *mut jack_port_t, dst: *mut jack_port_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_port_tie_impl; + f(src, dst) +} +pub unsafe fn jack_port_untie(port: *mut jack_port_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_port_untie_impl; + f(port) +} +pub unsafe fn jack_port_set_name( + port: *mut jack_port_t, + port_name: *const ::libc::c_char, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_port_set_name_impl; + f(port, port_name) +} +pub unsafe fn jack_port_set_alias( + port: *mut jack_port_t, + alias: *const ::libc::c_char, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_port_set_alias_impl; + f(port, alias) +} +pub unsafe fn jack_port_unset_alias( + port: *mut jack_port_t, + alias: *const ::libc::c_char, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_port_unset_alias_impl; + f(port, alias) +} +pub unsafe fn jack_port_get_aliases( + port: *const jack_port_t, + aliases: *mut *mut ::libc::c_char, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_port_get_aliases_impl; + f(port, aliases) +} +pub unsafe fn jack_port_request_monitor( + port: *mut jack_port_t, + onoff: ::libc::c_int, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_port_request_monitor_impl; + f(port, onoff) +} +pub unsafe fn jack_port_request_monitor_by_name( + client: *mut jack_client_t, + port_name: *const ::libc::c_char, + onoff: ::libc::c_int, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_port_request_monitor_by_name_impl; + f(client, port_name, onoff) +} +pub unsafe fn jack_port_ensure_monitor( + port: *mut jack_port_t, + onoff: ::libc::c_int, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_port_ensure_monitor_impl; + f(port, onoff) +} +pub unsafe fn jack_port_monitoring_input(port: *mut jack_port_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_port_monitoring_input_impl; + f(port) +} +pub unsafe fn jack_connect( + client: *mut jack_client_t, + source_port: *const ::libc::c_char, + destination_port: *const ::libc::c_char, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_connect_impl; + f(client, source_port, destination_port) +} +pub unsafe fn jack_disconnect( + client: *mut jack_client_t, + source_port: *const ::libc::c_char, + destination_port: *const ::libc::c_char, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_disconnect_impl; + f(client, source_port, destination_port) +} +pub unsafe fn jack_port_disconnect( + client: *mut jack_client_t, + port: *mut jack_port_t, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_port_disconnect_impl; + f(client, port) +} +pub unsafe fn jack_port_name_size() -> ::libc::c_int { + let f = FUNCTIONS.jack_port_name_size_impl; + f() +} +pub unsafe fn jack_port_type_size() -> ::libc::c_int { + let f = FUNCTIONS.jack_port_type_size_impl; + f() +} +pub unsafe fn jack_port_type_get_buffer_size( + client: *mut jack_client_t, + port_type: *const ::libc::c_char, +) -> ::libc::size_t { + let f = FUNCTIONS.jack_port_type_get_buffer_size_impl; + f(client, port_type) +} +pub unsafe fn jack_port_set_latency(port: *mut jack_port_t, arg1: jack_nframes_t) -> () { + let f = FUNCTIONS.jack_port_set_latency_impl; + f(port, arg1) +} +pub unsafe fn jack_port_get_latency_range( + port: *mut jack_port_t, + mode: jack_latency_callback_mode_t, + range: *mut jack_latency_range_t, +) -> () { + let f = FUNCTIONS.jack_port_get_latency_range_impl; + f(port, mode, range) +} +pub unsafe fn jack_port_set_latency_range( + port: *mut jack_port_t, + mode: jack_latency_callback_mode_t, + range: *mut jack_latency_range_t, +) -> () { + let f = FUNCTIONS.jack_port_set_latency_range_impl; + f(port, mode, range) +} +pub unsafe fn jack_recompute_total_latencies(client: *mut jack_client_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_recompute_total_latencies_impl; + f(client) +} +pub unsafe fn jack_port_get_latency(port: *mut jack_port_t) -> jack_nframes_t { + let f = FUNCTIONS.jack_port_get_latency_impl; + f(port) +} +pub unsafe fn jack_port_get_total_latency( + client: *mut jack_client_t, + port: *mut jack_port_t, +) -> jack_nframes_t { + let f = FUNCTIONS.jack_port_get_total_latency_impl; + f(client, port) +} +pub unsafe fn jack_recompute_total_latency( + arg1: *mut jack_client_t, + port: *mut jack_port_t, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_recompute_total_latency_impl; + f(arg1, port) +} +pub unsafe fn jack_get_ports( + client: *mut jack_client_t, + port_name_pattern: *const ::libc::c_char, + type_name_pattern: *const ::libc::c_char, + flags: ::libc::c_ulong, +) -> *mut *const ::libc::c_char { + let f = FUNCTIONS.jack_get_ports_impl; + f(client, port_name_pattern, type_name_pattern, flags) +} +pub unsafe fn jack_port_by_name( + client: *mut jack_client_t, + port_name: *const ::libc::c_char, +) -> *mut jack_port_t { + let f = FUNCTIONS.jack_port_by_name_impl; + f(client, port_name) +} +pub unsafe fn jack_port_by_id( + client: *mut jack_client_t, + port_id: jack_port_id_t, +) -> *mut jack_port_t { + let f = FUNCTIONS.jack_port_by_id_impl; + f(client, port_id) +} +pub unsafe fn jack_frames_since_cycle_start(arg1: *const jack_client_t) -> jack_nframes_t { + let f = FUNCTIONS.jack_frames_since_cycle_start_impl; + f(arg1) +} +pub unsafe fn jack_frame_time(arg1: *const jack_client_t) -> jack_nframes_t { + let f = FUNCTIONS.jack_frame_time_impl; + f(arg1) +} +pub unsafe fn jack_last_frame_time(client: *const jack_client_t) -> jack_nframes_t { + let f = FUNCTIONS.jack_last_frame_time_impl; + f(client) +} +pub unsafe fn jack_frames_to_time( + client: *const jack_client_t, + arg1: jack_nframes_t, +) -> jack_time_t { + let f = FUNCTIONS.jack_frames_to_time_impl; + f(client, arg1) +} +pub unsafe fn jack_time_to_frames( + client: *const jack_client_t, + arg1: jack_time_t, +) -> jack_nframes_t { + let f = FUNCTIONS.jack_time_to_frames_impl; + f(client, arg1) +} +pub unsafe fn jack_get_time() -> jack_time_t { + let f = FUNCTIONS.jack_get_time_impl; + f() +} +pub unsafe fn jack_set_error_function( + func: ::std::option::Option ()>, +) -> () { + let f = FUNCTIONS.jack_set_error_function_impl; + f(func) +} +pub unsafe fn jack_set_info_function( + func: ::std::option::Option ()>, +) -> () { + let f = FUNCTIONS.jack_set_info_function_impl; + f(func) +} +pub unsafe fn jack_free(ptr: *mut ::libc::c_void) -> () { + let f = FUNCTIONS.jack_free_impl; + f(ptr) +} +pub unsafe fn jack_client_real_time_priority(arg1: *mut jack_client_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_client_real_time_priority_impl; + f(arg1) +} +pub unsafe fn jack_client_max_real_time_priority(arg1: *mut jack_client_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_client_max_real_time_priority_impl; + f(arg1) +} +pub unsafe fn jack_set_session_callback( + client: *mut jack_client_t, + session_callback: JackSessionCallback, + arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_session_callback_impl; + f(client, session_callback, arg) +} +pub unsafe fn jack_session_reply( + client: *mut jack_client_t, + event: *mut jack_session_event_t, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_session_reply_impl; + f(client, event) +} +pub unsafe fn jack_session_event_free(event: *mut jack_session_event_t) -> () { + let f = FUNCTIONS.jack_session_event_free_impl; + f(event) +} +pub unsafe fn jack_client_get_uuid(client: *mut jack_client_t) -> *mut ::libc::c_char { + let f = FUNCTIONS.jack_client_get_uuid_impl; + f(client) +} +pub unsafe fn jack_session_notify( + client: *mut jack_client_t, + target: *const ::libc::c_char, + _type: jack_session_event_type_t, + path: *const ::libc::c_char, +) -> *mut jack_session_command_t { + let f = FUNCTIONS.jack_session_notify_impl; + f(client, target, _type, path) +} +pub unsafe fn jack_session_commands_free(cmds: *mut jack_session_command_t) -> () { + let f = FUNCTIONS.jack_session_commands_free_impl; + f(cmds) +} +pub unsafe fn jack_reserve_client_name( + client: *mut jack_client_t, + name: *const ::libc::c_char, + uuid: *const ::libc::c_char, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_reserve_client_name_impl; + f(client, name, uuid) +} +pub unsafe fn jack_client_has_session_callback( + client: *mut jack_client_t, + client_name: *const ::libc::c_char, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_client_has_session_callback_impl; + f(client, client_name) +} +pub unsafe fn jackctl_setup_signals(flags: ::libc::c_uint) -> Option<*mut jackctl_sigmask_t> { + let f = FUNCTIONS.jackctl_setup_signals_impl?; + Some(f(flags)) +} +pub unsafe fn jackctl_wait_signals(signals: *mut jackctl_sigmask_t) -> Option<()> { + let f = FUNCTIONS.jackctl_wait_signals_impl?; + Some(f(signals)) +} +pub unsafe fn jackctl_server_create( + on_device_acquire: ::std::option::Option< + unsafe extern "C" fn(device_name: *const ::libc::c_char) -> u8, + >, + on_device_release: ::std::option::Option< + unsafe extern "C" fn(device_name: *const ::libc::c_char) -> (), + >, +) -> Option<*mut jackctl_server_t> { + let f = FUNCTIONS.jackctl_server_create_impl?; + Some(f(on_device_acquire, on_device_release)) +} +pub unsafe fn jackctl_server_destroy(server: *mut jackctl_server_t) -> Option<()> { + let f = FUNCTIONS.jackctl_server_destroy_impl?; + Some(f(server)) +} +pub unsafe fn jackctl_server_open( + server: *mut jackctl_server_t, + driver: *mut jackctl_driver_t, +) -> Option { + let f = FUNCTIONS.jackctl_server_open_impl?; + Some(f(server, driver)) +} +pub unsafe fn jackctl_server_start(server: *mut jackctl_server_t) -> Option { + let f = FUNCTIONS.jackctl_server_start_impl?; + Some(f(server)) +} +pub unsafe fn jackctl_server_stop(server: *mut jackctl_server_t) -> Option { + let f = FUNCTIONS.jackctl_server_stop_impl?; + Some(f(server)) +} +pub unsafe fn jackctl_server_close(server: *mut jackctl_server_t) -> Option { + let f = FUNCTIONS.jackctl_server_close_impl?; + Some(f(server)) +} +pub unsafe fn jackctl_server_get_drivers_list( + server: *mut jackctl_server_t, +) -> Option<*const JSList> { + let f = FUNCTIONS.jackctl_server_get_drivers_list_impl?; + Some(f(server)) +} +pub unsafe fn jackctl_server_get_parameters( + server: *mut jackctl_server_t, +) -> Option<*const JSList> { + let f = FUNCTIONS.jackctl_server_get_parameters_impl?; + Some(f(server)) +} +pub unsafe fn jackctl_server_get_internals_list( + server: *mut jackctl_server_t, +) -> Option<*const JSList> { + let f = FUNCTIONS.jackctl_server_get_internals_list_impl?; + Some(f(server)) +} +pub unsafe fn jackctl_server_load_internal( + server: *mut jackctl_server_t, + internal: *mut jackctl_internal_t, +) -> Option { + let f = FUNCTIONS.jackctl_server_load_internal_impl?; + Some(f(server, internal)) +} +pub unsafe fn jackctl_server_unload_internal( + server: *mut jackctl_server_t, + internal: *mut jackctl_internal_t, +) -> Option { + let f = FUNCTIONS.jackctl_server_unload_internal_impl?; + Some(f(server, internal)) +} +pub unsafe fn jackctl_server_add_slave( + server: *mut jackctl_server_t, + driver: *mut jackctl_driver_t, +) -> Option { + let f = FUNCTIONS.jackctl_server_add_slave_impl?; + Some(f(server, driver)) +} +pub unsafe fn jackctl_server_remove_slave( + server: *mut jackctl_server_t, + driver: *mut jackctl_driver_t, +) -> Option { + let f = FUNCTIONS.jackctl_server_remove_slave_impl?; + Some(f(server, driver)) +} +pub unsafe fn jackctl_server_switch_master( + server: *mut jackctl_server_t, + driver: *mut jackctl_driver_t, +) -> Option { + let f = FUNCTIONS.jackctl_server_switch_master_impl?; + Some(f(server, driver)) +} +pub unsafe fn jackctl_driver_get_name( + driver: *mut jackctl_driver_t, +) -> Option<*const ::libc::c_char> { + let f = FUNCTIONS.jackctl_driver_get_name_impl?; + Some(f(driver)) +} +pub unsafe fn jackctl_driver_get_type( + driver: *mut jackctl_driver_t, +) -> Option { + let f = FUNCTIONS.jackctl_driver_get_type_impl?; + Some(f(driver)) +} +pub unsafe fn jackctl_driver_get_parameters( + driver: *mut jackctl_driver_t, +) -> Option<*const JSList> { + let f = FUNCTIONS.jackctl_driver_get_parameters_impl?; + Some(f(driver)) +} +pub unsafe fn jackctl_driver_params_parse( + driver: *mut jackctl_driver_t, + argc: ::libc::c_int, + argv: *mut *mut ::libc::c_char, +) -> Option<::libc::c_int> { + let f = FUNCTIONS.jackctl_driver_params_parse_impl?; + Some(f(driver, argc, argv)) +} +pub unsafe fn jackctl_internal_get_name( + internal: *mut jackctl_internal_t, +) -> Option<*const ::libc::c_char> { + let f = FUNCTIONS.jackctl_internal_get_name_impl?; + Some(f(internal)) +} +pub unsafe fn jackctl_internal_get_parameters( + internal: *mut jackctl_internal_t, +) -> Option<*const JSList> { + let f = FUNCTIONS.jackctl_internal_get_parameters_impl?; + Some(f(internal)) +} +pub unsafe fn jackctl_parameter_get_name( + parameter: *mut jackctl_parameter_t, +) -> Option<*const ::libc::c_char> { + let f = FUNCTIONS.jackctl_parameter_get_name_impl?; + Some(f(parameter)) +} +pub unsafe fn jackctl_parameter_get_short_description( + parameter: *mut jackctl_parameter_t, +) -> Option<*const ::libc::c_char> { + let f = FUNCTIONS.jackctl_parameter_get_short_description_impl?; + Some(f(parameter)) +} +pub unsafe fn jackctl_parameter_get_long_description( + parameter: *mut jackctl_parameter_t, +) -> Option<*const ::libc::c_char> { + let f = FUNCTIONS.jackctl_parameter_get_long_description_impl?; + Some(f(parameter)) +} +pub unsafe fn jackctl_parameter_get_type( + parameter: *mut jackctl_parameter_t, +) -> Option { + let f = FUNCTIONS.jackctl_parameter_get_type_impl?; + Some(f(parameter)) +} +pub unsafe fn jackctl_parameter_get_id( + parameter: *mut jackctl_parameter_t, +) -> Option<::libc::c_char> { + let f = FUNCTIONS.jackctl_parameter_get_id_impl?; + Some(f(parameter)) +} +pub unsafe fn jackctl_parameter_is_set(parameter: *mut jackctl_parameter_t) -> Option { + let f = FUNCTIONS.jackctl_parameter_is_set_impl?; + Some(f(parameter)) +} +pub unsafe fn jackctl_parameter_reset(parameter: *mut jackctl_parameter_t) -> Option { + let f = FUNCTIONS.jackctl_parameter_reset_impl?; + Some(f(parameter)) +} +pub unsafe fn jackctl_parameter_get_value( + parameter: *mut jackctl_parameter_t, +) -> Option { + let f = FUNCTIONS.jackctl_parameter_get_value_impl?; + Some(f(parameter)) +} +pub unsafe fn jackctl_parameter_set_value( + parameter: *mut jackctl_parameter_t, + value_ptr: *const Union_jackctl_parameter_value, +) -> Option { + let f = FUNCTIONS.jackctl_parameter_set_value_impl?; + Some(f(parameter, value_ptr)) +} +pub unsafe fn jackctl_parameter_get_default_value( + parameter: *mut jackctl_parameter_t, +) -> Option { + let f = FUNCTIONS.jackctl_parameter_get_default_value_impl?; + Some(f(parameter)) +} +pub unsafe fn jackctl_parameter_has_range_constraint( + parameter: *mut jackctl_parameter_t, +) -> Option { + let f = FUNCTIONS.jackctl_parameter_has_range_constraint_impl?; + Some(f(parameter)) +} +pub unsafe fn jackctl_parameter_has_enum_constraint( + parameter: *mut jackctl_parameter_t, +) -> Option { + let f = FUNCTIONS.jackctl_parameter_has_enum_constraint_impl?; + Some(f(parameter)) +} +pub unsafe fn jackctl_parameter_get_enum_constraints_count( + parameter: *mut jackctl_parameter_t, +) -> Option { + let f = FUNCTIONS.jackctl_parameter_get_enum_constraints_count_impl?; + Some(f(parameter)) +} +pub unsafe fn jackctl_parameter_get_enum_constraint_value( + parameter: *mut jackctl_parameter_t, + index: u32, +) -> Option { + let f = FUNCTIONS.jackctl_parameter_get_enum_constraint_value_impl?; + Some(f(parameter, index)) +} +pub unsafe fn jackctl_parameter_get_enum_constraint_description( + parameter: *mut jackctl_parameter_t, + index: u32, +) -> Option<*const ::libc::c_char> { + let f = FUNCTIONS.jackctl_parameter_get_enum_constraint_description_impl?; + Some(f(parameter, index)) +} +pub unsafe fn jackctl_parameter_get_range_constraint( + parameter: *mut jackctl_parameter_t, + min_ptr: *mut Union_jackctl_parameter_value, + max_ptr: *mut Union_jackctl_parameter_value, +) -> Option<()> { + let f = FUNCTIONS.jackctl_parameter_get_range_constraint_impl?; + Some(f(parameter, min_ptr, max_ptr)) +} +pub unsafe fn jackctl_parameter_constraint_is_strict( + parameter: *mut jackctl_parameter_t, +) -> Option { + let f = FUNCTIONS.jackctl_parameter_constraint_is_strict_impl?; + Some(f(parameter)) +} +pub unsafe fn jackctl_parameter_constraint_is_fake_value( + parameter: *mut jackctl_parameter_t, +) -> Option { + let f = FUNCTIONS.jackctl_parameter_constraint_is_fake_value_impl?; + Some(f(parameter)) +} +pub unsafe fn jack_set_property( + arg1: *mut jack_client_t, + subject: jack_uuid_t, + key: *const ::libc::c_char, + value: *const ::libc::c_char, + _type: *const ::libc::c_char, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_property_impl; + f(arg1, subject, key, value, _type) +} +pub unsafe fn jack_get_property( + subject: jack_uuid_t, + key: *const ::libc::c_char, + value: *mut *mut ::libc::c_char, + _type: *mut *mut ::libc::c_char, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_get_property_impl; + f(subject, key, value, _type) +} +pub unsafe fn jack_free_description( + desc: *mut jack_description_t, + free_description_itself: ::libc::c_int, +) -> () { + let f = FUNCTIONS.jack_free_description_impl; + f(desc, free_description_itself) +} +pub unsafe fn jack_get_properties( + subject: jack_uuid_t, + desc: *mut jack_description_t, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_get_properties_impl; + f(subject, desc) +} +pub unsafe fn jack_get_all_properties(descs: *mut *mut jack_description_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_get_all_properties_impl; + f(descs) +} +pub unsafe fn jack_remove_property( + client: *mut jack_client_t, + subject: jack_uuid_t, + key: *const ::libc::c_char, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_remove_property_impl; + f(client, subject, key) +} +pub unsafe fn jack_remove_properties( + client: *mut jack_client_t, + subject: jack_uuid_t, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_remove_properties_impl; + f(client, subject) +} +pub unsafe fn jack_remove_all_properties(client: *mut jack_client_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_remove_all_properties_impl; + f(client) +} +pub unsafe fn jack_set_property_change_callback( + client: *mut jack_client_t, + callback: JackPropertyChangeCallback, + arg: *mut ::libc::c_void, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_set_property_change_callback_impl; + f(client, callback, arg) +} +pub unsafe fn jack_get_internal_client_name( + client: *mut jack_client_t, + intclient: jack_intclient_t, +) -> Option<*mut ::libc::c_char> { + let f = FUNCTIONS.jack_get_internal_client_name_impl?; + Some(f(client, intclient)) +} +pub unsafe fn jack_internal_client_handle( + client: *mut jack_client_t, + client_name: *const ::libc::c_char, + status: *mut jack_status_t, +) -> Option { + let f = FUNCTIONS.jack_internal_client_handle_impl?; + Some(f(client, client_name, status)) +} +pub unsafe fn jack_internal_client_load( + client: *mut jack_client_t, + client_name: *const ::libc::c_char, + options: jack_options_t, + status: *mut jack_status_t, + load_name: *const ::libc::c_char, + load_init: *const ::libc::c_char, +) -> Option { + let f = FUNCTIONS.jack_internal_client_load_impl?; + Some(f( + client, + client_name, + options, + status, + load_name, + load_init, + )) +} +pub unsafe fn jack_internal_client_unload( + client: *mut jack_client_t, + intclient: jack_intclient_t, +) -> Option { + let f = FUNCTIONS.jack_internal_client_unload_impl?; + Some(f(client, intclient)) +} +pub unsafe fn jack_get_max_delayed_usecs(client: *mut jack_client_t) -> ::libc::c_float { + let f = FUNCTIONS.jack_get_max_delayed_usecs_impl; + f(client) +} +pub unsafe fn jack_get_xrun_delayed_usecs(client: *mut jack_client_t) -> ::libc::c_float { + let f = FUNCTIONS.jack_get_xrun_delayed_usecs_impl; + f(client) +} +pub unsafe fn jack_reset_max_delayed_usecs(client: *mut jack_client_t) -> () { + let f = FUNCTIONS.jack_reset_max_delayed_usecs_impl; + f(client) +} +pub unsafe fn jack_midi_get_event_count(port_buffer: *mut ::libc::c_void) -> u32 { + let f = FUNCTIONS.jack_midi_get_event_count_impl; + f(port_buffer) +} +pub unsafe fn jack_midi_event_get( + event: *mut jack_midi_event_t, + port_buffer: *mut ::libc::c_void, + event_index: u32, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_midi_event_get_impl; + f(event, port_buffer, event_index) +} +pub unsafe fn jack_midi_clear_buffer(port_buffer: *mut ::libc::c_void) -> () { + let f = FUNCTIONS.jack_midi_clear_buffer_impl; + f(port_buffer) +} +pub unsafe fn jack_midi_max_event_size(port_buffer: *mut ::libc::c_void) -> ::libc::size_t { + let f = FUNCTIONS.jack_midi_max_event_size_impl; + f(port_buffer) +} +pub unsafe fn jack_midi_event_reserve( + port_buffer: *mut ::libc::c_void, + time: jack_nframes_t, + data_size: ::libc::size_t, +) -> *mut jack_midi_data_t { + let f = FUNCTIONS.jack_midi_event_reserve_impl; + f(port_buffer, time, data_size) +} +pub unsafe fn jack_midi_event_write( + port_buffer: *mut ::libc::c_void, + time: jack_nframes_t, + data: *const jack_midi_data_t, + data_size: ::libc::size_t, +) -> ::libc::c_int { + let f = FUNCTIONS.jack_midi_event_write_impl; + f(port_buffer, time, data, data_size) +} +pub unsafe fn jack_midi_get_lost_event_count(port_buffer: *mut ::libc::c_void) -> u32 { + let f = FUNCTIONS.jack_midi_get_lost_event_count_impl; + f(port_buffer) +} +pub unsafe fn jack_ringbuffer_create(sz: ::libc::size_t) -> *mut jack_ringbuffer_t { + let f = FUNCTIONS.jack_ringbuffer_create_impl; + f(sz) +} +pub unsafe fn jack_ringbuffer_free(rb: *mut jack_ringbuffer_t) -> () { + let f = FUNCTIONS.jack_ringbuffer_free_impl; + f(rb) +} +pub unsafe fn jack_ringbuffer_get_read_vector( + rb: *const jack_ringbuffer_t, + vec: *mut jack_ringbuffer_data_t, +) -> () { + let f = FUNCTIONS.jack_ringbuffer_get_read_vector_impl; + f(rb, vec) +} +pub unsafe fn jack_ringbuffer_get_write_vector( + rb: *const jack_ringbuffer_t, + vec: *mut jack_ringbuffer_data_t, +) -> () { + let f = FUNCTIONS.jack_ringbuffer_get_write_vector_impl; + f(rb, vec) +} +pub unsafe fn jack_ringbuffer_read( + rb: *mut jack_ringbuffer_t, + dest: *mut ::libc::c_char, + cnt: ::libc::size_t, +) -> ::libc::size_t { + let f = FUNCTIONS.jack_ringbuffer_read_impl; + f(rb, dest, cnt) +} +pub unsafe fn jack_ringbuffer_peek( + rb: *mut jack_ringbuffer_t, + dest: *mut ::libc::c_char, + cnt: ::libc::size_t, +) -> ::libc::size_t { + let f = FUNCTIONS.jack_ringbuffer_peek_impl; + f(rb, dest, cnt) +} +pub unsafe fn jack_ringbuffer_read_advance(rb: *mut jack_ringbuffer_t, cnt: ::libc::size_t) -> () { + let f = FUNCTIONS.jack_ringbuffer_read_advance_impl; + f(rb, cnt) +} +pub unsafe fn jack_ringbuffer_read_space(rb: *const jack_ringbuffer_t) -> ::libc::size_t { + let f = FUNCTIONS.jack_ringbuffer_read_space_impl; + f(rb) +} +pub unsafe fn jack_ringbuffer_mlock(rb: *mut jack_ringbuffer_t) -> ::libc::c_int { + let f = FUNCTIONS.jack_ringbuffer_mlock_impl; + f(rb) +} +pub unsafe fn jack_ringbuffer_reset(rb: *mut jack_ringbuffer_t) -> () { + let f = FUNCTIONS.jack_ringbuffer_reset_impl; + f(rb) +} +pub unsafe fn jack_ringbuffer_write( + rb: *mut jack_ringbuffer_t, + src: *const ::libc::c_char, + cnt: ::libc::size_t, +) -> ::libc::size_t { + let f = FUNCTIONS.jack_ringbuffer_write_impl; + f(rb, src, cnt) +} +pub unsafe fn jack_ringbuffer_write_advance(rb: *mut jack_ringbuffer_t, cnt: ::libc::size_t) -> () { + let f = FUNCTIONS.jack_ringbuffer_write_advance_impl; + f(rb, cnt) +} +pub unsafe fn jack_ringbuffer_write_space(rb: *const jack_ringbuffer_t) -> ::libc::size_t { + let f = FUNCTIONS.jack_ringbuffer_write_space_impl; + f(rb) +} +pub unsafe fn jack_uuid_to_index(arg1: jack_uuid_t) -> u32 { + let f = FUNCTIONS.jack_uuid_to_index_impl; + f(arg1) +} +pub unsafe fn jack_uuid_compare(arg1: jack_uuid_t, arg2: jack_uuid_t) -> ::std::os::raw::c_int { + let f = FUNCTIONS.jack_uuid_compare_impl; + f(arg1, arg2) +} +pub unsafe fn jack_uuid_copy(dst: *mut jack_uuid_t, src: jack_uuid_t) -> () { + let f = FUNCTIONS.jack_uuid_copy_impl; + f(dst, src) +} +pub unsafe fn jack_uuid_clear(arg1: *mut jack_uuid_t) -> () { + let f = FUNCTIONS.jack_uuid_clear_impl; + f(arg1) +} +pub unsafe fn jack_uuid_parse( + buf: *const ::std::os::raw::c_char, + arg1: *mut jack_uuid_t, +) -> ::std::os::raw::c_int { + let f = FUNCTIONS.jack_uuid_parse_impl; + f(buf, arg1) +} +pub unsafe fn jack_uuid_unparse(arg1: jack_uuid_t, buf: *mut ::std::os::raw::c_char) -> () { + let f = FUNCTIONS.jack_uuid_unparse_impl; + f(arg1, buf) +} +pub unsafe fn jack_uuid_empty(arg1: jack_uuid_t) -> ::std::os::raw::c_int { + let f = FUNCTIONS.jack_uuid_empty_impl; + f(arg1) +} diff --git a/jack-sys/src/functions/mod.rs b/jack-sys/src/functions/mod.rs new file mode 100644 index 000000000..b9846c567 --- /dev/null +++ b/jack-sys/src/functions/mod.rs @@ -0,0 +1,5 @@ +#[cfg(feature = "dynamic_loading")] +pub mod dynamic_loading; + +#[cfg(not(feature = "dynamic_loading"))] +pub mod dynamic_linking; diff --git a/jack-sys/src/lib.rs b/jack-sys/src/lib.rs index 42372a4a4..ff51fe672 100644 --- a/jack-sys/src/lib.rs +++ b/jack-sys/src/lib.rs @@ -5,9 +5,7 @@ mod consts; mod types; // Contains both static and dynamic dispatched functions. -mod functions { - include!(concat!(env!("OUT_DIR"), "/functions.rs")); -} +mod functions; pub use consts::*; pub use types::*;