jacklib.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 # TODO:
   5 # - error-callback, function
   6 # - info-callback, function
   7
   8 # Imports
   9 from ctypes import *
  10 from sys import platform
  11
  12
  13 # Load Jack shared library
  14 if (platform == 'win32'):
  15   jacklib = cdll.LoadLibrary("libjack.dll")
  16 else:
  17   jacklib = cdll.LoadLibrary("libjack.so.0")
  18
  19
  20 # Defines
  21 MAX_FRAMES = 4294967295
  22 LOAD_INIT_LIMIT = 1024
  23
  24 DEFAULT_AUDIO_TYPE = "32 bit float mono audio"
  25 DEFAULT_MIDI_TYPE  = "8 bit raw midi"
  26
  27 # Jack Port Flags
  28 PortIsInput    = 0x1
  29 PortIsOutput   = 0x2
  30 PortIsPhysical = 0x4
  31 PortCanMonitor = 0x8
  32 PortIsTerminal = 0x10
  33 PortIsActive   = 0x20
  34
  35 # Jack Options
  36 NullOption    = 0x00
  37 NoStartServer = 0x01
  38 UseExactName  = 0x02
  39 ServerName    = 0x04
  40 LoadName      = 0x08
  41 LoadInit      = 0x10
  42 OpenOptions = (ServerName|NoStartServer|UseExactName)
  43 LoadOptions = (LoadInit|LoadName|UseExactName)
  44
  45 # Jack Status
  46 Failure       = 0x01
  47 InvalidOption = 0x02
  48 NameNotUnique = 0x04
  49 ServerStarted = 0x08
  50 ServerFailed  = 0x10
  51 ServerError   = 0x20
  52 NoSuchClient  = 0x40
  53 LoadFailure   = 0x80
  54 InitFailure   = 0x100
  55 ShmFailure    = 0x200
  56 VersionError  = 0x400
  57 BackendError  = 0x800
  58 ClientZombie  = 0x1000
  59
  60 # Jack Transport states
  61 TransportStopped     = 0
  62 TransportRolling     = 1
  63 TransportStarting    = 3
  64 TransportNetStarting = 4
  65
  66 # Optional struct jack_position_t fields
  67 PositionBBT      = 0x10
  68 PositionTimecode = 0x20
  69 BBTFrameOffset   = 0x40
  70 AudioVideoRatio  = 0x80
  71 VideoFrameOffset = 0x100
  72 POSITION_MASK = (PositionBBT|PositionTimecode)
  73
  74 # Optional struct jack_transport_info_t fields
  75 TransportState    = 0x1
  76 TransportPosition = 0x2
  77 TransportLoop     = 0x4
  78 TransportSMPTE    = 0x8
  79 TransportBBT      = 0x10
  80
  81 # Jack Session Event Type
  82 JackSessionSave = 1
  83 JackSessionSaveAndQuit = 2
  84 JackSessionSaveTemplate = 3
  85
  86 # Jack Session Flags
  87 SessionSaveError = 0x01
  88 SessionNeedTerminal = 0x02
  89
  90 # ? Not in the Jack API:
  91 AUDIO = 0
  92 MIDI  = 1
  93
  94
  95 # Types
  96 jack_shmsize_t = c_int32
  97 jack_nframes_t = c_uint32
  98 jack_time_t = c_uint64
  99 jack_intclient_t = c_uint64
 100 jack_port_id_t = c_uint32
 101 jack_port_type_id_t = c_uint32
 102 jack_default_audio_sample_t = c_float
 103 jack_unique_t = c_uint64
 104 jack_port_t = c_long #_jack_port
 105 jack_client_t = c_long #_jack_client
 106 jack_options_t = c_int
 107 jack_status_t = c_int
 108 jack_transport_state_t = c_int
 109 jack_position_bits_t = c_int
 110 jack_transport_bits_t = c_int
 111 jack_session_event_type_t = c_int
 112 jack_session_flags_t = c_int
 113
 114 class jack_position_t(Structure):
 115   _fields_ = [
 116     ("unique_1", jack_unique_t),
 117     ("usecs", jack_time_t),
 118     ("frame_rate", jack_nframes_t),
 119     ("frame", jack_nframes_t),
 120     ("valid", jack_position_bits_t),
 121     ("bar", c_int32),
 122     ("beat", c_int32),
 123     ("tick", c_int32),
 124     ("bar_start_tick", c_double),
 125     ("beats_per_bar", c_float),
 126     ("beat_type", c_float),
 127     ("ticks_per_beat", c_double),
 128     ("beats_per_minute", c_double),
 129     ("frame_time", c_double),
 130     ("next_time", c_double),
 131     ("bbt_offset", jack_nframes_t),
 132     ("audio_frames_per_video_frame", c_float),
 133     ("video_offset", jack_nframes_t),
 134     ("padding[7]", c_int32), #FIXME
 135     ("unique_2", jack_unique_t)
 136   ]
 137 jack_position_t = POINTER(jack_position_t)
 138
 139 class jack_session_event_t(Structure):
 140   _fields_ = [
 141     ("type", jack_session_event_type_t),
 142     ("session_dir", c_char_p),
 143     ("client_uuid", c_char_p),
 144     ("command_line", c_char),
 145     ("flags", jack_session_flags_t),
 146     ("future", c_uint32),
 147   ]
 148 jack_session_event_t = POINTER(jack_session_event_t)
 149
 150 class jack_session_command_t(Structure):
 151   _fields_ = [
 152     ("uuid", c_char_p),
 153     ("client_name", c_char_p),
 154     ("command", c_char_p),
 155     ("flags", jack_session_flags_t),
 156   ]
 157
 158
 159 # Special Callback defines
 160 global ThreadInitCallback, ShutdownCallback, InfoShutdownCallback
 161 global ProcessCallback, FreewheelCallback, BufferSizeCallback, SampleRateCallback
 162 global ClientRegistrationCallback, PortRegistrationCallback, PortConnectCallback, GraphOrderCallback, XRunCallback
 163 global ThreadCallback, SyncCallback, TimebaseCallback, SessionCallback
 164
 165
 166 # Internal C char** -> Python list conversion
 167 def __pointer_to_list(list_p):
 168   final_list = []
 169   i = 0
 170
 171   if (not list_p):
 172     jack_free(list_p)
 173     return final_list
 174
 175   while (True):
 176     new_char_p = list_p[i]
 177     if (new_char_p):
 178       final_list.append(str(new_char_p))
 179     else:
 180       break
 181     i += 1
 182
 183   jack_free(list_p)
 184   return final_list
 185
 186
 187 # Functions
 188
 189 def get_version_string():
 190   jacklib.jack_get_version_string.argtypes = None
 191   jacklib.jack_get_version_string.restype = c_char_p
 192   return jacklib.jack_get_version_string()
 193
 194 def client_open(client_name, options, status):
 195   if (not status): status = 0
 196   jacklib.jack_client_open.argtypes = [c_char_p, c_int, c_int]
 197   jacklib.jack_client_open.restype = jack_client_t
 198   return jacklib.jack_client_open(client_name, options, status)
 199
 200 def client_close(client):
 201   jacklib.jack_client_close.argtypes = [jack_client_t]
 202   jacklib.jack_client_close.restype = c_int
 203   return jacklib.jack_client_close(client)
 204
 205 def client_name_size():
 206   jacklib.jack_client_name_size.argtypes = None
 207   jacklib.jack_client_name_size.restype = c_int
 208   return jacklib.jack_client_name_size()
 209
 210 def client_name(client):
 211   jacklib.jack_get_client_name.argtypes = [jack_client_t]
 212   jacklib.jack_get_client_name.restype = c_char_p
 213   return jacklib.jack_get_client_name(client)
 214
 215 def activate(client):
 216   jacklib.jack_activate.argtypes = [jack_client_t]
 217   jacklib.jack_activate.restype = c_int
 218   return jacklib.jack_activate(client)
 219
 220 def deactivate(client):
 221   jacklib.jack_deactivate.argtypes = [jack_client_t]
 222   jacklib.jack_deactivate.restype = c_int
 223   return jacklib.jack_deactivate(client)
 224
 225 def get_client_pid(client):
 226   jacklib.jack_get_client_pid.argtypes = [jack_client_t]
 227   jacklib.jack_get_client_pid.restype = c_int
 228   return jacklib.jack_get_client_pid(client)
 229
 230 def get_client_thread_id(client): #TODO - restype as 'HANDLE'
 231   jacklib.jack_get_client_thread_id.argtypes = [jack_client_t]
 232   #jacklib.jack_get_client_thread_id.restype = HANDLE
 233   return jacklib.jack_get_client_thread_id(client)
 234
 235 def client_thread_id(client): #TODO - restype as 'pthread_t'
 236   jacklib.jack_client_thread_id.argtypes = [jack_client_t]
 237   #jacklib.jack_client_thread_id.restype = pthread_t
 238   return jacklib.jack_client_thread_id(client)
 239
 240 def is_realtime(client):
 241   jacklib.jack_is_realtime.argtypes = [jack_client_t]
 242   jacklib.jack_is_realtime.restype = c_int
 243   return jacklib.jack_is_realtime(client)
 244
 245
 246 # Non Callback API
 247
 248 def thread_wait(client):
 249   jacklib.jack_thread_wait.argtypes = [jack_client_t, c_int]
 250   jacklib.jack_thread_wait.restype = jack_nframes_t
 251   return jacklib.jack_thread_wait(client, status)
 252
 253 def cycle_wait(client):
 254   jacklib.jack_cycle_wait.argtypes = jack_client_t
 255   jacklib.jack_cycle_wait.restype = jack_nframes_t
 256   return jacklib.jack_cycle_wait(client)
 257
 258 def cycle_signal(client, status):
 259   jacklib.jack_cycle_signal.argtypes = [jack_client_t, status]
 260   jacklib.jack_cycle_signal.restype = None
 261   return jacklib.jack_cycle_signal(client, status)
 262
 263 def set_process_thread(client, thread_callback, arg=None):
 264   global ThreadCallback
 265   ThreadCallback = CFUNCTYPE(c_int, c_void_p)(thread_callback)
 266   jacklib.jack_set_process_thread.restype = c_int
 267   return jacklib.jack_set_process_thread(client)
 268
 269
 270 # Client Callbacks
 271
 272 def set_thread_init_callback(client, thread_init_callback, arg=None):
 273   global ThreadInitCallback
 274   ThreadInitCallback = CFUNCTYPE(c_int, c_void_p)(thread_init_callback)
 275   jacklib.jack_set_thread_init_callback.restype = c_int
 276   return jacklib.jack_set_thread_init_callback(client, ThreadInitCallback, arg)
 277
 278 def on_shutdown(client, shutdown_callback, arg=None):
 279   global ShutdownCallback
 280   ShutdownCallback = CFUNCTYPE(c_int, c_void_p)(shutdown_callback)
 281   jacklib.jack_on_shutdown(client, ShutdownCallback, arg)
 282
 283 def on_info_shutdown(client, shutdown_callback, arg=None):
 284   global InfoShutdownCallback
 285   InfoShutdownCallback = CFUNCTYPE(c_int, c_int, c_char_p, c_void_p)(shutdown_callback)
 286   jacklib.jack_on_info_shutdown(client, InfoShutdownCallback, arg)
 287
 288 def set_process_callback(client, process_callback, arg=None):
 289   global ProcessCallback
 290   ProcessCallback = CFUNCTYPE(c_int, c_int, c_void_p)(process_callback)
 291   jacklib.jack_set_process_callback.restype = c_int
 292   return jacklib.jack_set_process_callback(client, ProcessCallback, arg)
 293
 294 def set_freewheel_callback(client, freewheel_callback, arg=None):
 295   global FreewheelCallback
 296   FreewheelCallback = CFUNCTYPE(c_int, c_int, c_void_p)(freewheel_callback)
 297   jacklib.jack_set_freewheel_callback.restype = c_int
 298   return jacklib.jack_set_freewheel_callback(client, FreewheelCallback, arg)
 299
 300 def set_buffer_size_callback(client, buffer_size_callback, arg=None):
 301   global BufferSizeCallback
 302   BufferSizeCallback = CFUNCTYPE(c_int, c_int, c_void_p)(buffer_size_callback)
 303   jacklib.jack_set_buffer_size_callback.restype = c_int
 304   return jacklib.jack_set_buffer_size_callback(client, BufferSizeCallback, arg)
 305
 306 def set_sample_rate_callback(client, srate_callback, arg=None):
 307   global SampleRateCallback
 308   SampleRateCallback = CFUNCTYPE(c_int, c_int, c_void_p)(srate_callback)
 309   jacklib.jack_set_sample_rate_callback.restype = c_int
 310   return jacklib.jack_set_sample_rate_callback(client, SampleRateCallback, arg)
 311
 312 def set_client_registration_callback(client, registration_callback, arg=None):
 313   global ClientRegistrationCallback
 314   ClientRegistrationCallback = CFUNCTYPE(c_int, c_char_p, c_int, c_void_p)(registration_callback)
 315   jacklib.jack_set_client_registration_callback.restype = c_int
 316   return jacklib.jack_set_client_registration_callback(client, ClientRegistrationCallback, arg)
 317
 318 def set_port_registration_callback(client, registration_callback, arg=None):
 319   global PortRegistrationCallback
 320   PortRegistrationCallback = CFUNCTYPE(c_int, c_int, c_int, c_void_p)(registration_callback)
 321   jacklib.jack_set_port_registration_callback.restype = c_int
 322   return jacklib.jack_set_port_registration_callback(client, PortRegistrationCallback, arg)
 323
 324 def set_port_connect_callback(client, connect_callback, arg=None):
 325   global PortConnectCallback
 326   PortConnectCallback = CFUNCTYPE(c_int, c_int, c_int, c_int, c_void_p)(connect_callback)
 327   jacklib.jack_set_port_connect_callback.restype = c_int
 328   return jacklib.jack_set_port_connect_callback(client, PortConnectCallback, arg)
 329
 330 def set_port_rename_callback(client, rename_callback, arg=None):
 331   global PortRenameCallback
 332   PortRenameCallback = CFUNCTYPE(c_int, c_int, c_char_p, c_char_p, c_void_p)(rename_callback)
 333   jacklib.jack_set_port_rename_callback.restype = c_int
 334   return jacklib.jack_set_port_rename_callback(client, PortRenameCallback, arg)
 335
 336 def set_graph_order_callback(client, graph_callback, arg=None):
 337   global GraphOrderCallback
 338   GraphOrderCallback = CFUNCTYPE(c_int, c_void_p)(graph_callback)
 339   jacklib.jack_set_graph_order_callback.restype = c_int
 340   return jacklib.jack_set_graph_order_callback(client, GraphOrderCallback, arg)
 341
 342 def set_xrun_callback(client, xrun_callback, arg=None):
 343   global XRunCallback
 344   XRunCallback = CFUNCTYPE(c_int, c_void_p)(xrun_callback)
 345   jacklib.jack_set_xrun_callback.restype = c_int
 346   return jacklib.jack_set_xrun_callback(client, XRunCallback, arg)
 347
 348
 349 # ServerClientControl
 350
 351 def set_freewheel(client, onoff):
 352   jacklib.jack_set_freewheel.argtypes = [jack_client_t, c_int]
 353   jacklib.jack_set_freewheel.restype = c_int
 354   return jacklib.jack_set_freewheel(onoff)
 355
 356 def set_buffer_size(client, nframes):
 357   jacklib.jack_set_buffer_size.argtypes = [jack_client_t, jack_nframes_t]
 358   jacklib.jack_set_buffer_size.restype = c_int
 359   return jacklib.jack_set_buffer_size(client, nframes)
 360
 361 def get_sample_rate(client):
 362   jacklib.jack_get_sample_rate.argtypes = [jack_client_t]
 363   jacklib.jack_get_sample_rate.restype = jack_nframes_t
 364   return jacklib.jack_get_sample_rate(client)
 365
 366 def get_buffer_size(client):
 367   jacklib.jack_get_buffer_size.argtypes = [jack_client_t]
 368   jacklib.jack_get_buffer_size.restype = jack_nframes_t
 369   return jacklib.jack_get_buffer_size(client)
 370
 371 def cpu_load(client):
 372   jacklib.jack_cpu_load.argtypes = [jack_client_t]
 373   jacklib.jack_cpu_load.restype = c_float
 374   return jacklib.jack_cpu_load(client)
 375
 376
 377 # PortFunctions
 378
 379 def port_register(client, port_name, port_type, flags, buffer_size):
 380   jacklib.jack_port_short_name.argtypes = [jack_client_t, c_char_p, c_char_p, c_ulong, c_ulong]
 381   jacklib.jack_port_short_name.restype = c_char_p
 382   return jacklib.jack_port_register(client, port_name, port_type, flags, buffer_size)
 383
 384 def port_unregister(client, port):
 385   jacklib.jack_port_unregister.argtypes = [jack_client_t, jack_port_t]
 386   jacklib.jack_port_unregister.restype = c_int
 387   return jacklib.jack_port_unregister(client, port)
 388
 389 def port_name(port):
 390   jacklib.jack_port_name.argtypes = [jack_port_t]
 391   jacklib.jack_port_name.restype = c_char_p
 392   return jacklib.jack_port_name(port)
 393
 394 def port_short_name(port):
 395   jacklib.jack_port_short_name.argtypes = [jack_port_t]
 396   jacklib.jack_port_short_name.restype = c_char_p
 397   return jacklib.jack_port_short_name(port)
 398
 399 def port_flags(port):
 400   jacklib.jack_port_flags.argtypes = [jack_port_t]
 401   jacklib.jack_port_flags.restype = c_int
 402   return jacklib.jack_port_flags(port)
 403
 404 def port_type(port):
 405   jacklib.jack_port_type.argtypes = [jack_port_t]
 406   jacklib.jack_port_type.restype = c_char_p
 407   return jacklib.jack_port_type(port)
 408
 409 def port_type_id(port):
 410   jacklib.jack_port_type_id.argtypes = [jack_port_t]
 411   jacklib.jack_port_type_id.restype = jack_port_type_id_t
 412   return jacklib.jack_port_type_id(port)
 413
 414 def port_is_mine(client, port):
 415   jacklib.jack_port_is_mine.argtypes = [jack_client_t, jack_port_t]
 416   jacklib.jack_port_is_mine.restype = c_int
 417   return jacklib.jack_port_is_mine(client, port)
 418
 419 def port_connected(port):
 420   jacklib.jack_port_connected.argtypes = [jack_port_t]
 421   jacklib.jack_port_connected.restype = c_int
 422   return jacklib.jack_port_connected(port)
 423
 424 def port_connected_to(port, port_name):
 425   jacklib.jack_port_connected_to.argtypes = [jack_port_t, c_char_p]
 426   jacklib.jack_port_connected_to.restype = c_int
 427   return jacklib.jack_port_connected_to(port, port_name)
 428
 429 def port_get_connections(port):
 430   jacklib.jack_port_get_connections.argtypes = [jack_port_t]
 431   jacklib.jack_port_get_connections.restype = POINTER(c_char_p)
 432   list_p = jacklib.jack_port_get_connections(port)
 433   return __pointer_to_list(list_p)
 434
 435 def port_get_all_connections(client, port):
 436   jacklib.jack_port_get_all_connections.argtypes = [jack_client_t, jack_port_t]
 437   jacklib.jack_port_get_all_connections.restype = POINTER(c_char_p)
 438   list_p = jacklib.jack_port_get_all_connections(client, port)
 439   return __pointer_to_list(list_p)
 440
 441 def port_get_latency(port):
 442   jacklib.jack_port_get_latency.argtypes = [jack_port_t]
 443   jacklib.jack_port_get_latency.restype = jack_nframes_t
 444   return jacklib.jack_port_get_latency(port)
 445
 446 def port_get_total_latency(client, port):
 447   jacklib.jack_port_get_total_latency.argtypes = [jack_client_t, jack_port_t]
 448   jacklib.jack_port_get_total_latency.restype = jack_nframes_t
 449   return jacklib.jack_port_get_total_latency(client, port)
 450
 451 def port_set_latency(port, nframes):
 452   jacklib.jack_port_set_latency.argtypes = [jack_port_t, jack_nframes_t]
 453   jacklib.jack_port_set_latency.restype = None
 454   jacklib.jack_port_set_latency(port, nframes)
 455
 456 def recompute_total_latency(client, port):
 457   jacklib.jack_recompute_total_latency.argtypes = [jack_client_t, jack_port_t]
 458   jacklib.jack_recompute_total_latency.restype = c_int
 459   return jacklib.jack_recompute_total_latency(client, port)
 460
 461 def jack_recompute_total_latencies():
 462   jacklib.jack_recompute_total_latencies.argtypes = [jack_client_t]
 463   jacklib.jack_recompute_total_latencies.restype = c_int
 464   return jacklib.jack_jack_recompute_total_latencies()
 465
 466 def port_set_name(port, port_name):
 467   jacklib.jack_port_set_name.argtypes = [jack_port_t, c_char_p]
 468   jacklib.jack_port_set_name.restype = c_int
 469   return jacklib.jack_port_set_name(port, port_name)
 470
 471 def port_set_alias(port, alias):
 472   jacklib.jack_port_set_alias.argtypes = [jack_port_t, c_char_p]
 473   jacklib.jack_port_set_alias.restype = c_int
 474   return jacklib.jack_port_set_alias(port, alias)
 475
 476 def port_unset_alias(port, alias):
 477   jacklib.jack_port_unset_alias.argtypes = [jack_port_t, c_char_p]
 478   jacklib.jack_port_unset_alias.restype = c_int
 479   return jacklib.jack_port_unset_alias(port, alias)
 480
 481 def port_get_aliases(port, aliases): #TODO - check argtypes
 482   jacklib.jack_port_get_aliases.argtypes = [jack_port_t, POINTER(c_char_p)] #POINTER(ARRAY(c_char_p, 2))
 483   jacklib.jack_port_get_aliases.restype = c_int
 484   return jacklib.jack_port_get_aliases(port, pointer(c_char_p(aliases)))
 485
 486 def port_request_monitor(port, onoff):
 487   jacklib.jack_port_request_monitor.argtypes = [jack_port_t, c_int]
 488   jacklib.jack_port_request_monitor.restype = c_int
 489   return jacklib.jack_port_request_monitor(port, onoff)
 490
 491 def port_request_monitor_by_name(client, port_name, onoff):
 492   jacklib.jack_port_request_monitor_by_name.argtypes = [jack_client_t, c_char_p, c_int]
 493   jacklib.jack_port_request_monitor_by_name.restype = c_int
 494   return jacklib.jack_port_request_monitor_by_name(client, port_name, onoff)
 495
 496 def port_ensure_monitor(port, onoff):
 497   jacklib.jack_port_ensure_monitor.argtypes = [jack_port_t, c_int]
 498   jacklib.jack_port_ensure_monitor.restype = c_int
 499   return jacklib.jack_port_ensure_monitor(port, onoff)
 500
 501 def port_monitoring_input(port):
 502   jacklib.jack_port_monitoring_input.argtypes = [jack_port_t]
 503   jacklib.jack_port_monitoring_input.restype = c_int
 504   return jacklib.jack_port_monitoring_input(port)
 505
 506 def connect(client, source_port, destination_port):
 507   jacklib.jack_connect.argtypes = [jack_client_t, c_char_p, c_char_p]
 508   jacklib.jack_connect.restype = c_int
 509   return jacklib.jack_connect(client, source_port, destination_port)
 510
 511 def disconnect(client, source_port, destination_port):
 512   jacklib.jack_disconnect.argtypes = [jack_client_t, c_char_p, c_char_p]
 513   jacklib.jack_disconnect.restype = c_int
 514   return jacklib.jack_disconnect(client, source_port, destination_port)
 515
 516 def port_disconnect(client, port):
 517   jacklib.jack_port_disconnect.argtypes = [jack_client_t, jack_port_t]
 518   jacklib.jack_port_disconnect.restype = c_int
 519   return jacklib.jack_port_disconnect(client, port)
 520
 521 def port_name_size():
 522   jacklib.jack_port_name_size.argtypes = None
 523   jacklib.jack_port_name_size.restype = c_int
 524   return jacklib.jack_port_name_size()
 525
 526 def port_type_size():
 527   jacklib.jack_port_type_size.argtypes = None
 528   jacklib.jack_port_type_size.restype = c_int
 529   return jacklib.jack_port_type_size()
 530
 531
 532 # PortSearching
 533
 534 def get_ports(client, port_name_pattern, type_name_pattern, flags):
 535   jacklib.jack_get_ports.argtypes = [jack_client_t, c_char_p, c_char_p, c_ulong]
 536   jacklib.jack_get_ports.restype = POINTER(c_char_p)
 537   list_p = jacklib.jack_get_ports(client, port_name_pattern, type_name_pattern, flags)
 538   return __pointer_to_list(list_p)
 539
 540 def port_by_name(client, port_name):
 541   jacklib.jack_port_by_name.argtypes = [jack_client_t, c_char_p]
 542   jacklib.jack_port_by_name.restype = jack_port_t
 543   return jacklib.jack_port_by_name(client, port_name)
 544
 545 def port_by_id(client, port_id):
 546   jacklib.jack_port_by_id.argtypes = [jack_client_t, jack_port_id_t]
 547   jacklib.jack_port_by_id.restype = jack_port_t
 548   return jacklib.jack_port_by_id(client, port_id)
 549
 550
 551 # TimeFunctions
 552
 553 def frames_since_cycle_start(client):
 554   jacklib.jack_frames_since_cycle_start.argtypes = [jack_client_t]
 555   jacklib.jack_frames_since_cycle_start.restype = jack_nframes_t
 556   return jacklib.jack_frames_since_cycle_start(client)
 557
 558 def frame_time(client):
 559   jacklib.jack_frame_time.argtypes = [jack_client_t]
 560   jacklib.jack_frame_time.restype = jack_nframes_t
 561   return jacklib.jack_frame_time(client)
 562
 563 def last_frame_time(client):
 564   jacklib.jack_last_frame_time.argtypes = [jack_client_t]
 565   jacklib.jack_last_frame_time.restype = jack_nframes_t
 566   return jacklib.jack_last_frame_time(client)
 567
 568 def frames_to_time(client, nframes):
 569   jacklib.jack_frames_to_time.argtypes = [jack_client_t, jack_nframes_t]
 570   jacklib.jack_frames_to_time.restype = jack_time_t
 571   return jacklib.jack_frames_to_time(client, nframes)
 572
 573 def time_to_frames(client, time):
 574   jacklib.jack_time_to_frames.argtypes = [jack_client_t, jack_time_t]
 575   jacklib.jack_time_to_frames.restype = jack_nframes_t
 576   return jacklib.jack_time_to_frames(client, time)
 577
 578 def get_time():
 579   jacklib.jack_get_time.argtypes = [None]
 580   jacklib.jack_get_time.restype = jack_time_t
 581   return jacklib.jack_get_time()
 582
 583
 584 # Transport
 585
 586 def release_timebase(client):
 587   jacklib.jack_release_timebase.argtypes = [jack_client_t]
 588   jacklib.jack_release_timebase.restype = c_int
 589   return jacklib.jack_release_timebase(client)
 590
 591 def set_sync_callback(client, sync_callback, arg=None):
 592   global SyncCallback
 593   SyncCallback = CFUNCTYPE(c_int, c_int, type(pointer(jack_position_t)), c_void_p)(sync_callback)
 594   jacklib.jack_set_sync_callback.restype = c_int
 595   return jacklib.jack_set_sync_callback(client, SyncCallback, arg)
 596
 597 def set_sync_timeout(client, timeout):
 598   jacklib.jack_set_sync_timeout.argtypes = [jack_client_t, jack_time_t]
 599   jacklib.jack_set_sync_timeout.restype = c_int
 600   return jacklib.jack_set_sync_timeout(client, timeout)
 601
 602 def set_timebase_callback(client, conditional, timebase_callback, arg=None):
 603   global TimebaseCallback
 604   TimebaseCallback = CFUNCTYPE(c_int, c_int, c_int, type(pointer(jack_position_t)), c_int, c_void_p)(sync_callback)
 605   jacklib.jack_set_timebase_callback.restype = c_int
 606   return jacklib.jack_set_timebase_callback(client, conditional, TimebaseCallback, arg)
 607
 608 def transport_locate(client, frame):
 609   jacklib.jack_transport_locate.argtypes = [jack_client_t, jack_nframes_t]
 610   jacklib.jack_transport_locate.restype = c_int
 611   return jacklib.jack_transport_locate(client, frame)
 612
 613 def transport_query(client, pos=None): #FIXME - weird crash when using pointer(pos) (on exit only)
 614   jacklib.jack_transport_query.restype = c_int
 615   if (pos):
 616     jacklib.jack_transport_query.argtypes = [jack_client_t, type(pointer(jack_position_t))]
 617     return jacklib.jack_transport_query(client, pointer(pos))
 618   else:
 619     return jacklib.jack_transport_query(client, None)
 620
 621 def get_current_transport_frame(client):
 622   jacklib.jack_get_current_transport_frame.argtypes = [jack_client_t]
 623   jacklib.jack_get_current_transport_frame.restype = jack_nframes_t
 624   return jacklib.jack_get_current_transport_frame(client)
 625
 626 def transport_reposition(client, pos): #FIXME - weird crash when using pointer(pos) (on exit only)
 627   jacklib.jack_transport_reposition.argtypes = [jack_client_t, type(pointer(jack_position_t))]
 628   jacklib.jack_transport_reposition.restype = c_int
 629   return jacklib.jack_transport_reposition(client, pointer(pos))
 630
 631 def transport_start(client):
 632   jacklib.jack_transport_start.argtypes = [jack_client_t]
 633   jacklib.jack_transport_start.restype = None
 634   return jacklib.jack_transport_start(client)
 635
 636 def transport_stop(client):
 637   jacklib.jack_transport_stop.argtypes = [jack_client_t]
 638   jacklib.jack_transport_stop.restype = None
 639   return jacklib.jack_transport_stop(client)
 640
 641 def jack_free(ptr):
 642   jacklib.jack_free.argtypes = [c_void_p]
 643   jacklib.jack_free.restype = None
 644   return jacklib.jack_free(ptr)
 645
 646
 647 # Session Client Functions
 648
 649 def set_session_callback(client, session_callback, arg=None):
 650   global SessionCallback
 651   SessionCallback = CFUNCTYPE(jack_session_event_t, c_void_p)(session_callback)
 652   jacklib.jack_set_session_callback.restype = c_int
 653   return jacklib.jack_set_session_callback(client, SessionCallback, arg)
 654
 655 def session_reply(client, event):
 656   jacklib.jack_session_reply.argtypes = [jack_client_t, jack_session_event_t]
 657   jacklib.jack_session_reply.restype = c_int
 658   return jacklib.jack_session_reply(client, event)
 659
 660 def session_event_free(event):
 661   jacklib.jack_session_event_free.argtypes = [jack_session_event_t]
 662   jacklib.jack_session_event_free.restype = None
 663   return jacklib.jack_session_event_free(event)
 664
 665 def client_get_uuid(client):
 666   jacklib.jack_client_get_uuid.argtypes = [jack_client_t]
 667   jacklib.jack_client_get_uuid.restype = c_char_p
 668   return jacklib.jack_client_get_uuid(client)
 669
 670 def session_notify(client, target, type_, path):
 671   jacklib.jack_session_notify.argtypes = [jack_client_t, c_char_p, jack_session_event_type_t, c_char_p]
 672   jacklib.jack_session_notify.restype = c_int
 673   return jacklib.jack_session_notify(client, target, type_, path)
 674
 675 def session_commands_free(cmds):
 676   jacklib.jack_session_commands_free.argtypes = [jack_session_command_t]
 677   jacklib.jack_session_commands_free.restype = None
 678   return jacklib.jack_session_commands_free(cmds)
 679
 680 def get_uuid_for_client_name(client, client_name):
 681   jacklib.jack_get_uuid_for_client_name.argtypes = [jack_client_t, c_char_p]
 682   jacklib.jack_get_uuid_for_client_name.restype = c_char_p
 683   return jacklib.jack_get_uuid_for_client_name(client, client_name)
 684
 685 def get_client_name_by_uuid(client, client_uuid):
 686   jacklib.jack_get_client_name_by_uuid.argtypes = [jack_client_t, c_char_p]
 687   jacklib.jack_get_client_name_by_uuid.restype = c_char_p
 688   return jacklib.jack_get_client_name_by_uuid(client, client_uuid)
 689
 690 def reserve_client_name(client, name, uuid):
 691   jacklib.jack_reserve_client_name.argtypes = [jack_client_t, c_char_p, c_char_p]
 692   jacklib.jack_reserve_client_name.restype = c_int
 693   return jacklib.jack_reserve_client_name(client, name, uuid)