Switch to CFFI out-of-line ABI mode

CONTRIBUTING.rst

@@ -24,6 +24,10 @@ If you prefer, you can also replace the last command with::
 
 ... where ``-e`` stands for ``--editable``.
 
+Whenever the file ``jack_build.py`` changes (either because you edited it or it
+was updated by pulling from Github or switching branches), you have to run the
+last command again.
+
 If you make changes to the documentation, you can locally re-create the HTML
 pages using Sphinx_.
 You can install it and a few other necessary packages with::

MANIFEST.in

@@ -1,4 +1,5 @@
 include LICENSE
+include jack_build.py
 include *.rst
 include doc/requirements.txt
 recursive-include doc *.rst *.py

doc/conf.py

@@ -23,8 +23,8 @@
 sys.path.insert(0, os.path.abspath('.'))
 
 # Fake import to avoid actually loading CFFI and the JACK library
-import fake_cffi
-sys.modules['cffi'] = sys.modules['fake_cffi']
+import fake__jack
+sys.modules['_jack'] = sys.modules['fake__jack']
 
 # -- General configuration ------------------------------------------------
 

doc/fake_cffi.py → doc/fake__jack.py

@@ -1,17 +1,24 @@
 """Mock module for Sphinx autodoc."""
 
 
-class FFI(object):
+import ctypes
 
-    def cdef(self, _, packed=NotImplemented):
-        pass
 
-    def dlopen(self, _):
-        return self
+# Monkey-patch ctypes to disable searching for JACK
+ctypes.util.find_library = lambda _: NotImplemented
+
+
+class Fake(object):
 
     NULL = NotImplemented
 
     JackTransportStopped = 0
     JackTransportRolling = 1
     JackTransportStarting = 3
     JackTransportNetStarting = 4
+
+    def dlopen(self, _):
+        return self
+
+
+ffi = Fake()

jack_build.py

