Update jacklib; Implement canvas icons on Catia and Claudia

src/catia.py

@@ -95,6 +95,8 @@ iConnId     = 0
 iConnOutput = 1
 iConnInput  = 2
 
+URI_CANVAS_ICON = "http://kxstudio.sf.net/ns/canvas/icon"
+
 # ------------------------------------------------------------------------------------------------------------
 # Catia Main Window
 
@@ -235,7 +237,7 @@ class CatiaMainW(AbstractCanvasJackClass):
         self.connect(self, SIGNAL("XRunCallback()"), SLOT("slot_XRunCallback()"))
         self.connect(self, SIGNAL("BufferSizeCallback(int)"), SLOT("slot_BufferSizeCallback(int)"))
         self.connect(self, SIGNAL("SampleRateCallback(int)"), SLOT("slot_SampleRateCallback(int)"))
-        self.connect(self, SIGNAL("ClientRegistrationCallback(QString, bool)"), SLOT("slot_ClientRegistrationCallback(QString, bool)"))
+        self.connect(self, SIGNAL("ClientRenameCallback(QString, QString)"), SLOT("slot_ClientRenameCallback(QString, QString)"))
         self.connect(self, SIGNAL("PortRegistrationCallback(int, bool)"), SLOT("slot_PortRegistrationCallback(int, bool)"))
         self.connect(self, SIGNAL("PortConnectCallback(int, int, bool)"), SLOT("slot_PortConnectCallback(int, int, bool)"))
         self.connect(self, SIGNAL("PortRenameCallback(int, QString, QString)"), SLOT("slot_PortRenameCallback(int, QString, QString)"))
@@ -505,9 +507,8 @@ class CatiaMainW(AbstractCanvasJackClass):
         jacklib.set_session_callback(gJack.client, self.JackSessionCallback, None)
         jacklib.on_shutdown(gJack.client, self.JackShutdownCallback, None)
 
-        if jacklib.JACK2:
-            jacklib.set_client_registration_callback(gJack.client, self.JackClientRegistrationCallback, None)
-            jacklib.set_port_rename_callback(gJack.client, self.JackPortRenameCallback, None)
+        jacklib.set_client_rename_callback(gJack.client, self.JackClientRenameCallback, None)
+        jacklib.set_port_rename_callback(gJack.client, self.JackPortRenameCallback, None)
 
     def init_jackPorts(self):
         if not gJack.client:
@@ -701,8 +702,29 @@ class CatiaMainW(AbstractCanvasJackClass):
         return groupId
 
     def canvas_addJackGroup(self, groupName):
-        groupId = self.fLastGroupId
-        patchcanvas.addGroup(groupId, groupName)
+        ret, data, dataSize = jacklib.custom_get_data(gJack.client, groupName, URI_CANVAS_ICON)
+
+        groupId    = self.fLastGroupId
+        groupSplit = patchcanvas.SPLIT_UNDEF
+        groupIcon  = patchcanvas.ICON_APPLICATION
+
+        if ret == 0:
+            iconName = voidptr2str(data)
+            jacklib.free(data)
+
+            if iconName == "hardware":
+                groupSplit = patchcanvas.SPLIT_YES
+                groupIcon  = patchcanvas.ICON_HARDWARE
+            #elif iconName =="carla":
+                #groupIcon = patchcanvas.ICON_CARLA
+            elif iconName =="distrho":
+                groupIcon = patchcanvas.ICON_DISTRHO
+            elif iconName =="file":
+                groupIcon = patchcanvas.ICON_FILE
+            elif iconName =="plugin":
+                groupIcon = patchcanvas.ICON_PLUGIN
+
+        patchcanvas.addGroup(groupId, groupName, groupSplit, groupIcon)
 
         groupObj = [None, None, None]
         groupObj[iGroupId]   = groupId
@@ -1053,9 +1075,9 @@ class CatiaMainW(AbstractCanvasJackClass):
         self.emit(SIGNAL("SampleRateCallback(int)"), sampleRate)
         return 0
 
-    def JackClientRegistrationCallback(self, clientName, registerYesNo, arg):
-        if DEBUG: print("JackClientRegistrationCallback(\"%s\", %i)" % (clientName, registerYesNo))
-        self.emit(SIGNAL("ClientRegistrationCallback(QString, bool)"), str(clientName, encoding="utf-8"), bool(registerYesNo))
+    def JackClientRenameCallback(self, oldName, newName, arg):
+        if DEBUG: print("JackClientRenameCallback(\"%s\", \"%s\")" % (oldName, newName))
+        self.emit(SIGNAL("ClientRenameCallback(QString, QString)"), str(oldName, encoding="utf-8"), str(newName, encoding="utf-8"))
         return 0
 
     def JackPortRegistrationCallback(self, portId, registerYesNo, arg):
@@ -1161,17 +1183,12 @@ class CatiaMainW(AbstractCanvasJackClass):
     def slot_SampleRateCallback(self, sampleRate):
         self.ui_setSampleRate(sampleRate)
 
-    @pyqtSlot(str, bool)
-    def slot_ClientRegistrationCallback(self, clientName, registerYesNo):
-        if registerYesNo and clientName == "system" and gJack.client:
-            bufferSize = int(jacklib.get_buffer_size(gJack.client))
-            sampleRate = int(jacklib.get_sample_rate(gJack.client))
-            realtime   = bool(int(jacklib.is_realtime(gJack.client)))
+        self.ui_setRealTime(bool(int(jacklib.is_realtime(gJack.client))))
+        self.ui_setXruns(0)
 
-            self.ui_setBufferSize(bufferSize)
-            self.ui_setSampleRate(sampleRate)
-            self.ui_setRealTime(realtime)
-            self.ui_setXruns(0)
+    @pyqtSlot(str, str)
+    def slot_ClientRenameCallback(self, oldName, newName):
+        pass # TODO
 
     @pyqtSlot(int, bool)
     def slot_PortRegistrationCallback(self, portIdJack, registerYesNo):

src/claudia.py

@@ -1202,7 +1202,7 @@ class ClaudiaMainW(AbstractCanvasJackClass):
 
         return item
 
-    def canvas_add_group(self, group_id, group_name):
+    def canvas_add_group(self, groupId, groupName):
         # TODO - request ladish client type
 
         #if (False):
@@ -1212,27 +1212,49 @@ class ClaudiaMainW(AbstractCanvasJackClass):
             #icon  = patchcanvas.ICON_LADISH_ROOM
             #split = patchcanvas.SPLIT_NO
         #else:
-        icon = patchcanvas.ICON_APPLICATION
 
-        split_try = gDBus.ladish_graph.Get(GRAPH_DICT_OBJECT_TYPE_CLIENT, group_id, URI_CANVAS_SPLIT)
-        if split_try == "true":
-            split = patchcanvas.SPLIT_YES
-        elif split_try == "false":
-            split = patchcanvas.SPLIT_NO
+        splitTry = gDBus.ladish_graph.Get(GRAPH_DICT_OBJECT_TYPE_CLIENT, groupId, URI_CANVAS_SPLIT)
+
+        if splitTry == "true":
+            groupSplit = patchcanvas.SPLIT_YES
+        elif splitTry == "false":
+            groupSplit = patchcanvas.SPLIT_NO
         else:
