# Jackaudio > * [Data Structures](annotated.html) --- # Source: https://jackaudio.org/ JACK-AUDIO-CONNECTION-KIT --- * [Main Page](index.html) * [Related Pages](pages.html) * [Modules](modules.html) * [Data Structures](annotated.html) * [Files](files.html) * ![](search/mag_sel.svg) [![](search/close.svg)](javascript:searchBox.CloseResultsWindow\(\)) * [File List](files.html) * [Globals](globals.html) * [All](globals.html) * [Functions](globals_func.html) * [Variables](globals_vars.html) * [Typedefs](globals_type.html) * [Enumerations](globals_enum.html) * [Enumerator](globals_eval.html) * [Macros](globals_defs.html) * j ### \- j - * jack_acquire_real_time_scheduling() : [thread.h](group__ClientThreads.html#gaec301b7cb1dcd39d7fc88fa9f769dab8) * jack_activate() : [jack.h](group__ClientFunctions.html#ga9800d5b29bd7670d9944a15f6ea0ecf8) * jack_client_close() : [jack.h](group__ClientFunctions.html#ga405646705e600d8bf66327bdbab8e363) * jack_client_create_thread() : [thread.h](group__ClientThreads.html#ga522094adfc39ec4770d8e82bd601e365) * jack_client_get_uuid() : [session.h](group__SessionClientFunctions.html#gac45ae7c26843f51d27be729b902c7dbe) * jack_client_has_session_callback() : [session.h](group__JackSessionManagerAPI.html#gadc159d35a3814d463eaf0f7b36f4f241) * jack_client_max_real_time_priority() : [thread.h](group__ClientThreads.html#gaa266166c958e1b745ce48ef7ca89890f) * jack_client_name_size() : [jack.h](group__ClientFunctions.html#gab8b16ee616207532d0585d04a0bd1d60) * jack_client_new() : [jack.h](group__ClientFunctions.html#ga97482adad8116b76635a63f646a2d2f5) * jack_client_open() : [jack.h](group__ClientFunctions.html#gabbd2041bca191943b6ef29a991a131c5) * jack_client_real_time_priority() : [thread.h](group__ClientThreads.html#ga4ee2fcbb266618d66a2cf354d8c54359) * jack_client_thread_id() : [jack.h](group__ClientFunctions.html#ga4e78f0a2ca6c837709c7ec641afd9954) * jack_client_uuid_generate() : [uuid.h](uuid_8h.html#aa5fd1b6c787ee6a47fae186f8bfb58e5) * jack_connect() : [jack.h](group__PortFunctions.html#gae6090e81f2ee23b5c0e432a899085ec8) * jack_cpu_load() : [jack.h](group__ServerControl.html#ga9136d56397ad4f394a8b169462f5683b) * jack_cycle_signal() : [jack.h](group__NonCallbackAPI.html#ga4da168f4fb79585b19bc40db3bb06409) * jack_cycle_wait() : [jack.h](group__NonCallbackAPI.html#gabf0867ccf1ba257d84455d95ef3e1632) * jack_deactivate() : [jack.h](group__ClientFunctions.html#ga2c6447b766b13d3aa356aba2b48e51fa) * jack_disconnect() : [jack.h](group__PortFunctions.html#gaf2bd9f649c51dafdb382847f0c15963f) * jack_drop_real_time_scheduling() : [thread.h](group__ClientThreads.html#ga0d75ca78f4088f515f1befc108f3f2e7) * jack_engine_takeover_timebase() : [jack.h](group__ServerControl.html#ga2db0a4e9ab7b6d9984e91abba27ab71d) * jack_error() : [control.h](group__ControlAPI.html#gac6448626e0b75fc6d9da1ccbdca0355e) * jack_frame_time() : [jack.h](group__TimeFunctions.html#ga45cec2e76db58e72b46339229de64697) * jack_frames_since_cycle_start() : [jack.h](group__TimeFunctions.html#gad52dc447fd9027922d466f695e697660) * jack_frames_to_time() : [jack.h](group__TimeFunctions.html#ga9338f5b4866b3e749647d9c4b41c23b6) * jack_free() : [jack.h](group__TimeFunctions.html#ga437010097629ac8124a56c752c02f299) * jack_free_description() : [metadata.h](group__Metadata.html#gaafd9f68baaa56ff0ace13ba300db614b) * jack_get_all_properties() : [metadata.h](group__Metadata.html#ga539718c59d8a1fe68ed006e2699221df) * jack_get_buffer_size() : [jack.h](group__ServerControl.html#gad1f5972836af7e72e6d79ed6bc53916f) * jack_get_client_name() : [jack.h](group__ClientFunctions.html#ga49f7d301475b45a8a3cc0da848d81e2f) * jack_get_client_name_by_uuid() : [jack.h](group__ClientFunctions.html#gab4cf2516014b436e762907016b5be2b4) * jack_get_current_transport_frame() : [transport.h](group__TransportControl.html#gaef1df9479faa3b7f400c787be173f805) * jack_get_cycle_times() : [jack.h](group__TimeFunctions.html#ga06c9af1f47fc72a787435c723e19fa53) * jack_get_internal_client_name() : [intclient.h](intclient_8h.html#a06135991a92b175802b441cb07d2cc46) * jack_get_max_delayed_usecs() : [statistics.h](statistics_8h.html#ab4adfe9509eef86e4a44ccc6c38bda1f) * jack_get_ports() : [jack.h](group__PortSearching.html#gac8fc8e1745642cc983b1562ad43f99b1) * jack_get_properties() : [metadata.h](group__Metadata.html#ga63fd5c78f1185a2c0063323576350cc0) * jack_get_property() : [metadata.h](group__Metadata.html#ga1b7b25ad3e29266e056d7bc3e647b39e) * jack_get_sample_rate() : [jack.h](group__ServerControl.html#ga62022d4f2fbfba065f0874a497afd3b4) * jack_get_time() : [jack.h](group__TimeFunctions.html#ga3b26460e62a56cf012e9075dcb1b6294) * jack_get_transport_info() : [transport.h](group__TransportControl.html#ga994ea49b518181fbdee2adc9be1ee40e) * jack_get_uuid_for_client_name() : [jack.h](group__ClientFunctions.html#ga4c995eb51f38f3962dea4408122ced88) * jack_get_xrun_delayed_usecs() : [statistics.h](statistics_8h.html#a1594a8e3bbd718f128a9725057cf8877) * jack_info() : [control.h](group__ControlAPI.html#ga21328fd378306e0da7270952196eb717) * jack_internal_client_close() : [jack.h](group__ClientFunctions.html#ga0ad890884c983c78ba93ed2d9b8ee8cc) * jack_internal_client_handle() : [intclient.h](intclient_8h.html#a176a2daf66c8777eb1a845068fd7a822) * jack_internal_client_load() : [intclient.h](intclient_8h.html#aff038e9c251a2cdf4a5ce94d9d0ea88c) * jack_internal_client_new() : [jack.h](group__ClientFunctions.html#ga87be6679700acc40a0da17ac9ba3a31e) * jack_internal_client_unload() : [intclient.h](intclient_8h.html#a0cb5e85d41c1d0fd0163a64859ba3672) * jack_is_realtime() : [jack.h](group__ClientFunctions.html#ga15719a4abdcc5fa8415167dd6ed6512c) * jack_last_frame_time() : [jack.h](group__TimeFunctions.html#gae09e1c61ff0c43d4daea6cf480b7b915) * jack_log() : [control.h](group__ControlAPI.html#ga35f69faaee3bb9b958ed8c9a5f62246c) * jack_midi_clear_buffer() : [midiport.h](group__MIDIAPI.html#ga7635c6e0a4eb2314a5fb5a058c278078) * jack_midi_event_get() : [midiport.h](group__MIDIAPI.html#ga838c794bd1451bfd47edde1c7cd1ff4f) * jack_midi_event_reserve() : [midiport.h](group__MIDIAPI.html#ga150dcdc37583e1ecbe0a6f16b6ac48a9) * jack_midi_event_write() : [midiport.h](group__MIDIAPI.html#gaa25503c07ac3c2ed62d79be9c25d42ed) * jack_midi_get_event_count() : [midiport.h](group__MIDIAPI.html#ga0a87111085b94460401b0b688595a138) * jack_midi_get_lost_event_count() : [midiport.h](group__MIDIAPI.html#ga0f5af3d054e218a5b90fd4c636425e45) * jack_midi_max_event_size() : [midiport.h](group__MIDIAPI.html#gab69743a191f150757fa3708eae8fdb81) * jack_on_info_shutdown() : [jack.h](group__ClientCallbacks.html#gaf54d9f133267170ef1e6ce5219d24dd4) * jack_on_shutdown() : [jack.h](group__ClientCallbacks.html#ga417b907ee02efbe00f5e9a2f4d202599) * jack_port_by_id() : [jack.h](group__PortSearching.html#ga9988b33b2121b4bedadbd04e1f40a76d) * jack_port_by_name() : [jack.h](group__PortSearching.html#ga04dfd042bb01406c1411d0be5c7cf816) * jack_port_connected() : [jack.h](group__PortFunctions.html#gafa704768d67d1a30f263a9384d845b14) * jack_port_connected_to() : [jack.h](group__PortFunctions.html#ga996d8f5176b87bb8d333208468b6af12) * jack_port_disconnect() : [jack.h](group__PortFunctions.html#ga92f84d611d7dea399bc97516799ef89d) * jack_port_ensure_monitor() : [jack.h](group__PortFunctions.html#ga75f0438ba447ad96ae890c1922e4af0d) * jack_port_flags() : [jack.h](group__PortFunctions.html#ga2c9ed0ee016e19070b2e42f7f0a12b95) * jack_port_get_aliases() : [jack.h](group__PortFunctions.html#ga3fcae6e043fdb3ac87b173ff4cbf88d9) * jack_port_get_all_connections() : [jack.h](group__PortFunctions.html#ga4e1bd29a68acb4fb45f75931de0d36b2) * jack_port_get_buffer() : [jack.h](group__PortFunctions.html#ga209880b64774dd039c703ea8e3b9ca63) * jack_port_get_connections() : [jack.h](group__PortFunctions.html#gac1c942d03daee62ac6d0ed0ad044de43) * jack_port_get_latency() : [jack.h](group__LatencyFunctions.html#ga47fa957309f9b3111010284e10cc1de0) * jack_port_get_latency_range() : [jack.h](group__LatencyFunctions.html#gaf379bc0e88a6df6c4b7836db4b9382d7) * jack_port_get_total_latency() : [jack.h](group__LatencyFunctions.html#ga7f5835f17cb55a5ed64bb63cb18c462c) * jack_port_is_mine() : [jack.h](group__PortFunctions.html#ga2935e21ef49da7a420aca8cd25e179e6) * jack_port_monitoring_input() : [jack.h](group__PortFunctions.html#ga5e52890253590c913913765edf0f9606) * jack_port_name() : [jack.h](group__PortFunctions.html#ga2abf1e9c3fa7d2afae6fd85a6e2ba843) * jack_port_name_size() : [jack.h](group__PortFunctions.html#gabaebfd70bedfaecc834ebb02f4546eb1) * jack_port_register() : [jack.h](group__PortFunctions.html#ga3e21d145c3c82d273a889272f0e405e7) * jack_port_rename() : [jack.h](group__PortFunctions.html#ga2de80bfb1a64523a82d1a088379eb6f8) * jack_port_request_monitor() : [jack.h](group__PortFunctions.html#gab30737dde8a3168a575863de35ed5895) * jack_port_request_monitor_by_name() : [jack.h](group__PortFunctions.html#ga5fd1725d66427287abbec29fbae9214b) * jack_port_set_alias() : [jack.h](group__PortFunctions.html#gae76a201e7a6dfe3af6ee78b99a055117) * jack_port_set_latency() : [jack.h](group__LatencyFunctions.html#gaba121996f00bd96ceec5b1c1012fc767) * jack_port_set_latency_range() : [jack.h](group__LatencyFunctions.html#ga7a8f181fcec32945db7b8e06ee1ca94b) * jack_port_set_name() : [jack.h](group__PortFunctions.html#ga1591ad5d2eb3a3d086f2624e006e8daf) * jack_port_short_name() : [jack.h](group__PortFunctions.html#gaf1554d11abaff29321db1daf1fa614c1) * jack_port_tie() : [jack.h](group__PortFunctions.html#ga14afcad849c17bcd6cb739d14899cecf) * jack_port_type() : [jack.h](group__PortFunctions.html#gae2b2ef9ef3ba606be342a7d2c292cb00) * jack_port_type_get_buffer_size() : [jack.h](group__PortFunctions.html#ga52a65a0dd00695ecf75e23f1bd48f96a) * jack_port_type_size() : [jack.h](group__PortFunctions.html#ga8acf71c319f50c5789f7454e4b6ef2e5) * jack_port_unregister() : [jack.h](group__PortFunctions.html#ga9ac3ccd93be18999c0bd817bc032e876) * jack_port_unset_alias() : [jack.h](group__PortFunctions.html#ga51af66966211d2a81a749ab2f689872d) * jack_port_untie() : [jack.h](group__PortFunctions.html#gaab2cfe13d90991fbf1d03a2050b93f54) * jack_port_uuid() : [jack.h](group__PortFunctions.html#gae563c918af166e1285b8d2811199c302) * jack_port_uuid_generate() : [uuid.h](uuid_8h.html#a13b3f7ac6c5d9fb3cff895f302d5d620) * jack_recompute_total_latencies() : [jack.h](group__LatencyFunctions.html#ga46400b9a573389549784a356ab2d4e3b) * jack_recompute_total_latency() : [jack.h](group__LatencyFunctions.html#ga56372ab81d673cc4a419fd04cd3bfb8a) * jack_release_timebase() : [transport.h](group__TransportControl.html#gaea06ff63b129ec6266b2b805b6c8216a) * jack_remove_all_properties() : [metadata.h](group__Metadata.html#ga4fde77863c71057a8e8c8daa369f7a60) * jack_remove_properties() : [metadata.h](group__Metadata.html#ga80327b9c49b533d726fbf97705dbd874) * jack_remove_property() : [metadata.h](group__Metadata.html#gac17ed2c94fb09de5573e3cb7d08f88de) * jack_reserve_client_name() : [session.h](group__JackSessionManagerAPI.html#ga2693d2d6eface89e41394ec41ed49ea8) * jack_reset_max_delayed_usecs() : [statistics.h](statistics_8h.html#aeb7d2667d5f8281f4fe9c88db71a1843) * jack_ringbuffer_create() : [ringbuffer.h](ringbuffer_8h.html#a11f9045eb4b0561b26ec434c44e3c922) * jack_ringbuffer_free() : [ringbuffer.h](ringbuffer_8h.html#aa82de39e73e06aa729e092710b83ef61) * jack_ringbuffer_get_read_vector() : [ringbuffer.h](ringbuffer_8h.html#aa21aaf8ff173ba0e89b35554f20d4ccb) * jack_ringbuffer_get_write_vector() : [ringbuffer.h](ringbuffer_8h.html#a1c44a50c99f43bb683d8721f14aefc7d) * jack_ringbuffer_mlock() : [ringbuffer.h](ringbuffer_8h.html#aeb059ff23c65389d48ebbe948f05c2b2) * jack_ringbuffer_peek() : [ringbuffer.h](ringbuffer_8h.html#ad268f29e641b39bee8155e7e80ad4520) * jack_ringbuffer_read() : [ringbuffer.h](ringbuffer_8h.html#a4b001e5844a116a1d51006e2716c73bb) * jack_ringbuffer_read_advance() : [ringbuffer.h](ringbuffer_8h.html#aa9cdd4b69ae338c6ce464a1de00ee71a) * jack_ringbuffer_read_space() : [ringbuffer.h](ringbuffer_8h.html#a61e93fa7c9bfb6897dd2508d026d9317) * jack_ringbuffer_reset() : [ringbuffer.h](ringbuffer_8h.html#a40244c7eee331822cd99132a14e76896) * jack_ringbuffer_write() : [ringbuffer.h](ringbuffer_8h.html#a6d2fc75510e4df62f5b3dd249047b132) * jack_ringbuffer_write_advance() : [ringbuffer.h](ringbuffer_8h.html#a7255e067e485770d8127d821b6d7e9ec) * jack_ringbuffer_write_space() : [ringbuffer.h](ringbuffer_8h.html#a07a5f6086380300b7b2ccfd7cf9c2ef6) * jack_session_commands_free() : [session.h](group__JackSessionManagerAPI.html#ga62b659432fdfed7ec482054430e71431) * jack_session_event_free() : [session.h](group__SessionClientFunctions.html#gaeb90c4653b8f6ef713b9e19238d28c13) * jack_session_notify() : [session.h](group__JackSessionManagerAPI.html#gad5683da5880fc248ba87cdf2cc3c1887) * jack_session_reply() : [session.h](group__SessionClientFunctions.html#ga288d501f11a7c857a956a5a885a9855f) * jack_set_buffer_size() : [jack.h](group__ServerControl.html#gad96bda0901b924f5996e02e41a979685) * jack_set_buffer_size_callback() : [jack.h](group__ClientCallbacks.html#ga030cc371acb19abe52861492acb960ad) * jack_set_client_registration_callback() : [jack.h](group__ClientCallbacks.html#ga51b01a31e56c92f4e2788a94840f0f37) * jack_set_error_function() : [jack.h](group__TimeFunctions.html#ga550faaef2bb17b03b0068fe094e7b92f) * jack_set_freewheel() : [jack.h](group__ServerControl.html#gad65c741a1d1d2fb09efacf51437b841a) * jack_set_freewheel_callback() : [jack.h](group__ClientCallbacks.html#gae797e2cde20faecb9be510c8873fbdd6) * jack_set_graph_order_callback() : [jack.h](group__ClientCallbacks.html#gacd0804ccef7c6891d8265bd88e7429ee) * jack_set_info_function() : [jack.h](group__TimeFunctions.html#ga1555b7b4ae4056a42c70a3fa278ae17f) * jack_set_latency_callback() : [jack.h](group__ClientCallbacks.html#ga70a38fb1e74c5e9df9f1305c695c58bf) * jack_set_port_connect_callback() : [jack.h](group__ClientCallbacks.html#ga5312576d779c0664a7c703c87a9dba89) * jack_set_port_registration_callback() : [jack.h](group__ClientCallbacks.html#ga30983a0478551a3cd20b71d692b24007) * jack_set_port_rename_callback() : [jack.h](group__ClientCallbacks.html#ga0c73095c1d8ebba413de6834bd7757b9) * jack_set_process_callback() : [jack.h](group__ClientCallbacks.html#gafb5ec9fb4b736606d676c135fb97888b) * jack_set_process_thread() : [jack.h](group__NonCallbackAPI.html#ga66b623b80e34424dd380d38ae42b3261) * jack_set_property() : [metadata.h](group__Metadata.html#gae93daaae3727ad7b38d1156261889652) * jack_set_property_change_callback() : [metadata.h](group__Metadata.html#gaed0164bd6b54be3296a49bf988817477) * jack_set_sample_rate_callback() : [jack.h](group__ClientCallbacks.html#gac1b3eb298cfa2869b8773c6cecf7f4b3) * jack_set_session_callback() : [session.h](group__SessionClientFunctions.html#ga27846b86d11b2a8682b5d5220c87baa9) * jack_set_sync_callback() : [transport.h](group__TransportControl.html#gae53f7ac54804d2896d51b6ad599fa93c) * jack_set_sync_timeout() : [transport.h](group__TransportControl.html#ga2e89b0bb8702d34bcbbe1eac70685ab2) * jack_set_thread_creator() : [thread.h](group__ClientThreads.html#ga157ab0ade60e266ffd26ddffdb5545af) * jack_set_thread_init_callback() : [jack.h](group__ClientCallbacks.html#gad5a6904292f5c9790223c18aeab202bf) * jack_set_timebase_callback() : [transport.h](group__TransportControl.html#ga0c2f2f464f6ba1c0b2aa45e6507b7aa9) * jack_set_transport_info() : [transport.h](group__TransportControl.html#gad27bdf22d5642f2291ba77d7bdb2725a) * jack_set_xrun_callback() : [jack.h](group__ClientCallbacks.html#ga08196c75f06d9e68f9a3570dfcb1e323) * jack_thread_wait() : [jack.h](group__NonCallbackAPI.html#ga3f08587cfe43a0f883a1e2dfbb72edbb) * jack_time_to_frames() : [jack.h](group__TimeFunctions.html#ga968ec852b3a33127425fbc479c99f14e) * jack_transport_locate() : [transport.h](group__TransportControl.html#gab3f52a42084aead87fd1ee75ed25b240) * jack_transport_query() : [transport.h](group__TransportControl.html#ga5f08eb71a5ee5431a3d756af5729d5aa) * jack_transport_reposition() : [transport.h](group__TransportControl.html#ga2f371010358add3cbed8454bd0bd2ef8) * jack_transport_start() : [transport.h](group__TransportControl.html#gab7b158bec8f27c03da29795f142d1caf) * jack_transport_stop() : [transport.h](group__TransportControl.html#ga6be6637c314bd88344826e9bcc1957b0) * jack_uuid_clear() : [uuid.h](uuid_8h.html#a72738a8a6b86b770e6df660f29a192da) * jack_uuid_compare() : [uuid.h](uuid_8h.html#a154e3e261a5ca3b542d9101af61a5f15) * jack_uuid_copy() : [uuid.h](uuid_8h.html#a25391b3f81758bc650b8f942b10e7b8e) * jack_uuid_empty() : [uuid.h](uuid_8h.html#a60c52485117719d998d003a735fe1456) * jack_uuid_parse() : [uuid.h](uuid_8h.html#a6d8ca70e60136860cb1457d97e155f85) * jack_uuid_to_index() : [uuid.h](uuid_8h.html#ad61722f814c20487e2d67507a4377821) * jack_uuid_unparse() : [uuid.h](uuid_8h.html#ad0f407d1d45a9c00f55ae6499daa801e) * jackctl_driver_get_name() : [control.h](group__ControlAPI.html#ga9e28945c015f343e7a82c4e76e9cb1b4) * jackctl_driver_get_parameters() : [control.h](group__ControlAPI.html#ga0f73cfb0c40a401ca6aa617073303e72) * jackctl_internal_get_name() : [control.h](group__ControlAPI.html#ga4d14a6526174de9d085b203a7b7d632a) * jackctl_internal_get_parameters() : [control.h](group__ControlAPI.html#gade591618ee972b92724be7ee87a3943a) * jackctl_parameter_constraint_is_fake_value() : [control.h](group__ControlAPI.html#gafd1b5bc48305a978135692997abc8996) * jackctl_parameter_constraint_is_strict() : [control.h](group__ControlAPI.html#gac1d74fdcc7125293b7c2d329c0b09e9a) * jackctl_parameter_get_default_value() : [control.h](group__ControlAPI.html#gaa71bfc637794e50ccd5c39d0449b982a) * jackctl_parameter_get_enum_constraint_description() : [control.h](group__ControlAPI.html#gadbaa1566bcd829aa4233aac9234125ed) * jackctl_parameter_get_enum_constraint_value() : [control.h](group__ControlAPI.html#ga12fbe98c92f84dcfbd2de23421181567) * jackctl_parameter_get_enum_constraints_count() : [control.h](group__ControlAPI.html#ga1578b61842cf7a7cfb0d8fe54cf286ff) * jackctl_parameter_get_id() : [control.h](group__ControlAPI.html#ga864ee9036a98736910f264b1a62f0fe9) * jackctl_parameter_get_long_description() : [control.h](group__ControlAPI.html#ga97aae5c29e16539b71bc7dc2bddafc4b) * jackctl_parameter_get_name() : [control.h](group__ControlAPI.html#ga3a123ee66e7605b1f17db88d4f5b8ac8) * jackctl_parameter_get_range_constraint() : [control.h](group__ControlAPI.html#ga132d53b3fe319e84baf5a2381bd50fc6) * jackctl_parameter_get_short_description() : [control.h](group__ControlAPI.html#gaac9fe5577753455308a53f5569fe3106) * jackctl_parameter_get_type() : [control.h](group__ControlAPI.html#ga37fe25ce3d3fdbc631a12cab91c460bb) * jackctl_parameter_get_value() : [control.h](group__ControlAPI.html#ga9881e66c9c235484e5b8879ce27bc9f2) * jackctl_parameter_has_enum_constraint() : [control.h](group__ControlAPI.html#ga823ae164d023267b57002226444fe708) * jackctl_parameter_has_range_constraint() : [control.h](group__ControlAPI.html#gae7228c1726b5ecaae6458134bf4ab4d7) * jackctl_parameter_is_set() : [control.h](group__ControlAPI.html#ga439234cd9c8cb1ff35a8bffef526f04b) * jackctl_parameter_reset() : [control.h](group__ControlAPI.html#gac75904b4d63158841b6f4667a7928788) * jackctl_parameter_set_value() : [control.h](group__ControlAPI.html#gab769622731339e7d35e3b7093db347e6) * jackctl_server_add_slave() : [control.h](group__ControlAPI.html#gadacbb19d2f9e614ce33c8aedaa04fda1) * jackctl_server_create() : [control.h](group__ControlAPI.html#ga8b8c36f1be47c0d582e36ee2ea21e7bb) * jackctl_server_destroy() : [control.h](group__ControlAPI.html#gab6f848f11e9853f49d82f253c1df1121) * jackctl_server_get_drivers_list() : [control.h](group__ControlAPI.html#ga3edd82a413260dc1f4de2862f0a6a669) * jackctl_server_get_internals_list() : [control.h](group__ControlAPI.html#gacf1e2a650fec3f019bb36e49ffacde4f) * jackctl_server_get_parameters() : [control.h](group__ControlAPI.html#gaeaefa3144a6a9d843467d4951ca71f70) * jackctl_server_load_internal() : [control.h](group__ControlAPI.html#ga338effc099ff0cf03648971df51f9086) * jackctl_server_remove_slave() : [control.h](group__ControlAPI.html#gac71a7c5d85e891a51a57f2575aea627c) * jackctl_server_start() : [control.h](group__ControlAPI.html#ga0ee7d8a3386503ce677f1adbd206e971) * jackctl_server_stop() : [control.h](group__ControlAPI.html#gaf71c3fbc808e15305277e667ca6cfac4) * jackctl_server_switch_master() : [control.h](group__ControlAPI.html#ga3bfe5d4befb9d9bab8f05e13d37ca7b3) * jackctl_server_unload_internal() : [control.h](group__ControlAPI.html#gac0d0b9b2c5323da9193db9a0aa84bdf9) * jackctl_setup_signals() : [control.h](group__ControlAPI.html#gaaf1bee06690f756a6ffb463580590518) * jackctl_wait_signals() : [control.h](group__ControlAPI.html#ga90d8e0221779a24483fe4f4cce775d51) * * * Generated by [![doxygen](doxygen.svg)](https://www.doxygen.org/index.html) 1.9.1 --- # Source: https://jackaudio.org/ JACK-AUDIO-CONNECTION-KIT --- * [Main Page](index.html) * [Related Pages](pages.html) * [Modules](modules.html) * [Data Structures](annotated.html) * [Files](files.html) * ![](search/mag_sel.svg) [![](search/close.svg)](javascript:searchBox.CloseResultsWindow\(\)) Modules | Functions Setting Client Callbacks [Creating & manipulating clients](group__ClientFunctions.html) » [The non-callback API](group__NonCallbackAPI.html) ## Modules --- | [Controlling & querying JACK server operation](group__ServerControl.html) ## Functions --- int | [jack_set_thread_init_callback](group__ClientCallbacks.html#gad5a6904292f5c9790223c18aeab202bf) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, [JackThreadInitCallback](types_8h.html#a36a615301840e4edcfc3f61456c43020) thread_init_callback, void *arg) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) void | [jack_on_shutdown](group__ClientCallbacks.html#ga417b907ee02efbe00f5e9a2f4d202599) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, [JackShutdownCallback](types_8h.html#a1f461fe99711af7edcb1b73b1315fbb3) function, void *arg) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) void | [jack_on_info_shutdown](group__ClientCallbacks.html#gaf54d9f133267170ef1e6ce5219d24dd4) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, [JackInfoShutdownCallback](types_8h.html#ad30b9f6d5898ba8954bd51c4bc428a9e) function, void *arg) JACK_WEAK_EXPORT int | [jack_set_process_callback](group__ClientCallbacks.html#gafb5ec9fb4b736606d676c135fb97888b) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, [JackProcessCallback](types_8h.html#ab94e71df11ce055f9a278f55a6e476bc) process_callback, void *arg) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_set_freewheel_callback](group__ClientCallbacks.html#gae797e2cde20faecb9be510c8873fbdd6) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, [JackFreewheelCallback](types_8h.html#a2a9a8af9ac8206a0c67cef6a27e88be7) freewheel_callback, void *arg) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_set_buffer_size_callback](group__ClientCallbacks.html#ga030cc371acb19abe52861492acb960ad) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, [JackBufferSizeCallback](types_8h.html#aae24422729bb05aa0731a2d9545d278c) bufsize_callback, void *arg) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_set_sample_rate_callback](group__ClientCallbacks.html#gac1b3eb298cfa2869b8773c6cecf7f4b3) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, [JackSampleRateCallback](types_8h.html#a0735e21ddb96029d46bf35f14fc7e895) srate_callback, void *arg) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_set_client_registration_callback](group__ClientCallbacks.html#ga51b01a31e56c92f4e2788a94840f0f37) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *, [JackClientRegistrationCallback](types_8h.html#a9221225159a10a6eedaf0d98eff6de84) registration_callback, void *arg) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_set_port_registration_callback](group__ClientCallbacks.html#ga30983a0478551a3cd20b71d692b24007) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *, [JackPortRegistrationCallback](types_8h.html#ab67ac0b5c60ab9f94eba0c06ab16725c) registration_callback, void *arg) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_set_port_rename_callback](group__ClientCallbacks.html#ga0c73095c1d8ebba413de6834bd7757b9) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *, [JackPortRenameCallback](types_8h.html#ab5e21db10d45f938ec0fa688230c2c24) rename_callback, void *arg) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_set_port_connect_callback](group__ClientCallbacks.html#ga5312576d779c0664a7c703c87a9dba89) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *, [JackPortConnectCallback](types_8h.html#a351e09441e88b3013db37d3eb8e0a2b3) connect_callback, void *arg) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_set_graph_order_callback](group__ClientCallbacks.html#gacd0804ccef7c6891d8265bd88e7429ee) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *, [JackGraphOrderCallback](types_8h.html#ac3336628b231d38cfb07a94fd29067b3) graph_callback, void *) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_set_xrun_callback](group__ClientCallbacks.html#ga08196c75f06d9e68f9a3570dfcb1e323) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *, [JackXRunCallback](types_8h.html#ac19798b331fa11b864f874408d26a0b0) xrun_callback, void *arg) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_set_latency_callback](group__ClientCallbacks.html#ga70a38fb1e74c5e9df9f1305c695c58bf) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *, [JackLatencyCallback](types_8h.html#abbf969808e55bf3302079c2f57fae8c1) latency_callback, void *) JACK_WEAK_EXPORT ## Detailed Description ## Function Documentation ## ◆ jack_on_info_shutdown() void jack_on_info_shutdown | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | [JackInfoShutdownCallback](types_8h.html#ad30b9f6d5898ba8954bd51c4bc428a9e) | _function_ , | | void * | _arg_ | ) | | Parameters client| pointer to JACK client structure. ---|--- function| The jack_shutdown function pointer. arg| The arguments for the jack_shutdown function. Register a function (and argument) to be called if and when the JACK server shuts down the client thread. The function must be written as if it were an asynchonrous POSIX signal handler -- use only async-safe functions, and remember that it is executed from another thread. A typical function might set a flag or write to a pipe so that the rest of the application knows that the JACK client thread has shut down. NOTE: clients do not need to call this. It exists only to help more complex clients understand what is going on. It should be called before jack_client_activate(). NOTE: if a client calls this AND [jack_on_shutdown()](group__ClientCallbacks.html#ga417b907ee02efbe00f5e9a2f4d202599), then in the event of a client thread shutdown, the callback passed to this function will be called, and the one passed to [jack_on_shutdown()](group__ClientCallbacks.html#ga417b907ee02efbe00f5e9a2f4d202599) will not. ## ◆ jack_on_shutdown() void jack_on_shutdown | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | [JackShutdownCallback](types_8h.html#a1f461fe99711af7edcb1b73b1315fbb3) | _function_ , | | void * | _arg_ | ) | | Parameters client| pointer to JACK client structure. ---|--- function| The jack_shutdown function pointer. arg| The arguments for the jack_shutdown function. Register a function (and argument) to be called if and when the JACK server shuts down the client thread. The function must be written as if it were an asynchonrous POSIX signal handler -- use only async-safe functions, and remember that it is executed from another thread. A typical function might set a flag or write to a pipe so that the rest of the application knows that the JACK client thread has shut down. NOTE: clients do not need to call this. It exists only to help more complex clients understand what is going on. It should be called before jack_client_activate(). NOTE: if a client calls this AND [jack_on_info_shutdown()](group__ClientCallbacks.html#gaf54d9f133267170ef1e6ce5219d24dd4), then the event of a client thread shutdown, the callback passed to this function will not be called, and the one passed to [jack_on_info_shutdown()](group__ClientCallbacks.html#gaf54d9f133267170ef1e6ce5219d24dd4) will. ## ◆ jack_set_buffer_size_callback() int jack_set_buffer_size_callback | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | [JackBufferSizeCallback](types_8h.html#aae24422729bb05aa0731a2d9545d278c) | _bufsize_callback_ , | | void * | _arg_ | ) | | Tell JACK to call _bufsize_callback_ whenever the size of the the buffer that will be passed to the _process_callback_ is about to change. Clients that depend on knowing the buffer size must supply a _bufsize_callback_ before activating themselves. Parameters client| pointer to JACK client structure. ---|--- bufsize_callback| function to call when the buffer size changes. arg| argument for _bufsize_callback_. Returns 0 on success, otherwise a non-zero error code ## ◆ jack_set_client_registration_callback() int jack_set_client_registration_callback | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | , ---|---|---|--- | | [JackClientRegistrationCallback](types_8h.html#a9221225159a10a6eedaf0d98eff6de84) | _registration_callback_ , | | void * | _arg_ | ) | | Tell the JACK server to call _registration_callback_ whenever a port is registered or unregistered, passing _arg_ as a parameter. Returns 0 on success, otherwise a non-zero error code ## ◆ jack_set_freewheel_callback() int jack_set_freewheel_callback | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | [JackFreewheelCallback](types_8h.html#a2a9a8af9ac8206a0c67cef6a27e88be7) | _freewheel_callback_ , | | void * | _arg_ | ) | | Tell the Jack server to call _freewheel_callback_ whenever we enter or leave "freewheel" mode, passing _arg_ as the second argument. The first argument to the callback will be non-zero if JACK is entering freewheel mode, and zero otherwise. Returns 0 on success, otherwise a non-zero error code. ## ◆ jack_set_graph_order_callback() int jack_set_graph_order_callback | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | , ---|---|---|--- | | [JackGraphOrderCallback](types_8h.html#ac3336628b231d38cfb07a94fd29067b3) | _graph_callback_ , | | void * | | ) | | Tell the JACK server to call _graph_callback_ whenever the processing graph is reordered, passing _arg_ as a parameter. Returns 0 on success, otherwise a non-zero error code ## ◆ jack_set_latency_callback() int jack_set_latency_callback | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | , ---|---|---|--- | | [JackLatencyCallback](types_8h.html#abbf969808e55bf3302079c2f57fae8c1) | _latency_callback_ , | | void * | | ) | | Tell the Jack server to call _latency_callback_ whenever it is necessary to recompute the latencies for some or all Jack ports. _latency_callback_ will be called twice each time it is needed, once being passed JackCaptureLatency and once JackPlaybackLatency. See [Managing and determining latency](group__LatencyFunctions.html) for the definition of each type of latency and related functions. **IMPORTANT: Most JACK clients do NOT need to register a latency callback.** Clients that meet any of the following conditions do NOT need to register a latency callback: * have only input ports * have only output ports * their output is totally unrelated to their input * their output is not delayed relative to their input (i.e. data that arrives in a given process() callback is processed and output again in the same callback) Clients NOT registering a latency callback MUST also satisfy this condition: * have no multiple distinct internal signal pathways This means that if your client has more than 1 input and output port, and considers them always "correlated" (e.g. as a stereo pair), then there is only 1 (e.g. stereo) signal pathway through the client. This would be true, for example, of a stereo FX rack client that has a left/right input pair and a left/right output pair. However, this is somewhat a matter of perspective. The same FX rack client could be connected so that its two input ports were connected to entirely separate sources. Under these conditions, the fact that the client does not register a latency callback MAY result in port latency values being incorrect. Clients that do not meet any of those conditions SHOULD register a latency callback. Another case is when a client wants to use [jack_port_get_latency_range()](group__LatencyFunctions.html#gaf379bc0e88a6df6c4b7836db4b9382d7), which only returns meaninful values when ports get connected and latency values change. See the documentation for [jack_port_set_latency_range()](group__LatencyFunctions.html#ga7a8f181fcec32945db7b8e06ee1ca94b) on how the callback should operate. Remember that the _mode_ argument given to the latency callback will need to be passed into [jack_port_set_latency_range()](group__LatencyFunctions.html#ga7a8f181fcec32945db7b8e06ee1ca94b) Returns 0 on success, otherwise a non-zero error code ## ◆ jack_set_port_connect_callback() int jack_set_port_connect_callback | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | , ---|---|---|--- | | [JackPortConnectCallback](types_8h.html#a351e09441e88b3013db37d3eb8e0a2b3) | _connect_callback_ , | | void * | _arg_ | ) | | Tell the JACK server to call _connect_callback_ whenever a port is connected or disconnected, passing _arg_ as a parameter. Returns 0 on success, otherwise a non-zero error code ## ◆ jack_set_port_registration_callback() int jack_set_port_registration_callback | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | , ---|---|---|--- | | [JackPortRegistrationCallback](types_8h.html#ab67ac0b5c60ab9f94eba0c06ab16725c) | _registration_callback_ , | | void * | _arg_ | ) | | Tell the JACK server to call _registration_callback_ whenever a port is registered or unregistered, passing _arg_ as a parameter. Returns 0 on success, otherwise a non-zero error code ## ◆ jack_set_port_rename_callback() int jack_set_port_rename_callback | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | , ---|---|---|--- | | [JackPortRenameCallback](types_8h.html#ab5e21db10d45f938ec0fa688230c2c24) | _rename_callback_ , | | void * | _arg_ | ) | | Tell the JACK server to call _rename_callback_ whenever a port is renamed, passing _arg_ as a parameter. Returns 0 on success, otherwise a non-zero error code ## ◆ jack_set_process_callback() int jack_set_process_callback | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | [JackProcessCallback](types_8h.html#ab94e71df11ce055f9a278f55a6e476bc) | _process_callback_ , | | void * | _arg_ | ) | | Tell the Jack server to call _process_callback_ whenever there is work be done, passing _arg_ as the second argument. The code in the supplied function must be suitable for real-time execution. That means that it cannot call functions that might block for a long time. This includes all I/O functions (disk, TTY, network), malloc, free, printf, pthread_mutex_lock, sleep, wait, poll, select, pthread_join, pthread_cond_wait, etc, etc. Returns 0 on success, otherwise a non-zero error code, causing JACK to remove that client from the process() graph. ## ◆ jack_set_sample_rate_callback() int jack_set_sample_rate_callback | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | [JackSampleRateCallback](types_8h.html#a0735e21ddb96029d46bf35f14fc7e895) | _srate_callback_ , | | void * | _arg_ | ) | | Tell the Jack server to call _srate_callback_ whenever the system sample rate changes. Returns 0 on success, otherwise a non-zero error code ## ◆ jack_set_thread_init_callback() int jack_set_thread_init_callback | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | [JackThreadInitCallback](types_8h.html#a36a615301840e4edcfc3f61456c43020) | _thread_init_callback_ , | | void * | _arg_ | ) | | Tell JACK to call _thread_init_callback_ once just after the creation of the thread in which all other callbacks will be handled. The code in the supplied function does not need to be suitable for real-time execution. Returns 0 on success, otherwise a non-zero error code, causing JACK to remove that client from the process() graph. ## ◆ jack_set_xrun_callback() int jack_set_xrun_callback | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | , ---|---|---|--- | | [JackXRunCallback](types_8h.html#ac19798b331fa11b864f874408d26a0b0) | _xrun_callback_ , | | void * | _arg_ | ) | | Tell the JACK server to call _xrun_callback_ whenever there is a xrun, passing _arg_ as a parameter. Returns 0 on success, otherwise a non-zero error code * * * Generated by [![doxygen](doxygen.svg)](https://www.doxygen.org/index.html) 1.9.1 --- # Source: https://jackaudio.org/ JACK-AUDIO-CONNECTION-KIT --- * [Main Page](index.html) * [Related Pages](pages.html) * [Modules](modules.html) * [Data Structures](annotated.html) * [Files](files.html) * ![](search/mag_sel.svg) [![](search/close.svg)](javascript:searchBox.CloseResultsWindow\(\)) Modules | Functions Creating & manipulating clients ## Modules --- | [The non-callback API](group__NonCallbackAPI.html) ## Functions --- [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | [jack_client_open](group__ClientFunctions.html#gabbd2041bca191943b6ef29a991a131c5) (const char *client_name, [jack_options_t](types_8h.html#a0ef5011e5aab7655ad0d64babf7d91f0) options, [jack_status_t](types_8h.html#a49053418570427a7a99d1bb45fb43f38) *status,...) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | [jack_client_new](group__ClientFunctions.html#ga97482adad8116b76635a63f646a2d2f5) (const char *client_name) JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT int | [jack_client_close](group__ClientFunctions.html#ga405646705e600d8bf66327bdbab8e363) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_client_name_size](group__ClientFunctions.html#gab8b16ee616207532d0585d04a0bd1d60) (void) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) char * | [jack_get_client_name](group__ClientFunctions.html#ga49f7d301475b45a8a3cc0da848d81e2f) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) char * | [jack_get_uuid_for_client_name](group__ClientFunctions.html#ga4c995eb51f38f3962dea4408122ced88) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, const char *name) JACK_WEAK_EXPORT char * | [jack_get_client_name_by_uuid](group__ClientFunctions.html#gab4cf2516014b436e762907016b5be2b4) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, const char *uuid) JACK_WEAK_EXPORT int | [jack_internal_client_new](group__ClientFunctions.html#ga87be6679700acc40a0da17ac9ba3a31e) (const char *client_name, const char *load_name, const char *load_init) JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT void | [jack_internal_client_close](group__ClientFunctions.html#ga0ad890884c983c78ba93ed2d9b8ee8cc) (const char *client_name) JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT int | [jack_activate](group__ClientFunctions.html#ga9800d5b29bd7670d9944a15f6ea0ecf8) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_deactivate](group__ClientFunctions.html#ga2c6447b766b13d3aa356aba2b48e51fa) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) jack_native_thread_t | [jack_client_thread_id](group__ClientFunctions.html#ga4e78f0a2ca6c837709c7ec641afd9954) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_is_realtime](group__ClientFunctions.html#ga15719a4abdcc5fa8415167dd6ed6512c) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) ## Detailed Description Note: More documentation can be found in [jack/types.h](types_8h.html). ## Function Documentation ## ◆ jack_activate() int jack_activate | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_| ) | ---|---|---|---|---|--- Tell the Jack server that the program is ready to start processing audio. Returns 0 on success, otherwise a non-zero error code ## ◆ jack_client_close() int jack_client_close | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_| ) | ---|---|---|---|---|--- Disconnects an external client from a JACK server. Returns 0 on success, otherwise a non-zero error code ## ◆ jack_client_name_size() int jack_client_name_size | ( | void | | ) | ---|---|---|---|---|--- Returns the maximum number of characters in a JACK client name including the final NULL character. This value is a constant. ## ◆ jack_client_new() [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf)* jack_client_new | ( | const char * | _client_name_| ) | ---|---|---|---|---|--- **THIS FUNCTION IS DEPRECATED AND SHOULD NOT BE USED IN NEW JACK CLIENTS** ## ◆ jack_client_open() [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf)* jack_client_open | ( | const char * | _client_name_ , ---|---|---|--- | | [jack_options_t](types_8h.html#a0ef5011e5aab7655ad0d64babf7d91f0) | _options_ , | | [jack_status_t](types_8h.html#a49053418570427a7a99d1bb45fb43f38) * | _status_ , | | | _..._ | ) | | Open an external client session with a JACK server. This interface is more complex but more powerful than [jack_client_new()](group__ClientFunctions.html#ga97482adad8116b76635a63f646a2d2f5). With it, clients may choose which of several servers to connect, and control whether and how to start the server automatically, if it was not already running. There is also an option for JACK to generate a unique client name, when necessary. Parameters client_name| of at most [jack_client_name_size()](group__ClientFunctions.html#gab8b16ee616207532d0585d04a0bd1d60) characters. The name scope is local to each server. Unless forbidden by the [JackUseExactName](types_8h.html#a396617de2ef101891c51346f408a375ea352b176ffa092ec946a06b707f6aa21b) option, the server will modify this name to create a unique variant, if needed. ---|--- options| formed by OR-ing together [JackOptions](types_8h.html#a396617de2ef101891c51346f408a375e) bits. Only the [JackOpenOptions](types_8h.html#ab39e7f78dba631f3c0d34ac4cddcf80f) bits are allowed. status| (if non-NULL) an address for JACK to return information from the open operation. This status word is formed by OR-ing together the relevant [JackStatus](types_8h.html#aaf80297bce18297403b99e3d320ac8a8) bits. **Optional parameters:** depending on corresponding [_options_ bits] additional parameters may follow _status_ (in this order). * [[JackServerName](types_8h.html#a396617de2ef101891c51346f408a375ea348557bfdc579daed2e35cc41c4f09c7)] _(char *) server_name_ selects from among several possible concurrent server instances. Server names are unique to each user. If unspecified, use "default" unless $JACK_DEFAULT_SERVER is defined in the process environment. Returns Opaque client handle if successful. If this is NULL, the open operation failed, _*status_ includes [JackFailure](types_8h.html#aaf80297bce18297403b99e3d320ac8a8a354fbb027d989173f50921d239f3812b) and the caller is not a JACK client. ## ◆ jack_client_thread_id() jack_native_thread_t jack_client_thread_id | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | | ) | ---|---|---|---|---|--- Returns the pthread ID of the thread running the JACK client side code. ## ◆ jack_deactivate() int jack_deactivate | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_| ) | ---|---|---|---|---|--- Tell the Jack server to remove this _client_ from the process graph. Also, disconnect all ports belonging to it, since inactive clients have no port connections. Returns 0 on success, otherwise a non-zero error code ## ◆ jack_get_client_name() char* jack_get_client_name | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_| ) | ---|---|---|---|---|--- Returns pointer to actual client name. This is useful when [JackUseExactName](types_8h.html#a396617de2ef101891c51346f408a375ea352b176ffa092ec946a06b707f6aa21b) is not specified on open and [JackNameNotUnique](types_8h.html#aaf80297bce18297403b99e3d320ac8a8a09a73b951f3601ae9436bd3429ac0691) status was returned. In that case, the actual name will differ from the _client_name_ requested. ## ◆ jack_get_client_name_by_uuid() char* jack_get_client_name_by_uuid | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | const char * | _uuid_ | ) | | Returns a pointer to the name of the client with the UUID specified by uuid. Parameters client| making the request ---|--- uuid| the uuid of the client whose name is desired Return NULL if no such client with the given UUID exists ## ◆ jack_get_uuid_for_client_name() char* jack_get_uuid_for_client_name | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | const char * | _name_ | ) | | Returns pointer to a string representation of the UUID for a client named Parameters name| . If no such client exists, return NULL ---|--- client| the client making the request name| the name of the client whose UUID is desired Return NULL if no such client with the given name exists ## ◆ jack_internal_client_close() void jack_internal_client_close | ( | const char * | _client_name_| ) | ---|---|---|---|---|--- Remove an internal client from a JACK server. **[Deprecated:](deprecated.html#_deprecated000002)** Please use [jack_internal_client_load()](intclient_8h.html#aff038e9c251a2cdf4a5ce94d9d0ea88c). ## ◆ jack_internal_client_new() int jack_internal_client_new | ( | const char * | _client_name_ , ---|---|---|--- | | const char * | _load_name_ , | | const char * | _load_init_ | ) | | Load an internal client into the Jack server. Internal clients run inside the JACK server process. They can use most of the same functions as external clients. Each internal client must declare jack_initialize() and jack_finish() entry points, called at load and unload times. See inprocess.c for an example of how to write an internal client. **[Deprecated:](deprecated.html#_deprecated000001)** Please use [jack_internal_client_load()](intclient_8h.html#aff038e9c251a2cdf4a5ce94d9d0ea88c). Parameters client_name| of at most [jack_client_name_size()](group__ClientFunctions.html#gab8b16ee616207532d0585d04a0bd1d60) characters. ---|--- load_name| of a shared object file containing the code for the new client. load_init| an arbitary string passed to the jack_initialize() routine of the new client (may be NULL). Returns 0 if successful. ## ◆ jack_is_realtime() int jack_is_realtime | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_| ) | ---|---|---|---|---|--- Parameters client| pointer to JACK client structure. ---|--- Check if the JACK subsystem is running with -R (-realtime). Returns 1 if JACK is running realtime, 0 otherwise * * * Generated by [![doxygen](doxygen.svg)](https://www.doxygen.org/index.html) 1.9.1 --- # Source: https://jackaudio.org/ JACK-AUDIO-CONNECTION-KIT --- * [Main Page](index.html) * [Related Pages](pages.html) * [Modules](modules.html) * [Data Structures](annotated.html) * [Files](files.html) * ![](search/mag_sel.svg) [![](search/close.svg)](javascript:searchBox.CloseResultsWindow\(\)) Functions | Variables Reading and writing MIDI data ## Functions --- [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) | [jack_midi_get_event_count](group__MIDIAPI.html#ga0a87111085b94460401b0b688595a138) (void *port_buffer) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_midi_event_get](group__MIDIAPI.html#ga838c794bd1451bfd47edde1c7cd1ff4f) ([jack_midi_event_t](midiport_8h.html#ae34bec0cd504eee54afffda51122a352) *event, void *port_buffer, uint32_t event_index) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) void | [jack_midi_clear_buffer](group__MIDIAPI.html#ga7635c6e0a4eb2314a5fb5a058c278078) (void *port_buffer) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) size_t | [jack_midi_max_event_size](group__MIDIAPI.html#gab69743a191f150757fa3708eae8fdb81) (void *port_buffer) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) [jack_midi_data_t](midiport_8h.html#ad1df9c73b07584ffb69c276421ff55c9) * | [jack_midi_event_reserve](group__MIDIAPI.html#ga150dcdc37583e1ecbe0a6f16b6ac48a9) (void *port_buffer, [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) time, size_t data_size) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_midi_event_write](group__MIDIAPI.html#gaa25503c07ac3c2ed62d79be9c25d42ed) (void *port_buffer, [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) time, const [jack_midi_data_t](midiport_8h.html#ad1df9c73b07584ffb69c276421ff55c9) *data, size_t data_size) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) uint32_t | [jack_midi_get_lost_event_count](group__MIDIAPI.html#ga0f5af3d054e218a5b90fd4c636425e45) (void *port_buffer) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) ## Variables --- [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) | [_jack_midi_event::time](group__MIDIAPI.html#ga7acc6a81ac12e2a042d5af9fb7b56532) size_t | [_jack_midi_event::size](group__MIDIAPI.html#gabc254ee669d342c75ccfa49658b54a56) [jack_midi_data_t](midiport_8h.html#ad1df9c73b07584ffb69c276421ff55c9) * | [_jack_midi_event::buffer](group__MIDIAPI.html#gadebcb1577b20165e4da170f8992bc0ba) ## Detailed Description ## Function Documentation ## ◆ jack_midi_clear_buffer() void jack_midi_clear_buffer | ( | void * | _port_buffer_| ) | ---|---|---|---|---|--- Clear an event buffer. This should be called at the beginning of each process cycle before calling [jack_midi_event_reserve](group__MIDIAPI.html#ga150dcdc37583e1ecbe0a6f16b6ac48a9) or [jack_midi_event_write](group__MIDIAPI.html#gaa25503c07ac3c2ed62d79be9c25d42ed). This function may not be called on an input port's buffer. Parameters port_buffer| Port buffer to clear (must be an output port buffer). ---|--- ## ◆ jack_midi_event_get() int jack_midi_event_get | ( | [jack_midi_event_t](midiport_8h.html#ae34bec0cd504eee54afffda51122a352) * | _event_ , ---|---|---|--- | | void * | _port_buffer_ , | | uint32_t | _event_index_ | ) | | Get a MIDI event from an event port buffer. Jack MIDI is normalised, the MIDI event returned by this function is guaranteed to be a complete MIDI event (the status byte will always be present, and no realtime events will interspered with the event). Parameters event| Event structure to store retrieved event in. ---|--- port_buffer| Port buffer from which to retrieve event. event_index| Index of event to retrieve. Returns 0 on success, ENODATA if buffer is empty. ## ◆ jack_midi_event_reserve() [jack_midi_data_t](midiport_8h.html#ad1df9c73b07584ffb69c276421ff55c9)* jack_midi_event_reserve | ( | void * | _port_buffer_ , ---|---|---|--- | | [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) | _time_ , | | size_t | _data_size_ | ) | | Allocate space for an event to be written to an event port buffer. Clients are to write the actual event data to be written starting at the pointer returned by this function. Clients must not write more than _data_size_ bytes into this buffer. Clients must write normalised MIDI data to the port - no running status and no (1-byte) realtime messages interspersed with other messages (realtime messages are fine when they occur on their own, like other messages). Events must be written in order, sorted by their sample offsets. JACK will not sort the events for you, and will refuse to store out-of-order events. Parameters port_buffer| Buffer to write event to. ---|--- time| Sample offset of event. data_size| Length of event's raw data in bytes. Returns Pointer to the beginning of the reserved event's data buffer, or NULL on error (ie not enough space). ## ◆ jack_midi_event_write() int jack_midi_event_write | ( | void * | _port_buffer_ , ---|---|---|--- | | [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) | _time_ , | | const [jack_midi_data_t](midiport_8h.html#ad1df9c73b07584ffb69c276421ff55c9) * | _data_ , | | size_t | _data_size_ | ) | | Write an event into an event port buffer. This function is simply a wrapper for [jack_midi_event_reserve](group__MIDIAPI.html#ga150dcdc37583e1ecbe0a6f16b6ac48a9) which writes the event data into the space reserved in the buffer. Clients must not write more than _data_size_ bytes into this buffer. Clients must write normalised MIDI data to the port - no running status and no (1-byte) realtime messages interspersed with other messages (realtime messages are fine when they occur on their own, like other messages). Events must be written in order, sorted by their sample offsets. JACK will not sort the events for you, and will refuse to store out-of-order events. Parameters port_buffer| Buffer to write event to. ---|--- time| Sample offset of event. data| Message data to be written. data_size| Length of _data_ in bytes. Returns 0 on success, ENOBUFS if there's not enough space in buffer for event. ## ◆ jack_midi_get_event_count() [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) jack_midi_get_event_count | ( | void * | _port_buffer_| ) | ---|---|---|---|---|--- ## ◆ jack_midi_get_lost_event_count() uint32_t jack_midi_get_lost_event_count | ( | void * | _port_buffer_| ) | ---|---|---|---|---|--- Get the number of events that could not be written to _port_buffer_. This function returning a non-zero value implies _port_buffer_ is full. Currently the only way this can happen is if events are lost on port mixdown. Parameters port_buffer| Port to receive count for. ---|--- Returns Number of events that could not be written to _port_buffer_. ## ◆ jack_midi_max_event_size() size_t jack_midi_max_event_size | ( | void * | _port_buffer_| ) | ---|---|---|---|---|--- Get the size of the largest event that can be stored by the port. This function returns the current space available, taking into account events already stored in the port. Parameters port_buffer| Port buffer to check size of. ---|--- ## Variable Documentation ## ◆ buffer [jack_midi_data_t](midiport_8h.html#ad1df9c73b07584ffb69c276421ff55c9)* _jack_midi_event::buffer --- Raw MIDI data ## ◆ size size_t _jack_midi_event::size --- Number of bytes of data in _buffer_ ## ◆ time [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) _jack_midi_event::time --- Sample index at which event is valid * * * Generated by [![doxygen](doxygen.svg)](https://www.doxygen.org/index.html) 1.9.1 --- # Source: https://jackaudio.org/ JACK-AUDIO-CONNECTION-KIT --- * [Main Page](index.html) * [Related Pages](pages.html) * [Modules](modules.html) * [Data Structures](annotated.html) * [Files](files.html) * ![](search/mag_sel.svg) [![](search/close.svg)](javascript:searchBox.CloseResultsWindow\(\)) Modules | Functions Creating & manipulating ports [Creating & manipulating clients](group__ClientFunctions.html) » [The non-callback API](group__NonCallbackAPI.html) » [Setting Client Callbacks](group__ClientCallbacks.html) » [Controlling & querying JACK server operation](group__ServerControl.html) ## Modules --- | [Managing and determining latency](group__LatencyFunctions.html) ## Functions --- [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | [jack_port_register](group__PortFunctions.html#ga3e21d145c3c82d273a889272f0e405e7) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, const char *port_name, const char *port_type, unsigned long flags, unsigned long buffer_size) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_port_unregister](group__PortFunctions.html#ga9ac3ccd93be18999c0bd817bc032e876) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *, [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) void * | [jack_port_get_buffer](group__PortFunctions.html#ga209880b64774dd039c703ea8e3b9ca63) ([jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *, [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6)) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) const char * | [jack_port_name](group__PortFunctions.html#ga2abf1e9c3fa7d2afae6fd85a6e2ba843) (const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) [jack_uuid_t](types_8h.html#a346b785a201c9eb5a41a106f87829c9f) | [jack_port_uuid](group__PortFunctions.html#gae563c918af166e1285b8d2811199c302) (const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) const char * | [jack_port_short_name](group__PortFunctions.html#gaf1554d11abaff29321db1daf1fa614c1) (const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_port_flags](group__PortFunctions.html#ga2c9ed0ee016e19070b2e42f7f0a12b95) (const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) const char * | [jack_port_type](group__PortFunctions.html#gae2b2ef9ef3ba606be342a7d2c292cb00) (const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_port_is_mine](group__PortFunctions.html#ga2935e21ef49da7a420aca8cd25e179e6) (const [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *, const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_port_connected](group__PortFunctions.html#gafa704768d67d1a30f263a9384d845b14) (const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_port_connected_to](group__PortFunctions.html#ga996d8f5176b87bb8d333208468b6af12) (const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port, const char *port_name) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) const char ** | [jack_port_get_connections](group__PortFunctions.html#gac1c942d03daee62ac6d0ed0ad044de43) (const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) const char ** | [jack_port_get_all_connections](group__PortFunctions.html#ga4e1bd29a68acb4fb45f75931de0d36b2) (const [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_port_tie](group__PortFunctions.html#ga14afcad849c17bcd6cb739d14899cecf) ([jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *src, [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *dst) JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT int | [jack_port_untie](group__PortFunctions.html#gaab2cfe13d90991fbf1d03a2050b93f54) ([jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port) JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT int | [jack_port_set_name](group__PortFunctions.html#ga1591ad5d2eb3a3d086f2624e006e8daf) ([jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port, const char *port_name) JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT int | [jack_port_rename](group__PortFunctions.html#ga2de80bfb1a64523a82d1a088379eb6f8) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port, const char *port_name) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_port_set_alias](group__PortFunctions.html#gae76a201e7a6dfe3af6ee78b99a055117) ([jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port, const char *alias) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_port_unset_alias](group__PortFunctions.html#ga51af66966211d2a81a749ab2f689872d) ([jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port, const char *alias) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_port_get_aliases](group__PortFunctions.html#ga3fcae6e043fdb3ac87b173ff4cbf88d9) (const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port, char *const aliases[2]) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_port_request_monitor](group__PortFunctions.html#gab30737dde8a3168a575863de35ed5895) ([jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port, int onoff) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_port_request_monitor_by_name](group__PortFunctions.html#ga5fd1725d66427287abbec29fbae9214b) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, const char *port_name, int onoff) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_port_ensure_monitor](group__PortFunctions.html#ga75f0438ba447ad96ae890c1922e4af0d) ([jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port, int onoff) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_port_monitoring_input](group__PortFunctions.html#ga5e52890253590c913913765edf0f9606) ([jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *port) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_connect](group__PortFunctions.html#gae6090e81f2ee23b5c0e432a899085ec8) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *, const char *source_port, const char *destination_port) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_disconnect](group__PortFunctions.html#gaf2bd9f649c51dafdb382847f0c15963f) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *, const char *source_port, const char *destination_port) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_port_disconnect](group__PortFunctions.html#ga92f84d611d7dea399bc97516799ef89d) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *, [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) *) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_port_name_size](group__PortFunctions.html#gabaebfd70bedfaecc834ebb02f4546eb1) (void) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_port_type_size](group__PortFunctions.html#ga8acf71c319f50c5789f7454e4b6ef2e5) (void) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) size_t | [jack_port_type_get_buffer_size](group__PortFunctions.html#ga52a65a0dd00695ecf75e23f1bd48f96a) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, const char *port_type) JACK_WEAK_EXPORT ## Detailed Description ## Function Documentation ## ◆ jack_connect() int jack_connect | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | , ---|---|---|--- | | const char * | _source_port_ , | | const char * | _destination_port_ | ) | | Establish a connection between two ports. When a connection exists, data written to the source port will be available to be read at the destination port. Precondition The port types must be identical. The [JackPortFlags](types_8h.html#acbcada380e9dfdd5bff1296e7156f478) of the _source_port_ must include [JackPortIsOutput](types_8h.html#acbcada380e9dfdd5bff1296e7156f478aa0e103ad40ec14c6b50120dd85089c26). The [JackPortFlags](types_8h.html#acbcada380e9dfdd5bff1296e7156f478) of the _destination_port_ must include [JackPortIsInput](types_8h.html#acbcada380e9dfdd5bff1296e7156f478a9dea0e7c0d7f57b9674f7c321a5cc50c). Returns 0 on success, EEXIST if the connection is already made, otherwise a non-zero error code ## ◆ jack_disconnect() int jack_disconnect | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | , ---|---|---|--- | | const char * | _source_port_ , | | const char * | _destination_port_ | ) | | Remove a connection between two ports. Precondition The port types must be identical. The [JackPortFlags](types_8h.html#acbcada380e9dfdd5bff1296e7156f478) of the _source_port_ must include [JackPortIsOutput](types_8h.html#acbcada380e9dfdd5bff1296e7156f478aa0e103ad40ec14c6b50120dd85089c26). The [JackPortFlags](types_8h.html#acbcada380e9dfdd5bff1296e7156f478) of the _destination_port_ must include [JackPortIsInput](types_8h.html#acbcada380e9dfdd5bff1296e7156f478a9dea0e7c0d7f57b9674f7c321a5cc50c). Returns 0 on success, otherwise a non-zero error code ## ◆ jack_port_connected() int jack_port_connected | ( | const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_| ) | ---|---|---|---|---|--- Returns number of connections to or from _port_. Precondition The calling client must own _port_. ## ◆ jack_port_connected_to() int jack_port_connected_to | ( | const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_ , ---|---|---|--- | | const char * | _port_name_ | ) | | Returns TRUE if the locally-owned _port_ is **directly** connected to the _port_name_. See also [jack_port_name_size()](group__PortFunctions.html#gabaebfd70bedfaecc834ebb02f4546eb1) ## ◆ jack_port_disconnect() int jack_port_disconnect | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | , ---|---|---|--- | | [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | | ) | | Perform the same function as [jack_disconnect()](group__PortFunctions.html#gaf2bd9f649c51dafdb382847f0c15963f) using port handles rather than names. This avoids the name lookup inherent in the name-based version. Clients connecting their own ports are likely to use this function, while generic connection clients (e.g. patchbays) would use [jack_disconnect()](group__PortFunctions.html#gaf2bd9f649c51dafdb382847f0c15963f). ## ◆ jack_port_ensure_monitor() int jack_port_ensure_monitor | ( | [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_ , ---|---|---|--- | | int | _onoff_ | ) | | If [JackPortCanMonitor](types_8h.html#acbcada380e9dfdd5bff1296e7156f478a0271c73ded98c373ebf8c5e59b51bb0c) is set for a port, this function turns on input monitoring if it was off, and turns it off if only one request has been made to turn it on. Otherwise it does nothing. Returns 0 on success, otherwise a non-zero error code ## ◆ jack_port_flags() int jack_port_flags | ( | const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_| ) | ---|---|---|---|---|--- Returns the [JackPortFlags](types_8h.html#acbcada380e9dfdd5bff1296e7156f478) of the jack_port_t. ## ◆ jack_port_get_aliases() int jack_port_get_aliases | ( | const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_ , ---|---|---|--- | | char *const | _aliases_[2] | ) | | ## ◆ jack_port_get_all_connections() const char** jack_port_get_all_connections | ( | const [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_ | ) | | Returns a null-terminated array of full port names to which the _port_ is connected. If none, returns NULL. The caller is responsible for calling jack_free(3) on any non-NULL returned value. This differs from [jack_port_get_connections()](group__PortFunctions.html#gac1c942d03daee62ac6d0ed0ad044de43) in two important respects: 1) You may not call this function from code that is executed in response to a JACK event. For example, you cannot use it in a GraphReordered handler. 2) You need not be the owner of the port to get information about its connections. See also [jack_port_name_size()](group__PortFunctions.html#gabaebfd70bedfaecc834ebb02f4546eb1) ## ◆ jack_port_get_buffer() void* jack_port_get_buffer | ( | [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | , ---|---|---|--- | | [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) | | ) | | This returns a pointer to the memory area associated with the specified port. For an output port, it will be a memory area that can be written to; for an input port, it will be an area containing the data from the port's connection(s), or zero-filled. if there are multiple inbound connections, the data will be mixed appropriately. Do not cache the returned address across process() callbacks. Port buffers have to be retrieved in each callback for proper functionning. ## ◆ jack_port_get_connections() const char** jack_port_get_connections | ( | const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_| ) | ---|---|---|---|---|--- Returns a null-terminated array of full port names to which the _port_ is connected. If none, returns NULL. The caller is responsible for calling jack_free(3) on any non-NULL returned value. Parameters port| locally owned jack_port_t pointer. ---|--- See also [jack_port_name_size()](group__PortFunctions.html#gabaebfd70bedfaecc834ebb02f4546eb1), [jack_port_get_all_connections()](group__PortFunctions.html#ga4e1bd29a68acb4fb45f75931de0d36b2) ## ◆ jack_port_is_mine() int jack_port_is_mine | ( | const [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | , ---|---|---|--- | | const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_ | ) | | Returns TRUE if the jack_port_t belongs to the jack_client_t. ## ◆ jack_port_monitoring_input() int jack_port_monitoring_input | ( | [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_| ) | ---|---|---|---|---|--- Returns TRUE if input monitoring has been requested for _port_. ## ◆ jack_port_name() const char* jack_port_name | ( | const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_| ) | ---|---|---|---|---|--- Returns the full name of the jack_port_t (including the _"client_name:"_ prefix). See also [jack_port_name_size()](group__PortFunctions.html#gabaebfd70bedfaecc834ebb02f4546eb1). ## ◆ jack_port_name_size() int jack_port_name_size | ( | void | | ) | ---|---|---|---|---|--- Returns the maximum number of characters in a full JACK port name including the final NULL character. This value is a constant. A port's full name contains the owning client name concatenated with a colon (:) followed by its short name and a NULL character. ## ◆ jack_port_register() [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931)* jack_port_register | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | const char * | _port_name_ , | | const char * | _port_type_ , | | unsigned long | _flags_ , | | unsigned long | _buffer_size_ | ) | | Create a new port for the client. This is an object used for moving data of any type in or out of the client. Ports may be connected in various ways. Each port has a short name. The port's full name contains the name of the client concatenated with a colon (:) followed by its short name. The [jack_port_name_size()](group__PortFunctions.html#gabaebfd70bedfaecc834ebb02f4546eb1) is the maximum length of this full name. Exceeding that will cause the port registration to fail and return NULL. The _port_name_ must be unique among all ports owned by this client. If the name is not unique, the registration will fail. All ports have a type, which may be any non-NULL and non-zero length string, passed as an argument. Some port types are built into the JACK API, like JACK_DEFAULT_AUDIO_TYPE or JACK_DEFAULT_MIDI_TYPE Parameters client| pointer to JACK client structure. ---|--- port_name| non-empty short name for the new port (not including the leading _"client_name:"_). Must be unique. port_type| port type name. If longer than [jack_port_type_size()](group__PortFunctions.html#ga8acf71c319f50c5789f7454e4b6ef2e5), only that many characters are significant. flags| [JackPortFlags](types_8h.html#acbcada380e9dfdd5bff1296e7156f478) bit mask. buffer_size| must be non-zero if this is not a built-in _port_type_. Otherwise, it is ignored. Returns jack_port_t pointer on success, otherwise NULL. ## ◆ jack_port_rename() int jack_port_rename | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_ , | | const char * | _port_name_ | ) | | Modify a port's short name. May NOT be called from a callback handling a server event. If the resulting full name (including the _"client_name:"_ prefix) is longer than [jack_port_name_size()](group__PortFunctions.html#gabaebfd70bedfaecc834ebb02f4546eb1), it will be truncated. Returns 0 on success, otherwise a non-zero error code. This differs from [jack_port_set_name()](group__PortFunctions.html#ga1591ad5d2eb3a3d086f2624e006e8daf) by triggering PortRename notifications to clients that have registered a port rename handler. ## ◆ jack_port_request_monitor() int jack_port_request_monitor | ( | [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_ , ---|---|---|--- | | int | _onoff_ | ) | | If [JackPortCanMonitor](types_8h.html#acbcada380e9dfdd5bff1296e7156f478a0271c73ded98c373ebf8c5e59b51bb0c) is set for this _port_ , turn input monitoring on or off. Otherwise, do nothing. ## ◆ jack_port_request_monitor_by_name() int jack_port_request_monitor_by_name | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | const char * | _port_name_ , | | int | _onoff_ | ) | | If [JackPortCanMonitor](types_8h.html#acbcada380e9dfdd5bff1296e7156f478a0271c73ded98c373ebf8c5e59b51bb0c) is set for this _port_name_ , turn input monitoring on or off. Otherwise, do nothing. Returns 0 on success, otherwise a non-zero error code. See also [jack_port_name_size()](group__PortFunctions.html#gabaebfd70bedfaecc834ebb02f4546eb1) ## ◆ jack_port_set_alias() int jack_port_set_alias | ( | [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_ , ---|---|---|--- | | const char * | _alias_ | ) | | Set _alias_ as an alias for _port_. May be called at any time. If the alias is longer than [jack_port_name_size()](group__PortFunctions.html#gabaebfd70bedfaecc834ebb02f4546eb1), it will be truncated. After a successful call, and until JACK exits or [jack_port_unset_alias()](group__PortFunctions.html#ga51af66966211d2a81a749ab2f689872d) is called, may be used as a alternate name for the port. Ports can have up to two aliases - if both are already set, this function will return an error. Returns 0 on success, otherwise a non-zero error code. ## ◆ jack_port_set_name() int jack_port_set_name | ( | [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_ , ---|---|---|--- | | const char * | _port_name_ | ) | | Modify a port's short name. May be called at any time. If the resulting full name (including the _"client_name:"_ prefix) is longer than [jack_port_name_size()](group__PortFunctions.html#gabaebfd70bedfaecc834ebb02f4546eb1), it will be truncated. Returns 0 on success, otherwise a non-zero error code. ## ◆ jack_port_short_name() const char* jack_port_short_name | ( | const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_| ) | ---|---|---|---|---|--- Returns the short name of the jack_port_t (not including the _"client_name:"_ prefix). See also [jack_port_name_size()](group__PortFunctions.html#gabaebfd70bedfaecc834ebb02f4546eb1). ## ◆ jack_port_tie() int jack_port_tie | ( | [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _src_ , ---|---|---|--- | | [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _dst_ | ) | | **[Deprecated:](deprecated.html#_deprecated000004)** This function will be removed from a future version of JACK. Do not use it. There is no replacement. It has turned out to serve essentially no purpose in real-life JACK clients. ## ◆ jack_port_type() const char* jack_port_type | ( | const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_| ) | ---|---|---|---|---|--- Returns the _port_ type, at most [jack_port_type_size()](group__PortFunctions.html#ga8acf71c319f50c5789f7454e4b6ef2e5) characters including a final NULL. ## ◆ jack_port_type_get_buffer_size() size_t jack_port_type_get_buffer_size | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | const char * | _port_type_ | ) | | Returns the buffersize of a port of type * port_type. this function may only be called in a buffer_size callback. ## ◆ jack_port_type_size() int jack_port_type_size | ( | void | | ) | ---|---|---|---|---|--- Returns the maximum number of characters in a JACK port type name including the final NULL character. This value is a constant. ## ◆ jack_port_unregister() int jack_port_unregister | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | , ---|---|---|--- | | [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | | ) | | Remove the port from the client, disconnecting any existing connections. Returns 0 on success, otherwise a non-zero error code ## ◆ jack_port_unset_alias() int jack_port_unset_alias | ( | [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_ , ---|---|---|--- | | const char * | _alias_ | ) | | Remove _alias_ as an alias for _port_. May be called at any time. After a successful call, _alias_ can no longer be used as a alternate name for the port. Returns 0 on success, otherwise a non-zero error code. ## ◆ jack_port_untie() int jack_port_untie | ( | [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_| ) | ---|---|---|---|---|--- **[Deprecated:](deprecated.html#_deprecated000005)** This function will be removed from a future version of JACK. Do not use it. There is no replacement. It has turned out to serve essentially no purpose in real-life JACK clients. ## ◆ jack_port_uuid() [jack_uuid_t](types_8h.html#a346b785a201c9eb5a41a106f87829c9f) jack_port_uuid | ( | const [jack_port_t](types_8h.html#a91bf0f8fb0619705676136a7f5e3a931) * | _port_| ) | ---|---|---|---|---|--- Returns the UUID of the jack_port_t See also jack_uuid_to_string() to convert into a string representation * * * Generated by [![doxygen](doxygen.svg)](https://www.doxygen.org/index.html) 1.9.1 --- # Source: https://jackaudio.org/ JACK-AUDIO-CONNECTION-KIT --- * [Main Page](index.html) * [Related Pages](pages.html) * [Modules](modules.html) * [Data Structures](annotated.html) * [Files](files.html) * ![](search/mag_sel.svg) [![](search/close.svg)](javascript:searchBox.CloseResultsWindow\(\)) Data Structures | Typedefs | Enumerations | Enumerator | Functions | Variables Transport and Timebase control ## Data Structures --- struct | [jack_transport_info_t](structjack__transport__info__t.html) ## Typedefs --- typedef int(* | [JackSyncCallback](group__TransportControl.html#ga566f27eba84e0029eb05a631be52b2e5)) ([jack_transport_state_t](transport_8h.html#a66e50952a88eb087867922bfe3d0bd72) state, [jack_position_t](structjack__position__t.html) *pos, void *arg) typedef void(* | [JackTimebaseCallback](group__TransportControl.html#ga27ed5006f91b931408b11a5b31150af0)) ([jack_transport_state_t](transport_8h.html#a66e50952a88eb087867922bfe3d0bd72) state, [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) nframes, [jack_position_t](structjack__position__t.html) *pos, int new_pos, void *arg) ## Enumerations --- enum | [jack_transport_bits_t](group__TransportControl.html#ga230191365921fd425c389ed5eab18eef) { [JackTransportState](group__TransportControl.html#gga230191365921fd425c389ed5eab18eefa6da5504263d81baf27d53ce2e40e2e9d) = 0x1 , [JackTransportPosition](group__TransportControl.html#gga230191365921fd425c389ed5eab18eefa16f3fb237dea88a0ff61515efc2e6ec8) = 0x2 , [JackTransportLoop](group__TransportControl.html#gga230191365921fd425c389ed5eab18eefa1757aa4327bc7be2cea3f7d07a570896) = 0x4 , [JackTransportSMPTE](group__TransportControl.html#gga230191365921fd425c389ed5eab18eefa19f7f95e8c369e9a2bd91f1e7b75d8ec) = 0x8 , [JackTransportBBT](group__TransportControl.html#gga230191365921fd425c389ed5eab18eefac018587585c9420479978cd49154d02e) = 0x10 } ## Functions --- int | [jack_release_timebase](group__TransportControl.html#gaea06ff63b129ec6266b2b805b6c8216a) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_set_sync_callback](group__TransportControl.html#gae53f7ac54804d2896d51b6ad599fa93c) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, [JackSyncCallback](group__TransportControl.html#ga566f27eba84e0029eb05a631be52b2e5) sync_callback, void *arg) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_set_sync_timeout](group__TransportControl.html#ga2e89b0bb8702d34bcbbe1eac70685ab2) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, [jack_time_t](types_8h.html#af9a29b8728e95cc38e2932c0ef855b7e) timeout) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_set_timebase_callback](group__TransportControl.html#ga0c2f2f464f6ba1c0b2aa45e6507b7aa9) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, int conditional, [JackTimebaseCallback](group__TransportControl.html#ga27ed5006f91b931408b11a5b31150af0) timebase_callback, void *arg) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_transport_locate](group__TransportControl.html#gab3f52a42084aead87fd1ee75ed25b240) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) frame) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) [jack_transport_state_t](transport_8h.html#a66e50952a88eb087867922bfe3d0bd72) | [jack_transport_query](group__TransportControl.html#ga5f08eb71a5ee5431a3d756af5729d5aa) (const [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, [jack_position_t](structjack__position__t.html) *pos) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) | [jack_get_current_transport_frame](group__TransportControl.html#gaef1df9479faa3b7f400c787be173f805) (const [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) int | [jack_transport_reposition](group__TransportControl.html#ga2f371010358add3cbed8454bd0bd2ef8) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, const [jack_position_t](structjack__position__t.html) *pos) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) void | [jack_transport_start](group__TransportControl.html#gab7b158bec8f27c03da29795f142d1caf) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) void | [jack_transport_stop](group__TransportControl.html#ga6be6637c314bd88344826e9bcc1957b0) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client) [JACK_OPTIONAL_WEAK_EXPORT](weakmacros_8h.html#adf1bde0dd996bbf61a44311165014dd1) void | [jack_get_transport_info](group__TransportControl.html#ga994ea49b518181fbdee2adc9be1ee40e) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, [jack_transport_info_t](structjack__transport__info__t.html) *tinfo) JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT void | [jack_set_transport_info](group__TransportControl.html#gad27bdf22d5642f2291ba77d7bdb2725a) ([jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) *client, [jack_transport_info_t](structjack__transport__info__t.html) *tinfo) JACK_OPTIONAL_WEAK_DEPRECATED_EXPORT ## Variables --- [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) | [jack_transport_info_t::frame_rate](group__TransportControl.html#gab9dcc731355c88c22554ccd18fdcacc0) [jack_time_t](types_8h.html#af9a29b8728e95cc38e2932c0ef855b7e) | [jack_transport_info_t::usecs](group__TransportControl.html#gafa8d37eda78c4ce47469157674aaa7e3) [jack_transport_bits_t](group__TransportControl.html#ga230191365921fd425c389ed5eab18eef) | [jack_transport_info_t::valid](group__TransportControl.html#ga69fc58b6d2004fd243186255acc7292e) [jack_transport_state_t](transport_8h.html#a66e50952a88eb087867922bfe3d0bd72) | [jack_transport_info_t::transport_state](group__TransportControl.html#ga748678d245f92f396833cefaca67630c) [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) | [jack_transport_info_t::frame](group__TransportControl.html#ga7d823f347b9788095d6473dd4ffdf589) [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) | [jack_transport_info_t::loop_start](group__TransportControl.html#ga1ae73aca12a5e0404bf02f0aed497f02) [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) | [jack_transport_info_t::loop_end](group__TransportControl.html#ga9effad51f43ef06580217c2c92b3f78d) long | [jack_transport_info_t::smpte_offset](group__TransportControl.html#gad04a7477cc221e0dec25b0e207352a2e) float | [jack_transport_info_t::smpte_frame_rate](group__TransportControl.html#ga62b6bea05fdb499ca5945a5a32a64350) int | [jack_transport_info_t::bar](group__TransportControl.html#gaf2a616f6b626180ca1755ace9b47f25f) int | [jack_transport_info_t::beat](group__TransportControl.html#ga3aa1e26090cfefa28315dc3ea2570b84) int | [jack_transport_info_t::tick](group__TransportControl.html#ga45efc4128e2405f4f54c8b2340c064cd) double | [jack_transport_info_t::bar_start_tick](group__TransportControl.html#ga95bc4a23ed5feaf1f21b5655913c3695) float | [jack_transport_info_t::beats_per_bar](group__TransportControl.html#ga7129c362cf296e381ffd992bb70c5659) float | [jack_transport_info_t::beat_type](group__TransportControl.html#ga3a568f42b2597a1a8fe5c5681b832c2e) double | [jack_transport_info_t::ticks_per_beat](group__TransportControl.html#ga4d98a25dc59cf9c7beb203f32b911a51) double | [jack_transport_info_t::beats_per_minute](group__TransportControl.html#ga4505cb67b61179da4a9dd03b7137144e) ## Server-set fields --- these cannot be set from clients; the server sets them [jack_unique_t](transport_8h.html#af01026c6ef9eb9ef003ed23b6d8ada5f) | [jack_position_t::unique_1](group__TransportControl.html#ga2fe4e3ede6d03c170abce08f867f9bc7) [jack_time_t](types_8h.html#af9a29b8728e95cc38e2932c0ef855b7e) | [jack_position_t::usecs](group__TransportControl.html#ga08e43943a7153ecff15b0f8ba6517e95) [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) | [jack_position_t::frame_rate](group__TransportControl.html#gade3f7758360f5ec5432abaead67b553a) ## Mandatory fields --- [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) | [jack_position_t::frame](group__TransportControl.html#gab1d0fe08334f47b1aa8bb36ba722228f) [jack_position_bits_t](transport_8h.html#a64608154318de05af9e763bfb5fb8529) | [jack_position_t::valid](group__TransportControl.html#ga838c733e8006d1a0cc6921b4a132a8e4) ## JackPositionBBT fields --- Bar:Beat.Tick-related information. Applications that support JackPositionBBT are encouraged to also fill the JackBBTFrameOffset int32_t | [jack_position_t::bar](group__TransportControl.html#ga4f42cef08eb48a97a1b746698697d0de) int32_t | [jack_position_t::beat](group__TransportControl.html#gafb3f220fd87757095057abc152289110) int32_t | [jack_position_t::tick](group__TransportControl.html#ga9ba36f6c4eaede3bb1c9b7a85b5f76d1) double | [jack_position_t::bar_start_tick](group__TransportControl.html#ga67ff65ba02ba4146b1e46ce6d51ec644) float | [jack_position_t::beats_per_bar](group__TransportControl.html#gadc52988414544ba1b86429dad68c6260) float | [jack_position_t::beat_type](group__TransportControl.html#ga15383588a3fb97333204bc564cf1c06c) double | [jack_position_t::ticks_per_beat](group__TransportControl.html#ga08ca4c388c6460dcef82f03346ccbf52) double | [jack_position_t::beats_per_minute](group__TransportControl.html#ga657486be93ebcb20e3a1b45a91f30d33) ## JackPositionTimecode fields
--- EXPERIMENTAL: could change double | [jack_position_t::frame_time](group__TransportControl.html#gabd97b0d447281eebffa750c2b90e791d) double | [jack_position_t::next_time](group__TransportControl.html#ga83e65f9658fa4d93658cbad47d446b0b) [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) | [jack_position_t::bbt_offset](group__TransportControl.html#gae4bb9383734d2e7ca7758011102c03b2) float | [jack_position_t::audio_frames_per_video_frame](group__TransportControl.html#gaf28a3e9ee8b36a92309de372093f56f3) [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) | [jack_position_t::video_offset](group__TransportControl.html#gac03889456c88714ddf680784ee970d3b) ## JACK Extra transport fields --- double | [jack_position_t::tick_double](group__TransportControl.html#gabf43d666f71ba6a9dd7f81c68affce99) ## Other fields --- int32_t | [jack_position_t::padding](group__TransportControl.html#ga13b42068f5024ec6c29686de66647a73) [5] [jack_unique_t](transport_8h.html#af01026c6ef9eb9ef003ed23b6d8ada5f) | [jack_position_t::unique_2](group__TransportControl.html#ga9c3d31034160d5d2b9205eae9983e385) ## Detailed Description ## Typedef Documentation ## ◆ JackSyncCallback typedef int(* JackSyncCallback) ([jack_transport_state_t](transport_8h.html#a66e50952a88eb087867922bfe3d0bd72) state, [jack_position_t](structjack__position__t.html) *pos, void *arg) --- Prototype for the _sync_callback_ defined by [slow-sync clients](transport-design.html#slowsyncclients). When the client is active, this callback is invoked just before process() in the same thread. This occurs once after registration, then subsequently whenever some client requests a new position, or the transport enters the [JackTransportStarting](group__TransportControl.html#ga66e50952a88eb087867922bfe3d0bd72a8c1e22fce8ef6c18baf7a5c6a69060ac) state. This realtime function must not wait. The transport _state_ will be: * [JackTransportStopped](group__TransportControl.html#ga66e50952a88eb087867922bfe3d0bd72a30087dc754e67549d91e78a4242393f0) when a new position is requested; * [JackTransportStarting](group__TransportControl.html#ga66e50952a88eb087867922bfe3d0bd72a8c1e22fce8ef6c18baf7a5c6a69060ac) when the transport is waiting to start; * [JackTransportRolling](group__TransportControl.html#ga66e50952a88eb087867922bfe3d0bd72a4077d7d6fe566f3f0441755a588ad1b2) when the timeout has expired, and the position is now a moving target. Parameters state| current transport state. ---|--- pos| new transport position. arg| the argument supplied by [jack_set_sync_callback()](group__TransportControl.html#gae53f7ac54804d2896d51b6ad599fa93c). Returns TRUE (non-zero) when ready to roll. ## ◆ JackTimebaseCallback typedef void(* JackTimebaseCallback) ([jack_transport_state_t](transport_8h.html#a66e50952a88eb087867922bfe3d0bd72) state, [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) nframes, [jack_position_t](structjack__position__t.html) *pos, int new_pos, void *arg) --- Prototype for the _timebase_callback_ used to provide extended position information. Its output affects all of the following process cycle. This realtime function must not wait. This function is called immediately after process() in the same thread whenever the transport is rolling, or when any client has requested a new position in the previous cycle. The first cycle after [jack_set_timebase_callback()](group__TransportControl.html#ga0c2f2f464f6ba1c0b2aa45e6507b7aa9) is also treated as a new position, or the first cycle after [jack_activate()](group__ClientFunctions.html#ga9800d5b29bd7670d9944a15f6ea0ecf8) if the client had been inactive. The timebase master may not use its _pos_ argument to set _pos- >frame_. To change position, use [jack_transport_reposition()](group__TransportControl.html#ga2f371010358add3cbed8454bd0bd2ef8) or [jack_transport_locate()](group__TransportControl.html#gab3f52a42084aead87fd1ee75ed25b240). These functions are realtime-safe, the _timebase_callback_ can call them directly. Parameters state| current transport state. ---|--- nframes| number of frames in current period. pos| address of the position structure for the next cycle; _pos- >frame_ will be its frame number. If _new_pos_ is FALSE, this structure contains extended position information from the current cycle. If TRUE, it contains whatever was set by the requester. The _timebase_callback's_ task is to update the extended information here. new_pos| TRUE (non-zero) for a newly requested _pos_ , or for the first cycle after the _timebase_callback_ is defined. arg| the argument supplied by [jack_set_timebase_callback()](group__TransportControl.html#ga0c2f2f464f6ba1c0b2aa45e6507b7aa9). ## Enumeration Type Documentation ## ◆ jack_transport_bits_t enum [jack_transport_bits_t](group__TransportControl.html#ga230191365921fd425c389ed5eab18eef) --- Optional struct [jack_transport_info_t](structjack__transport__info__t.html) fields. See also [jack_position_bits_t](transport_8h.html#a64608154318de05af9e763bfb5fb8529). Enumerator --- JackTransportState | Transport state JackTransportPosition | Frame number JackTransportLoop | Loop boundaries (ignored) JackTransportSMPTE | SMPTE (ignored) JackTransportBBT | Bar, Beat, Tick ## Function Documentation ## ◆ jack_get_current_transport_frame() [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) jack_get_current_transport_frame | ( | const [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_| ) | ---|---|---|---|---|--- Return an estimate of the current transport frame, including any time elapsed since the last transport positional update. Parameters client| the JACK client structure ---|--- ## ◆ jack_get_transport_info() void jack_get_transport_info | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | [jack_transport_info_t](structjack__transport__info__t.html) * | _tinfo_ | ) | | Gets the current transport info structure (deprecated). Parameters client| the JACK client structure. ---|--- tinfo| current transport info structure. The "valid" field describes which fields contain valid data. **[Deprecated:](deprecated.html#_deprecated000018)** This is for compatibility with the earlier transport interface. Use [jack_transport_query()](group__TransportControl.html#ga5f08eb71a5ee5431a3d756af5729d5aa), instead. Precondition Must be called from the process thread. ## ◆ jack_release_timebase() int jack_release_timebase | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_| ) | ---|---|---|---|---|--- Called by the timebase master to release itself from that responsibility. If the timebase master releases the timebase or leaves the JACK graph for any reason, the JACK engine takes over at the start of the next process cycle. The transport state does not change. If rolling, it continues to play, with frame numbers as the only available position information. See also [jack_set_timebase_callback](group__TransportControl.html#ga0c2f2f464f6ba1c0b2aa45e6507b7aa9) Parameters client| the JACK client structure. ---|--- Returns 0 on success, otherwise a non-zero error code. ## ◆ jack_set_sync_callback() int jack_set_sync_callback | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | [JackSyncCallback](group__TransportControl.html#ga566f27eba84e0029eb05a631be52b2e5) | _sync_callback_ , | | void * | _arg_ | ) | | Register (or unregister) as a [slow-sync client](transport-design.html#slowsyncclients), that cannot respond immediately to transport position changes. The _sync_callback_ will be invoked at the first available opportunity after its registration is complete. If the client is currently active this will be the following process cycle, otherwise it will be the first cycle after calling [jack_activate()](group__ClientFunctions.html#ga9800d5b29bd7670d9944a15f6ea0ecf8). After that, it runs according to the [JackSyncCallback](group__TransportControl.html#ga566f27eba84e0029eb05a631be52b2e5) rules. Clients that don't set a _sync_callback_ are assumed to be ready immediately any time the transport wants to start. Parameters client| the JACK client structure. ---|--- sync_callback| is a realtime function that returns TRUE when the client is ready. Setting _sync_callback_ to NULL declares that this client no longer requires slow-sync processing. arg| an argument for the _sync_callback_ function. Returns 0 on success, otherwise a non-zero error code. ## ◆ jack_set_sync_timeout() int jack_set_sync_timeout | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | [jack_time_t](types_8h.html#af9a29b8728e95cc38e2932c0ef855b7e) | _timeout_ | ) | | Set the timeout value for [slow-sync clients](transport-design.html#slowsyncclients). This timeout prevents unresponsive slow-sync clients from completely halting the transport mechanism. The default is two seconds. When the timeout expires, the transport starts rolling, even if some slow-sync clients are still unready. The _sync_callbacks_ of these clients continue being invoked, giving them a chance to catch up. See also [jack_set_sync_callback](group__TransportControl.html#gae53f7ac54804d2896d51b6ad599fa93c) Parameters client| the JACK client structure. ---|--- timeout| is delay (in microseconds) before the timeout expires. Returns 0 on success, otherwise a non-zero error code. ## ◆ jack_set_timebase_callback() int jack_set_timebase_callback | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | int | _conditional_ , | | [JackTimebaseCallback](group__TransportControl.html#ga27ed5006f91b931408b11a5b31150af0) | _timebase_callback_ , | | void * | _arg_ | ) | | Register as timebase master for the JACK subsystem. The timebase master registers a callback that updates extended position information such as beats or timecode whenever necessary. Without this extended information, there is no need for this function. There is never more than one master at a time. When a new client takes over, the former _timebase_callback_ is no longer called. Taking over the timebase may be done conditionally, so it fails if there was a master already. The method may be called whether the client has been activated or not. Parameters client| the JACK client structure. ---|--- conditional| non-zero for a conditional request. timebase_callback| is a realtime function that returns position information. arg| an argument for the _timebase_callback_ function. Returns * 0 on success; * EBUSY if a conditional request fails because there was already a timebase master; * other non-zero error code. ## ◆ jack_set_transport_info() void jack_set_transport_info | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | [jack_transport_info_t](structjack__transport__info__t.html) * | _tinfo_ | ) | | Set the transport info structure (deprecated). **[Deprecated:](deprecated.html#_deprecated000019)** This function still exists for compatibility with the earlier transport interface, but it does nothing. Instead, define a [JackTimebaseCallback](group__TransportControl.html#ga27ed5006f91b931408b11a5b31150af0). ## ◆ jack_transport_locate() int jack_transport_locate | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) | _frame_ | ) | | Reposition the transport to a new frame number. May be called at any time by any client. The new position takes effect in two process cycles. If there are [slow-sync clients](transport-design.html#slowsyncclients) and the transport is already rolling, it will enter the [JackTransportStarting](group__TransportControl.html#ga66e50952a88eb087867922bfe3d0bd72a8c1e22fce8ef6c18baf7a5c6a69060ac) state and begin invoking their _sync_callbacks_ until ready. This function is realtime-safe. See also [jack_transport_reposition](group__TransportControl.html#ga2f371010358add3cbed8454bd0bd2ef8), [jack_set_sync_callback](group__TransportControl.html#gae53f7ac54804d2896d51b6ad599fa93c) Parameters client| the JACK client structure. ---|--- frame| frame number of new transport position. Returns 0 if valid request, non-zero otherwise. ## ◆ jack_transport_query() [jack_transport_state_t](transport_8h.html#a66e50952a88eb087867922bfe3d0bd72) jack_transport_query | ( | const [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | [jack_position_t](structjack__position__t.html) * | _pos_ | ) | | Query the current transport state and position. This function is realtime-safe, and can be called from any thread. If called from the process thread, _pos_ corresponds to the first frame of the current cycle and the state returned is valid for the entire cycle. Parameters client| the JACK client structure. ---|--- pos| pointer to structure for returning current transport position; _pos- >valid_ will show which fields contain valid data. If _pos_ is NULL, do not return position information. Returns Current transport state. ## ◆ jack_transport_reposition() int jack_transport_reposition | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_ , ---|---|---|--- | | const [jack_position_t](structjack__position__t.html) * | _pos_ | ) | | Request a new transport position. May be called at any time by any client. The new position takes effect in two process cycles. If there are [slow-sync clients](transport-design.html#slowsyncclients) and the transport is already rolling, it will enter the [JackTransportStarting](group__TransportControl.html#ga66e50952a88eb087867922bfe3d0bd72a8c1e22fce8ef6c18baf7a5c6a69060ac) state and begin invoking their _sync_callbacks_ until ready. This function is realtime-safe. See also [jack_transport_locate](group__TransportControl.html#gab3f52a42084aead87fd1ee75ed25b240), [jack_set_sync_callback](group__TransportControl.html#gae53f7ac54804d2896d51b6ad599fa93c) Parameters client| the JACK client structure. ---|--- pos| requested new transport position. Fill pos->valid to specify which fields should be taken into account. If you mark a set of fields as valid, you are expected to fill them all. Returns 0 if valid request, EINVAL if position structure rejected. ## ◆ jack_transport_start() void jack_transport_start | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_| ) | ---|---|---|---|---|--- Start the JACK transport rolling. Any client can make this request at any time. It takes effect no sooner than the next process cycle, perhaps later if there are [slow-sync clients](transport-design.html#slowsyncclients). This function is realtime-safe. See also [jack_set_sync_callback](group__TransportControl.html#gae53f7ac54804d2896d51b6ad599fa93c) Parameters client| the JACK client structure. ---|--- ## ◆ jack_transport_stop() void jack_transport_stop | ( | [jack_client_t](types_8h.html#a96cf103940d2ee71b141d4b9d0c116bf) * | _client_| ) | ---|---|---|---|---|--- Stop the JACK transport. Any client can make this request at any time. It takes effect on the next process cycle. This function is realtime-safe. Parameters client| the JACK client structure. ---|--- ## Variable Documentation ## ◆ audio_frames_per_video_frame float jack_position_t::audio_frames_per_video_frame --- number of audio frames per video frame. Should be assumed zero if JackAudioVideoRatio is not set. If JackAudioVideoRatio is set and the value is zero, no video data exists within the JACK graph ## ◆ bar [1/2] int32_t jack_position_t::bar --- current bar Should be >0: the first bar is bar '1'. ## ◆ bar [2/2] int jack_transport_info_t::bar --- ## ◆ bar_start_tick [1/2] double jack_position_t::bar_start_tick --- number of ticks that have elapsed between frame 0 and the first beat of the current measure. ## ◆ bar_start_tick [2/2] double jack_transport_info_t::bar_start_tick --- ## ◆ bbt_offset [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) jack_position_t::bbt_offset --- frame offset for the BBT fields (the given bar, beat, and tick values actually refer to a time frame_offset frames before the start of the cycle), should be assumed to be 0 if JackBBTFrameOffset is not set. If JackBBTFrameOffset is set and this value is zero, the BBT time refers to the first frame of this cycle. If the value is positive, the BBT time refers to a frame that many frames before the start of the cycle. ## ◆ beat [1/2] int32_t jack_position_t::beat --- current beat-within-bar Should be >0 and <=beats_per_bar: the first beat is beat '1'. ## ◆ beat [2/2] int jack_transport_info_t::beat --- ## ◆ beat_type [1/2] float jack_position_t::beat_type --- time signature "denominator" ## ◆ beat_type [2/2] float jack_transport_info_t::beat_type --- ## ◆ beats_per_bar [1/2] float jack_position_t::beats_per_bar --- time signature "numerator" ## ◆ beats_per_bar [2/2] float jack_transport_info_t::beats_per_bar --- ## ◆ beats_per_minute [1/2] double jack_position_t::beats_per_minute --- BPM, quantized to block size. This means when the tempo is not constant within this block, the BPM value should adapted to compensate for this. This is different from most fields in this struct, which specify the value at the beginning of the block rather than an average. ## ◆ beats_per_minute [2/2] double jack_transport_info_t::beats_per_minute --- ## ◆ frame [1/2] [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) jack_position_t::frame --- frame number, always present/required. This is the frame number on the transport timeline, which is not the same as what [jack_frame_time](group__TimeFunctions.html#ga45cec2e76db58e72b46339229de64697) returns. ## ◆ frame [2/2] [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) jack_transport_info_t::frame --- ## ◆ frame_rate [1/2] [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) jack_position_t::frame_rate --- current frame rate, in frames per second ## ◆ frame_rate [2/2] [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) jack_transport_info_t::frame_rate --- current frame rate (per second) ## ◆ frame_time double jack_position_t::frame_time --- current time in seconds ## ◆ loop_end [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) jack_transport_info_t::loop_end --- ## ◆ loop_start [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) jack_transport_info_t::loop_start --- ## ◆ next_time double jack_position_t::next_time --- next sequential frame_time (unless repositioned) ## ◆ padding int32_t jack_position_t::padding[5] --- ## ◆ smpte_frame_rate float jack_transport_info_t::smpte_frame_rate --- 29.97, 30, 24 etc. ## ◆ smpte_offset long jack_transport_info_t::smpte_offset --- SMPTE offset (from frame 0) ## ◆ tick [1/2] int32_t jack_position_t::tick --- current tick-within-beat Should be >= 0 and < ticks_per_beat: the first tick is tick '0'. ## ◆ tick [2/2] int jack_transport_info_t::tick --- ## ◆ tick_double double jack_position_t::tick_double --- current tick-within-beat in double resolution. Should be assumed zero if JackTickDouble is not set. Since older versions of JACK do not expose this variable, the macro JACK_TICK_DOUBLE is provided, which can be used as build-time detection. ## ◆ ticks_per_beat [1/2] double jack_position_t::ticks_per_beat --- number of ticks within a beat. Usually a moderately large integer with many denominators, such as 1920.0 ## ◆ ticks_per_beat [2/2] double jack_transport_info_t::ticks_per_beat --- ## ◆ transport_state [jack_transport_state_t](transport_8h.html#a66e50952a88eb087867922bfe3d0bd72) jack_transport_info_t::transport_state --- ## ◆ unique_1 [jack_unique_t](transport_8h.html#af01026c6ef9eb9ef003ed23b6d8ada5f) jack_position_t::unique_1 --- unique ID ## ◆ unique_2 [jack_unique_t](transport_8h.html#af01026c6ef9eb9ef003ed23b6d8ada5f) jack_position_t::unique_2 --- unique ID ## ◆ usecs [1/2] [jack_time_t](types_8h.html#af9a29b8728e95cc38e2932c0ef855b7e) jack_position_t::usecs --- microsecond timestamp that is guaranteed to be monotonic, but not neccessarily linear. The absolute value is implementation-dependent (i.e. it could be wall-clock, time since jack started, uptime, etc). ## ◆ usecs [2/2] [jack_time_t](types_8h.html#af9a29b8728e95cc38e2932c0ef855b7e) jack_transport_info_t::usecs --- monotonic, free-rolling ## ◆ valid [1/2] [jack_position_bits_t](transport_8h.html#a64608154318de05af9e763bfb5fb8529) jack_position_t::valid --- which other fields are valid, as a bitmask constructed from values in [jack_position_bits_t](transport_8h.html#a64608154318de05af9e763bfb5fb8529) ## ◆ valid [2/2] [jack_transport_bits_t](group__TransportControl.html#ga230191365921fd425c389ed5eab18eef) jack_transport_info_t::valid --- which fields are legal to read ## ◆ video_offset [jack_nframes_t](types_8h.html#aa954df532e901ae5172e68a23f3da9b6) jack_position_t::video_offset --- audio frame at which the first video frame in this cycle occurs. Should be assumed to be 0 if JackVideoFrameOffset is not set. If JackVideoFrameOffset is set, but the value is zero, there is no video frame within this cycle. * * * Generated by [![doxygen](doxygen.svg)](https://www.doxygen.org/index.html) 1.9.1 --- # Source: https://jackaudio.org/ JACK-AUDIO-CONNECTION-KIT --- * [Main Page](index.html) * [Related Pages](pages.html) * [Modules](modules.html) * [Data Structures](annotated.html) * [Files](files.html) * ![](search/mag_sel.svg) [![](search/close.svg)](javascript:searchBox.CloseResultsWindow\(\)) JACK Audio Connection Kit # Introduction JACK is a low-latency audio server, written for any operating system that is reasonably POSIX compliant. It currently exists for Linux, OS X, Solaris, FreeBSD and Windows. It can connect several client applications to an audio device, and allow them to share audio with each other. Clients can run as separate processes like normal applications, or within the JACK server as "plugins". JACK was designed from the ground up for professional audio work, and its design focuses on two key areas: synchronous execution of all clients, and low latency operation. See also # JACK Overview Traditionally it has been hard if not impossible to write audio applications that can share data with each other. In addition, configuring and managing audio interface hardware has often been one of the most complex aspect of writing audio software. JACK changes all this by providing an API that does several things: 1. provides a high level abstraction for programmers that removes the audio interface hardware from the picture and allows them to concentrate on the core functionality of their software. 2. allows applications to send and receive audio data to/from each other as well as the audio interface. There is no difference in how an application sends or receives data regardless of whether it comes from/goes to another application or an audio interface. For programmers with experience of several other audio APIs such as PortAudio, Apple's CoreAudio, Steinberg's VST and ASIO as well as many others, JACK presents a familiar model: your program provides a "callback" function that will be executed at the right time. Your callback can send and receive data as well as do other signal processing tasks. You are not responsible for managing audio interfaces or threading, and there is no "format negotiation": all audio data within JACK is represented as 32 bit floating point values. For those with experiences rooted in the Unix world, JACK presents a somewhat unfamiliar API. Most Unix APIs are based on the read/write model spawned by the "everything is a file" abstraction that Unix is rightly famous for. The problem with this design is that it fails to take the realtime nature of audio interfaces into account, or more precisely, it fails to force application developers to pay sufficient attention to this aspect of their task. In addition, it becomes rather difficult to facilitate inter-application audio routing when different programs are not all running synchronously. Using JACK within your program is very simple, and typically consists of just: * calling [jack_client_open()](group__ClientFunctions.html#gabbd2041bca191943b6ef29a991a131c5) to connect to the JACK server. * registering "ports" to enable data to be moved to and from your application. * registering a "process callback" which will be called at the right time by the JACK server. * telling JACK that your application is ready to start processing data. There is a lot more that you can do with JACK's interfaces, but for many applications, this is all that is needed. The simple_client.c example demonstrates a complete (simple!) JACK application that just copies the signal arriving at its input port to its output port. Similarly, inprocess.c shows how to write an internal client "plugin" that runs within the JACK server process. # Reference The JACK programming interfaces are described in several header files. We present them here broken into useful categories to make the API a little clearer: * [Creating & manipulating clients](group__ClientFunctions.html) * [Setting Client Callbacks](group__ClientCallbacks.html) * [Creating and managing client threads](group__ClientThreads.html) * [Controlling & querying JACK server operation](group__ServerControl.html) * [Creating & manipulating ports](group__PortFunctions.html) * [Looking up ports](group__PortSearching.html) * [Managing and determining latency](group__LatencyFunctions.html) * [Handling time](group__TimeFunctions.html) * [Transport and Timebase control](group__TransportControl.html) * [Controlling error/information output](group__ErrorOutput.html) * [The non-callback API](group__NonCallbackAPI.html) * [Reading and writing MIDI data](group__MIDIAPI.html) * [Session API for clients.](group__SessionClientFunctions.html) * [managing support for newer/older versions of JACK](group__WeakLinkage.html) * [the API for starting and controlling a JACK server](group__ControlAPI.html) * [Metadata API.](group__Metadata.html) The full API is described in: * [](jack_8h.html) is the main JACK interface. * [](statistics_8h.html) provides interfaces for monitoring the performance of a running JACK server. * [](intclient_8h.html) allows loading and unloading JACK internal clients. * [](ringbuffer_8h.html) defines a simple API for using lock-free ringbuffers. These are a good way to pass data between threads, when streaming realtime data to slower media, like audio file playback or recording. * [](transport_8h.html) defines a simple transport control mechanism for starting, stopping and repositioning clients. This is described in the [JACK Transport Design](transport-design.html) document. * [](types_8h.html) defines the main JACK data types. * [](thread_8h.html) functions standardize thread creation for JACK and its clients. * [](midiport_8h.html) functions to handle reading and writing of MIDI data to a port * [](session_8h.html) functions that form the JACK session API * [](control_8h.html) the API for starting and controlling a JACK server * [](metadata_8h.html) the API for managing metadata about objects within JACK (clients and ports) In addition, the tools directory provides numerous examples of simple JACK clients that nevertheless use the API to do something useful. It includes * a metronome. * a recording client that can capture any number of channels from any JACK sources and store them as an audio file. * command line clients to control the transport mechanism, change the buffer size and more. * commands to load and unload JACK internal clients. * tools for checking the status of a running JACK system. and many more. # Porting JACK is designed to be portable to any system supporting the relevant POSIX and ANSI C standards. It currently runs under GNU/Linux, Mac OS X and Berkeley Unix on several different processor architectures. If you want to port JACK to another platform, please read the [Porting JACK](porting-guide.html) document. # License Copyright (C) 2001-2019 by Paul Davis, Stephane Letz, Jack O'Quinn, Torben Hohn, Filipe Coelho and others. JACK is free software; you can redistribute it and/or modify it under the terms of the GNU GPL and LGPL licenses as published by the Free Software Foundation, . The JACK server uses the GPL, as noted in the source file headers. However, the JACK library is licensed under the LGPL, allowing proprietary programs to link with it and use JACK services. You should have received a copy of these Licenses along with the program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. * * * Generated by [![doxygen](doxygen.svg)](https://www.doxygen.org/index.html) 1.9.1 --- # Source: https://jackaudio.org/ JACK-AUDIO-CONNECTION-KIT --- * [Main Page](index.html) * [Related Pages](pages.html) * [Modules](modules.html) * [Data Structures](annotated.html) * [Files](files.html) * ![](search/mag_sel.svg) [![](search/close.svg)](javascript:searchBox.CloseResultsWindow\(\)) Modules Here is a list of all modules: [detail level 123456789] [the API for starting and controlling a JACK server](group__ControlAPI.html)| ---|--- ▼[Creating & manipulating clients](group__ClientFunctions.html)| ▼[The non-callback API](group__NonCallbackAPI.html)| ▼[Setting Client Callbacks](group__ClientCallbacks.html)| ▼[Controlling & querying JACK server operation](group__ServerControl.html)| ▼[Creating & manipulating ports](group__PortFunctions.html)| ▼[Managing and determining latency](group__LatencyFunctions.html)| ▼[Looking up ports](group__PortSearching.html)| ▼[Handling time](group__TimeFunctions.html)| [Controlling error/information output](group__ErrorOutput.html)| [Metadata API.](group__Metadata.html)| [Reading and writing MIDI data](group__MIDIAPI.html)| [Session API for clients.](group__SessionClientFunctions.html)| [API for a session manager.](group__JackSessionManagerAPI.html)| [Creating and managing client threads](group__ClientThreads.html)| [Transport and Timebase control](group__TransportControl.html)| [managing support for newer/older versions of JACK](group__WeakLinkage.html)| * * * Generated by [![doxygen](doxygen.svg)](https://www.doxygen.org/index.html) 1.9.1 --- # Source: https://jackaudio.org/ JACK-AUDIO-CONNECTION-KIT --- * [Main Page](index.html) * [Related Pages](pages.html) * [Modules](modules.html) * [Data Structures](annotated.html) * [Files](files.html) * ![](search/mag_sel.svg) [![](search/close.svg)](javascript:searchBox.CloseResultsWindow\(\)) Related Pages Here is a list of all related documentation pages: [JACK Transport Design](transport-design.html)| ---|--- [Porting JACK](porting-guide.html)| [Deprecated List](deprecated.html)| * * * Generated by [![doxygen](doxygen.svg)](https://www.doxygen.org/index.html) 1.9.1 --- # Source: https://jackaudio.org/ --- title: "Applications" --- ## Audio File Editors * [**Audacity**](http://audacity.sourceforge.net/) is a cross-platform multitrack audio editor. Please read [this post](https://web.archive.org/web/20150511071618/https://music.columbia.edu/pipermail/linux-audio-user/2005-July/024519.html) for instructions on how to get Jackaudio and Audacity working together. * [**gi_editor**](https://github.com/kmtaylor/gi_editor) is a software editor for the [**Juno Gi**](http://www.roland.com/products/en/JUNO-Gi/), based on Roland's midi specification. * [**Gnusound**](http://www.gnu.org/software/gnusound) is a multitrack sound editor for GNOME 1 and 2. * [**Marlin**](http://live.gnome.org/Marlin) is a sample editor. * [**mhWaveEdit**](https://gna.org/projects/mhwaveedit) a graphical audio editor. * [**ReZound**](http://rezound.sourceforge.net/) a graphical audio editor. Version 0.7.0 or above. * [**sauditor**](http://dis-dot-dat.net/index.cgi?item=/code/sauditor) a simple sample auditor. * [**snd**](http://ccrma.stanford.edu/software/snd) a sound editor. * [**snd-ls**](http://ccrma.stanford.edu/~kjetil/src) is a distribution of Bill Schottstaedt's sound editor SND. Its target are people that don't know scheme very well, and don't want to spend too much time configuring Snd. * [**Swami**](http://swami.sourceforge.net/) is an advanced instrument editor for MIDI music composition and a software synthesizer frontend. ## Control Applications * [**Aj-snapshot**](http://aj-snapshot.sourceforge.net/) is a small program that can be used to make snapshots of the connections made between JACK and/or ALSA clients. It is also capable of running in the background, restoring connections while clients and ports appear. * [**ALSA Patch Bay**](http://pkl.net/~node/software/alsa-patch-bay) is a graphical patch bay for the ALSA sequencer API and the JACK audio API. It can use FLTK or GTKmm for the interface and take advantage LASH session management. * [**gjacktransport**](http://gjacktransport.sourceforge.net/) is a standalone application that provides access to the JACK transport mechanism via a dynamic graphical slider. * [**njconnect**](http://sourceforge.net/projects/njconnect/) is a curses Jack connection manager, based on naconnect by [**Nedko Arnaudov**](http://nedko.arnaudov.name/). * [**patchage**](http://drobilla.net/software/patchage/) is a modular patch bay for audio and MIDI systems based on Jack and Alsa. * [**pyjack**](http://sourceforge.net/projects/py-jack/) is a Python module which provides an interface to Jack. * [**QJackConnect**](http://www.suse.de/~mana/jack.html) is a Qt based patchbay for JACK * [**QjackCtl**](http://qjackctl.sourceforge.net/) is a Qt based graphical control application for JACK with routing capabilities. * [**Cadence (KXStudio)**](http://kxstudio.sourceforge.net/Applications:Cadence) manages JACK, calls other tools and also checks and tweaks the system. * [**Catarina(KXStudio)**](http://kxstudio.sourceforge.net/Applications:Catarina) is a JACK Patchbay similar to Patchage that supports JACK Transport. * [**Claudia (KXStudio)**](http://kxstudio.sourceforge.net/Applications:Claudia) is a LADISH frontend. * [**Jack Sanity**](https://github.com/psychoticmeow/jack-sanity) is a scriptable environment for controlling jackdbus clients. * [**PatchMatrix**](https://github.com/OpenMusicKontrollers/patchmatrix) is a standalone JACK patch bay with metadata support in matrix layout. ## DJ Software * [**DJPlay**](http://djplay.sourceforge.net/) a dual player designed for the live DJ. * [**Mixxx**](http://mixxx.sourceforge.net/) a digital DJ system, for wave, ogg and mp3 files. * [**xwax**](http://www.xwax.co.uk/) is open-source vinyl emulation software for Linux. ## Effects Processors * [**arcangel**](http://dis-dot-dat.net/index.cgi?item=/code/arcangel/) is a Jack effect and LADSPA plugin for arctan distortion. * [**Bristol Synthesizer Emulator**](http://bristol.sourceforge.net/) application. The latest version uses Jack. * [**BruteFIR**](https://torger.se/anders/brutefir.html) a software convolution engine. * [**CP-GFX**](http://cp-gfx.sourceforge.net/) Guitar effects processor. * [**creox**](https://github.com/laudrup/Creox4) a realtime sound processor. * [**DSSI**](http://dssi.sourceforge.net/) is an API for audio processing plugins, particularly useful for software synthesis plugins with user interfaces. * [**freqtweak**](http://freqtweak.sourceforge.net/) a frequency domain FX box. This is one of the coolest FX boxes you may ever use. * [**Guitarix**](http://guitarix.sourceforge.net/) is a simple Linux amplifier with one input and two outputs. * [**IEM Plug-in Suite**](https://plugins.iem.at/) is a set of VST-plugins (with a DAW independent standalone-mode) for Ambisonics sound field encoding, analysis, processing and decoding. * [**jackEQ**](https://sourceforge.net/projects/jackeq/) a tool for routing and manipulating audio from/to multiple input/output sources. ([An archived copy of the original (now dead) project site](https://web.archive.org/web/20190830084309/http://djcj.org/jackeq/) is available.) * [**JAMin**](http://jamin.sourceforge.net/) the state-of-the-art realtime mastering processor. * [**linuxDSP**](http://www.linuxdsp.co.uk/) provides 'plugin' audio processing software for linux. * [**Louderbox**](http://nixbit.com/cat/multimedia/audio/louderbox/) an 8 band audio processor. * [**Rakarrack**](http://rakarrack.sourceforge.net/) is a guitar effects processor that is easy to use, but it contains features that make it unique in this field of applications. * [**RedFX**](http://sourceforge.net/projects/astylredfx) is an effects processor mainly for guitars. * [**ReTiSAR**](https://github.com/AppliedAcousticsChalmers/ReTiSAR) is a binaural renderer for live-streamed, recorded or measurement-based spherical microphone array signals. * [**SoundScape Renderer**](http://spatialaudio.net/ssr/) is a tool for real-time spatial audio rendering providing a variety of rendering algorithms such as WFS and binaural. * [**tapiir**](http://www.resorama.com/maarten/files) is an audio effects processor inspired by the classical magnetic tape delay systems. Version 0.7.0 or above. ##### Legacy (effects processors) * [**Ecamegapedal**](https://web.archive.org/web/20130606111504/http://www.eca.cx:80/ecamegapedal/) was a real-time effect processor. ## Graphics Applications * [**Blender**](http://www.blender.org/) is the free open source 3D content creation suite. Currently, Blender 2.50a1 and above use Jack. * [**fluxus**](http://www.pawfal.org/fluxus) is a graphical live coding environment for Scheme. Builds for Linux or OSX, and released under the GPL licence. * [**Le Biniou**](http://biniou.net/) is a program which creates images from sound, in an intelligent way. * [**Sonify**](http://mrkrbrts.com/blog) iterates pixel-by-pixel through an image, encoding each pixel's hue and luminance values as a waveform of a particular frequency and amplitude. * [**VisualJackM**](https://bitbucket.org/asiniscalchi/visualjackm) lets you connect [ProjectM](http://projectm.sourceforge.net/) to Jack. ## Live Loopers * [**Freewheeling**](https://github.com/free-wheeling/freewheeling) a live looping instrument. * [**Giada**](http://www.monocasual.com/giada/) is a free, minimal, hardcore audio tool for djs and live performers. * [**Loopcenter**](http://loopcenter.sourceforge.net/) is an easy-to-use live looper with functionality similar to the Boss LoopStation pedal. You can record and overdub at user-set tempos and meters. * [**SooperLooper**](http://essej.net/sooperlooper) a live looping sampler capable of immediate loop recording, overdubbing, multiplying, reversing and more. ## Media Players * [**AlsaPlayer**](http://alsaplayer.sourceforge.net/) a "new type of pcm player". Can play mp3s, oggs, cds, among other audio file formats. Thanks go to Andy Lo-A-Foe for releasing the first application with support for Jack! * [**Aqualung**](http://aqualung.sourceforge.net/) It plays audio files from your filesystem and has the feature of inserting no gaps between adjacent tracks * [**Audacious**](http://audacious-media-player.org/) is a fork of beep-media-player 0.9.7.1 * [**Data Jockey**](http://x37v.info/datajockey) is a digital disc jockey tool which leverages audio meta-data (both computed and manually added by the user) in order to allow for new approaches in content selection and juxtaposition. * [**kluppe**](http://kluppe.klingt.org/) a gtk-based loop player for files and live-input. * [**MadJack**](http://www.aelius.com/njh/madjack/) is an MPEG Audio Deck with an [**OSC**](http://www.opensoundcontrol.org/) based control interface. * [**MOC**](http://moc.daper.net/) Music On Console is a console audio player for LINUX/UNIX, designed to be powerful and easy to use. * [**MPlayer**](http://www.mplayerhq.hu/) a movie player. * [**Qmmp**](http://code.google.com/p/qmmp/) is a Qt-based media player with a similar UI as XMMS or Winamp. * [**Tttrigger**](http://sourceforge.net/projects/tttrigger) is a program for playing sound effects in connection with a theater or other show. * [**veejay**](http://www.veejayhq.net/) a visual 'music' instrument. * [**VLC**](http://www.videolan.org/vlc) is a highly portable multimedia player for various audio and video formats (MPEG-1, MPEG-2, MPEG-4, DivX, mp3, ogg, ...) as well as DVDs, VCDs, and various streaming protocols. * [**xmms-jack**](http://xmms-jack.sourceforge.net/) an XMMS audio output plugin for jack. ## Metering and Analysis * [**Baudline**](http://www.baudline.com/) is a time-frequency browser designed for scientific visualization of the spectral domain. * [**Brianalyze**](http://humanleg.org.uk/code/brianalyze/) is a pretty simple JACK-connected spectrum analyzer * [**BRP-PACU**](http://sourceforge.net/projects/brp-pacu) is a dual channel FFT based acoustic analysis tool to help engineers configure professional sound systems by using the transfer function. * [**Ebumeter**](http://kokkinizita.linuxaudio.org/linuxaudio/ebumeter-doc/quickguide.html) provides level metering according to the EBU R-128 recommendation. The current release implements all features required by the EBU document except the oversampled peak level monitoring. This will be added in a future release. * [**Jaaa**](http://kokkinizita.linuxaudio.org/linuxaudio/index.html) an audio signal generator and spectrum analyser. * [**JACK demolition**](http://plugin.org.uk/releases/jack-demolition) a very simple jack client that connects to every input port and squirts undesirable numbers (denomals, HUGE, NaN, Inf etc.) to it. * [**Jack Meter**](http://www.aelius.com/njh/jackmeter/) is a basic console based DPM (Digital Peak Meter). * [**japa**](http://kokkinizita.linuxaudio.org/linuxaudio/index.html) is a 'perceptual' or 'psychoacoustic' audio spectrum analyser. * [**Loudspeaker Frequency Allocator**](http://www.thuneau.com/allocator.htm) is a 4-way, stereo DSP loudspeaker crossover that works with ASIO compatible multichannel sound cards on a Windows XP computer. Jack4win [instructions can be found here.](http://www.thuneau.com/forum/viewtopic.php?t=168) * [**meterbridge**](http://plugin.org.uk/meterbridge) a nice VU-style meter to watch signal levels on arbitrary JACK ports. * [**Sonic Visualiser**](http://www.sonicvisualiser.org/) is an application for viewing and analysing the contents of music audio files. * [**Tap Reverb Editor**](http://tap-plugins.sourceforge.net/reverbed.html) an interactive tool for room acoustics simulation. ## Mixers * [**jack_mixer**](http://home.gna.org/jackmixer) is a GTK+JACK audio mixer app with a look similar to its hardware counterpart. It has lots of useful features, apart from being able to mix multiple JACKaudio streams. * [**JackMiniMix**](http://www.aelius.com/njh/jackminimix) is a simple mixer with an [**OSC**](http://www.opensoundcontrol.org/) based control interface. * [**JackMix**](http://www.arnoldarts.de/jackmix/) is a Jack mixer. * [**The Non Mixer**](http://non-mixer.tuxfamily.org/) is a powerful, reliable and fast modular Digital Audio Mixer. ##### Legacy (mixers) * [**JackMaster**](http://69b.org/cms/jackmaster) was a Master Console. ## Multi-track sequencers and HDR systems * [**ardour**](http://ardour.org/) a multichannel hard disk recorder and digital audio workstation. * [**dino**](http://dino.nongnu.org/) is a pattern based MIDI sequencer * [**ecasound**](http://eca.cx/ecasound) a "software package designed for multitrack audio processing". Check the original release announcement here. * [**Jackbeat**](http://jackbeat.samalyse.org/) is an audio sequencer. * [**LinuxBand**](http://linuxband.org/) is a GUI front-end for MMA (Musical MIDI Accompaniment). Type in the chords, choose the groove and LinuxBand will play a musical accompaniment for you. * [**LMMS**](http://lmms.sourceforge.net/) is a free cross-platform alternative to commercial programs like FL Studio®, which allow you to produce music with your computer. * [**MusE**](http://muse-sequencer.org/) a MIDI/Audio sequencer with recording and editing capabilities. * [**OpenOctaveMidi**](http://www.openoctave.org/) is a linux-based classic midi/audio sequencer with a look and feel, users will find in commercial equivalents. * [**Qtractor**](http://qtractor.sourceforge.net/qtractor-index.html) is an Audio/MIDI multi-track sequencer application written in C++ around the Qt4 toolkit. * [**quincer**](http://very.busted.systems/quincer) is a sequencer for composed music with text-editable input. * [**Renoise**](http://www.renoise.com/) is a contemporary digital audio workstation (DAW) based upon the heritage and development of tracker software. Its primary use is the composition of music using sound samples, soft synths, and effects plug-ins. It is also able to interface with MIDI equipment. * [**Rosegarden**](http://www.rosegardenmusic.com/) a sophisticated MIDI (and audio) sequencer and notation editor * [**The Non DAW**](http://non-daw.tuxfamily.org/) is a powerful, reliable and fast modular Digital Audio Workstation system. * [**The Non Sequencer**](http://non-sequencer.tuxfamily.org/) is a powerful real-time, pattern-based MIDI sequencer for Linux. * [**Traverso**](http://traverso-daw.org/) is a GPL licensed, cross platform multitrack audio recording and editing suite, with an innovative and easy to master User Interface. It's suited for both the professional and home user, who needs a robust and solid DAW. * [**Wired**](http://wired.sourceforge.net/) a music production and creation software. * [**Bitwig Studio**](http://www.bitwig.com/) Bitwig Studio is dynamic software for creation and performance of your musical ideas on stage or in the studio. * [**Zrythm**](http://www.zrythm.org/) a digital audio workstation designed to be featureful and easy to use. ## Music Notation Editors * [**Denemo**](http://denemo.org/) is a music notation editor that lets you rapidly enter notation for typesetting via the LilyPond music engraver. You can compose, transcribe, arrange, listen to the music and much more. * [**MuseScore**](http://musescore.org/) lets you notate and compose music easily with your keyboard, your mouse, or a MIDI keyboard. ## Plugin Hosts * [**Carla (KXStudio)**](http://kxstudio.sourceforge.net/Applications:Carla) is an audio plugin host. * [**FSTHOST**](http://sourceforge.net/projects/fsthost/) is a linux VST host - hybrid using winelib. Runs as a Jack client for Audio/MIDI, and with GTK GUI. * [**JACK Rack**](http://jack-rack.sourceforge.net/) a LADSPA effects rack for jack. * [**jackspa**](http://code.google.com/p/jackspa/) is a small utility which will host a LADSPA plugin, providing JACK ports for its audio inputs and outputs. * [**jost**](http://www.anticore.org/jucetice/?page_id=4) is a host for native linux vst plugins (jack / alsa_seq). * [**ng-jackspa**](https://gna.org/projects/ngjackspa) is a set of simple user interfaces that host a LADSPA plugin, providing JACK ports for its audio inputs and outputs, and dynamic setting of its control inputs. Additionally, the plugin controls can be exported to or controlled by control voltages on standard JACK audio ports. * [**Soundtank**](http://sourceforge.net/projects/soundtank) a midi controlled host for softsynths made out of LADSPA plugins. * [**Synthpod**](http://open-music-kontrollers.ch/lv2/synthpod) is a lightweight non-linear plugin container. ## Programming Libraries * [**Allegro**](http://alleg.sourceforge.net/) a game programming library. * [**Clam**](http://clam-project.org/) is a multiplatform software framework for research and application development for the Audio and Music domains. * [**FAUST**](http://faust.grame.fr/) is a compiled language for real-time audio signal processing. * [**GTKIOStream**](http://sourceforge.net/projects/gtkiostream/) provides allows easy use of JACK within GTK apps and has many other tools for DSP, Audio Masking, FFTs and plotting data. * [**jackcpp**](http://x37v.info/projects/jackcpp) is a C++ class wrapping most of the jack client functionality, a "blocking" interface for jack and a template class wrapping the jack ring buffer. * [**libjackasyn**](http://packages.debian.org/source/stable/libjackasyn) is a library that allows to access the jack audio server in asynchronous mode. * [**libjackmm**](http://sourceforge.net/projects/libjackmm) is a C++ interface to the jack audio connection kit. * [**Praxis Live**](http://www.praxislive.org/) is an hybrid visual live programming for creatives, for programmers, for students, for tinkerers. * [**Pure Data**](http://puredata.info/) is a real-time graphical programming environment for audio, video, and graphical processing. * [**Qjack**](https://bitbucket.org/asiniscalchi/qjack) allows you to connect Jack to QT very easily. * [**RtAudio**](http://www.music.mcgill.ca/~gary/rtaudio) is a set of C++ classes that provide a common API (Application Programming Interface) for realtime audio input/output. * [**Wine**](http://www.winehq.com/) an application that lets you run and recompile Windows applications under Linux. ## Language Bindings ### C# * [**JackSharp**](https://github.com/residuum/JackSharp) is a .NET and Mono API for JACK. * [**NAudio.Jack**](https://github.com/residuum/JackSharp) is a binding of JackSharp for NAudio, a .NET audio library. * [**luajack**](https://github.com/stetre/luajack) is a Lua bindings for JACK. ### Go * [**go-jack**](https://github.com/xthexder/go-jack) ### haskell * [**jack**](http://hackage.haskell.org/package/jack) ### Java * [**JNAJack**](https://github.com/jaudiolibs/jnajack) an alternative Java bridge API for JACK. Provides a more direct mapping of JACK functions, and supports all platforms that JACK runs on. ### Python * [**jackclient-python**](https://jackclient-python.readthedocs.io/) * [**PyJack**](http://sourceforge.net/projects/py-jack/) a Python module which provides an interface to Jack. ### Rust * [**RustAudio/rust-jack**](https://github.com/RustAudio/rust-jack) ## Radio * [**admin-srb**](https://github.com/srb-fm/admin-srb) Administration and radioautomation of public radiostations * [**ARAS**](http://aras.sourceforge.net/) is an open source radio automation system, it has been designed to be highly configurable and easy to manage. It uses JACK through GStreamer library, in both playback and recording. * [**Internet DJ Console**](http://idjc.sourceforge.net/) is an Internet radio app for making a live radio show or podcast. * [**JMPX**](http://homepages.paradise.net.nz/peterfr2/jmpxencoder/jmpx.html) is a software-based FM stereo encoder. * [**J-QAM**](http://homepages.paradise.net.nz/peterfr2/QAM.htm) is a QAM soundcard modem. * [**Rivendell**](http://www.rivendellaudio.org/) an audio automation system aimed at professional radio broadcasters. ## Simple Recorders * [**jack_capture**](http://www.notam02.no/arkiv/src) is a small program to capture whatever sound is going out to your speakers into a file. * [**JACK Timemachine**](http://plugin.org.uk/timemachine) an application that constantly records signals coming in on its inputs, waiting for you to press record. When you do it writes the last ten seconds to disk and keeps recording. * [**meterec**](http://sourceforge.net/projects/meterec) is a console based multi-track monitoring and recording tool. Focus on your instrument, not on the software! * [**QARecord**](http://alsamodular.sourceforge.net/) a simple but multithreaded stereo recording tool. * [**QJackRcd**](http://sourceforge.net/projects/qjackrcd) is a simple stereo recorder for Jack with few features as silence processing for automatic pause, file splitting, background file post-processing. ## Sound Generators * [**AlsaModularSynth**](http://alsamodular.sourceforge.net/) a realtime modular synthesizer and effect processor. You will need version 1.5.3c or above. * [**amSynth**](http://amsynthe.sourceforge.net/amSynth) an analogue-modelling soft synth. * [**arpage**](http://sourceforge.net/projects/arpage) is a MIDI Arpeggiator w/ JACK Tempo Sync. * [**CheeseTracker**](http://cheesetracker.sourceforge.net/) a portable Impulse Tracker clone. * [**ClockLoop**](http://plugin.org.uk/clockloop) a very simple JACK application for playing back audio loops. * [**CodeSounding**](http://www.codesounding.org/indexeng.html) is a java [sonification](http://en.wikipedia.org/wiki/Sonification) library: the sound produced running a .class (or .jar) is a function of how was structured its source code before compilation. You can therefore produce computer-generated music. * [**Csound5**](http://csound.sourceforge.net/) is a sound and music synthesis system, providing facilities for composition and performance over a wide range of platforms. * [**din**](http://dinisnoise.org/) is a software musical instrument and audio synthesizer. * [**energyXT2**](http://www.energy-xt.com/) is a complete music studio. Commercial product with a free demo available. * [**fastbreeder**](http://www.pawfal.org/Software/fastbreeder) is an experimental genetic programming synthesiser. * [**FluidSynth**](http://sourceforge.net/projects/fluidsynth) a real-time software synthesizer based on the Soundfont2 specifications. * [**gAlan**](http://galan.sourceforge.net/) a modular synthesiser, drum-machine, sequencer and effects-unit. Version 0.3.0-test1 or above. * [**Gneutronica**](http://gneutronica.sourceforge.net/) a MIDI drum machine for Linux. * [**Haruhi**](https://github.com/mcvsama/haruhi/) is a virtual analog audio synthesizer written in Qt. * [**hearnet**](http://github.com/fugalh/hearnet) a simple granular synthesizer driven by your incoming network traffic. * [**Horgand**](http://horgand.berlios.de/) an organ synthesizer. * [**Hydrogen**](http://www.hydrogen-music.org/) a pattern based drum machine. * [**ingen**](http://wiki.drobilla.net/Ingen) is a modular audio processing system for GNU/Linux audio systems using the Jack audio server and LV2, LADSPA or DSSI plugins. * [**Jack Keyboard**](http://jack-keyboard.sourceforge.net/) is a virtual MIDI keyboard - a program that allows you to send JACK MIDI events (play ;-) using your PC keyboard. * [**Jacker**](http://bitbucket.org/paniq/jacker/wiki/Home) is a MIDI tracker for Jack. * [**jMax**](http://www.jmax-phoenix.org/) a visual programming environment for building interactive real-time musical and multimedia applications. Version 4.0.1 or above. * [**LegaSynth**](http://sourceforge.net/projects/cheesetronic) an old chip/synthesizer emulator. * [**LDrum**](http://sourceforge.net/projects/ldrum/) a drum machine. * [**LinuxSampler**](http://www.linuxsampler.org/) a software audio sampler. * [**Midi Player Pro**](http://www.selasky.org/hans_petter/midistudio) is the software you need to be able to play any kind of music in seconds with your fingertips. It uses [**libumidi20**](http://www.freebsd.org/cgi/ports.cgi?query=libumidi&stype=all&sektion=all), which also uses Jack. * [**Mx44**](http://web.comhem.se/luna/) is a polyphonic multichannel midi realtime software synthesizer. * [**Octavian**](http://octavian.sourceforge.net/) a realtime software synthesizer. * [**Pd**](http://www-crca.ucsd.edu/~msp/software.html) a real-time music and multimedia environment. * [**Pianoteq**](http://www.pianoteq.com/) is a high-class virtual piano software offering superb dynamics, natural resonances and unique physical parameters. This is a **commercial** product. * [**Phasex**](http://packages.debian.org/unstable/sound/phasex) is an experimental software synthesizer. * [**QMidiArp**](http://alsamodular.sourceforge.net/) is a MIDI-Arpeggiator. * [**QMIDICurves**](http://ubuntu-music.org/blog) lets you change the velocity response of any MIDI device (like a MIDI keyboard for instance). * [**reMID**](http://gp2x.org/remid) uses the reSID emulation library to provide a virtual SID based synthesizer, controllable in real-time via MIDI. SID was the sound chip used in the Commodore 64 computer. * [**rtsynth**](http://linux-sound.org/rtsynth) a reliable, if plain, multi-oscillator synthesizer * [**Sampson**](https://bitbucket.org/tdammers/sampson) is a small, lightweight, no-frills software sampler focusing on drums and percussion. * [**Seq24**](http://www.filter24.org/seq24) a loop based MIDI sequencer * [**Simsam**](http://simsam.sourceforge.net/) a simple MIDI sample playback program * [**Slag**](http://www.nongnu.org/slag) is a pattern-based audio sequencer that can currently be used as a simple drum box. * [**Solfege**](http://www.solfege.org/) s free music education software. Use it to train your rhythm, interval, scale and chord skills. Solfege - Smarten your ears! * [**Soundtracker**](http://www.soundtracker.org/) a music tracker similar to FastTracker and ProTracker. Version 0.6.7pre1 or above. * [**Specimen**](http://zhevny.com/specimen) a midi controlled audio sampler. * [**Spiral Synth Modular**](http://www.pawfal.org/Software/SSM) a cool and expandable modular synthesizer. * [**SuperCollider**](http://supercollider.sourceforge.net/) a realtime sound synthesis server and an interpreted object oriented language. * [**terminatorX**](http://terminatorx.org/) a realtime audio synthesizer that allows you to "scratch". * [**Timidity++**](http://timidity.sourceforge.net/) a software synthesizer. Jack support currently only in CVS. * [**Virtual Keyboard**](http://www.alsa-project.org/~tiwai/alsa.html#vkeybd) is a simple fake of a MIDI keyboard on X-windows system. * [**ZynAddSubFX**](http://zynaddsubfx.sourceforge.net/) a software synthesizer. ## Streamers * [**ac3jack**](http://essej.net/ac3jack) a tool for creating an AC-3 (Dolby Digital) multichannel stream from its JACK input ports. * [**Darkice**](http://darkice.sourceforge.net/) Live audio streamer. * [**edcast-reborn**](http://code.google.com/p/edcast-reborn/) is an Icecast/Shoutcast streamer. * [**Jamulus**](https://jamulus.io/) is an audio streaming application for musicians to play together in real-time over the internet. * [**SonoBus**](https://sonobus.net/) is an easy to use application for streaming high-quality, low-latency peer-to-peer audio between devices over the internet or a local network. ## Tuners * [**Free Music Instrument Tuner**](http://home.gna.org/fmit) a... free music instrument tuner. * [**tuneit**](http://delysid.org/tuneit.html) a simple command-line instrument tuner. * [**qjacktuner**](http://developer.berlios.de/projects/qjacktuner) an instrument tuner for JACK. ## Utilities * [**aubio**](https://aubio.org/) a tool designed for the extraction of annotations from audio signals. * [**bio2jack**](http://bio2jack.sourceforge.net/) a library that allows for simple porting of blocked io OSS/ALSA audio applications to Jack. * [**FxEngine**](http://www.smprocess.com/) Framework simplifies the plugin architecture for the data flow processing. * [**FxJackPack**](http://sourceforge.net/projects/fxjackpack) contains two plugins for the FxEngine framework which enables the recording and playback of sound through JACK. * [**GLASHCtl**](http://dino.nongnu.org/glashctl) is a simple applet for controlling the LASH Audio Session Handler. * [**jack_convolve**](http://sourceforge.net/projects/heaven/files/Audio%20Applications/Jack%20Related/jack_convolve/) is a simple command line based, convolution engine for JACK. * [**jack_snapshot**](https://sourceforge.net/projects/heaven/files/Audio%20Applications/Jack%20Related/jack_snapshot/) is a little tool for storing/restoring jack connection states. Version 0.0.4 will compile with gcc-4.3+ * [**Jack-smf-utils**](http://sourceforge.net/projects/jack-smf-utils/) is a set of two utilities - jack-smf-player and jack-smf-recorder. * [**Lash**](http://www.nongnu.org/lash) is a session management system for JACK audio and ALSA MIDI applications. * [**jass**](http://github.com/fps/jass) is a rather simple sampler application for jackd. * [**jiss**](http://github.com/fps/jiss) Jack Interactive Sequencer Software. * [**kontroll**](http://github.com/fps/kontroll) is a small utility to create midi cc messages from mouse position regardless of window focus. * [**LinABX**](http://remco.beryllium.net/linabx/) Linabx can be used to get information about audibility and to train your ears in an audio-technical way. * [**netjack**](http://netjack.sourceforge.net/) Realtime audio transport over a generic IP network. * [**Oscilloscope**](http://ll-plugins.sf.net/) plugin with two channels, controllable trigger, time resolution, separate amplification and DC offset for both channels. * [**polarbear**](http://www.resorama.com/maarten/files) is a tool for designing filters in the complex domain. Version 0.5.0 or above. * [**QLoud**](http://gaydenko.com/qloud) a tool to measure loudspeaker frequency and step responses and distortions. * [**QOscC**](https://sourceforge.net/projects/heaven/files/Audio%20Applications/Jack%20Related/QOscC/) is a highly flexible and configurable software Oscilloscope. * [**sauditor**](http://dis-dot-dat.net/index.cgi?item=/code/sauditor/) is a sample auditor that is intended to be simple and quick to use. * [**Silent Jack**](http://www.aelius.com/njh/silentjack/) is a silence/dead air detector. * [**Simple Sysexxer**](http://www.christeck.de/wp/products/simple-sysexxer) is a small tool to load, send, receive, save and request sysex data. It can be used to do backups of the memory contents of MIDI devices like synthesizers, MIDI controllers or effects processors. * [**slat**](http://dis-dot-dat.net/index.cgi?item=/code/slat/) allows you to use your mouse to adjust pitch and volume by waving the pointer over the interface. * [**SoundPatty**](https://github.com/Motiejus/SoundPatty/) is an efficient and fast sound (i.e. record) recognition software. * [**Synthclone**](http://code.google.com/p/synthclone) is a Qt-based application that can "clone" your MIDI-capable instruments. It does this by sending out MIDI data that instructs an instrument to emit sounds for a series of notes, velocities, controls, and aftertouch values. It then saves this data as a sample-based instrument that can be loaded by sampler software. ## Video Applications * [**KSubtile**](http://ksubtile.sourceforge.net/) is a KDE program which provides an easy to use interface to edit subtitles in the SRT format. It supports moving, stretching and individual editing of subtitles in a file. To help you synchronize with a particular movie we provide GUI con * [**LiVES**](http://lives.sourceforge.net/) is a Video Editing System. It is designed to be simple to use, yet powerful. It is small in size, yet it has many advanced features. * [**Shotcut**](https://shotcut.org/) is a free and open-source cross-platform video editing application for FreeBSD, Linux, macOS and Windows. * [**VideoJack**](http://www.piksel.no/pwiki/VideoJack) a tool that reads video and audio signals from its jack inputs. * [**xjadeo**](http://xjadeo.sourceforge.net/) is a very simple video player that is synchronized to jack transport. ##### Legacy (Video Applications) * [**Open Movie Editor**](http://openmovieeditor.sourceforge.net/) is designed to be a simple tool, that provides basic movie making capabilities. ## VOIP * [**Asterisk**](http://www.asterisk.org/) is the world’s leading open source telephony engine and tool kit. Offering flexibility unheard of in the world of proprietary communications, Asterisk empowers developers and integrators to create advanced communication solutions...for free. * [**I Hear U**](http://ihu.sourceforge.net/) is a Voice over IP (VoIP) application that creates an audio stream between two computers easily and with the minimal network traffic. ## VST * [**fst**](http://joebutton.co.uk/fst/) is a program by which uses Wine, Jack and Steinberg's VST Audio Plug-Ins SDK to enable the use of many VST audio plugins under Gnu/Linux. ## Other * [**Mozilla Firefox**](https://www.mozilla.org/en-US/firefox/new/) provides JACK support when compiled with custom [build flags](https://bugzilla.mozilla.org/show_bug.cgi?id=783733#c81) ## Wikipedia References * [**Ardour**](http://en.wikipedia.org/wiki/Ardour_%28audio_processor%29) * [**Jack Audio Connection Kit**](http://en.wikipedia.org/wiki/JACK_Audio_Connection_Kit) --- # Source: https://jackaudio.org/ --- title: "Community Network" --- # Mailing Lists ## jackaudio@lists.linuxaudio.org [ [sign up](https://lists.linuxaudio.org/listinfo/jackaudio/) | [archives](https://lists.linuxaudio.org/archives/jackaudio/) ] For discussion of the jack server as well as jack applications. If you're doing anything with jack, you need to be on this list. See linux-audio-dev for email prior to 27 Nov 2001. ## linux-audio-user@lists.linuxaudio.org [ [sign up](https://lists.linuxaudio.org/listinfo/linux-audio-user/) | [archives](https://lists.linuxaudio.org/archives/linux-audio-user/) ] Not dedicated to JACK alone, but very often you will get help on questions about usage and troubleshooting with JACK here. # IRC ## jack @ libera.chat For those that prefer real-time chat. Join channel #jack on irc.libera.chat. ## linux-audio-users @ libera.chat For more casual talk, use #lau or #opensourcemusicians channels. # Communities ## [linuxaudio.org] A general resource for Linux Audio related questions. The [WIKI] also contains information about JACK and related topics. ## [linuxmusicians] Provides a discussion forum for Linux audio related topics. Of course JACK included. [linuxaudio.org]: https://linuxaudio.org/ [WIKI]: https://wiki.linuxaudio.org/wiki/start [linuxmusicians]: https://linuxmusicians.com/ --- # Source: https://jackaudio.org/ --- title: "JACK Developer Information" --- # JACK Developer Information Want to use JACK in your software? Great, grab the [source] and see the [docs]. ## Want to get involved? How about getting on the [mailing list]. Filipe Coelho (aka falkTX) is the current maintainer of this project. ## Found a bug? Send your report to the respective bug-trackers of [jack1] or [jack2] or send your report to the [mailing list]. This homepage is maintained as a community effort and has it's own bugtracker. For anything else send a mail to the [mailing list] people are friendly and will respond if they can. ## Contributors JACK was inspired by and partially designed during discussions on the Linux Audio Developers mailing list. Particularly significant contributions to those discussions came from (in alphabetical order): * Paul Davis * Richard Günther * David Olofson * Benno Sennoner * Kai Vehmanen Paul Davis was the principal author of the JACK API and of its sample implementation. Very significant contributions have been made by: * Jack O'Quin * Bob Ham * Steve Harris * Stephane Letz * Taybin Rutkin * Ian Esten Jack O'Quin frequently acted as the primary maintainer of JACK for long periods, and has contributed many new interfaces and bug fixes. Stephane Letz ported JACK to OS X and wrote the new C++ SMP-aware implementation [jackdmp]. He and Johnny Petrantoni created [JackOSX], including JACK and utilities for OS X. Rui Nuno Capela wrote the fantastic JACK control application "qjackctl". Others who have contributed to JACK in ways large and small: * Andy Wingo, * Fernando Pablo Lopez-Lezcano, * Jeremy Hall, * Steve Harris, * Martin Boer, * Melanie Thielker, * Jussi Laako, * Tilman Linneweh, * Karsten Weise, * Lee Revell, * Jesse Chappel, * Filipe Coelho, * Robin Gareus [docs]: /api/ [source]: /downloads/ [mailing list]: /community.html [jack1]: https://github.com/jackaudio/jack1 [jack2]: https://github.com/jackaudio/jack2 [jackdmp]: https://web.archive.org/web/20120606050919/http://www.grame.fr/~letz/jackdmp.html [JackOSX]: https://web.archive.org/web/20180531095918/http://jackosx.com/ --- # Source: https://jackaudio.org/ --- title: "Downloads" --- # Downloading JACK ## Linux * **Binaries**: please use your distribution's package manager (`apt-get, yum, synaptic` etc.) * **Source tarball**: [JACK 1.9.22]. ## macOS * **Intel 64bit Installer**: [JACK 1.9.22 macOS-intel]. * **Universal Installer**: [JACK 1.9.22 macOS-universal]. * **Source tarball**: [JACK 1.9.22]. For macOS 10.12 or higher. Nightly builds are available through [JACK2 GitHub actions]. ## Windows * **32bit installer**: [JACK 1.9.22 win32]. * **64bit installer**: [JACK 1.9.22 win64]. * **Source tarball**: [JACK 1.9.22]. For Windows 7 or higher. 64bit builds provide mixed 32/64bit support. Nightly builds are available through [JACK2 GitHub actions]. ## JACK Source Code Repository JACK uses Git as its source control system. Our central git repository is hosted by GitHub. We are currently working toward linking the repositories for JACK1 and JACK2 but this work is not complete, so for now the commands to get a copy of the source are a little different depending on which tree/version you want. ### JACK2 Git Repository Those without write access can access the repository with this command: ``` git clone https://github.com/jackaudio/jack2.git ``` You can also point a web browser at ``` https://github.com/jackaudio/jack2 ``` to be able to browse current source code and full history with all the usual GitHub goodies. #### Write Access Those who have been granted write access and have supplied a public key can get to the repository with the following command: ``` git clone git@github.com:jackaudio/jack2.git ``` ### JACK1 Git Repository Those without write access can access the repository with these commands: ``` git clone https://github.com/jackaudio/jack1.git cd jack1 git submodule init git submodule update ``` You can also point a web browser at ``` https://github.com/jackaudio/jack1 ``` to be able to browse current source code and full history with all the usual GitHub goodies. #### Write Access Those who have been granted write access and have supplied a public key can clone the repository with the following commands: ``` git clone git@github.com:jackaudio/jack1.git cd jack1 git submodule init git submodule update ``` You must then edit the `.git/config` file within jack1 so that the submodule entries correctly reference the write-access URL. They should look like this: ``` [submodule "example-clients"] url = git@github.com:jackaudio/example-clients.git [submodule "jack"] url = git@github.com:jackaudio/headers.git [submodule "tools"] url = git@github.com:jackaudio/tools.git ``` Eventually the same setup for the submodules will be required for both JACK2 and JACK1, but this is only the case for JACK1 at this time. [JACK 1.9.22]: https://github.com/jackaudio/jack2/archive/v1.9.22.tar.gz [JACK 1.9.22 macOS-intel]: https://github.com/jackaudio/jack2-releases/releases/download/v1.9.22/jack2-macOS-intel-v1.9.22.tar.gz [JACK 1.9.22 macOS-universal]: https://github.com/jackaudio/jack2-releases/releases/download/v1.9.22/jack2-macOS-universal-v1.9.22.tar.gz [JACK 1.9.22 win32]: https://github.com/jackaudio/jack2-releases/releases/download/v1.9.22/jack2-win32-v1.9.22.exe [JACK 1.9.22 win64]: https://github.com/jackaudio/jack2-releases/releases/download/v1.9.22/jack2-win64-v1.9.22.exe [JACK2 GitHub actions]: https://github.com/jackaudio/jack2/actions/workflows/build.yml --- # Source: https://jackaudio.org/ --- title: "FAQ" --- ## JACK FAQ * [What is JACK?] * [What is the difference between JACK1 and JACK2?] * [What audio devices are supported by JACK?] * [How do I refer to a soundcard so that the name always works?] * How do I stop JACK from creating pops, clicks and other artifacts? * What are the best settings to use? * What are the best settings to use for a USB1 audio device? * [How can I use multiple soundcards with JACK?] * [How do I use JACK over a network?] * [Do I need a realtime kernel to use realtime scheduling?] * [How do I configure my Linux system to allow realtime scheduling?] * [How does using Linux with RT_GROUP_SCHED enabled affect JACK?] * How can I save/restore JACK connections? * [How can I setup persistent connections?] * [How can I use PulseAudio and JACK on the same machine?] * How can I play audio from ... via JACK? * [Flash] * [GStreamer applications] (e.g. Totem, Rhythmbox & many more) * [Phonon applications] * [XMMS / Audacious] * [Applications using ALSA directly] * How do I connect my ALSA sequencer applications to JACK MIDI? * [How does JACK compare to ... ?] * [Does using JACK add latency?] * [How do I build and install JACK?] * [How do I make an app that uses JACK?] * [How do I use JACK on Windows?] ## Hardware Specific Questions * [Macbook w/Linux: audio played via JACK output is distorted], but direct ALSA output is fine * [How do I use an M-Audio Fast Track Pro?] [What is JACK?]: about.html [What is the difference between JACK1 and JACK2?]: https://github.com/jackaudio/jackaudio.github.com/wiki/Differences-between-jack1-and-jack2 [What audio devices are supported by JACK?]: device_support.html [How do I refer to a soundcard so that the name always works?]: device_naming.html [How can I use multiple soundcards with JACK?]: multiple_devices.html [How do I use JACK over a network?]: netjack.html [Do I need a realtime kernel to use realtime scheduling?]: realtime_vs_realtime_kernel.html [How do I configure my Linux system to allow realtime scheduling?]: linux_rt_config.html [How does using Linux with RT_GROUP_SCHED enabled affect JACK?]: linux_group_sched.html [How can I setup persistent connections?]: persistent_connections.html [How can I use PulseAudio and JACK on the same machine?]: pulseaudio_and_jack.html [Flash]: routing_flash.html [GStreamer applications]: gstreamer_via_jack.html [Phonon applications]: routing_phonon.html [XMMS / Audacious]: routing_audacious.html [Applications using ALSA directly]: routing_alsa.html [How does JACK compare to ... ?]: comparing_jack.html [Does using JACK add latency?]: no_extra_latency.html [How do I build and install JACK?]: build_info.html [How do I make an app that uses JACK?]: making_a_jack_app.html [How do I use JACK on Windows?]: jack_on_windows.html [Macbook w/Linux: audio played via JACK output is distorted]: macbook_distortion.html [How do I use an M-Audio Fast Track Pro?]: http://joegiampaoli.blogspot.mx/2011/06/m-audio-fast-track-pro-for-debian-linux.html --- # Source: https://jackaudio.org/ --- title: "About Jack" --- JACK (JACK Audio Connection Kit) refers to an [API](/api) and two implementations of this API, jack1 and jack2. It provides a basic infrastructure for audio applications to communicate with each other and with audio hardware. Through JACK, users are enabled to build powerful systems for signal processing and music production. --- # Source: https://jackaudio.org/ --- title: "How do I build JACK from the source code?" --- # How do I build JACK from the source code? ### Important Caveats There can be a variety of reasons to want to build, install and use a source code version of JACK. However, it is **vitally important** that you **NEVER EVER** have two versions of JACK installed on a machine at the same time. If you have an existing installation of JACK (for example, from a Linux distribution) then you must either * remove it (this may not be possible) * install the source version "on top" of the existing one Failure to do this will more or less guarantee that JACK will no longer work on your machine. ### (For Linux only) tmpfs file system JACK's performance on Linux is much improved if it can use a "tmpfs" (shared memory) file system for certain purposes. Specifically, it will try to use a tmpfs filesystem mounted on /dev/shm by default. You can test if you have this already by running the following command in a terminal: mount | grep shm If it generates any output, you are all set. Most modern Linux systems will be this way. If yours is not then we are going to assume that you know what you are doing and understand how to set up a new tmpfs filesystem and how to tell JACK to use it. ### For JACK1 Note that if you are installing JACK "on top" of an existing version, you need to add `--prefix /usr` or similar to the ./configure command, to ensure that the install step will overwrite the existing version. By default these commands will install JACK to /usr/local/bin whereas any system-installed version will likely exist in /usr/bin. ./configure make make install If you are using JACK from svn, you will need to run `sh ./autogen.sh` before the configure step. ### For JACK2 Note that if you are installing JACK "on top" of an existing version, you need to add `--prefix /usr` or similar to the ./waf configure command, to ensure that the install step will overwrite the existing version. By default these commands will install JACK to /usr/local/bin whereas any system-installed version will likely exist in /usr/bin. ./waf configure ./waf ./waf install --- # Source: https://jackaudio.org/ --- title: "How does JACK compare to ..." --- # How does JACK compare to ... Please mail the jack-devel mailing list if you have any concerns about the answers to these questions. Also, no disrespect to any effort is intended, only a recognition of different goals and design principles. ## Other Linux-centered systems * ALSA: both a HAL and a user-space library for audio under Linux. ALSA is used to provide the default audio i/o driver for JACK. ALSA is a very powerful audio API, but it does not provide a callback-based API or offer any solutions for inter-application communication, though it has been discussed and is theoretically possible. * aRts, a streaming media architecture: aRts was not designed from the ground up with low-latency in mind. Not a fault, but a design decision. A jack output element could be written for aRts, though, as far as I can tell. Note: aRts is not really used anymore by any Linux systems. * GStreamer, another streaming media architecture: GStreamer is designed for in-process construction of media pipelines, and is not used to link applications. JACK elements for GStreamer are under available. * LADSPA, LV2: LADSPA is an internal plugin API for DSP routines, not a way of linking external applications together. * Phonon * Canberra ## Cross-platform systems * PortAudio: a "cross platform, open-source, audio I/O library" offering both callback- and blocking I/O-based APIs. PortAudio backends exist for various Windows, Mac, and Unix HALs. It is mainly focused on hardware I/O rather than a general concept of ports and connections. The callback-style API used by both projects makes it relatively easy to port between the two (no pun intended), and there is a JACK backend for PortAudio so porting is not always necessary. * SDL: * SFML: * OpenAL: ## MacOS- and/or Windows-centered systems * CoreAudio, the Mac OS X audio API: Very similar to JACK in some the sense of being centered on a synchronous-execution-via-callback API, but does not include inter-application audio routing. CoreAudio also includes a hardware-level abstraction layer, whereas JACK uses higher-level drivers for that purpose. The first JACK driver was based on ALSA, but others are available for the OSS and PortAudio interfaces. * ASIO: a HAL for both Windows and MacOS that replaces the native device driver model with something much cleaner. It supports hardware-level latencies, but it does not connect applications to each other. Also, it is subject to license restrictions, and does not exist for Linux (though it would not be impossible to implement it on top of ALSA). * ReWire, an inter-app communications API for Windows and MacOS from PropellerHeads and Steinberg, ReWire is similar in that it provides inter-application audio routing, but does not allow for fully independent processes, and has silly restrictions ("up to 64 channels", etc). JACK also comes without silly license restrictions. * VST, AudioUnits, DirectX, MAS, RTAS: these are all Windows/MacOS audio plugin APIs. None of them permit inter-application data sharing. Some plugin hosts can make this possible by using some other system such as ReWire. These APIs also require that the callback you write to process/generate data be executed in the context of the plugin host; JACK allows your callback to be executed within the context of your own application (if you wish to). * Virtual Audio Cable, VAC (Windows only): Creates a set of virtual audio devices named "Virtual Cables", each consisting of a pair of the waveform input/output devices. Applications can send audio stream to an output side of a cable, and any other application can receive this stream from an input side. ASIO-compatible. --- # Source: https://jackaudio.org/ --- title: "How do I refer to a soundcard so that the name always works?" --- # How do I refer to a soundcard so that the name always works? The precise order in which a Linux system discovers any soundcards can vary each time the machine is rebooted. This is particularly true of USB devices. The device that used to be `hw:0` can become `hw:1` after a reboot, or vice versa. Fortunately, you don't need to use names like this, and can instead use a form that isn't dependent on the order that the Linux discovers your soundcards. First, in a terminal window, run this command: `cat /proc/asound/cards`. You'll see output a bit like this: 0 [SB ]: HDA-Intel - HDA ATI SB HDA ATI SB at 0xfcef8000 irq 16 1 [DSP ]: H-DSP - Hammerfall DSP RME Hammerfall DSP + Digiface at 0xfcff0000, irq 20 2 [NVidia ]: HDA-Intel - HDA NVidia HDA NVidia at 0xfe57c000 irq 32 The "name" of each soundcard is in square brackets. With this information, you can now refer to a particular device as, for example `hw:DSP` (for the RME Hammerfall DSP in the above example. Even if the devices end up re-ordered for any reason, `hw:DSP` will still refer to the same device. The one case where this fails is if you have multiple instances of the same type of soundcard. This is a much trickier situation to deal with and is covered in detail [here](http://alsa.opensrc.org/Udev). ### Where do I use this name? You can type it into the device name selector in the upper left of qjacktl's setup dialog. You can use it as the argument to the `-d` flag of JACK's ALSA backend (e.g. `jackd -d alsa -d hw:DSP`. --- # Source: https://jackaudio.org/ --- title: "What audio devices are supported by JACK?" --- # What audio devices are supported by JACK? ## On OS X All devices with functioning CoreAudio drivers will work with JACK. ## On Linux All devices [supported by ALSA](http://www.alsa-project.org/main/index.php/Matrix:Main) (PCI, USB and Bluetooth) or [FFADO](http://ffado.org/) (FireWire) will work with JACK. ## On other operating systems If there is a working audio device driver then it will likely work with JACK. --- # Source: https://jackaudio.org/ --- title: "JACK Documentation" --- # JACK Documentation ## Using JACK * JACK [FAQ](/faq) ## Programming with JACK * The JACK API Reference Manual [ [html](/api) | [pdf](http://jackaudio.org/files/refman.pdf) ] * A handy [tutorial/walk-through] (http://dis-dot-dat.net/index.cgi?item=/jacktuts/starting/) for programming with JACK, including some simple clients ## The Design of JACK * Paul Davis' JACK presentation, Linux Audio Conference 2003. This is probably the most comprehensive overview of JACK's design currently available. There are [slides] (http://lad.linuxaudio.org/events/2003_zkm/slides/paul_davis-jack/title.html) and [audio] (http://lad.linuxaudio.org/events/2003_zkm/recordings/paul_davis-jack.ogg) available. * JACK Schematic diagram. Tarball includes dia and eps versions. [ [small](http://jackaudio.org/files/JACK-Diagram-screensize.png) | [large](http://jackaudio.org/files/JACK-Diagram.png) | [tarball](http://jackaudio.org/files/JACK-Diagram.tar.gz) ] * [Porting JACK to OS X] (http://www.soundonsound.com/sos/Oct04/articles/applenotes.htm) * [Jackdmp](http://lac.zkm.de/2005/proceedings.shtml#letz_et_al) a multiprocessor version of JACK. Various publications on Jack on OSX as well as Jackdmp are available [here](http://www.grame.fr/publications). ## The Wiki There is quite a lot of good information on the [JACK wiki] (http://trac.jackaudio.org/), although it is not particularly organized. --- # Source: https://jackaudio.org/ --- title: "Routing GStreamer audio via JACK" --- # Routing GStreamer audio via JACK Its relatively easy to get audio from GStreamer to flow via JACK: 1. You need the GStreamer JACK audio plugin, which is currently (Fall 2009) part of the "bad" plugins collection. Most Linux distributions make this available through their normal software install/update systems. The name of the package containing this plugin will vary from distribution to distribution: on Fedora its called "gstreamer-plugins-bad-free-extra", on Ubuntu its called "gst-plugins-bad", etc. etc. 2. Next, you need to configure GStreamer to tell it to use this plugin for audio output. There are 3 methods available: * Through the command line using gconf2 (you may need to install this first) * Install/run gconf-editor, which is a general purpose utility for configuring many GNOME-centric applications. * Some systems may have the gstreamer-properties command available, which offers a graphical tool for configuring gstreamer. 3. Your goal is set the value of: * `/system/gstreamer/0.10/audio/default/musicaudiosink` * `/system/gstreamer/0.10/audio/default/audiosink` to this value: `jackaudiosink buffer-time=2000000`. The exact value of `buffer-time` doesn't matter too much, but higher values reduce the chance of glitches/drop-outs in the audio stream. You might also choose to set `/system/gstreamer/0.10/audio/default/chataudiosink` to the same value, but its less likely to be useful to you. The impact of this will vary depending on how much your system uses GStreamer. On modern GNOME-based systems, it will effectively divert all system sounds and all audio playback via JACK. On other systems (e.g. KDE-based systems) it will have less of an effect, though it will still impact specific applications that use GStreamer. --- # Source: https://jackaudio.org/ --- title: "Using JACK on Windows" --- # Using JACK on Windows ## Introduction As on other platforms, JACK on Windows is a multi-purpose audio server that connects audio and MIDI streams using the Windows system drivers. It connects (OUTPUT) to those audio drivers using the PortAudio project (so JACK can connect using dsound, wmme, ASIO, etc) depending on what the soundcard's drivers support. JACK provides an Audio, MIDI and transport API (Application Programming Interface) that can be used natively by audio application developers. There are already some existing *native* JACK Windows applications (that is, audio applications that use the JACK API directly). Through the API, JACK on Windows offers native JACK connections (INPUT), and the JACK-Router ASIO driver (INPUT) that offers an ASIO linker to the JACK Server. So any ASIO application will be able to use the JACK-Router ASIO driver to connect to JACK, and JACK can then be used to route that audio to other applications connected to the JACK Server, or out to the system sound device. Several applications have native JACK support: * [Ardour](https://ardour.org/) * [Bitwig Studio](https://www.bitwig.com/) * [Carla Plugin Host](https://kx.studio/Applications:Carla) * [Foo YC20](https://github.com/sampov2/foo-yc20) * [Harisson MixBus](https://harrisonconsoles.com/product/mixbus/) * [Jamulus](https://jamulus.io) (starting from Version 3.8.1 as separate build) * [LMMS](https://lmms.io/) (starting from v1.3) * [MuseScore](http://musescore.org/) * [Radium](http://users.notam02.no/~kjetism/radium/) * [Zrythm](https://www.zrythm.org/en/) Native JACK applications can make use of the full power of the JACK audio and MIDI connection system (for instance, they can open or close JACK connections from within the application, rather than having to set an ASIO driver to use use JACK-Router). Also, the use of natively provided JACK ports provides the ability to sync audio streams between applications. The JACK-Router ASIO driver is "only" there so that users are able to use ASIO applications in the Windows context of JACK, but this connection obviously has some limitations that native applications won't have. JACK uses a 'Server <-> Client' architecture to supply the audio connection between your sound device and the ASIO application(s). When the JACK Server is running, the JACK-Router driver is then able to create connections between clients (ASIO applications) and the JACK Server. These connections can be seen in the QjackCtl -> Graph screen. If the JACK Server is not running, then JACK-Router will not be available to your ASIO application(s), and an error report may be shown. By default, JACK-Router is set to provide 4 Input and 4 Output connections. This setting can be customized to suite your needs by editing the JackRouter.ini file within your `C:\Program Files\JACK\jack-router\win32` (or `C:\Program Files\JACK\jack-router\win64` folder depending of the JACK 32 or 64-bit version). In Windows Explorer, right click on the file and choose the 'Edit' option. Change the settings in the [IO] portion of the file. ## Installation and Configuration 1. Download the JACK2 installer for Windows from the [download page.](/downloads/) 2. Use the installer. Either the 32-bit or the 64-bit one (which still allows 32-bit clients). 3. Pick "Full installation (with JACK-Router)" during installation. 4. From the Windows Start menu, locate the QjackCtl application and run it. 5. On the QjackCtl application, click "Setup" and adjust "Interface", "Sample Rate" and "Frames/Period" as needed for your device/sound-card. Do not change settings you do not understand. 6. Click on OK to close the Setup dialog. 8. Click on "Start" to start the JACK Server with the parameters you just set up. When the JACK Server is running the JACK-Router ASIO interface will be available to all ASIO capable applications. ## Uninstalling JACK Just open the "Programs and Features" in the Windows Control Panel and remove "JACK2 version ..." from there. This will uninstall the JACK Server, JACK-Router and QjackCtl. ## Connecting Audio Applications 1. Start the JACK Server using QjackCtl 2. With the Jack Audio Server started, the JackRouter ASIO driver will be available for your ASIO supported applications. 3. Within your audio application, select JACK-Router as the audio device. 4. Within QjackCtl, click the "Graph" button. You can route the output of ASIO applications into the inputs of other ASIO applications (like a VST host application), and then connect the audio output of that application to your system output (or a combination of both). Multiple channel audio is also supported, but may require more configuration than the simple setup described here. --- # Source: https://jackaudio.org/ --- title: "How does using Linux with RT_GROUP_SCHED enabled affect JACK?" --- # How does using Linux with RT_GROUP_SCHED enabled affect JACK? Recently, Linux distributions have been released that use a kernel that has the option RT_GROUP_SCHED enabled. This has the potential to wreak havoc on applications that want to use realtime scheduling, but need not do so. If you have followed the [instructions on setting up RT scheduling access](linux_rt_config.html) and you still cannot start JACK with realtime scheduling, you should read this [detailed page on RT_GROUP_SCHED](https://github.com/jackaudio/jackaudio.github.com/wiki/Cgroups). We are leaving the page in the Wiki for now, because the situation may be fluid and its easier for people with the relevant knowledge to update it there. Note that we provide this information mostly as a matter of record - we do not intend that individual users should need to grapple with CGroup configuration, but distributions should try to take care of this so as not to make using JACK with realtime scheduling effectively impossible for their users. --- # Source: https://jackaudio.org/ --- title: "How do I configure my linux system to allow JACK to use realtime scheduling?" --- # How do I configure my linux system to allow JACK to use realtime scheduling? Realtime (RT) scheduling is a feature of all Linux operating systems that enables an application to meet timing deadlines more reliably. Almost all Linux distributions consider RT scheduling to be a potential source of system abuse, and so access to it is limited to varying degrees. As mentioned in the [FAQ](realtime_vs_realtime_kernel.html), it is very important to understand that **you do NOT need an "RT kernel" to use RT scheduling** (this is a very common misconception.) JACK requires real time (RT) scheduling privileges for reliable, dropout-free operation. Modern versions of JACK request RT scheduling by default, though it can be disabled with the -r option. Older versions require the -R option to request RT scheduling. If your system is not setup correctly, then JACK will print a message like when it tries to run with RT scheduling (it will appear in the messages window of QJackctl if you use that to start JACK): cannot use real-time scheduling (FIFO at priority 10) ... (1: Operation not permitted) Some distributions configure everything so that any user can use RT scheduling with absolutely no work at all. This is great, when it happens. However, many if not most Linux distributions do not allow applications run by ordinary users to request RT scheduling by default. Some distributions' JACK packages will configure things more or less correctly for you, but in almost every case, some work is required. Distributions that are known to get this completely right include: * AVLinux * 64Studio These distributions have JACK packages that will create and configure a group with the required priviledges for RT scheduling, but will not add you to that group. * Debian Squeeze * Fedora 13 and later * Ubuntu Studio * Ubuntu - However, the user needs to be added to "audio" group. Ultimately, the only way to find out if your system is configured properly is to run JACK with RT scheduling and see if it works. ## This may not work! If you follow all these steps carefully and they do not work, you should review the information over [here](linux_group_sched.html) and consider whether this may apply to your system. ## Systems using PAM PAM (Pluggable Authentication Modules) are used by almost all modern Linux distributions nowadays to handle various tasks related to granting a user permission to do something (e.g. to login). If your system has PAM, it will also have a file called `/etc/security/limits.conf` and/or a directory called `/etc/security/limits.d. You need to carry out 3 steps to be able to run JACK with RT scheduling. In what follows, several references are made to the "audio" group. If this group name already exists, pick a different name and use it instead of "audio" when following the rest of these instructions. The actual name of the group is completely irrelevant. ### 1. Editing the configuration file If your system has no directory called `/etc/security/limits.d` then you will need to edit `/etc/security/limits.conf`. If `/etc/security/limits.d` does exist on your machine, then you will need to create and edit a file called `/etc/security/limits.d/audio.conf`. The file must contain (at least) the following two lines: @audio - rtprio 95 @audio - memlock unlimited Contrary to a lot of misinformation on the web, there is no reason to include a line here that provides enhanced "niceness" control, which is completely irrelevant for realtime scheduling and low latency audio applications. ### 2. Creating an "audio" group **As the super-user ("root")** run the following commands from a terminal window: groupadd audio usermod -a -G audio yourUserID You should substitute your actual user id or "login" for "yourUserID". If you prefer, you can carry out these two steps using the graphical tools that are available under the "System Adminstration" section of your desktop's main menu, but this text-based method is faster and much easier to explain. If you are using a distribution that has already created the group and configured the "limits" file, you will need to determine the name of the group (it is likely called "audio" or "jackuser") and then you can just add yourself to the group with this command (run as the superuser inside a terminal window): usermod -a -G theGroupName yourUserId substituting the real names for `theGroupName` and `yourUserId` ### 3. Logout and back in None of the changes you have made above will have any effect until you logout and back in. If that does not work, try rebooting. In either case, you do not need to reinstall any software. --- # Source: https://jackaudio.org/ --- title: "MacBook running Linux: audio via JACK is distorted, audio via ALSA is not" --- # MacBook running Linux: audio via JACK is distorted, audio via ALSA is not As of April 2012 there seems to be driver problem that affects the audio interface on the Macbook when it is used in 24 or 32 bit mode. To avoid the resulting distortion, use the -S flag to the ALSA backend to force it to use 16 bit sample data format. --- # Source: https://jackaudio.org/ --- title: "How do I make an application use JACK?" --- # How do I make an application use JACK? Your app must be callback-based. This means that you should not block on writes or reads from a PCM device; rather, you should have your app be "driven" by a function that gets called at regular intervals. This is a design decision. Then, take a look at the simple client code, and do your interesting stuff inside the process() function. Note that code written for any callback API can generally be ported to any other callback API fairly easily. Code that is written around a "blocking I/O" model generally needs to completely redesigned to be used in any kind of callback API. ### Linking with JACK JACK uses pkg-config. Find a package for your favorite distribution and OS, or build it from source. To build your JACK program, try $ gcc -o myprog `pkg-config --cflags --libs jack` myprog.c Most build systems worth using have builtin ways to integrate pkg-config with your build scripts. --- # Source: https://jackaudio.org/ --- title: "How can I use multiple soundcards with JACK?" --- # How can I use multiple soundcards with JACK? JACK is fundamentally designed to be a component in a pro-audio/music creation environment and standard operating practice for such setups involves using only a single digital sample "clock" (something counting off the time between audio samples). This means that trying to use multiple independent soundcards is problematic, because each soundcard has its own sample clock, running independently from the others. Over time, these different clocks drift out of sync with each other, and cause glitches in the audio. You can't stop this drift, although in some cases the effects may be insignificant enough that some people might not care about them. Thus in an ideal world you should not use multiple independent soundcards but instead use a single device with a single clock and all the inputs, outputs and other features that you need. Of course, a lot of people don't live in an ideal world, and believe that software should make up for this. Accordingly, JACK offers several ways for you to use more than 1 device at a time. ### 1. Use the alsa_in and alsa_out clients (Linux & ALSA only) If you are using JACK on Linux and want to use additional devices that have ALSA driver support (i.e. most PCI, USB and Bluetooth devices), then this is the best option. `alsa_in` and `alsa_out` are two clients written by Torben Hohn that make a single specified ALSA device appear as a set of JACK ports. They both use Erik de Castro Lopo's libsamplerate library to do any resampling required to keep the audio in sync as the clocks of each device drift over time. To use them, you start JACK as normal. Then you start an instance of `alsa_in` or alsa_out for each additional device (and "direction") that you want to use. `alsa_out` will create a set of ports representing the playback capabilities of the device, and `alsa_in` will represent the capture/recording capabilities. These two clients must be run inside a terminal window - there is no GUI for either of them. They both take arguments very much like those of the JACK ALSA backend, with some additional controls that affect the way that resampling is done. Full details are available in the man pages for each client, which you can read in a terminal window with the command `man alsa_in` (this page covers both clients, since their arguments are identical). Note that you can use these clients even if you are running JACK with a FFADO- supported device. The requirement for ALSA support only applies to the extra devices you want to use, not the one that JACK itself is using. ### 2. Use the JACK2 audio adapter(s) (Jack2 only) _More information is needed on this option_ ### 3. Using OS facilities to merge devices into a single pseudo-device Both OS X and Linux provide ways to configure your machine so that it appears to have a new audio device that is actually a combination of one or more real devices. You can use this approach to create the configuration you want to use and then start up JACK using that new "pseudo" device. #### OS X **You must perform these steps as a user with administrative priviledges**. The first thing to do is to open up Applications -> Utilities -> Audio/MIDI Setup. Go to the main menu bar, click on Audio and then select Open aggregate device editor. Follow the simple instructions to add each desired playback or capture device to your new aggregate device. Then pick a name for the new device. This is the name you will also use to choose the device for use with JACK. Note that there are quite a few subtle bugs with Apple's "aggregate device" facilities. Various things can happen that will cause the device to lose all of its playback channels or all of its capture channels, for example. If this happens, it is generally necessary to close all applications that are using any audio devices, and quite often a reboot is required. Starting with JACK2 version 1.9.6, the CoreAudio backend can now dynamically create "aggregate devices" when needed (like when the -C and -P arguments are used to specify the separated input and output devices). #### Linux You will need to use a text editor to create or add to your `~/.asoundrc` file. This file is read by any ALSA application (including JACK, if its using the ALSA backend) and can be used to define pseudo-devices of many different kinds. The key idea here is that you're going to define a new pseudo-device composed of 2 or more other devices. In our example, we'll just focus on 2 devices being merged into 1, where both devices have just 2 channels in and out. This is the text you need to make sure is in `~/.asoundrc` (below, we describe what this does): pcm.merge { type multi; slaves.a.pcm hw:0 slaves.a.channels 2; slaves.b.pcm hw:1 slaves.b.channels 2; bindings.0.slave a; bindings.0.channel 0; bindings.1.slave b; bindings.1.channel 0; bindings.2.slave a; bindings.2.channel 1; bindings.3.slave b; bindings.3.channel 1; } Lets see what this does. * It defines a new audio pseudo-device called "merge". You can use this name anywhere you might use the name of an ALSA audio device, such as "hw:0" or "hw:HDA" or "hw:DSP" or "plughw:1". * It names "hw:0" as the first component (or "slave") of this pseudo-device (slave.a.pcm) and "hw:1" as the second component (slave.b.pcm) * It states that the pseudo-device will use 2 channels from the first component and 2 channels from the 2nd component. * The lines contains `binding.` list, in order, which channel of which component will correspond to the 4 channels of the pseudo-device. In the mapping shown above, the first channel comes from the first component, then the 2nd channel from the 2nd component, the 3rd from the first component and the 4th from the second component. Note that numbering of devices and channels in ALSA starts at zero, not one. The most important and complex part of the above definition is the channel mappings defined by the `bindings` lines. A full channel mapping definition consists of a pair of a lines of the following general form: bindings.CHANNEL_OF_PSEUDO_DEVICE.slave SLAVE_DEVICE_THAT_WILL_PROVIDE_THIS_CHANNEL bindings.CHANNEL_OF_PSEUDO_DEVICE.channel CHANNEL_OF_SLAVE_DEVICE_THAT_WILL_PROVIDE_THIS_CHANNEL So the specific pair of lines: bindings.0.slave a; bindings.0.channel 0; mean that "channel 0 of the pseudo-device will correspond to channel 0 of the first slave device". Obviously by playing with this definition you can create all sorts of wierd and wonderful mappings from the real physical device channels to the pseudo-device channels. You probably don't want to do that, though. The example above shows the most common example: take the first N channels from the first device, and the second M channels from the second device. ### The Control Pseudo-device In theory, the above is enough to define a new pseudo-device, but many applications, including JACK's ALSA backend, also want to open a "control device" associated with the audio playback device. This is where they can find out (and possibly control) various hardware parameters associated with the device. Unfortunately there is no way to merge these together in the same way, so we have to provide a "dummy" control device definition that will keep such applications happy. This definition looks like this: ctl.merge { type hw card 0 } Notice that name following the `ctl.` text **must** be the same as the name following `pcm.` in the device definition above. The control device definition we've given here effectively means "if you want to open the control device associated with "merge", open the control device associated with the first installed audio/MIDI device". This probably isn't right of course - "merge" involves two cards - but it will generally work just fine. You can use this same approach to merge more than 2 devices - the resulting `pcm._DEVICE-NAME_` specification will obviously include more lines. You can also use different devices than we did above, where we just used the first and second installed card. ### "Slave" Device naming Note that you are likely better off using "hw:CARD" device names, rather than "hw:N" names, when defining a "multi" pseudo-device, as explained [here](device_naming.html). But further note that if you are using multiple instances of the same type of audio hardware (say, 4 RME Multiface devices), you will have to use "hw:N" because every card will have the same "CARD" name. In fact, with such hardware, it may be very difficult to ensure that "hw:0" always refers to the same audio interface, because there is no ALSA name that uniquely defines a particular PCI slot. This is currently an unsolved problem when using multiple identical devices. If you use PCI (or PCIe or PCIx or other derivatives of PCI) devices, the chances are that the first card will always be the same one, and so forth, so its not likely to be an issue. If you use several identical USB devices, it may be a more significant problem. ### 4. Using the -P and -C arguments to a JACK backend Several JACK backends, including the ALSA, FFADO and CoreAudio versions, support the -P and -C arguments that can be used to specify two different devices, one for playback and one for capture/recording. You cannot use this to merge multiple devices for playback or capture. This approach will not do any clock drift correction, so as the two devices drift over time, you may get glitches in the audio stream. Nevertheless, it can be an easy if unreliable way to set up JACK so that, for example, it records from a USB microphone and plays back via a builtin audio device. When using `-P` or `-C` to specify different devices, do not use the `-d` argument (which specifies a single device) and do not use the `-D` argument (which tells JACK to configure a device for playback & capture). --- # Source: https://jackaudio.org/ --- title: "How do I use JACK over a network?" --- # How do I use JACK over a network? Before we move onto answering the question "How do I use JACK over a network?", we must first deal with one of the unfortunate ugly realities of the open source world: choice. There have been several efforts to provide JACK-over-a-network. The most important thing to realize about each of these alternatives is that they are all **mutually incompatible**. You cannot run netJACK2 on one machine and netJACK1 on another, or any other combination. Both "ends" of the network link must be using the same software: netJACK1, netJACK2 or jack.trip. Each system has some qualititative differences from the others: netJACK1, also known as "netone" is designed and implemented primarily by Torben Hohn, this is the most widely used JACK-over-a-network system. Exists for Linux, OS X and Windows. Can be run with and without data compression. netJACK2 Designed and implemented primarily by Romain Moret at GRAME. Exists for Linux, OS X and Windows. No data compression. jack.trip Designed and implemented by the Soundwire group at CCRMA at Stanford University. Exists for Linux, and OS X. No synchronization, variable data compression. ## netJACK1 netJACK1 was originally designed to allow JACK to distribute audio across a high bandwidth local area network. Later, it was modified to allow it to use the CELT codec for data compression, thus allow use across a wide area network with less bandwidth (and more latency and possible data loss). It uses a master/slave design in which a single machine runs a JACK server that is connectved to sound card (the "master") and any number of other machines function as slaves. ## netJACK2 Like netJACK1, netJACK2 was primarily focused on allowing JACK to distribute audio across a high bandwidth local area network. However, it has the additional property of having a "discovery" system so that both of the ends of the connection can find each other more or less automatically. When discovered, each slave appears as a new in-server JACK client. It has no way to use data compression for use in wide area networks, and cannot tolerate packet loss. It uses the same master/slave design as netJACK1. ## jack.trip jack.trip was originally created for streaming relatively large numbers of channels across a high bandwidth wide area network. It has been used multiple times to stream 16-24 channels of uncompressed audio across Internet2 (a high bandwidth "version" of the internet generally only accessible to universities and research institutions). It doesn't care too much about relatively high latency (say, 100msec) which makes it very useful for some purposes, and not for others. It doesn't try to provide synchronization between the two ends of the link, and instead resamples to keep things reasonably aligned. Fundamentally, it just connects two independent JACK servers running on separate machines rather than using the master/slave design of netJACK1/2. ## zita-j2n TODO --- # Source: https://jackaudio.org/ --- title: "Does using JACK add latency?" --- # Does using JACK add latency? There is **NO** extra latency caused by using JACK for audio input and output. When we say none, we mean absolutely zero. The only impact of using JACK is a slight increase in the amount of work done by the CPU to process a given chunk of audio, which means that in theory you could not get 100% of the processing power that you might get it if your application(s) used ALSA or CoreAudio directly. However, given that the difference is less than 1%, and that your system will be unstable before you get close to 80% of the theoretical processing power, the effect is completely disregardable. --- # Source: https://jackaudio.org/ --- title: "How can I set up persistent connections?" --- # How can I set up persistent connections? Sometimes you want a JACK setup where every time you start a particular application ("client") it gets reconnected to the same ports. JACK by itself doesn't offer this capability, and most clients don't either but there are a number of ways of accomplishing the goal. The semi-automatic, script-based one is described in another FAQ. A completely automatic graphical approach is the QJackctl Patchbay, [lovingly described by its creator](http://www.rncbc.org/drupal/node/76). Please note that the Patchbay is **not** the same as the QJackctl Connections dialog. There is comment on the Patchbay page that [describes the differences in depth ](http://www.rncbc.org/drupal/node/76#comment-1743). Finally, there is fully blown session management (still to be documented) --- # Source: https://jackaudio.org/ --- title: "How use PulseAudio and JACK?" --- ## How use PulseAudio and JACK? Many Linux systems now use PulseAudio as the default sound server, using it to handle all sound playback (media players, desktop alerts, web browsers and more). Here are a couple of basic observations about using JACK and PulseAudio together: 1. While PulseAudio is running, JACK cannot access the same soundcard that Pulse is using. Even though in theory ALSA provides mechanisms for this to be possible (e.g. "dmix" device access), they do not work well enough to support both of these systems reliably. 2. PulseAudio and JACK can appear to have similar goals to many people, and they wonder why its not possible to replace one with the other. However, beyond a very superficial similarity, they really do not have much in common: * PulseAudio is focused on desktop and mobile audio needs. It doesn't try to address low latency usage, but does provide seamless device switching, network routing, global per-application volume control and lots more great stuff. * JACK is focused on the needs of pro-audio and music creation users. It offers the lowest possible latency, complete routing flexibility between applications and audio hardware, and all audio is always sample synchronized - apps don't run ahead or behind of others. It doesn't provide the smooth desktop experience that PulseAudio is aiming at. Combining PulseAudio and JACK on the same machine can be problematic. There are several options, some of which leave PulseAudio and JACK as entirely separate systems with no audio flow between them. Others connect them so that audio from one of them can be heard via the other. ## Option 1: don't use PulseAudio with JACK The most experienced and demanding users of JACK do not attempt to link PulseAudio and JACK. Many of them will not run PulseAudio at all, having either never installed it, removed it from their systems, or disabled it. They will generally route audio from other apps to JACK without using PulseAudio, via the techniques described in the "How can I play audio from ... via JACK" section of the [FAQ]. ## Option 2: use two different soundcards Many users of JACK have computer systems with more than 1 soundcard. Typically there is the builtin soundcard, which is a cheap consumer grade device, often with a variety of limitations that make it less suitable for use with JACK. The user has subsequently added another audio device, either as an internal (PCI) card or an external unit connected via FireWire or USB. ### Two ALSA-supported soundcards All that is necessary in this case is to define the device that PulseAudio and JACK will use. Run the following command in a terminal window: `cat /proc/asound/cards` You will some output like this: ``` 0 [SB ]: HDA-Intel - HDA ATI SB HDA ATI SB at 0xfcef8000 irq 16 1 [DSP ]: H-DSP - Hammerfall DSP RME Hammerfall DSP + Digiface at 0xfcff0000, irq 20 2 [NVidia]: HDA-Intel - HDA NVidia HDA NVidia at 0xfe57c000 irq 32 ``` (This is from a machine with 3 soundcards: a builtin device, an additional 26 channel RME Hammerfall DSP device, and (unintentionally) an NVidia video adapter that also has an HDMI audio output.) Each of these cards can be accessed using its name, which is contained within the square brackets `[]`. Generally, the name will simply be the conjunction of "hw:" and the card name. So for example, `"hw:DSP"` refers to the RME Hammerfall DSP in the above list, and `"hw:SB"` refers to the builtin soundcard. The names in your system will vary. ### Telling JACK which device to use To tell JACK to use the RME Hammerfall DSP, you would typically do this either via any available Graphical User Interface or on the command line, by passing `-d hw:DSP` to JACK's ALSA backend. ### Telling PulseAudio which device to use ## Option 3: route PulseAudio to JACK while JACK is running Please see [this wikipage]. ## Option 4: suspend PulseAudio while JACK is running If you start JACK using QJackctl, then you should go into its setup dialog and edit the field labelled "Server path". Insert `pasuspender --` in front of whatever is there (probably just something like `jackd`). So for example, if you had "jackd" in the "Server path" field already, it should now say: ``` pasuspender -- jackd ``` This will cause PulseAudio to suspend itself while JACK runs, and restart when JACK exits (or crashes). If you start JACK any other way, you will need to figure out how to make your method use `pasuspender --` as the command that actually starts JACK. [FAQ]: /faq/ [this wikipage]: https://github.com/jackaudio/jackaudio.github.com/wiki/WalkThrough_User_PulseOnJack --- # Source: https://jackaudio.org/ --- title: "Do I need a realtime kernel to use realtime scheduling?" --- # Do I need a realtime kernel to use realtime scheduling? No. Realtime scheduling is available on all Linux systems no matter what kernel they use, and current versions of JACK use it by default. A kernel built with the realtime patches (an "RT kernel") is needed only if: * You want to run JACK with very low latency settings that require realtime performance that can only be achieved with an RT kernel * Your hardware configuration triggers poor latency behaviour which might be improved with an RT kernel Most users do not need an RT kernel in order to use JACK, and most will be happy using settings that are effective without an RT kernel. --- # Source: https://jackaudio.org/ --- title: "How do I route audio to/from generic ALSA-using applications?" --- # How do I route audio to/from generic ALSA-using applications? If you use applications that use the ALSA API for audio I/O and not some intermediate such as GStreamer or PulseAudio, you can still force most of them to route their audio to/from JACK. There are two ways of approaching this. ## Using an ALSA Loopback device and JACK alsa_in/alsa_out clients This more complex but probably more robust approach is well-documented in [this document](http://alsa.opensrc.org/Jack_and_Loopback_device_as_Alsa-to-Jack_bridge). ## Using the ALSA JACK PCM plugin The simpler approach has its drawbacks: if an application stops playing audio, it will disappear from the JACK world, which can be quite inconvenient. Some people have also found it quite buggy or unstable in some situations. For basic audio playback, it works quite well but when used with a more demanding application or one with more of its own "quirks" (e.g. VirtualBox), this approach isn't recommended. It requires an ALSA "plugin" that is **not** installed by default on many Linux distributions, and the name of the package containing it will vary from distribution to distribution. On Fedora, the package is called "alsa-plugins- jack"; on some Debian-related systems, it can be found in "libasound2-plugins". You should install this using your system's normal software install/update tool(s). Once you have it installed, you can use it by editing the file `~/.asoundrc` (this file may not exist when you start this, or it may already have some content). You need to add the following text to it: pcm.rawjack { type jack playback_ports { 0 system:playback_1 1 system:playback_2 } capture_ports { 0 system:capture_1 1 system:capture_2 } } pcm.jack { type plug slave { pcm "rawjack" } hint { description "JACK Audio Connection Kit" } } This first PCM definition above example defines a virtual audio device called "pcm.rawjack" that has 2 input channels and two output channels. Each channel definition consists of a number (starting from zero), and a named JACK port that it will be connected to (it is not possible to create a disconnected channel). We have called the device "rawjack" because it reflects only the capabilities of JACK itself - the sample rate, sample format and so forth must all match JACK's. This is not normally very useful, so we add a second PCM definition for a device called "pcm.jack". This has the same configuration but when an application uses this device, ALSA will do whatever is needed to convert between audio data formats. Having done this, you can now use the name "pcm.jack" when using any application that allows you to specify a device name (which in theory all ALSA applications are supposed to do). The simplest test case to make sure that things work is to use the ALSA `aplay` utility like this: `aplay -D pcm.jack /path/to/some/non-compressed/audio/file` If you wanted to make all ALSA applications use this device by default (i.e. even when no explicit name is given) then your `~/.asoundrc` should also contain this text: pcm.!default { type plug slave { pcm "rawjack" } } You should check the rest of the file for other definitions of "pcm.!default" - only the last one will have any effect and there should be preferably only be one. Note that this solution will create some latency: the ALSA JACK plugin has to use a buffer between the data being sent by the application and JACK itself to avoid clicks and dropouts. --- # Source: https://jackaudio.org/ --- title: "How can I route audio from xmms/audacious/beep to JACK?" --- # How can I route audio from xmms/audacious/beep to JACK? The xmms family of audio players is one of the oldest on the Linux platform, and is still a rather nice program to use for certain purposes. xmms evolved into beep which then evolved into audacious, but despite these multiple versions there is a nice, very functional plugin for all of them that will connect it to JACK. The instructions below refer to audacious but the steps are the same for any version of xmms/beep/audacious. 1. Install the audacious plugin for JACK. The name of the package that contains this will vary depending on which Linux distribution you are using. On Fedora, its called `audacious-plugins-jack`. On Ubuntu, its called `audacious-plugins`. It might already be installed on your system. 2. Start audacious. Click on the upper-right button to bring up the "main menu" and then click on "Preferences" 3. Make sure you are looking at the "Audio" tab 4. Select "JACK Output Plugin " from the "Current Output Selector" at the top. 5. The default operation of the plugin is to connect its two outputs to the first two physical JACK outputs it can find. If you would prefer that it remain disconnected by default, or connect to all available ports (!), click on the "Output Plugin Preferences" button just below to make your choice. 6. That's it! --- # Source: https://jackaudio.org/ --- title: "How do I route audio from Flash to JACK?" --- # How do I route audio from Flash to JACK? There are a couple of approaches here. 1. systems that route audio from the web browser via ALSA: [routing ALSA audio via JACK](routing_alsa.html) 2. systems that route audio from the web browser via GStreamer: [routing GStreamer via JACK](gstreamer_via_jack.html) 3. systems that route audio from the web browser via PulseAudio: [routing PulseAudio via JACK](pulseaudio_and_jack.html) 4. use the libflashsupport-jack library from Torben Hohn The first three solutions that are described via the linked pages. The final one uses a little-known feature that Adobe provides in its browser Flash plugin: the plugin will (optionally) attempt to load a software library and use it for delivery audio data. There could be many different uses for this library, but in our case we only care about the one implemented by Torben Hohn which sends the audio onto JACK. Its probably the least-hassle, most reliable way to get audio out of Flash and into JACK. Unfortunately, at this point in time (Fall 2010), most Linux distributions do not package this library, so if you want to use it you will need to build it yourself. This is not that hard if you've used the command line a few times: git clone git://repo.or.cz/libflashsupport-jack.git cd libflashsupport sh bootstrap.sh make sudo make install You need some tools installed for this build process to work: * ALSA development libraries * JACK development libraries * libsamplerate development libraries * libssl development libraries * basic software development package * git-core * autoconf * automake * libtool If you are on a 64-bit distribution that uses /usr/lib64, you may also need to arrange a symbolic link: sudo ln -s /usr/local/lib/flashsupport.so /usr/lib64 On some versions of Linux that use a web browser that looks for things in slightly different locations (Ubuntu Lucid is one example), you may also need a command somewhat like this: sudo ln -s /usr/local/lib/libflashsupport.so /usr/lib/firefox-3.6.3/ After installation, quit any existing browser and then start a browser, visiting some Flash-using URL. Assuming that JACK is running, things should just work. Latency (the video/audio lag) is a little high - work might be done in the future to address this. --- # Source: https://jackaudio.org/ --- title: "How do I route audio from Phonon applications to JACK?" --- # How do I route audio from Phonon applications to JACK? Phonon is a "thin" layer used by many KDE applications to play and record audio. It actually doesn't contain any implementation itself, but instead uses another software library to get stuff done. The most common backend for this is GStreamer, and so to get Phonon to route audio via JACK you should generally just follow the [instructions for GStreamer](gstreamer_via_jack.html). If you use Phonon with the Xine backend instead of GStreamer, there's no information for you here yet. --- # Source: https://jackaudio.org/ --- title: "Home" --- JACK Audio Connection Kit (or JACK) is a professional sound server API and pair of daemon implementations to provide real-time, low-latency connections for both audio and MIDI data between applications. Have you ever wanted to take the audio output of one piece of software and send it to another? How about taking the output of that same program and send it to two others, then record the result in the first program? Or maybe you're a [programmer] who writes real-time audio and music [applications] and who is looking for a cross-platform API that enables not only device sharing but also inter-application audio routing, and is incredibly easy to learn and use? If so, JACK may be what you've been looking for. [programmer]: /developers.html [applications]: /applications/ --- # Source: https://jackaudio.org/ --- title: "Metadata" --- ## JACK Metadata API A running instance of JACK involves three types of conceptual objects: * Clients * Ports * Connections The rest of this tutorial refers **ONLY** to the first two - connections are not currently covered by the metadata implementation even though the API theoretically covers them. Each of these objects is typically referred to by its name, which typically provides some indication of what it is and/or what it could be used for. But a single name is often not enough. Consider a given pair of JACK ports. You may want to know that they correspond to the first two channels of your audio interface. You might also like a reminder that they are connected to to your speakers. You might also want to somehow mark these two as the default ports that should be used when making connections. A single name cannot perform this sort of multi-faceted role, but if we could add some additional data to each port, which other things could look up, then the goal becomes a lot easier. # UUIDs Before we can attach any additional data to an object, we must have a unique way of referring to the object. The names of ports can be changed, and JACK2 introduced the possibility of client name changes too. So using names isn't adequate. JACK1 now creates a UUID (Universally Unique Identifier) for all objects. This identifier never changes during the object's existence, and is thus suitable for using when attaching additional data to the object. These identifiers are created automatically, and you have no control over them. # Key/Value (you can forget Type) Just attaching a random piece of data to an object isn't very useful - nothing will be able to do any kind of structured query to find out if the data is present or not. All metadata in JACK consists of a pair of strings. One of them, the "key" identifies what type of information is represented by the other (the "value"). This allows us to ask of each object "Does this object have any value for ``?" and get a meaningful answer. The key part of a piece of metadata is just a string containing a URI. The URI may or may not correspond to a URL - if it does, then an `HTTP GET` request to the URL should retrieve something that explains the meaning of the key and how to use it. For example, [http://jackaudio.org/metadata/pretty-name] is a URI that also corresponds to a URL that describes what "pretty-name" data is and how to use it. Both key and value are strings, but the value part could represent arbitrary different kinds of data - a name, an image, audio, anything basically. We therefore provide an optional third component to each piece of metadata - a specification of the "type" of data represented by the value part. If it is empty, then the value is assumed to be just a normal (null-terminated) C string, useful for naming things in various ways. The type can also be any MIME type or any URI. If find a piece of metadata with a type that you cannot understand, you should ignore that metadata. The [API documentation] should be consulted for more details. # What to do with metadata? If we know the UUID of an object, we can do 3 things with metadata: 1. Add, or "define", a given piece of metadata for that UUID 2. Alter an existing piece of metadata for that UUID 3. Delete an existing piece of metadata for that UUID The man page for `jack_property` shows how to use that tool to do any of these 3 tasks. Note that by default `jack_property` requires a UUID, but you can pass it an additional argument to allow you to use a port or client name instead of the UUID. In addition to these three operations, we might be interested in knowing about changes to metadata. If so, a JACK client can register a "property change callback", which will be told about the UUID and key whenever a piece of metadata is created, altered or deleted. The API docs cover the details. # Who does what? At this time, the metadata API is still quite new, so there are not a lot of programs using it. Most of the information that one might want in a metadata system is known only to the user anyway, which means that existing JACK clients can't really define much of it all by themselves. Your DAW has no idea what your audio interface is connected to, or what the best names to display for the first two channels are, or where the best places to connect to in order to play audible material are. However, `jack_property` can be used to do all these things (note that "all these things" only involves creating metadata, not actually using it for anything useful). The script below shows a sample use of `jack_property` to define "pretty-name" metadata for all ports (and the backend) of a JACK system running on an RME HDSP device. ```bash #!/bin/sh # # set up nice names for all the ports # for n in `seq 1 24` ; do jack_property -p -s system:playback_$n http://jackaudio.org/metadata/pretty-name "ADAT $n" jack_property -p -s system:capture_$n http://jackaudio.org/metadata/pretty-name "ADAT $n" done jack_property -p -s system:playback_25 http://jackaudio.org/metadata/pretty-name "S/PDIF L" jack_property -p -s system:capture_25 http://jackaudio.org/metadata/pretty-name "S/PDIF L" jack_property -p -s system:playback_26 http://jackaudio.org/metadata/pretty-name "S/PDIF R" jack_property -p -s system:capture_26 http://jackaudio.org/metadata/pretty-name "S/PDIF R" # and now the driver itself jack_property -c -s system http://jackaudio.org/metadata/pretty-name "RME HDSP" exit 0 ``` At the time of writing, `jack_property`, `patchage` and `qjackctl` allow to display port + client "pretty-names" if the user chooses to do so (it falls back to the current regular names if there is no metadata for a given object). `jack_lsp` can also be used to display port and client UUIDs - see the man page for details. [http://jackaudio.org/metadata/pretty-name]: /metadata/pretty-name/ [API documentation]: https://jackaudio.org/api/group__Metadata.html --- # Source: https://jackaudio.org/ --- title: "Metadata: connected" --- ## JACK Metadata API: connected A value that identifies what the hardware port is connected to (an external device of some kind). Possible values might be "E-Piano" or "Master 2 Track". --- # Source: https://jackaudio.org/ --- title: "Metadata: event-types" --- ## JACK Metadata API: event-types This is a kludge around Jack only supporting MIDI, particularly for OSC. This property is a comma-separated list of event types, currently "MIDI" or "OSC". If this contains "OSC", the port may carry OSC bundles (first byte '#') or OSC messages (first byte '/'). Note that the "status byte" of both OSC events is not a valid MIDI status byte, so MIDI clients that check the status byte will gracefully ignore OSC messages if the user makes an inappropriate connection. --- # Source: https://jackaudio.org/ --- title: "Metadata: hardware" --- ## JACK Metadata API: hardware A value that should be shown when attempting to identify the specific hardware outputs of a client. Typical values might be "ADAT1", "S/PDIF L" or "MADI 43". --- # Source: https://jackaudio.org/ --- title: "Metadata: icon-large" --- ## JACK Metadata API: icon-large A value with a MIME type of "image/png;base64" that is an encoding of an NxN (with 32 < N <= 128) image to be used when displaying a visual representation of that client or port. --- # Source: https://jackaudio.org/ --- title: "Metadata: icon-name" --- ## JACK Metadata API: icon-name The name of the icon for the subject (typically client). This is used for looking up icons on the system, possibly with many sizes or themes. Icons should be searched for according to the freedesktop Icon Theme Specification: --- # Source: https://jackaudio.org/ --- title: "Metadata: icon-small" --- ## JACK Metadata API: icon-small A value with a MIME type of "image/png;base64" that is an encoding of an NxN (with N <=32) image to be used when displaying a visual representation of that client or port. --- # Source: https://jackaudio.org/ --- title: "Metadata: order" --- ## JACK Metadata API: order Order for a port. This is used to specify the best order to show ports in user interfaces. The value MUST be an integer. There are no other requirements, so there may be gaps in the orders for several ports. Applications should compare the orders of ports to determine their relative order, but must not assign any other relevance to order values. It is encouraged to use as the type. --- # Source: https://jackaudio.org/ --- title: "Metadata: port-group" --- ## JACK Metadata API: port-group --- # Source: https://jackaudio.org/ --- title: "Metadata: pretty-name" --- ## JACK Metadata API: pretty-name A value that should be shown to the user when displaying a port to the user, unless the user has explicitly overridden that a request to show the port name, or some other key value. --- # Source: https://jackaudio.org/ --- title: "Metadata: signal-type" --- ## JACK Metadata API: signal-type The type of an audio signal. This property allows audio ports to be tagged with a "meaning". The value is a simple string. Currently, the only type is "CV", for "control voltage" ports. Hosts SHOULD be take care to not treat CV ports as audibile nd send their output directly to speakers. In particular, CV ports are not necessarily periodic at all and may have very high DC.