@@ -0,0 +1,272 @@
+from cffi import FFI
+
+ffibuilder = FFI()
+ffibuilder.set_source("_jack", None)
+ffibuilder.cdef("""
+
+/* types.h */
+
+typedef uint64_t jack_uuid_t;
+typedef uint32_t jack_nframes_t;
+typedef uint64_t jack_time_t;
+typedef struct _jack_port jack_port_t;
+typedef struct _jack_client jack_client_t;
+typedef uint32_t jack_port_id_t;
+typedef uint32_t jack_port_type_id_t;
+enum JackOptions {
+    JackNullOption = 0x00,
+    JackNoStartServer = 0x01,
+    JackUseExactName = 0x02,
+    JackServerName = 0x04,
+    JackLoadName = 0x08,
+    JackLoadInit = 0x10,
+    JackSessionID = 0x20
+};
+typedef enum JackOptions jack_options_t;
+enum JackStatus {
+    JackFailure = 0x01,
+    JackInvalidOption = 0x02,
+    JackNameNotUnique = 0x04,
+    JackServerStarted = 0x08,
+    JackServerFailed = 0x10,
+    JackServerError = 0x20,
+    JackNoSuchClient = 0x40,
+    JackLoadFailure = 0x80,
+    JackInitFailure = 0x100,
+    JackShmFailure = 0x200,
+    JackVersionError = 0x400,
+    JackBackendError = 0x800,
+    JackClientZombie = 0x1000
+};
+typedef enum JackStatus jack_status_t;
+typedef int (*JackProcessCallback)(jack_nframes_t nframes, void* arg);
+typedef int (*JackGraphOrderCallback)(void* arg);
+typedef int (*JackXRunCallback)(void* arg);
+typedef int (*JackBufferSizeCallback)(jack_nframes_t nframes, void* arg);
+typedef int (*JackSampleRateCallback)(jack_nframes_t nframes, void* arg);
+typedef void (*JackPortRegistrationCallback)(jack_port_id_t port, int /* register */, void* arg);
+typedef void (*JackClientRegistrationCallback)(const char* name, int /* register */, void* arg);
+typedef void (*JackPortConnectCallback)(jack_port_id_t a, jack_port_id_t b, int connect, void* arg);
+typedef int (*JackPortRenameCallback)(jack_port_id_t port, const char* old_name, const char* new_name, void* arg);
+typedef void (*JackFreewheelCallback)(int starting, void* arg);
+/* not implemented: JackShutdownCallback (only JackInfoShutdownCallback is used) */
+typedef void (*JackInfoShutdownCallback)(jack_status_t code, const char* reason, void* arg);
+/* JACK_DEFAULT_AUDIO_TYPE: see _AUDIO */
+/* JACK_DEFAULT_MIDI_TYPE: see _MIDI */
+/* not implemented: jack_default_audio_sample_t (hard-coded as float) */
+enum JackPortFlags {
+    JackPortIsInput = 0x1,
+    JackPortIsOutput = 0x2,
+    JackPortIsPhysical = 0x4,
+    JackPortCanMonitor = 0x8,
+    JackPortIsTerminal = 0x10,
+};
+typedef enum {
+    JackTransportStopped = 0,
+    JackTransportRolling = 1,
+    JackTransportLooping = 2,  /* deprecated */
+    JackTransportStarting = 3,
+    JackTransportNetStarting = 4,
+} jack_transport_state_t;
+typedef uint64_t jack_unique_t;
+typedef enum {
+    JackPositionBBT = 0x10,
+    JackPositionTimecode = 0x20,
+    JackBBTFrameOffset = 0x40,
+    JackAudioVideoRatio = 0x80,
+    JackVideoFrameOffset = 0x100,
+} jack_position_bits_t;
+/* _jack_position: see below in "packed" section */
+typedef struct _jack_position jack_position_t;
+typedef void (*JackTimebaseCallback)(jack_transport_state_t state, jack_nframes_t nframes, jack_position_t *pos, int new_pos, void *arg);
+/* deprecated: jack_transport_bits_t */
+/* deprecated: jack_transport_info_t */
+
+/* jack.h */
+
+void jack_get_version(int* major_ptr, int* minor_ptr, int* micro_ptr, int* proto_ptr);
+const char* jack_get_version_string();
+jack_client_t* jack_client_open(const char* client_name, jack_options_t options, jack_status_t* status, ...);
+/* deprecated: jack_client_new */
+int jack_client_close(jack_client_t* client);
+int jack_client_name_size(void);
+char* jack_get_client_name(jack_client_t* client);
+char* jack_get_uuid_for_client_name(jack_client_t* client, const char* client_name);
+char* jack_get_client_name_by_uuid(jack_client_t* client, const char* client_uuid);
+/* deprecated: jack_internal_client_new */
+/* deprecated: jack_internal_client_close */
+int jack_activate(jack_client_t* client);
+int jack_deactivate(jack_client_t* client);
+int jack_get_client_pid(const char* name);
+/* not implemented: jack_client_thread_id */
+int jack_is_realtime(jack_client_t* client);
+/* deprecated: jack_thread_wait */
+/* not implemented: jack_cycle_wait */
+/* not implemented: jack_cycle_signal */
+/* not implemented: jack_set_process_thread */
+/* not implemented: jack_set_thread_init_callback */
+/* not implemented (jack_on_info_shutdown is used): jack_on_shutdown */
+void jack_on_info_shutdown(jack_client_t* client, JackInfoShutdownCallback shutdown_callback, void* arg);
+int jack_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg);
+int jack_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg);
+int jack_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg);
+int jack_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg);
+int jack_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg);
+int jack_set_port_registration_callback(jack_client_t* client, JackPortRegistrationCallback registration_callback, void* arg);
+int jack_set_port_connect_callback(jack_client_t* client, JackPortConnectCallback connect_callback, void* arg);
+int jack_set_port_rename_callback(jack_client_t* client, JackPortRenameCallback rename_callback, void* arg);
+int jack_set_graph_order_callback(jack_client_t* client, JackGraphOrderCallback graph_callback, void*);
+int jack_set_xrun_callback(jack_client_t* client, JackXRunCallback xrun_callback, void* arg);
+/* TODO: jack_set_latency_callback */
+int jack_set_freewheel(jack_client_t* client, int onoff);
+int jack_set_buffer_size(jack_client_t* client, jack_nframes_t nframes);
+jack_nframes_t jack_get_sample_rate(jack_client_t*);
+jack_nframes_t jack_get_buffer_size(jack_client_t*);
+/* deprecated: jack_engine_takeover_timebase */
+float jack_cpu_load(jack_client_t* client);
+jack_port_t* jack_port_register(jack_client_t* client, const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size);
+int jack_port_unregister(jack_client_t* client, jack_port_t* port);
+void* jack_port_get_buffer(jack_port_t* port, jack_nframes_t);
+jack_uuid_t jack_port_uuid(const jack_port_t* port);
+const char* jack_port_name(const jack_port_t* port);
+const char* jack_port_short_name(const jack_port_t* port);
+int jack_port_flags(const jack_port_t* port);
+const char* jack_port_type(const jack_port_t* port);
+/* not implemented: jack_port_type_id */
+int jack_port_is_mine(const jack_client_t* client, const jack_port_t* port);
+int jack_port_connected(const jack_port_t* port);
+int jack_port_connected_to(const jack_port_t* port, const char* port_name);
+const char** jack_port_get_connections(const jack_port_t* port);
+const char** jack_port_get_all_connections(const jack_client_t* client, const jack_port_t* port);
+/* deprecated: jack_port_tie */
+/* deprecated: jack_port_untie */
+int jack_port_set_name(jack_port_t* port, const char* port_name);
+/* TODO: jack_port_set_alias */
+/* TODO: jack_port_unset_alias */
+/* TODO: jack_port_get_aliases */
+int jack_port_request_monitor(jack_port_t *port, int onoff);
+/* not implemented (use jack_port_request_monitor): jack_port_request_monitor_by_name */
+/* TODO: jack_port_ensure_monitor */
+/* TODO: jack_port_monitoring_input */
+int jack_connect(jack_client_t* client, const char* source_port, const char* destination_port);
+int jack_disconnect(jack_client_t* client, const char* source_port, const char* destination_port);
+int jack_port_disconnect(jack_client_t* client, jack_port_t* port);
+int jack_port_name_size(void);
+/* not implemented: jack_port_type_size */
+/* not implemented: jack_port_type_get_buffer_size */
+/* TODO: jack_port_set_latency */
+/* TODO: jack_port_get_latency_range */
+/* TODO: jack_port_set_latency_range */
+/* TODO: jack_recompute_total_latencies */
+/* TODO: jack_port_get_latency */
+/* TODO: jack_port_get_total_latency */
+/* TODO: jack_recompute_total_latency */
+const char** jack_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, unsigned long flags);
+jack_port_t* jack_port_by_name(jack_client_t* client, const char* port_name);
+jack_port_t* jack_port_by_id(jack_client_t* client, jack_port_id_t port_id);
+jack_nframes_t jack_frames_since_cycle_start(const jack_client_t*);
+jack_nframes_t jack_frame_time(const jack_client_t*);
+jack_nframes_t jack_last_frame_time(const jack_client_t* client);
+/* TODO: jack_get_cycle_times */
+/* TODO: jack_frames_to_time */
+/* TODO: jack_time_to_frames */
+/* TODO: jack_get_time */
+void jack_set_error_function(void (*func)(const char*));
+void jack_set_info_function(void (*func)(const char*));
+void jack_free(void* ptr);
+
+/* ringbuffer.h */
+
+typedef struct {
+    char* buf;
+    size_t len;
+} jack_ringbuffer_data_t;
+typedef struct {
+    char* buf;
+    volatile size_t write_ptr;
+    volatile size_t read_ptr;
+    size_t size;
+    size_t size_mask;
+    int mlocked;
+} jack_ringbuffer_t;
+jack_ringbuffer_t* jack_ringbuffer_create(size_t sz);
+void jack_ringbuffer_free(jack_ringbuffer_t* rb);
+void jack_ringbuffer_get_read_vector(const jack_ringbuffer_t* rb, jack_ringbuffer_data_t* vec);
+void jack_ringbuffer_get_write_vector(const jack_ringbuffer_t* rb, jack_ringbuffer_data_t* vec);
+size_t jack_ringbuffer_read(jack_ringbuffer_t* rb, char* dest, size_t cnt);
+size_t jack_ringbuffer_peek(jack_ringbuffer_t* rb, char* dest, size_t cnt);
+void jack_ringbuffer_read_advance(jack_ringbuffer_t* rb, size_t cnt);
+size_t jack_ringbuffer_read_space(const jack_ringbuffer_t* rb);
+int jack_ringbuffer_mlock(jack_ringbuffer_t* rb);
+void jack_ringbuffer_reset(jack_ringbuffer_t* rb);
+void jack_ringbuffer_reset_size (jack_ringbuffer_t* rb, size_t sz);
+/* Note: "char*" was changed to "unsigned char*" to support iterables of int */
+size_t jack_ringbuffer_write(jack_ringbuffer_t* rb, const unsigned char* src, size_t cnt);
+void jack_ringbuffer_write_advance(jack_ringbuffer_t* rb, size_t cnt);
+size_t jack_ringbuffer_write_space(const jack_ringbuffer_t* rb);
+
+/* transport.h */
+
+/* TODO: jack_release_timebase */
+/* TODO: jack_set_sync_callback */
+/* TODO: jack_set_sync_timeout */
+int jack_set_timebase_callback(jack_client_t* client, int conditional, JackTimebaseCallback timebase_callback, void* arg);
+int jack_transport_locate(jack_client_t* client, jack_nframes_t frame);
+jack_transport_state_t jack_transport_query(const jack_client_t* client, jack_position_t* pos);
+jack_nframes_t jack_get_current_transport_frame(const jack_client_t* client);
+int jack_transport_reposition(jack_client_t* client, const jack_position_t* pos);
+void jack_transport_start(jack_client_t* client);
+void jack_transport_stop(jack_client_t* client);
+/* deprecated: jack_get_transport_info */
+/* deprecated: jack_set_transport_info */
+
+/* statistics.h */
+
+float jack_get_xrun_delayed_usecs(jack_client_t* client);
+
+/* midiport.h */
+
+typedef unsigned char jack_midi_data_t;
+typedef struct _jack_midi_event {
+    jack_nframes_t time;
+    size_t size;
+    jack_midi_data_t* buffer;
+} jack_midi_event_t;
+uint32_t jack_midi_get_event_count(void* port_buffer);
+int jack_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index);
+void jack_midi_clear_buffer(void* port_buffer);
+/* not implemented: jack_midi_reset_buffer */
+size_t jack_midi_max_event_size(void* port_buffer);
+jack_midi_data_t* jack_midi_event_reserve(void* port_buffer, jack_nframes_t time, size_t data_size);
+int jack_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, size_t data_size);
+uint32_t jack_midi_get_lost_event_count(void* port_buffer);
+""")
+
+# Packed structure
+ffibuilder.cdef("""
+struct _jack_position {
+    jack_unique_t unique_1;
+    jack_time_t usecs;
+    jack_nframes_t frame_rate;
+    jack_nframes_t frame;
+    jack_position_bits_t valid;
+    int32_t bar;
+    int32_t beat;
+    int32_t tick;
+    double bar_start_tick;
+    float beats_per_bar;
+    float beat_type;
+    double ticks_per_beat;
+    double beats_per_minute;
+    double frame_time;
+    double next_time;
+    jack_nframes_t bbt_offset;
+    float audio_frames_per_video_frame;
+    jack_nframes_t video_offset;
+    int32_t padding[7];
+    jack_unique_t unique_2;
+};
+""", packed=True)
+
+if __name__ == "__main__":
+    ffibuilder.compile(verbose=True)

setup.py

@@ -29,8 +29,10 @@ def run_tests(self):
     version=__version__,
     package_dir={'': 'src'},
     py_modules=['jack'],
-    install_requires=['CFFI'],
+    setup_requires=['CFFI>=1.0'],
+    install_requires=['CFFI>=1.0'],
     extras_require={'NumPy': ['NumPy']},
+    cffi_modules=['jack_build.py:ffibuilder'],
     author='Matthias Geier',
     author_email='Matthias.Geier@gmail.com',
     description='JACK Audio Connection Kit (JACK) Client for Python',