-            split = patchcanvas.SPLIT_UNDEF
+            groupSplit = patchcanvas.SPLIT_UNDEF
 
-        patchcanvas.addGroup(group_id, group_name, split, icon)
+        groupIcon = patchcanvas.ICON_APPLICATION
 
-        x  = gDBus.ladish_graph.Get(GRAPH_DICT_OBJECT_TYPE_CLIENT, group_id, URI_CANVAS_X)
-        y  = gDBus.ladish_graph.Get(GRAPH_DICT_OBJECT_TYPE_CLIENT, group_id, URI_CANVAS_Y)
-        x2 = gDBus.ladish_graph.Get(GRAPH_DICT_OBJECT_TYPE_CLIENT, group_id, URI_CANVAS_X_SPLIT)
-        y2 = gDBus.ladish_graph.Get(GRAPH_DICT_OBJECT_TYPE_CLIENT, group_id, URI_CANVAS_Y_SPLIT)
+        if gJack.client:
+            ret, data, dataSize = jacklib.custom_get_data(gJack.client, groupName, URI_CANVAS_ICON)
+
+            if ret == 0:
+                iconName = voidptr2str(data)
+                jacklib.free(data)
+
+                if iconName == "hardware":
+                    groupIcon = patchcanvas.ICON_HARDWARE
+                    if groupSplit == patchcanvas.SPLIT_UNDEF:
+                        groupSplit = patchcanvas.SPLIT_YES
+                #elif iconName =="carla":
+                    #groupIcon = patchcanvas.ICON_CARLA
+                elif iconName =="distrho":
+                    groupIcon = patchcanvas.ICON_DISTRHO
+                elif iconName =="file":
+                    groupIcon = patchcanvas.ICON_FILE
+                elif iconName =="plugin":
+                    groupIcon = patchcanvas.ICON_PLUGIN
+
+        patchcanvas.addGroup(groupId, groupName, groupSplit, groupIcon)
+
+        x  = gDBus.ladish_graph.Get(GRAPH_DICT_OBJECT_TYPE_CLIENT, groupId, URI_CANVAS_X)
+        y  = gDBus.ladish_graph.Get(GRAPH_DICT_OBJECT_TYPE_CLIENT, groupId, URI_CANVAS_Y)
+        x2 = gDBus.ladish_graph.Get(GRAPH_DICT_OBJECT_TYPE_CLIENT, groupId, URI_CANVAS_X_SPLIT)
+        y2 = gDBus.ladish_graph.Get(GRAPH_DICT_OBJECT_TYPE_CLIENT, groupId, URI_CANVAS_Y_SPLIT)
 
         if x != None and y != None:
             if x2 is None: x2 = "%f" % (float(x) + 50)
             if y2 is None: y2 = "%f" % (float(y) + 50)
-            patchcanvas.setGroupPosFull(group_id, float(x), float(y), float(x2), float(y2))
+            patchcanvas.setGroupPosFull(groupId, float(x), float(y), float(x2), float(y2))
 
         QTimer.singleShot(0, self.ui.miniCanvasPreview, SLOT("update()"))
 

src/jacklib.py

@@ -65,7 +65,7 @@ class pthread_t(Structure):
 # ------------------------------------------------------------------------------------------------------------
 # Defines
 
-JACK_MAX_FRAMES = 4294967295
+JACK_MAX_FRAMES      = 4294967295
 JACK_LOAD_INIT_LIMIT = 1024
 JACK_DEFAULT_AUDIO_TYPE = "32 bit float mono audio"
 JACK_DEFAULT_MIDI_TYPE  = "8 bit raw midi"
@@ -73,26 +73,25 @@ JACK_DEFAULT_MIDI_TYPE  = "8 bit raw midi"
 # ------------------------------------------------------------------------------------------------------------
 # Types
 
-jack_shmsize_t = c_int32
-jack_nframes_t = c_uint32
-jack_time_t = c_uint64
-jack_intclient_t = c_uint64
-jack_port_t = _jack_port
-jack_client_t = _jack_client
-jack_port_id_t = c_uint32
-jack_port_type_id_t = c_uint32 # JACK2 only
-jack_native_thread_t = pthread_t
-jack_options_t = c_enum # JackOptions
-jack_status_t = c_enum # JackStatus
-jack_latency_callback_mode_t = c_enum # JackLatencyCallbackMode
-jack_default_audio_sample_t = c_float
-jack_transport_state_t = c_enum # Transport states
-jack_unique_t = c_uint64
-jack_position_bits_t = c_enum # Optional struct jack_position_t fields.
-jack_transport_bits_t = c_enum # Optional struct jack_transport_info_t fields
+jack_nframes_t   = c_uint32
+jack_port_id_t   = c_uint32
+jack_time_t      = c_uint64
+jack_unique_t    = c_uint64
 jack_midi_data_t = c_uchar
+jack_default_audio_sample_t = c_float
+
+jack_options_t = c_enum # JackOptions
+jack_status_t  = c_enum # JackStatus
+jack_transport_state_t    = c_enum # JackTransportState
+jack_position_bits_t      = c_enum # JackPositionBits
 jack_session_event_type_t = c_enum # JackSessionEventType
-jack_session_flags_t = c_enum # JackSessionFlags
+jack_session_flags_t      = c_enum # JackSessionFlags
+jack_custom_change_t      = c_enum # JackCustomChange
+jack_latency_callback_mode_t = c_enum # JackLatencyCallbackMode
+
+jack_port_t   = _jack_port
+jack_client_t = _jack_client
+jack_port_type_id_t  = c_uint32 # JACK2 only
 
 # enum JackOptions
 JackNullOption    = 0x00
@@ -130,29 +129,22 @@ JackPortIsOutput   = 0x2
 JackPortIsPhysical = 0x4
 JackPortCanMonitor = 0x8
 JackPortIsTerminal = 0x10
+JackPortIsControlVoltage = 0x100
 
-# Transport states
+# enum JackTransportState
 JackTransportStopped     = 0
 JackTransportRolling     = 1
 JackTransportLooping     = 2
 JackTransportStarting    = 3
 JackTransportNetStarting = 4 # JACK2 only
 
-# Optional struct jack_position_t fields
+# enum JackPositionBits
 JackPositionBBT      = 0x10
 JackPositionTimecode = 0x20
 JackBBTFrameOffset   = 0x40
 JackAudioVideoRatio  = 0x80
 JackVideoFrameOffset = 0x100
 JACK_POSITION_MASK   = JackPositionBBT|JackPositionTimecode|JackBBTFrameOffset|JackAudioVideoRatio|JackVideoFrameOffset
-#EXTENDED_TIME_INFO   = 0
-
-# Optional struct jack_transport_info_t fields
-JackTransportState    = 0x1
-JackTransportPosition = 0x2
-JackTransportLoop     = 0x4
-JackTransportSMPTE    = 0x8
-JackTransportBBT      = 0x10
 
 # enum JackSessionEventType
 JackSessionSave         = 1
@@ -163,9 +155,21 @@ JackSessionSaveTemplate = 3
 JackSessionSaveError    = 0x01
 JackSessionNeedTerminal = 0x02
 
+# enum JackCustomChange
+JackCustomRemoved  = 0
+JackCustomAdded    = 1
+JackCustomReplaced = 2
+
 # ------------------------------------------------------------------------------------------------------------
 # Structs
 
+class jack_midi_event_t(Structure):
+    _fields_ = [
+        ("time", jack_nframes_t),
+        ("size", c_size_t),
+        ("buffer", POINTER(jack_midi_data_t))
+    ]
+
 class jack_latency_range_t(Structure):
     _fields_ = [
         ("min", jack_nframes_t),
@@ -196,34 +200,6 @@ class jack_position_t(Structure):
         ("unique_2", jack_unique_t)
     ]
 
-class jack_transport_info_t(Structure):
-    _fields_ = [
-        ("frame_rate", jack_nframes_t),
-        ("usecs", jack_time_t),
-        ("valid", jack_transport_bits_t),
-        ("transport_state", jack_transport_state_t),
-        ("frame", jack_nframes_t),
-        ("loop_start", jack_nframes_t),
-        ("loop_end", jack_nframes_t),
-        ("smpte_offset", c_long),
-        ("smpte_frame_rate", c_float),
-        ("bar", c_int),
-        ("beat", c_int),
-        ("tick", c_int),
-        ("bar_start_tick", c_double),
-        ("beats_per_bar", c_float),
-        ("beat_type", c_float),
-        ("ticks_per_beat", c_double),
-        ("beats_per_minute", c_double)
-    ]
-
-class jack_midi_event_t(Structure):
-    _fields_ = [
-        ("time", jack_nframes_t),
-        ("size", c_size_t),
-        ("buffer", POINTER(jack_midi_data_t))
-    ]
-
 class jack_session_event_t(Structure):
     _fields_ = [
         ("type", jack_session_event_type_t),
@@ -247,137 +223,177 @@ class jack_session_command_t(Structure):
 
 JackLatencyCallback = CFUNCTYPE(None, jack_latency_callback_mode_t, c_void_p)
 JackProcessCallback = CFUNCTYPE(c_int, jack_nframes_t, c_void_p)
+JackThreadCallback  = CFUNCTYPE(c_void_p, c_void_p)
 JackThreadInitCallback = CFUNCTYPE(None, c_void_p)
 JackGraphOrderCallback = CFUNCTYPE(c_int, c_void_p)
-JackXRunCallback = CFUNCTYPE(c_int, c_void_p)
+JackXRunCallback       = CFUNCTYPE(c_int, c_void_p)
 JackBufferSizeCallback = CFUNCTYPE(c_int, jack_nframes_t, c_void_p)
 JackSampleRateCallback = CFUNCTYPE(c_int, jack_nframes_t, c_void_p)
-JackPortRegistrationCallback = CFUNCTYPE(None, jack_port_id_t, c_int, c_void_p)
+JackPortRegistrationCallback   = CFUNCTYPE(None, jack_port_id_t, c_int, c_void_p)
 JackClientRegistrationCallback = CFUNCTYPE(None, c_char_p, c_int, c_void_p)
-JackPortConnectCallback = CFUNCTYPE(None, jack_port_id_t, jack_port_id_t, c_int, c_void_p)
-JackPortRenameCallback = CFUNCTYPE(c_int, jack_port_id_t, c_char_p, c_char_p, c_void_p) # JACK2 only
-JackFreewheelCallback = CFUNCTYPE(None, c_int, c_void_p)
-JackThreadCallback = CFUNCTYPE(c_void_p, c_void_p)
-JackShutdownCallback = CFUNCTYPE(None, c_void_p)
+JackClientRenameCallback = CFUNCTYPE(c_int, c_char_p, c_char_p, c_void_p) # JACK2 only
+JackPortConnectCallback  = CFUNCTYPE(None, jack_port_id_t, jack_port_id_t, c_int, c_void_p)
+JackPortRenameCallback   = CFUNCTYPE(c_int, jack_port_id_t, c_char_p, c_char_p, c_void_p) # JACK2 only
+JackFreewheelCallback    = CFUNCTYPE(None, c_int, c_void_p)
+JackShutdownCallback     = CFUNCTYPE(None, c_void_p)
 JackInfoShutdownCallback = CFUNCTYPE(None, jack_status_t, c_char_p, c_void_p)
-JackSyncCallback = CFUNCTYPE(c_int, jack_transport_state_t, POINTER(jack_position_t), c_void_p)
+JackSyncCallback     = CFUNCTYPE(c_int, jack_transport_state_t, POINTER(jack_position_t), c_void_p)
 JackTimebaseCallback = CFUNCTYPE(None, jack_transport_state_t, jack_nframes_t, POINTER(jack_position_t), c_int, c_void_p)
-JackSessionCallback = CFUNCTYPE(None, jack_session_event_t, c_void_p)
+JackSessionCallback  = CFUNCTYPE(None, POINTER(jack_session_event_t), c_void_p)
+JackCustomDataAppearanceCallback = CFUNCTYPE(None, c_char_p, c_char_p, jack_custom_change_t, c_void_p)
 
 # ------------------------------------------------------------------------------------------------------------
 # Functions
 
-if JACK2:
+try:
     jacklib.jack_get_version_string.argtypes = None
-    jacklib.jack_get_version_string.restype = c_char_p
-
-jacklib.jack_client_open.argtypes = [c_char_p, jack_options_t, POINTER(jack_status_t), c_char_p]
-jacklib.jack_client_open.restype = POINTER(jack_client_t)
-
-jacklib.jack_client_new.argtypes = [c_char_p]
-jacklib.jack_client_new.restype = POINTER(jack_client_t)
+    jacklib.jack_get_version_string.restype  = c_char_p
+except:
+    jacklib.jack_get_version_string = None
 
-jacklib.jack_client_close.argtypes = [POINTER(jack_client_t)]
-jacklib.jack_client_close.restype = c_int
+try:
+    jacklib.jack_client_open.argtypes = [c_char_p, jack_options_t, POINTER(jack_status_t), c_char_p]
+    jacklib.jack_client_open.restype  = POINTER(jack_client_t)
+except:
+    jacklib.jack_client_open = None
 
-jacklib.jack_client_name_size.argtypes = None
-jacklib.jack_client_name_size.restype = c_int
+try:
+    jacklib.jack_client_rename.argtypes = [POINTER(jack_client_t), c_char_p]
+    jacklib.jack_client_rename.restype  = c_char_p
+except:
+    jacklib.jack_client_rename = None
 
-jacklib.jack_get_client_name.argtypes = [POINTER(jack_client_t)]
-jacklib.jack_get_client_name.restype = c_char_p
+try:
+    jacklib.jack_client_close.argtypes = [POINTER(jack_client_t)]
+    jacklib.jack_client_close.restype  = c_int
+except:
+    jacklib.jack_client_close = None
 
-jacklib.jack_internal_client_new.argtypes = [c_char_p, c_char_p, c_char_p]
-jacklib.jack_internal_client_new.restype = c_int
+try:
+    jacklib.jack_client_name_size.argtypes = None
+    jacklib.jack_client_name_size.restype  = c_int
+except:
+    jacklib.jack_client_name_size = None
 
-jacklib.jack_internal_client_close.argtypes = [c_char_p]
-jacklib.jack_internal_client_close.restype = None
+try:
+    jacklib.jack_get_client_name.argtypes = [POINTER(jack_client_t)]
+    jacklib.jack_get_client_name.restype  = c_char_p
+except:
+    jacklib.jack_get_client_name = None
 
-jacklib.jack_activate.argtypes = [POINTER(jack_client_t)]
-jacklib.jack_activate.restype = c_int
+try:
+    jacklib.jack_activate.argtypes = [POINTER(jack_client_t)]
+    jacklib.jack_activate.restype  = c_int
+except:
+    jacklib.jack_activate = None
 
-jacklib.jack_deactivate.argtypes = [POINTER(jack_client_t)]
-jacklib.jack_deactivate.restype = c_int
+try:
+    jacklib.jack_deactivate.argtypes = [POINTER(jack_client_t)]
+    jacklib.jack_deactivate.restype  = c_int
+except:
+    jacklib.jack_deactivate = None
 
-if JACK2:
+try:
     jacklib.jack_get_client_pid.argtypes = [c_char_p]
-    jacklib.jack_get_client_pid.restype = c_int
-
-jacklib.jack_client_thread_id.argtypes = [POINTER(jack_client_t)]
-jacklib.jack_client_thread_id.restype = jack_native_thread_t
+    jacklib.jack_get_client_pid.restype  = c_int
+except:
+    jacklib.jack_get_client_pid = None
 
-jacklib.jack_is_realtime.argtypes = [POINTER(jack_client_t)]
-jacklib.jack_is_realtime.restype = c_int
+try:
+    jacklib.jack_is_realtime.argtypes = [POINTER(jack_client_t)]
+    jacklib.jack_is_realtime.restype  = c_int
+except:
+    jacklib.jack_is_realtime = None
 
 def get_version_string(): # JACK2 only
-    return jacklib.jack_get_version_string()
+    if jacklib.jack_get_version_string:
+        return jacklib.jack_get_version_string()
+    return None
 
 def client_open(client_name, options, status, uuid=""):
-    return jacklib.jack_client_open(client_name.encode("utf-8"), options, status, uuid.encode("utf-8"))
+    if jacklib.jack_client_open:
+        return jacklib.jack_client_open(client_name.encode("utf-8"), options, status, uuid.encode("utf-8") if uuid else None)
+    return None
 
-def client_new(client_name):
-    return jacklib.jack_client_new(client_name.encode("utf-8"))
+def client_rename(client, new_name):
+    if jacklib.jack_client_rename:
+        return jacklib.jack_client_rename(client, new_name.encode("utf-8"))
+    return None
 
 def client_close(client):
-    return jacklib.jack_client_close(client)
+    if jacklib.jack_client_close:
+        return jacklib.jack_client_close(client)
+    return -1
 
 def client_name_size():
-    return jacklib.jack_client_name_size()
+    if jacklib.jack_client_name_size:
+        return jacklib.jack_client_name_size()
+    return 0
 
 def get_client_name(client):
-    return jacklib.jack_get_client_name(client)
-
-def internal_client_new(client_name, load_name, load_init):
-    return jacklib.jack_internal_client_new(client_name.encode("utf-8"), load_name.encode("utf-8"), load_init.encode("utf-8"))
-
-def internal_client_close(client_name):
-    jacklib.jack_internal_client_close(client_name.encode("utf-8"))
+    if jacklib.jack_get_client_name:
+        return jacklib.jack_get_client_name(client)
+    return None
 
 def activate(client):
-    return jacklib.jack_activate(client)
+    if jacklib.jack_activate:
+        return jacklib.jack_activate(client)
+    return -1
 
 def deactivate(client):
-    return jacklib.jack_deactivate(client)
+    if jacklib.jack_deactivate:
+        return jacklib.jack_deactivate(client)
+    return -1
 
 def get_client_pid(name): # JACK2 only
-    return jacklib.jack_get_client_pid(name.encode("utf-8"))
-
-def client_thread_id(client):
-    return jacklib.jack_client_thread_id(client)
+    if jacklib.jack_get_client_pid:
+        return jacklib.jack_get_client_pid(name.encode("utf-8"))
+    return 0
 
 def is_realtime(client):
-    return jacklib.jack_is_realtime(client)
+    if jacklib.jack_is_realtime:
+        return jacklib.jack_is_realtime(client)
+    return 0
 
 # ------------------------------------------------------------------------------------------------------------
-# Non Callback API
+# Non-Callback API
 
 global _thread_callback
 _thread_callback = None
 
-jacklib.jack_thread_wait.argtypes = [POINTER(jack_client_t), c_int]
-jacklib.jack_thread_wait.restype = jack_nframes_t
-
-jacklib.jack_cycle_wait.argtypes = [POINTER(jack_client_t)]
-jacklib.jack_cycle_wait.restype = jack_nframes_t
-
-jacklib.jack_cycle_signal.argtypes = [POINTER(jack_client_t), c_int]
-jacklib.jack_cycle_signal.restype = None
+try:
+    jacklib.jack_cycle_wait.argtypes = [POINTER(jack_client_t)]
+    jacklib.jack_cycle_wait.restype  = jack_nframes_t
+except:
+    jacklib.jack_cycle_wait = None
 
-jacklib.jack_set_process_thread.argtypes = [POINTER(jack_client_t), JackThreadCallback, c_void_p]
-jacklib.jack_set_process_thread.restype = c_int
+try:
+    jacklib.jack_cycle_signal.argtypes = [POINTER(jack_client_t), c_int]
+    jacklib.jack_cycle_signal.restype  = None
+except:
+    jacklib.jack_cycle_signal = None
 
-def thread_wait(client, status):
-    return jacklib.jack_thread_wait(client, status)
+try:
+    jacklib.jack_set_process_thread.argtypes = [POINTER(jack_client_t), JackThreadCallback, c_void_p]
+    jacklib.jack_set_process_thread.restype  = c_int
+except:
+    jacklib.jack_set_process_thread = None
 
 def cycle_wait(client):
-    return jacklib.jack_cycle_wait(client)
+    if jacklib.jack_cycle_wait:
+        return jacklib.jack_cycle_wait(client)
+    return 0
 
 def cycle_signal(client, status):
-    jacklib.jack_cycle_signal(client, status)
+    if jacklib.jack_cycle_signal:
+        jacklib.jack_cycle_signal(client, status)
 
 def set_process_thread(client, thread_callback, arg):
-    global _thread_callback
-    _thread_callback = JackThreadCallback(thread_callback)
-    return jacklib.jack_set_process_thread(client, _thread_callback, arg)
+    if jacklib.jack_set_process_thread:
+        global _thread_callback
+        _thread_callback = JackThreadCallback(thread_callback)
+        return jacklib.jack_set_process_thread(client, _thread_callback, arg)
+    return -1
 
 # ------------------------------------------------------------------------------------------------------------
 # Client Callbacks
@@ -390,134 +406,207 @@ global _freewheel_callback
 global _bufsize_callback
 global _srate_callback
 global _client_registration_callback
+global _client_rename_callback
 global _port_registration_callback
-global _connect_callback
-global _rename_callback
+global _port_connect_callback
+global _port_rename_callback
 global _graph_callback
 global _xrun_callback
 global _latency_callback
 
 _thread_init_callback = _shutdown_callback = _info_shutdown_callback = None
 _process_callback = _freewheel_callback = _bufsize_callback = _srate_callback = None
-_client_registration_callback = _port_registration_callback = _connect_callback = _rename_callback = None
+_client_registration_callback = _client_rename_callback = None
+_port_registration_callback = _port_connect_callback = _port_rename_callback = None
 _graph_callback = _xrun_callback = _latency_callback = None
 
-jacklib.jack_set_thread_init_callback.argtypes = [POINTER(jack_client_t), JackThreadInitCallback, c_void_p]
-jacklib.jack_set_thread_init_callback.restype = c_int
+try:
+    jacklib.jack_set_thread_init_callback.argtypes = [POINTER(jack_client_t), JackThreadInitCallback, c_void_p]
+    jacklib.jack_set_thread_init_callback.restype = c_int
+except:
+    jacklib.jack_set_thread_init_callback = None
 
-jacklib.jack_on_shutdown.argtypes = [POINTER(jack_client_t), JackShutdownCallback, c_void_p]
-jacklib.jack_on_shutdown.restype = None
+try:
+    jacklib.jack_on_shutdown.argtypes = [POINTER(jack_client_t), JackShutdownCallback, c_void_p]
+    jacklib.jack_on_shutdown.restype = None
+except:
+    jacklib.jack_on_shutdown = None
 
-try: # JACK_WEAK_EXPORT
+try:
     jacklib.jack_on_info_shutdown.argtypes = [POINTER(jack_client_t), JackInfoShutdownCallback, c_void_p]
     jacklib.jack_on_info_shutdown.restype = None
 except:
     jacklib.jack_on_info_shutdown = None
 
-jacklib.jack_set_process_callback.argtypes = [POINTER(jack_client_t), JackProcessCallback, c_void_p]
-jacklib.jack_set_process_callback.restype = c_int
+try:
+    jacklib.jack_set_process_callback.argtypes = [POINTER(jack_client_t), JackProcessCallback, c_void_p]
+    jacklib.jack_set_process_callback.restype = c_int
+except:
+    jacklib.jack_set_process_callback = None
 
-jacklib.jack_set_freewheel_callback.argtypes = [POINTER(jack_client_t), JackFreewheelCallback, c_void_p]
-jacklib.jack_set_freewheel_callback.restype = c_int
+try:
+    jacklib.jack_set_freewheel_callback.argtypes = [POINTER(jack_client_t), JackFreewheelCallback, c_void_p]
+    jacklib.jack_set_freewheel_callback.restype = c_int
+except:
+    jacklib.jack_set_freewheel_callback = None
 
-jacklib.jack_set_buffer_size_callback.argtypes = [POINTER(jack_client_t), JackBufferSizeCallback, c_void_p]
-jacklib.jack_set_buffer_size_callback.restype = c_int
+try:
+    jacklib.jack_set_buffer_size_callback.argtypes = [POINTER(jack_client_t), JackBufferSizeCallback, c_void_p]
+    jacklib.jack_set_buffer_size_callback.restype = c_int
+except:
+    jacklib.jack_set_buffer_size_callback = None
 
-jacklib.jack_set_sample_rate_callback.argtypes = [POINTER(jack_client_t), JackSampleRateCallback, c_void_p]
-jacklib.jack_set_sample_rate_callback.restype = c_int
+try:
+    jacklib.jack_set_sample_rate_callback.argtypes = [POINTER(jack_client_t), JackSampleRateCallback, c_void_p]
+    jacklib.jack_set_sample_rate_callback.restype = c_int
+except:
+    jacklib.jack_set_sample_rate_callback = None
+
+try:
+    jacklib.jack_set_client_registration_callback.argtypes = [POINTER(jack_client_t), JackClientRegistrationCallback, c_void_p]
+    jacklib.jack_set_client_registration_callback.restype = c_int
+except:
+    jacklib.jack_set_client_registration_callback = None
 
-jacklib.jack_set_client_registration_callback.argtypes = [POINTER(jack_client_t), JackClientRegistrationCallback, c_void_p]
-jacklib.jack_set_client_registration_callback.restype = c_int
+try:
+    jacklib.jack_set_client_rename_callback.argtypes = [POINTER(jack_client_t), JackClientRenameCallback, c_void_p]
+    jacklib.jack_set_client_rename_callback.restype = c_int
+except:
+    jacklib.jack_set_client_rename_callback = None
 
-jacklib.jack_set_port_registration_callback.argtypes = [POINTER(jack_client_t), JackPortRegistrationCallback, c_void_p]
-jacklib.jack_set_port_registration_callback.restype = c_int
+try:
+    jacklib.jack_set_port_registration_callback.argtypes = [POINTER(jack_client_t), JackPortRegistrationCallback, c_void_p]
+    jacklib.jack_set_port_registration_callback.restype = c_int
+except:
+    jacklib.jack_set_port_registration_callback = None
 
-jacklib.jack_set_port_connect_callback.argtypes = [POINTER(jack_client_t), JackPortConnectCallback, c_void_p]
-jacklib.jack_set_port_connect_callback.restype = c_int
+try:
+    jacklib.jack_set_port_connect_callback.argtypes = [POINTER(jack_client_t), JackPortConnectCallback, c_void_p]
+    jacklib.jack_set_port_connect_callback.restype = c_int
+except:
+    jacklib.jack_set_port_connect_callback = None
 
-if JACK2:
+try:
     jacklib.jack_set_port_rename_callback.argtypes = [POINTER(jack_client_t), JackPortRenameCallback, c_void_p]
     jacklib.jack_set_port_rename_callback.restype = c_int
+except:
+    jacklib.jack_set_port_rename_callback = None
 
-jacklib.jack_set_graph_order_callback.argtypes = [POINTER(jack_client_t), JackGraphOrderCallback, c_void_p]
-jacklib.jack_set_graph_order_callback.restype = c_int
+try:
+    jacklib.jack_set_graph_order_callback.argtypes = [POINTER(jack_client_t), JackGraphOrderCallback, c_void_p]
+    jacklib.jack_set_graph_order_callback.restype = c_int
+except:
+    jacklib.jack_set_graph_order_callback = None
 
-jacklib.jack_set_xrun_callback.argtypes = [POINTER(jack_client_t), JackXRunCallback, c_void_p]
-jacklib.jack_set_xrun_callback.restype = c_int
+try:
+    jacklib.jack_set_xrun_callback.argtypes = [POINTER(jack_client_t), JackXRunCallback, c_void_p]
+    jacklib.jack_set_xrun_callback.restype = c_int
+except:
+    jacklib.jack_set_xrun_callback = None
 
-try: # JACK_WEAK_EXPORT
+try:
     jacklib.jack_set_latency_callback.argtypes = [POINTER(jack_client_t), JackLatencyCallback, c_void_p]
     jacklib.jack_set_latency_callback.restype = c_int
 except:
     jacklib.jack_set_latency_callback = None
 
 def set_thread_init_callback(client, thread_init_callback, arg):
-    global _thread_init_callback
-    _thread_init_callback = JackThreadInitCallback(thread_init_callback)
-    return jacklib.jack_set_thread_init_callback(client, _thread_init_callback, arg)
+    if jacklib.jack_set_thread_init_callback:
+        global _thread_init_callback
+        _thread_init_callback = JackThreadInitCallback(thread_init_callback)
+        return jacklib.jack_set_thread_init_callback(client, _thread_init_callback, arg)
+    return -1
 
 def on_shutdown(client, shutdown_callback, arg):
-    global _shutdown_callback
-    _shutdown_callback = JackShutdownCallback(shutdown_callback)
-    jacklib.jack_on_shutdown(client, _shutdown_callback, arg)
+    if jacklib.jack_on_shutdown:
+        global _shutdown_callback
+        _shutdown_callback = JackShutdownCallback(shutdown_callback)
+        jacklib.jack_on_shutdown(client, _shutdown_callback, arg)
 
-def on_info_shutdown(client, info_shutdown_callback, arg): # JACK_WEAK_EXPORT
+def on_info_shutdown(client, info_shutdown_callback, arg):
     if jacklib.jack_on_info_shutdown:
         global _info_shutdown_callback
         _info_shutdown_callback = JackInfoShutdownCallback(info_shutdown_callback)
         jacklib.jack_on_info_shutdown(client, _info_shutdown_callback, arg)
 
 def set_process_callback(client, process_callback, arg):
-    global _process_callback
-    _process_callback = JackProcessCallback(process_callback)
-    return jacklib.jack_set_process_callback(client, _process_callback, arg)
+    if jacklib.jack_set_process_callback:
+        global _process_callback
+        _process_callback = JackProcessCallback(process_callback)
+        return jacklib.jack_set_process_callback(client, _process_callback, arg)
+    return -1
 
 def set_freewheel_callback(client, freewheel_callback, arg):
-    global _freewheel_callback
-    _freewheel_callback = JackFreewheelCallback(freewheel_callback)
-    return jacklib.jack_set_freewheel_callback(client, _freewheel_callback, arg)
+    if jacklib.jack_set_freewheel_callback:
+        global _freewheel_callback
+        _freewheel_callback = JackFreewheelCallback(freewheel_callback)
+        return jacklib.jack_set_freewheel_callback(client, _freewheel_callback, arg)
+    return -1
 
 def set_buffer_size_callback(client, bufsize_callback, arg):
-    global _bufsize_callback
-    _bufsize_callback = JackBufferSizeCallback(bufsize_callback)
-    return jacklib.jack_set_buffer_size_callback(client, _bufsize_callback, arg)
+    if jacklib.jack_set_buffer_size_callback:
+        global _bufsize_callback
+        _bufsize_callback = JackBufferSizeCallback(bufsize_callback)
+        return jacklib.jack_set_buffer_size_callback(client, _bufsize_callback, arg)
+    return -1
 
 def set_sample_rate_callback(client, srate_callback, arg):
-    global _srate_callback
-    _srate_callback = JackSampleRateCallback(srate_callback)
-    return jacklib.jack_set_sample_rate_callback(client, _srate_callback, arg)
+    if jacklib.jack_set_sample_rate_callback:
+        global _srate_callback
+        _srate_callback = JackSampleRateCallback(srate_callback)
+        return jacklib.jack_set_sample_rate_callback(client, _srate_callback, arg)
+    return -1
 
 def set_client_registration_callback(client, client_registration_callback, arg):
-    global _client_registration_callback
-    _client_registration_callback = JackClientRegistrationCallback(client_registration_callback)
-    return jacklib.jack_set_client_registration_callback(client, _client_registration_callback, arg)
+    if jacklib.jack_set_client_registration_callback:
+        global _client_registration_callback
+        _client_registration_callback = JackClientRegistrationCallback(client_registration_callback)
+        return jacklib.jack_set_client_registration_callback(client, _client_registration_callback, arg)
+    return -1
+
+def set_client_rename_callback(client, client_rename_callback, arg): # JACK2 only
+    if jacklib.jack_set_client_rename_callback:
+        global _client_rename_callback
+        _client_rename_callback = JackClientRenameCallback(client_rename_callback)
+        return jacklib.jack_set_client_rename_callback(client, _client_rename_callback, arg)
+    return -1
 
 def set_port_registration_callback(client, port_registration_callback, arg):
-    global _port_registration_callback
-    _port_registration_callback = JackPortRegistrationCallback(port_registration_callback)
-    return jacklib.jack_set_port_registration_callback(client, _port_registration_callback, arg)
+    if jacklib.jack_set_port_registration_callback:
+        global _port_registration_callback
+        _port_registration_callback = JackPortRegistrationCallback(port_registration_callback)
+        return jacklib.jack_set_port_registration_callback(client, _port_registration_callback, arg)
+    return -1
 
 def set_port_connect_callback(client, connect_callback, arg):
-    global _connect_callback
-    _connect_callback = JackPortConnectCallback(connect_callback)
-    return jacklib.jack_set_port_connect_callback(client, _connect_callback, arg)
+    if jacklib.jack_set_port_connect_callback:
+        global _port_connect_callback
+        _port_connect_callback = JackPortConnectCallback(connect_callback)
+        return jacklib.jack_set_port_connect_callback(client, _port_connect_callback, arg)
+    return -1
 
 def set_port_rename_callback(client, rename_callback, arg): # JACK2 only
-    global _rename_callback
-    _rename_callback = JackPortRenameCallback(rename_callback)
-    return jacklib.jack_set_port_rename_callback(client, _rename_callback, arg)
+    if jacklib.jack_set_port_rename_callback:
+        global _port_rename_callback
+        _port_rename_callback = JackPortRenameCallback(rename_callback)
+        return jacklib.jack_set_port_rename_callback(client, _port_rename_callback, arg)
+    return -1
 
 def set_graph_order_callback(client, graph_callback, arg):
-    global _graph_callback
-    _graph_callback = JackGraphOrderCallback(graph_callback)
-    return jacklib.jack_set_graph_order_callback(client, _graph_callback, arg)
+    if jacklib.jack_set_graph_order_callback:
+        global _graph_callback
+        _graph_callback = JackGraphOrderCallback(graph_callback)
+        return jacklib.jack_set_graph_order_callback(client, _graph_callback, arg)
+    return -1
 
 def set_xrun_callback(client, xrun_callback, arg):
-    global _xrun_callback
-    _xrun_callback = JackXRunCallback(xrun_callback)
-    return jacklib.jack_set_xrun_callback(client, _xrun_callback, arg)
+    if jacklib.jack_set_xrun_callback:
+        global _xrun_callback
+        _xrun_callback = JackXRunCallback(xrun_callback)
+        return jacklib.jack_set_xrun_callback(client, _xrun_callback, arg)
+    return -1
 
-def set_latency_callback(client, latency_callback, arg): # JACK_WEAK_EXPORT
+def set_latency_callback(client, latency_callback, arg):
     if jacklib.jack_set_latency_callback:
         global _latency_callback
         _latency_callback = JackLatencyCallback(latency_callback)
@@ -651,7 +740,7 @@ jacklib.jack_port_name_size.restype = c_int
 jacklib.jack_port_type_size.argtypes = None
 jacklib.jack_port_type_size.restype = c_int
 
-try: # JACK_WEAK_EXPORT
+try:
     jacklib.jack_port_type_get_buffer_size.argtypes = [POINTER(jack_client_t), c_char_p]
     jacklib.jack_port_type_get_buffer_size.restype = c_size_t
 except:
@@ -748,7 +837,7 @@ def port_name_size():
 def port_type_size():
     return jacklib.jack_port_type_size()
 
-def port_type_get_buffer_size(client, port_type): # JACK_WEAK_EXPORT
+def port_type_get_buffer_size(client, port_type):
     if jacklib.jack_port_type_get_buffer_size:
         return jacklib.jack_port_type_get_buffer_size(client, port_type.encode("utf-8"))
     return 0
@@ -759,13 +848,13 @@ def port_type_get_buffer_size(client, port_type): # JACK_WEAK_EXPORT
 jacklib.jack_port_set_latency.argtypes = [POINTER(jack_port_t), jack_nframes_t]
 jacklib.jack_port_set_latency.restype = None
 
-try: # JACK_WEAK_EXPORT
+try:
     jacklib.jack_port_get_latency_range.argtypes = [POINTER(jack_port_t), jack_latency_callback_mode_t, POINTER(jack_latency_range_t)]
     jacklib.jack_port_get_latency_range.restype = None
 except:
     jacklib.jack_port_get_latency_range = None
 
-try: # JACK_WEAK_EXPORT
+try:
     jacklib.jack_port_set_latency_range.argtypes = [POINTER(jack_port_t), jack_latency_callback_mode_t, POINTER(jack_latency_range_t)]
     jacklib.jack_port_set_latency_range.restype = None
 except:
@@ -786,11 +875,11 @@ jacklib.jack_recompute_total_latency.restype = c_int
 def port_set_latency(port, nframes):
     jacklib.jack_port_set_latency(port, nframes)
 
-def port_get_latency_range(port, mode, range_): # JACK_WEAK_EXPORT
+def port_get_latency_range(port, mode, range_):
     if jacklib.jack_port_get_latency_range:
         jacklib.jack_port_get_latency_range(port, mode, range_)
 
-def port_set_latency_range(port, mode, range_): # JACK_WEAK_EXPORT
+def port_set_latency_range(port, mode, range_):
     if jacklib.jack_port_set_latency_range:
         jacklib.jack_port_set_latency_range(port, mode, range_)
 
@@ -896,7 +985,6 @@ def free(ptr):
 
 global _sync_callback
 global _timebase_callback
-
 _sync_callback = _timebase_callback = None
 
 jacklib.jack_release_timebase.argtypes = [POINTER(jack_client_t)]
@@ -929,12 +1017,6 @@ jacklib.jack_transport_start.restype = None
 jacklib.jack_transport_stop.argtypes = [POINTER(jack_client_t)]
 jacklib.jack_transport_stop.restype = None
 
-jacklib.jack_get_transport_info.argtypes = [POINTER(jack_client_t), POINTER(jack_transport_info_t)]
-jacklib.jack_get_transport_info.restype = None
-
-jacklib.jack_set_transport_info.argtypes = [POINTER(jack_client_t), POINTER(jack_transport_info_t)]
-jacklib.jack_set_transport_info.restype = None
-
 def release_timebase(client):
     return jacklib.jack_release_timebase(client)
 
@@ -969,12 +1051,6 @@ def transport_start(client):
 def transport_stop(client):
     return jacklib.jack_transport_stop(client)
 
-def get_transport_info(client, tinfo):
-    return jacklib.jack_get_transport_info(client, tinfo)
-
-def set_transport_info(client, tinfo):
-    return jacklib.jack_set_transport_info(client, tinfo)
-
 # ------------------------------------------------------------------------------------------------------------
 # MIDI
 
@@ -1024,115 +1100,184 @@ def midi_get_lost_event_count(port_buffer):
 # Session
 
 global _session_callback
-
 _session_callback = None
 
-try: # JACK_WEAK_EXPORT
+try:
     jacklib.jack_set_session_callback.argtypes = [POINTER(jack_client_t), JackSessionCallback, c_void_p]
     jacklib.jack_set_session_callback.restype = c_int
 except:
     jacklib.jack_set_session_callback = None
 
-try: # JACK_WEAK_EXPORT
+try:
     jacklib.jack_session_reply.argtypes = [POINTER(jack_client_t), POINTER(jack_session_event_t)]
     jacklib.jack_session_reply.restype = c_int
 except:
     jacklib.jack_session_reply = None
 
-try: # JACK_WEAK_EXPORT
+try:
     jacklib.jack_session_event_free.argtypes = [POINTER(jack_session_event_t)]
     jacklib.jack_session_event_free.restype = None
 except:
     jacklib.jack_session_event_free = None
 
-try: # JACK_WEAK_EXPORT
+try:
     jacklib.jack_client_get_uuid.argtypes = [POINTER(jack_client_t)]
     jacklib.jack_client_get_uuid.restype = c_char_p
 except:
     jacklib.jack_client_get_uuid = None
 
-try: # JACK_WEAK_EXPORT
+try:
     jacklib.jack_session_notify.argtypes = [POINTER(jack_client_t), c_char_p, jack_session_event_type_t, c_char_p]
     jacklib.jack_session_notify.restype = POINTER(jack_session_command_t)
 except:
     jacklib.jack_session_notify = None
 
-try: # JACK_WEAK_EXPORT
+try:
     jacklib.jack_session_commands_free.argtypes = [POINTER(jack_session_command_t)]
     jacklib.jack_session_commands_free.restype = None
 except:
     jacklib.jack_session_commands_free = None
 
-try: # JACK_WEAK_EXPORT
+try:
     jacklib.jack_get_uuid_for_client_name.argtypes = [POINTER(jack_client_t), c_char_p]
     jacklib.jack_get_uuid_for_client_name.restype = c_char_p
 except:
     jacklib.jack_get_uuid_for_client_name = None
 
-try: # JACK_WEAK_EXPORT
+try:
     jacklib.jack_get_client_name_by_uuid.argtypes = [POINTER(jack_client_t), c_char_p]
     jacklib.jack_get_client_name_by_uuid.restype = c_char_p
 except:
     jacklib.jack_get_client_name_by_uuid = None
 
-try: # JACK_WEAK_EXPORT
+try:
     jacklib.jack_reserve_client_name.argtypes = [POINTER(jack_client_t), c_char_p, c_char_p]
     jacklib.jack_reserve_client_name.restype = c_int
 except:
     jacklib.jack_reserve_client_name = None
 
-try: # JACK_WEAK_EXPORT
+try:
     jacklib.jack_client_has_session_callback.argtypes = [POINTER(jack_client_t), c_char_p]
     jacklib.jack_client_has_session_callback.restype = c_int
 except:
     jacklib.jack_client_has_session_callback = None
 
-def set_session_callback(client, session_callback, arg): # JACK_WEAK_EXPORT
+def set_session_callback(client, session_callback, arg):
     if jacklib.jack_set_session_callback:
         global _session_callback
         _session_callback = JackSessionCallback(session_callback)
         return jacklib.jack_set_session_callback(client, _session_callback, arg)
     return -1
 
-def session_reply(client, event): # JACK_WEAK_EXPORT
+def session_reply(client, event):
     if jacklib.jack_session_reply:
         return jacklib.jack_session_reply(client, event)
     return -1
 
-def session_event_free(event): # JACK_WEAK_EXPORT
+def session_event_free(event):
     if jacklib.jack_session_event_free:
         jacklib.jack_session_event_free(event)
 
-def client_get_uuid(client): # JACK_WEAK_EXPORT
+def client_get_uuid(client):
     if jacklib.jack_client_get_uuid:
         return jacklib.jack_client_get_uuid(client)
-    return c_char_p()
+    return None
 
-def session_notify(client, target, type_, path): # JACK_WEAK_EXPORT
+def session_notify(client, target, type_, path):
     if jacklib.jack_session_notify:
         return jacklib.jack_session_notify(client, target.encode("utf-8"), type_, path.encode("utf-8"))
     return jack_session_command_t()
 
-def session_commands_free(cmds): # JACK_WEAK_EXPORT
+def session_commands_free(cmds):
     if jacklib.jack_session_commands_free:
         jacklib.jack_session_commands_free(cmds)
 
-def get_uuid_for_client_name(client, client_name): # JACK_WEAK_EXPORT
+def get_uuid_for_client_name(client, client_name):
     if jacklib.jack_get_uuid_for_client_name:
         return jacklib.jack_get_uuid_for_client_name(client, client_name.encode("utf-8"))
-    return c_char_p()
+    return None
 
-def get_client_name_by_uuid(client, client_uuid): # JACK_WEAK_EXPORT
+def get_client_name_by_uuid(client, client_uuid):
     if jacklib.jack_get_client_name_by_uuid:
         return jacklib.jack_get_client_name_by_uuid(client, client_uuid.encode("utf-8"))
-    return c_char_p()
+    return None
 
-def reserve_client_name(client, name, uuid): # JACK_WEAK_EXPORT
+def reserve_client_name(client, name, uuid):
     if jacklib.jack_reserve_client_name:
         return jacklib.jack_reserve_client_name(client, name.encode("utf-8"), uuid.encode("utf-8"))
     return -1
 
-def client_has_session_callback(client, client_name): # JACK_WEAK_EXPORT
+def client_has_session_callback(client, client_name):
     if jacklib.jack_client_has_session_callback:
         return jacklib.jack_client_has_session_callback(client, client_name.encode("utf-8"))
     return -1
+
+# ------------------------------------------------------------------------------------------------------------
+# Custom
+
+global _custom_appearance_callback
+_custom_appearance_callback = None
+
+try:
+    jacklib.jack_custom_publish_data.argtypes = [POINTER(jack_client_t), c_char_p, c_void_p, c_size_t]
+    jacklib.jack_custom_publish_data.restype  = c_int
+except:
+    jacklib.jack_custom_publish_data = None
+
+try:
+    jacklib.jack_custom_get_data.argtypes = [POINTER(jack_client_t), c_char_p, c_char_p, POINTER(c_void_p), POINTER(c_size_t)]
+    jacklib.jack_custom_get_data.restype  = c_int
+except:
+    jacklib.jack_custom_get_data = None
+
+try:
+    jacklib.jack_custom_unpublish_data.argtypes = [POINTER(jack_client_t), c_char_p]
+    jacklib.jack_custom_unpublish_data.restype  = c_int
+except:
+    jacklib.jack_custom_unpublish_data = None
+
+try:
+    jacklib.jack_custom_get_keys.argtypes = [POINTER(jack_client_t), c_char_p]
+    jacklib.jack_custom_get_keys.restype  = POINTER(c_char_p)
+except:
+    jacklib.jack_custom_get_keys = None
+
+try:
+    jacklib.jack_custom_set_data_appearance_callback.argtypes = [POINTER(jack_client_t), JackCustomDataAppearanceCallback, c_void_p]
+    jacklib.jack_custom_set_data_appearance_callback.restype  = c_int
+except:
+    jacklib.jack_custom_set_data_appearance_callback = None
+
+def custom_publish_data(client, key, data, size):
+    if jacklib.jack_custom_publish_data:
+        return jacklib.jack_custom_publish_data(client, key.encode("utf-8"), data, size)
+    return -1
+
+def custom_get_data(client, client_name, key):
+    # NOTE - this function has no extra arguments in jacklib
+    # Instead, data and size will be passed in return value, in form of (int ret, void* data, size_t size)
+
+    if jacklib.jack_custom_get_data:
+        data = c_void_p(0)
+        size = c_size_t(0)
+        ret = jacklib.jack_custom_get_data(client, client_name.encode("utf-8"), key.encode("utf-8"), pointer(data), pointer(size))
+        return (ret, data, size)
+
+    return (ret, None, 0)
+
+def custom_unpublish_data(client, key):
+    if jacklib.jack_custom_unpublish_data:
+        return jacklib.jack_custom_unpublish_data(client, key.encode("utf-8"))
+    return -1
+
+def custom_get_keys(client, client_name):
+    if jacklib.jack_custom_get_keys:
+        return jacklib.jack_custom_get_keys(client, client_name.encode("utf-8"))
+    return None
+
+def custom_set_data_appearance_callback(client, custom_callback, arg):
+    if jacklib.jack_custom_set_data_appearance_callback:
+        global _custom_appearance_callback
+        _custom_appearance_callback = JackCustomDataAppearanceCallback(custom_callback)
+        return jacklib.jack_custom_set_data_appearance_callback(client, _custom_appearance_callback, arg)
+    return -1

src/jacklib_helpers.py

@@ -84,6 +84,14 @@ def c_char_p_p_to_list(c_char_p_p):
     jacklib.free(c_char_p_p)
     return retList
 
+# ------------------------------------------------------------------------------------------------------------
+# Convert C void* -> string
+
+def voidptr2str(void_p):
+    char_p = jacklib.cast(void_p, jacklib.c_char_p)
+    string = str(char_p.value, encoding="utf-8")
+    return string
+
 # ------------------------------------------------------------------------------------------------------------
 # Convert C void* -> jack_default_audio_sample_t*