Package zzub
[hide private]
[frames] | no frames]

Package zzub

source code

Classes [hide private]
  zzub_plugin_t
Plugin methods Retreive more details about plugins.
  zzub_event_data_new_plugin_t
  zzub_event_data_delete_plugin_t
  zzub_event_data_midi_message_t
  zzub_event_data_connect_t
  zzub_event_data_plugin_changed_t
  zzub_event_data_change_parameter_t
  zzub_event_data_set_tracks_t
  zzub_event_data_player_state_changed_t
  zzub_event_data_osc_message_t
  zzub_event_data_vu_t
  zzub_archive_t
  zzub_event_data_serialize_t
  zzub_event_data_set_sequence_tracks_t
  zzub_event_data_set_sequence_event_t
  zzub_event_data_new_pattern_t
  zzub_event_data_delete_pattern_t
  zzub_event_data_edit_pattern_t
  zzub_event_data_pattern_changed_t
  zzub_wave_t
Wave table
  zzub_event_data_change_wave_t
  zzub_event_data_delete_wave_t
  zzub_wavelevel_t
Wavelevel
  zzub_event_data_allocate_wavelevel_t
  zzub_event_data_pattern_insert_rows_t
  zzub_event_data_pattern_remove_rows_t
  zzub_event_data_custom_t
  zzub_event_data_all_t
  zzub_event_data_unknown_t
  zzub_event_data_union_00000000_t
  zzub_event_data_t
  zzub_audiodriver_t
Audio Driver Methods Configure and create an audio driver instance.
  zzub_mididriver_t
MIDI Driver Methods Open midi devices.
  zzub_plugincollection_t
Plugin Collection Methods For enumerating and configuring plugin collections.
  zzub_input_t
  zzub_output_t
  zzub_midimapping_t
MIDI Mapping Methods
  zzub_pattern_t
Offline pattern methods These functions are meant to help editing patterns.
  zzub_parameter_t
Parameter methods Retreive more details from zzub_parameter_t objects.
  zzub_attribute_t
Attribute methods Retreive more details from zzub_attribute_t objects.
  zzub_pluginloader_t
Plugin loading methods Retreive more details from zzub_pluginloader_t objects.
  zzub_sequence_t
Sequencer methods
  zzub_envelope_t
Envelopes
  zzub_recorder_t
Memory and file streams - load/save from/to file/clipboard Create file or memory data streams for use by e.g zzub_wavetable_load_sample() and zzub_player_load_bmx()/zzub_player_save_bmx().
  zzub_player_t
Player Methods
  EventData
  Audiodriver
Audio Driver Methods Configure and create an audio driver instance.
  Mididriver
MIDI Driver Methods Open midi devices.
  Plugincollection
Plugin Collection Methods For enumerating and configuring plugin collections.
  Input
  Output
  Archive
  Midimapping
MIDI Mapping Methods
  Pattern
Offline pattern methods These functions are meant to help editing patterns.
  Parameter
Parameter methods Retreive more details from zzub_parameter_t objects.
  Attribute
Attribute methods Retreive more details from zzub_attribute_t objects.
  Pluginloader
Plugin loading methods Retreive more details from zzub_pluginloader_t objects.
  Plugin
Plugin methods Retreive more details about plugins.
  Sequence
Sequencer methods
  Wavelevel
Wavelevel
  Envelope
Envelopes
  Wave
Wave table
  Recorder
Memory and file streams - load/save from/to file/clipboard Create file or memory data streams for use by e.g zzub_wavetable_load_sample() and zzub_player_load_bmx()/zzub_player_save_bmx().
  Player
Player Methods
Functions [hide private]
ctypes CDLL handle
load_library(*names, **kw)
searches for a library with given names and returns a ctypes .so/.dll library object if successful.
source code
 
dlopen(*args, **kwds)
Opens a library by name and returns a handle object.
source code
 
dlsym(lib, name, restype, *args)
Retrieves a symbol from a library loaded by dlopen and assigns correct result and argument types.
source code
 
callback_from_param(cls, obj)
A workaround to assign None to a CFUNCTYPE object.
source code
Variables [hide private]
  libzzub = <CDLL '../../lib/libzzub.so', handle 1016bb60 at 104...
  zzub_version = 15
  zzub_buffer_size = 256
  zzub_event_type_pre_flag = 16384
  zzub_event_type_double_click = 0
  zzub_event_type_new_plugin = 1
  zzub_event_type_delete_plugin = 2
  zzub_event_type_pre_delete_plugin = 9
  zzub_event_type_disconnect = 3
  zzub_event_type_connect = 4
  zzub_event_type_plugin_changed = 30
  zzub_event_type_parameter_changed = 7
  zzub_event_type_set_tracks = 13
  zzub_event_type_set_sequence_tracks = 23
  zzub_event_type_set_sequence_event = 24
  zzub_event_type_new_pattern = 25
  zzub_event_type_delete_pattern = 26
  zzub_event_type_pre_delete_pattern = 47
  zzub_event_type_edit_pattern = 27
  zzub_event_type_pattern_changed = 31
  zzub_event_type_pattern_insert_rows = 42
  zzub_event_type_pattern_remove_rows = 43
  zzub_event_type_sequencer_add_track = 32
  zzub_event_type_sequencer_remove_track = 33
  zzub_event_type_sequencer_changed = 41
  zzub_event_type_pre_disconnect = 34
  zzub_event_type_pre_connect = 35
  zzub_event_type_post_connect = 46
  zzub_event_type_pre_set_tracks = 36
  zzub_event_type_post_set_tracks = 45
  zzub_event_type_envelope_changed = 37
  zzub_event_type_slices_changed = 38
  zzub_event_type_wave_changed = 39
  zzub_event_type_delete_wave = 40
  zzub_event_type_load_progress = 8
  zzub_event_type_midi_control = 11
  zzub_event_type_wave_allocated = 12
  zzub_event_type_player_state_changed = 20
  zzub_event_type_osc_message = 21
  zzub_event_type_vu = 22
  zzub_event_type_custom = 44
  zzub_event_type_all = 255
  zzub_player_state_playing = 0
  zzub_player_state_stopped = 1
  zzub_player_state_muted = 2
  zzub_player_state_released = 3
  zzub_parameter_type_note = 0
  zzub_parameter_type_switch = 1
  zzub_parameter_type_byte = 2
  zzub_parameter_type_word = 3
  zzub_wave_buffer_type_si16 = 0
  zzub_wave_buffer_type_f32 = 1
  zzub_wave_buffer_type_si32 = 2
  zzub_wave_buffer_type_si24 = 3
  zzub_oscillator_type_sine = 0
  zzub_oscillator_type_sawtooth = 1
  zzub_oscillator_type_pulse = 2
  zzub_oscillator_type_triangle = 3
  zzub_oscillator_type_noise = 4
  zzub_oscillator_type_sawtooth_303 = 5
  zzub_note_value_none = 0
  zzub_note_value_off = 255
  zzub_note_value_min = 1
  zzub_note_value_max = 156
  zzub_note_value_c4 = 65
  zzub_switch_value_none = 255
  zzub_switch_value_off = 0
  zzub_switch_value_on = 1
  zzub_wavetable_index_value_none = 0
  zzub_wavetable_index_value_min = 1
  zzub_wavetable_index_value_max = 200
  zzub_parameter_flag_wavetable_index = 1
  zzub_parameter_flag_state = 2
  zzub_parameter_flag_event_on_edit = 4
  zzub_plugin_flag_mono_to_stereo = 1
  zzub_plugin_flag_plays_waves = 2
  zzub_plugin_flag_uses_lib_interface = 4
  zzub_plugin_flag_uses_instruments = 8
  zzub_plugin_flag_does_input_mixing = 16
  zzub_plugin_flag_no_output = 32
  zzub_plugin_flag_control_plugin = 64
  zzub_plugin_flag_auxiliary = 128
  zzub_plugin_flag_is_root = 65536
  zzub_plugin_flag_has_audio_input = 131072
  zzub_plugin_flag_has_audio_output = 262144
  zzub_plugin_flag_has_event_input = 524288
  zzub_plugin_flag_has_event_output = 1048576
  zzub_plugin_flag_offline = 2097152
  zzub_plugin_flag_stream = 4194304
  zzub_plugin_flag_import = 33554432
  zzub_plugin_flag_has_midi_input = 8388608
  zzub_plugin_flag_has_midi_output = 16777216
  zzub_plugin_flag_no_undo = 33554432
  zzub_plugin_flag_no_save = 67108864
  zzub_state_flag_playing = 1
  zzub_state_flag_recording = 2
  zzub_wave_flag_loop = 1
  zzub_wave_flag_extended = 4
  zzub_wave_flag_stereo = 8
  zzub_wave_flag_pingpong = 16
  zzub_wave_flag_envelope = 128
  zzub_envelope_flag_sustain = 1
  zzub_envelope_flag_loop = 2
  zzub_process_mode_no_io = 0
  zzub_process_mode_read = 1
  zzub_process_mode_write = 2
  zzub_process_mode_read_write = 3
  zzub_connection_type_audio = 0
  zzub_connection_type_event = 1
  zzub_connection_type_midi = 2
  zzub_parameter_group_connection = 0
  zzub_parameter_group_global = 1
  zzub_parameter_group_track = 2
  zzub_sequence_type_pattern = 0
  zzub_sequence_type_wave = 1
  zzub_sequence_type_automation = 2
  zzub_audiodriver_create_portaudio = dlsym(libzzub, "zzub_audio...
  zzub_audiodriver_create_rtaudio = dlsym(libzzub, "zzub_audiodr...
  zzub_audiodriver_create_silent = dlsym(libzzub, "zzub_audiodri...
  zzub_audiodriver_create = dlsym(libzzub, "zzub_audiodriver_cre...
  zzub_audiodriver_get_count = dlsym(libzzub, "zzub_audiodriver_...
  zzub_audiodriver_get_name = dlsym(libzzub, "zzub_audiodriver_g...
  zzub_audiodriver_get_supported_samplerates = dlsym(libzzub, "z...
  zzub_audiodriver_get_supported_output_channels = dlsym(libzzub...
  zzub_audiodriver_get_supported_input_channels = dlsym(libzzub,...
  zzub_audiodriver_create_device = dlsym(libzzub, "zzub_audiodri...
  zzub_audiodriver_enable = dlsym(libzzub, "zzub_audiodriver_ena...
  zzub_audiodriver_get_enabled = dlsym(libzzub, "zzub_audiodrive...
  zzub_audiodriver_destroy = dlsym(libzzub, "zzub_audiodriver_de...
  zzub_audiodriver_destroy_device = dlsym(libzzub, "zzub_audiodr...
  zzub_audiodriver_set_samplerate = dlsym(libzzub, "zzub_audiodr...
  zzub_audiodriver_get_samplerate = dlsym(libzzub, "zzub_audiodr...
  zzub_audiodriver_set_buffersize = dlsym(libzzub, "zzub_audiodr...
  zzub_audiodriver_get_buffersize = dlsym(libzzub, "zzub_audiodr...
  zzub_audiodriver_get_cpu_load = dlsym(libzzub, "zzub_audiodriv...
  zzub_audiodriver_is_output = dlsym(libzzub, "zzub_audiodriver_...
  zzub_audiodriver_is_input = dlsym(libzzub, "zzub_audiodriver_i...
  zzub_audiodriver_get_master_channel = dlsym(libzzub, "zzub_aud...
  zzub_audiodriver_set_master_channel = dlsym(libzzub, "zzub_aud...
  zzub_mididriver_get_count = dlsym(libzzub, "zzub_mididriver_ge...
  zzub_mididriver_get_name = dlsym(libzzub, "zzub_mididriver_get...
  zzub_mididriver_is_input = dlsym(libzzub, "zzub_mididriver_is_...
  zzub_mididriver_is_output = dlsym(libzzub, "zzub_mididriver_is...
  zzub_mididriver_open = dlsym(libzzub, "zzub_mididriver_open", ...
  zzub_mididriver_close_all = dlsym(libzzub, "zzub_mididriver_cl...
  zzub_plugincollection_get_by_uri = dlsym(libzzub, "zzub_plugin...
  zzub_plugincollection_configure = dlsym(libzzub, "zzub_pluginc...
  zzub_input_open_file = dlsym(libzzub, "zzub_input_open_file", ...
  zzub_input_destroy = dlsym(libzzub, "zzub_input_destroy", None...
  zzub_input_read = dlsym(libzzub, "zzub_input_read", None, ("in...
  zzub_input_size = dlsym(libzzub, "zzub_input_size", c_int, ("i...
  zzub_input_position = dlsym(libzzub, "zzub_input_position", c_...
  zzub_input_seek = dlsym(libzzub, "zzub_input_seek", None, ("in...
  zzub_output_create_file = dlsym(libzzub, "zzub_output_create_f...
  zzub_output_destroy = dlsym(libzzub, "zzub_output_destroy", No...
  zzub_output_write = dlsym(libzzub, "zzub_output_write", None, ...
  zzub_output_position = dlsym(libzzub, "zzub_output_position", ...
  zzub_output_seek = dlsym(libzzub, "zzub_output_seek", None, ("...
  zzub_archive_create_memory = dlsym(libzzub, "zzub_archive_crea...
  zzub_archive_get_output = dlsym(libzzub, "zzub_archive_get_out...
  zzub_archive_get_input = dlsym(libzzub, "zzub_archive_get_inpu...
  zzub_archive_destroy = dlsym(libzzub, "zzub_archive_destroy", ...
  zzub_midimapping_get_plugin = dlsym(libzzub, "zzub_midimapping...
  zzub_midimapping_get_group = dlsym(libzzub, "zzub_midimapping_...
  zzub_midimapping_get_track = dlsym(libzzub, "zzub_midimapping_...
  zzub_midimapping_get_column = dlsym(libzzub, "zzub_midimapping...
  zzub_midimapping_get_channel = dlsym(libzzub, "zzub_midimappin...
  zzub_midimapping_get_controller = dlsym(libzzub, "zzub_midimap...
  zzub_pattern_destroy = dlsym(libzzub, "zzub_pattern_destroy", ...
  zzub_pattern_get_name = dlsym(libzzub, "zzub_pattern_get_name"...
  zzub_pattern_set_name = dlsym(libzzub, "zzub_pattern_set_name"...
  zzub_pattern_get_row_count = dlsym(libzzub, "zzub_pattern_get_...
  zzub_pattern_get_group_count = dlsym(libzzub, "zzub_pattern_ge...
  zzub_pattern_get_track_count = dlsym(libzzub, "zzub_pattern_ge...
  zzub_pattern_get_column_count = dlsym(libzzub, "zzub_pattern_g...
  zzub_pattern_get_value = dlsym(libzzub, "zzub_pattern_get_valu...
  zzub_pattern_set_value = dlsym(libzzub, "zzub_pattern_set_valu...
  zzub_pattern_interpolate = dlsym(libzzub, "zzub_pattern_interp...
  zzub_parameter_get_type = dlsym(libzzub, "zzub_parameter_get_t...
  zzub_parameter_get_name = dlsym(libzzub, "zzub_parameter_get_n...
  zzub_parameter_get_description = dlsym(libzzub, "zzub_paramete...
  zzub_parameter_get_value_min = dlsym(libzzub, "zzub_parameter_...
  zzub_parameter_get_value_max = dlsym(libzzub, "zzub_parameter_...
  zzub_parameter_get_value_none = dlsym(libzzub, "zzub_parameter...
  zzub_parameter_get_value_default = dlsym(libzzub, "zzub_parame...
  zzub_parameter_get_flags = dlsym(libzzub, "zzub_parameter_get_...
  zzub_attribute_get_name = dlsym(libzzub, "zzub_attribute_get_n...
  zzub_attribute_get_value_min = dlsym(libzzub, "zzub_attribute_...
  zzub_attribute_get_value_max = dlsym(libzzub, "zzub_attribute_...
  zzub_attribute_get_value_default = dlsym(libzzub, "zzub_attrib...
  zzub_pluginloader_get_name = dlsym(libzzub, "zzub_pluginloader...
  zzub_pluginloader_get_short_name = dlsym(libzzub, "zzub_plugin...
  zzub_pluginloader_get_parameter_count = dlsym(libzzub, "zzub_p...
  zzub_pluginloader_get_parameter = dlsym(libzzub, "zzub_pluginl...
  zzub_pluginloader_get_attribute_count = dlsym(libzzub, "zzub_p...
  zzub_pluginloader_get_attribute = dlsym(libzzub, "zzub_pluginl...
  zzub_pluginloader_get_loader_name = dlsym(libzzub, "zzub_plugi...
  zzub_pluginloader_get_flags = dlsym(libzzub, "zzub_pluginloade...
  zzub_pluginloader_get_uri = dlsym(libzzub, "zzub_pluginloader_...
  zzub_pluginloader_get_author = dlsym(libzzub, "zzub_pluginload...
  zzub_pluginloader_get_instrument_list = dlsym(libzzub, "zzub_p...
  zzub_pluginloader_get_tracks_min = dlsym(libzzub, "zzub_plugin...
  zzub_pluginloader_get_tracks_max = dlsym(libzzub, "zzub_plugin...
  zzub_pluginloader_get_stream_format_count = dlsym(libzzub, "zz...
  zzub_pluginloader_get_stream_format_ext = dlsym(libzzub, "zzub...
  zzub_plugin_destroy = dlsym(libzzub, "zzub_plugin_destroy", c_...
  zzub_plugin_load = dlsym(libzzub, "zzub_plugin_load", c_int, (...
  zzub_plugin_save = dlsym(libzzub, "zzub_plugin_save", c_int, (...
  zzub_plugin_set_name = dlsym(libzzub, "zzub_plugin_set_name", ...
  zzub_plugin_get_name = dlsym(libzzub, "zzub_plugin_get_name", ...
  zzub_plugin_get_id = dlsym(libzzub, "zzub_plugin_get_id", c_in...
  zzub_plugin_get_position = dlsym(libzzub, "zzub_plugin_get_pos...
  zzub_plugin_set_position = dlsym(libzzub, "zzub_plugin_set_pos...
  zzub_plugin_set_position_direct = dlsym(libzzub, "zzub_plugin_...
  zzub_plugin_get_flags = dlsym(libzzub, "zzub_plugin_get_flags"...
  zzub_plugin_get_track_count = dlsym(libzzub, "zzub_plugin_get_...
  zzub_plugin_set_track_count = dlsym(libzzub, "zzub_plugin_set_...
  zzub_plugin_get_group_track_count = dlsym(libzzub, "zzub_plugi...
  zzub_plugin_get_mute = dlsym(libzzub, "zzub_plugin_get_mute", ...
  zzub_plugin_set_mute = dlsym(libzzub, "zzub_plugin_set_mute", ...
  zzub_plugin_get_bypass = dlsym(libzzub, "zzub_plugin_get_bypas...
  zzub_plugin_configure = dlsym(libzzub, "zzub_plugin_configure"...
  zzub_plugin_set_bypass = dlsym(libzzub, "zzub_plugin_set_bypas...
  zzub_plugin_get_commands = dlsym(libzzub, "zzub_plugin_get_com...
  zzub_plugin_get_sub_commands = dlsym(libzzub, "zzub_plugin_get...
  zzub_plugin_command = dlsym(libzzub, "zzub_plugin_command", No...
  zzub_plugin_get_pluginloader = dlsym(libzzub, "zzub_plugin_get...
  zzub_plugin_get_midi_output_device_count = dlsym(libzzub, "zzu...
  zzub_plugin_get_midi_output_device = dlsym(libzzub, "zzub_plug...
  zzub_plugin_get_envelope_count = dlsym(libzzub, "zzub_plugin_g...
  zzub_plugin_get_envelope_flags = dlsym(libzzub, "zzub_plugin_g...
  zzub_plugin_get_envelope_name = dlsym(libzzub, "zzub_plugin_ge...
  zzub_plugin_set_stream_source = dlsym(libzzub, "zzub_plugin_se...
  zzub_plugin_set_instrument = dlsym(libzzub, "zzub_plugin_set_i...
  zzub_plugin_create_range_pattern = dlsym(libzzub, "zzub_plugin...
  zzub_plugin_create_pattern = dlsym(libzzub, "zzub_plugin_creat...
  zzub_plugin_get_pattern_count = dlsym(libzzub, "zzub_plugin_ge...
  zzub_plugin_add_pattern = dlsym(libzzub, "zzub_plugin_add_patt...
  zzub_plugin_remove_pattern = dlsym(libzzub, "zzub_plugin_remov...
  zzub_plugin_move_pattern = dlsym(libzzub, "zzub_plugin_move_pa...
  zzub_plugin_update_pattern = dlsym(libzzub, "zzub_plugin_updat...
  zzub_plugin_get_pattern = dlsym(libzzub, "zzub_plugin_get_patt...
  zzub_plugin_get_pattern_by_name = dlsym(libzzub, "zzub_plugin_...
  zzub_plugin_get_pattern_name = dlsym(libzzub, "zzub_plugin_get...
  zzub_plugin_set_pattern_name = dlsym(libzzub, "zzub_plugin_set...
  zzub_plugin_get_pattern_length = dlsym(libzzub, "zzub_plugin_g...
  zzub_plugin_set_pattern_length = dlsym(libzzub, "zzub_plugin_s...
  zzub_plugin_get_pattern_value = dlsym(libzzub, "zzub_plugin_ge...
  zzub_plugin_set_pattern_value = dlsym(libzzub, "zzub_plugin_se...
  zzub_plugin_get_new_pattern_name = dlsym(libzzub, "zzub_plugin...
  zzub_plugin_linear_to_pattern = dlsym(libzzub, "zzub_plugin_li...
  zzub_plugin_pattern_to_linear = dlsym(libzzub, "zzub_plugin_pa...
  zzub_plugin_get_pattern_column_count = dlsym(libzzub, "zzub_pl...
  zzub_plugin_insert_pattern_rows = dlsym(libzzub, "zzub_plugin_...
  zzub_plugin_remove_pattern_rows = dlsym(libzzub, "zzub_plugin_...
  zzub_plugin_describe_value = dlsym(libzzub, "zzub_plugin_descr...
  zzub_plugin_get_parameter_value = dlsym(libzzub, "zzub_plugin_...
  zzub_plugin_set_parameter_value = dlsym(libzzub, "zzub_plugin_...
  zzub_plugin_set_parameter_value_direct = dlsym(libzzub, "zzub_...
  zzub_plugin_get_parameter_count = dlsym(libzzub, "zzub_plugin_...
  zzub_plugin_get_parameter = dlsym(libzzub, "zzub_plugin_get_pa...
  zzub_plugin_get_input_connection_count = dlsym(libzzub, "zzub_...
  zzub_plugin_get_input_connection_by_type = dlsym(libzzub, "zzu...
  zzub_plugin_get_input_connection_type = dlsym(libzzub, "zzub_p...
  zzub_plugin_get_input_connection_plugin = dlsym(libzzub, "zzub...
  zzub_plugin_get_output_connection_count = dlsym(libzzub, "zzub...
  zzub_plugin_get_output_connection_by_type = dlsym(libzzub, "zz...
  zzub_plugin_get_output_connection_type = dlsym(libzzub, "zzub_...
  zzub_plugin_get_output_connection_plugin = dlsym(libzzub, "zzu...
  zzub_plugin_add_input = dlsym(libzzub, "zzub_plugin_add_input"...
  zzub_plugin_delete_input = dlsym(libzzub, "zzub_plugin_delete_...
  zzub_plugin_get_mixbuffer = dlsym(libzzub, "zzub_plugin_get_mi...
  zzub_plugin_get_last_peak = dlsym(libzzub, "zzub_plugin_get_la...
  zzub_plugin_get_last_worktime = dlsym(libzzub, "zzub_plugin_ge...
  zzub_plugin_get_last_cpu_load = dlsym(libzzub, "zzub_plugin_ge...
  zzub_plugin_get_last_midi_result = dlsym(libzzub, "zzub_plugin...
  zzub_plugin_get_last_audio_result = dlsym(libzzub, "zzub_plugi...
  zzub_plugin_invoke_event = dlsym(libzzub, "zzub_plugin_invoke_...
  zzub_plugin_tick = dlsym(libzzub, "zzub_plugin_tick", None, ("...
  zzub_plugin_get_attribute_value = dlsym(libzzub, "zzub_plugin_...
  zzub_plugin_set_attribute_value = dlsym(libzzub, "zzub_plugin_...
  zzub_plugin_play_midi_note = dlsym(libzzub, "zzub_plugin_play_...
  zzub_plugin_play_pattern_row_ref = dlsym(libzzub, "zzub_plugin...
  zzub_plugin_play_pattern_row = dlsym(libzzub, "zzub_plugin_pla...
  zzub_plugin_set_midi_connection_device = dlsym(libzzub, "zzub_...
  zzub_plugin_add_event_connection_binding = dlsym(libzzub, "zzu...
  zzub_sequence_destroy = dlsym(libzzub, "zzub_sequence_destroy"...
  zzub_sequence_move = dlsym(libzzub, "zzub_sequence_move", None...
  zzub_sequence_insert_events = dlsym(libzzub, "zzub_sequence_in...
  zzub_sequence_remove_events = dlsym(libzzub, "zzub_sequence_re...
  zzub_sequence_set_event = dlsym(libzzub, "zzub_sequence_set_ev...
  zzub_sequence_get_plugin = dlsym(libzzub, "zzub_sequence_get_p...
  zzub_sequence_get_event_at = dlsym(libzzub, "zzub_sequence_get...
  zzub_sequence_get_event_count = dlsym(libzzub, "zzub_sequence_...
  zzub_sequence_get_event = dlsym(libzzub, "zzub_sequence_get_ev...
  zzub_sequence_get_type = dlsym(libzzub, "zzub_sequence_get_typ...
  zzub_wavelevel_get_wave = dlsym(libzzub, "zzub_wavelevel_get_w...
  zzub_wavelevel_clear = dlsym(libzzub, "zzub_wavelevel_clear", ...
  zzub_wavelevel_get_sample_count = dlsym(libzzub, "zzub_wavelev...
  zzub_wavelevel_set_sample_count = dlsym(libzzub, "zzub_wavelev...
  zzub_wavelevel_get_root_note = dlsym(libzzub, "zzub_wavelevel_...
  zzub_wavelevel_set_root_note = dlsym(libzzub, "zzub_wavelevel_...
  zzub_wavelevel_get_samples_per_second = dlsym(libzzub, "zzub_w...
  zzub_wavelevel_set_samples_per_second = dlsym(libzzub, "zzub_w...
  zzub_wavelevel_get_loop_start = dlsym(libzzub, "zzub_wavelevel...
  zzub_wavelevel_set_loop_start = dlsym(libzzub, "zzub_wavelevel...
  zzub_wavelevel_get_loop_end = dlsym(libzzub, "zzub_wavelevel_g...
  zzub_wavelevel_set_loop_end = dlsym(libzzub, "zzub_wavelevel_s...
  zzub_wavelevel_get_format = dlsym(libzzub, "zzub_wavelevel_get...
  zzub_wavelevel_remove_sample_range = dlsym(libzzub, "zzub_wave...
  zzub_wavelevel_get_samples_digest = dlsym(libzzub, "zzub_wavel...
  zzub_envelope_get_attack = dlsym(libzzub, "zzub_envelope_get_a...
  zzub_envelope_get_decay = dlsym(libzzub, "zzub_envelope_get_de...
  zzub_envelope_get_sustain = dlsym(libzzub, "zzub_envelope_get_...
  zzub_envelope_get_release = dlsym(libzzub, "zzub_envelope_get_...
  zzub_envelope_set_attack = dlsym(libzzub, "zzub_envelope_set_a...
  zzub_envelope_set_decay = dlsym(libzzub, "zzub_envelope_set_de...
  zzub_envelope_set_sustain = dlsym(libzzub, "zzub_envelope_set_...
  zzub_envelope_set_release = dlsym(libzzub, "zzub_envelope_set_...
  zzub_envelope_get_subdivision = dlsym(libzzub, "zzub_envelope_...
  zzub_envelope_set_subdivision = dlsym(libzzub, "zzub_envelope_...
  zzub_envelope_get_flags = dlsym(libzzub, "zzub_envelope_get_fl...
  zzub_envelope_set_flags = dlsym(libzzub, "zzub_envelope_set_fl...
  zzub_envelope_is_enabled = dlsym(libzzub, "zzub_envelope_is_en...
  zzub_envelope_enable = dlsym(libzzub, "zzub_envelope_enable", ...
  zzub_envelope_get_point_count = dlsym(libzzub, "zzub_envelope_...
  zzub_envelope_get_point = dlsym(libzzub, "zzub_envelope_get_po...
  zzub_envelope_set_point = dlsym(libzzub, "zzub_envelope_set_po...
  zzub_envelope_insert_point = dlsym(libzzub, "zzub_envelope_ins...
  zzub_envelope_delete_point = dlsym(libzzub, "zzub_envelope_del...
  zzub_wave_get_index = dlsym(libzzub, "zzub_wave_get_index", c_...
  zzub_wave_load_sample = dlsym(libzzub, "zzub_wave_load_sample"...
  zzub_wave_save_sample = dlsym(libzzub, "zzub_wave_save_sample"...
  zzub_wave_save_sample_range = dlsym(libzzub, "zzub_wave_save_s...
  zzub_wave_clear = dlsym(libzzub, "zzub_wave_clear", c_int, ("w...
  zzub_wave_get_name = dlsym(libzzub, "zzub_wave_get_name", c_ch...
  zzub_wave_set_name = dlsym(libzzub, "zzub_wave_set_name", None...
  zzub_wave_get_path = dlsym(libzzub, "zzub_wave_get_path", c_ch...
  zzub_wave_set_path = dlsym(libzzub, "zzub_wave_set_path", None...
  zzub_wave_get_flags = dlsym(libzzub, "zzub_wave_get_flags", c_...
  zzub_wave_set_flags = dlsym(libzzub, "zzub_wave_set_flags", No...
  zzub_wave_get_volume = dlsym(libzzub, "zzub_wave_get_volume", ...
  zzub_wave_set_volume = dlsym(libzzub, "zzub_wave_set_volume", ...
  zzub_wave_get_envelope_count = dlsym(libzzub, "zzub_wave_get_e...
  zzub_wave_set_envelope_count = dlsym(libzzub, "zzub_wave_set_e...
  zzub_wave_get_envelope = dlsym(libzzub, "zzub_wave_get_envelop...
  zzub_wave_set_envelope = dlsym(libzzub, "zzub_wave_set_envelop...
  zzub_wave_get_level_count = dlsym(libzzub, "zzub_wave_get_leve...
  zzub_wave_get_level = dlsym(libzzub, "zzub_wave_get_level", PO...
  zzub_player_create = dlsym(libzzub, "zzub_player_create", POIN...
  zzub_player_destroy = dlsym(libzzub, "zzub_player_destroy", No...
  zzub_player_add_plugin_path = dlsym(libzzub, "zzub_player_add_...
  zzub_player_blacklist_plugin = dlsym(libzzub, "zzub_player_bla...
  zzub_player_initialize = dlsym(libzzub, "zzub_player_initializ...
  zzub_player_load_bmx = dlsym(libzzub, "zzub_player_load_bmx", ...
  zzub_player_save_bmx = dlsym(libzzub, "zzub_player_save_bmx", ...
  zzub_player_load_ccm = dlsym(libzzub, "zzub_player_load_ccm", ...
  zzub_player_save_ccm = dlsym(libzzub, "zzub_player_save_ccm", ...
  zzub_player_get_state = dlsym(libzzub, "zzub_player_get_state"...
  zzub_player_set_state = dlsym(libzzub, "zzub_player_set_state"...
  zzub_player_get_bpm = dlsym(libzzub, "zzub_player_get_bpm", c_...
  zzub_player_get_tpb = dlsym(libzzub, "zzub_player_get_tpb", c_...
  zzub_player_set_bpm = dlsym(libzzub, "zzub_player_set_bpm", No...
  zzub_player_set_tpb = dlsym(libzzub, "zzub_player_set_tpb", No...
  zzub_player_get_pluginloader_count = dlsym(libzzub, "zzub_play...
  zzub_player_get_pluginloader = dlsym(libzzub, "zzub_player_get...
  zzub_player_get_pluginloader_by_name = dlsym(libzzub, "zzub_pl...
  zzub_player_get_plugin_count = dlsym(libzzub, "zzub_player_get...
  zzub_player_add_midimapping = dlsym(libzzub, "zzub_player_add_...
  zzub_player_remove_midimapping = dlsym(libzzub, "zzub_player_r...
  zzub_player_get_plugin_by_name = dlsym(libzzub, "zzub_player_g...
  zzub_player_get_plugin_by_id = dlsym(libzzub, "zzub_player_get...
  zzub_player_get_plugin = dlsym(libzzub, "zzub_player_get_plugi...
  zzub_player_work_stereo = dlsym(libzzub, "zzub_player_work_ste...
  zzub_player_clear = dlsym(libzzub, "zzub_player_clear", None, ...
  zzub_player_get_position = dlsym(libzzub, "zzub_player_get_pos...
  zzub_player_set_position = dlsym(libzzub, "zzub_player_set_pos...
  zzub_player_get_loop_start = dlsym(libzzub, "zzub_player_get_l...
  zzub_player_get_loop_end = dlsym(libzzub, "zzub_player_get_loo...
  zzub_player_set_loop_start = dlsym(libzzub, "zzub_player_set_l...
  zzub_player_set_loop_end = dlsym(libzzub, "zzub_player_set_loo...
  zzub_player_get_loop = dlsym(libzzub, "zzub_player_get_loop", ...
  zzub_player_set_loop = dlsym(libzzub, "zzub_player_set_loop", ...
  zzub_player_get_song_start = dlsym(libzzub, "zzub_player_get_s...
  zzub_player_get_song_end = dlsym(libzzub, "zzub_player_get_son...
  zzub_player_set_song_start = dlsym(libzzub, "zzub_player_set_s...
  zzub_player_set_song_end = dlsym(libzzub, "zzub_player_set_son...
  zzub_player_set_loop_enabled = dlsym(libzzub, "zzub_player_set...
  zzub_player_get_loop_enabled = dlsym(libzzub, "zzub_player_get...
  zzub_player_get_sequence_track_count = dlsym(libzzub, "zzub_pl...
  zzub_player_get_sequence = dlsym(libzzub, "zzub_player_get_seq...
  zzub_player_get_currently_playing_pattern = dlsym(libzzub, "zz...
  zzub_player_get_currently_playing_pattern_row = dlsym(libzzub,...
  zzub_player_get_wave_count = dlsym(libzzub, "zzub_player_get_w...
  zzub_player_get_wave = dlsym(libzzub, "zzub_player_get_wave", ...
  zzub_player_get_next_event = dlsym(libzzub, "zzub_player_get_n...
  zzub_player_set_callback = dlsym(libzzub, "zzub_player_set_cal...
  zzub_player_handle_events = dlsym(libzzub, "zzub_player_handle...
  zzub_player_set_event_queue_state = dlsym(libzzub, "zzub_playe...
  zzub_player_get_midimapping = dlsym(libzzub, "zzub_player_get_...
  zzub_player_get_midimapping_count = dlsym(libzzub, "zzub_playe...
  zzub_player_get_automation = dlsym(libzzub, "zzub_player_get_a...
  zzub_player_set_automation = dlsym(libzzub, "zzub_player_set_a...
  zzub_player_get_midi_transport = dlsym(libzzub, "zzub_player_g...
  zzub_player_set_midi_transport = dlsym(libzzub, "zzub_player_s...
  zzub_player_get_infotext = dlsym(libzzub, "zzub_player_get_inf...
  zzub_player_set_infotext = dlsym(libzzub, "zzub_player_set_inf...
  zzub_player_set_midi_plugin = dlsym(libzzub, "zzub_player_set_...
  zzub_player_get_midi_plugin = dlsym(libzzub, "zzub_player_get_...
  zzub_player_get_new_plugin_name = dlsym(libzzub, "zzub_player_...
  zzub_player_reset_keyjazz = dlsym(libzzub, "zzub_player_reset_...
  zzub_player_create_plugin = dlsym(libzzub, "zzub_player_create...
  zzub_player_create_sequence = dlsym(libzzub, "zzub_player_crea...
  zzub_player_flush = dlsym(libzzub, "zzub_player_flush", None, ...
  zzub_player_undo = dlsym(libzzub, "zzub_player_undo", None, ("...
  zzub_player_redo = dlsym(libzzub, "zzub_player_redo", None, ("...
  zzub_player_history_commit = dlsym(libzzub, "zzub_player_histo...
  zzub_player_history_get_uncomitted_operations = dlsym(libzzub,...
  zzub_player_history_flush_last = dlsym(libzzub, "zzub_player_h...
  zzub_player_history_flush = dlsym(libzzub, "zzub_player_histor...
  zzub_player_history_get_size = dlsym(libzzub, "zzub_player_his...
  zzub_player_history_get_position = dlsym(libzzub, "zzub_player...
  zzub_player_history_get_description = dlsym(libzzub, "zzub_pla...
  zzub_player_set_host_info = dlsym(libzzub, "zzub_player_set_ho...
  __package__ = 'zzub'
Function Details [hide private]

load_library(*names, **kw)

source code 

searches for a library with given names and returns a ctypes .so/.dll library object if successful. if the library can not be loaded, an assertion error will be thrown.

Parameters:
  • names (list of strings) - one or more aliases for required libraries, e.g. 'SDL','SDL-1.2'.
Returns: ctypes CDLL handle

dlopen(*args, **kwds)

source code 

Opens a library by name and returns a handle object. See {library.load} for more information.

dlsym(lib, name, restype, *args)

source code 

Retrieves a symbol from a library loaded by dlopen and assigns correct result and argument types.

Parameters:
  • lib (ctypes.CDLL) - Library object.
  • name (str) - Name of symbol.
  • restype - Type of function return value.
  • args - Types of function arguments.

Variables Details [hide private]

libzzub

Value:
<CDLL '../../lib/libzzub.so', handle 1016bb60 at 104e2730>

zzub_audiodriver_create_portaudio

Value:
dlsym(libzzub, "zzub_audiodriver_create_portaudio", POINTER(zzub_audio\
driver_t), ("player", POINTER(zzub_player_t)))

zzub_audiodriver_create_rtaudio

Value:
dlsym(libzzub, "zzub_audiodriver_create_rtaudio", POINTER(zzub_audiodr\
iver_t), ("player", POINTER(zzub_player_t)))

zzub_audiodriver_create_silent

Value:
dlsym(libzzub, "zzub_audiodriver_create_silent", POINTER(zzub_audiodri\
ver_t), ("player", POINTER(zzub_player_t)), ("name", c_char_p), ("out_\
channels", c_int), ("in_channels", c_int), ("supported_rates", POINTER\
(c_int)), ("num_rates", c_int))

zzub_audiodriver_create

Value:
dlsym(libzzub, "zzub_audiodriver_create", POINTER(zzub_audiodriver_t),\
 ("player", POINTER(zzub_player_t)))

zzub_audiodriver_get_count

Value:
dlsym(libzzub, "zzub_audiodriver_get_count", c_int, ("audiodriver", PO\
INTER(zzub_audiodriver_t)))

zzub_audiodriver_get_name

Value:
dlsym(libzzub, "zzub_audiodriver_get_name", c_int, ("audiodriver", POI\
NTER(zzub_audiodriver_t)), ("index", c_int), ("name", c_char_p), ("max\
_len", c_int))

zzub_audiodriver_get_supported_samplerates

Value:
dlsym(libzzub, "zzub_audiodriver_get_supported_samplerates", c_int, ("\
audiodriver", POINTER(zzub_audiodriver_t)), ("index", c_int), ("result\
", POINTER(c_int)), ("maxrates", c_int))

zzub_audiodriver_get_supported_output_channels

Value:
dlsym(libzzub, "zzub_audiodriver_get_supported_output_channels", c_int\
, ("audiodriver", POINTER(zzub_audiodriver_t)), ("index", c_int))

zzub_audiodriver_get_supported_input_channels

Value:
dlsym(libzzub, "zzub_audiodriver_get_supported_input_channels", c_int,\
 ("audiodriver", POINTER(zzub_audiodriver_t)), ("index", c_int))

zzub_audiodriver_create_device

Value:
dlsym(libzzub, "zzub_audiodriver_create_device", c_int, ("audiodriver"\
, POINTER(zzub_audiodriver_t)), ("input_index", c_int), ("output_index\
", c_int))

zzub_audiodriver_enable

Value:
dlsym(libzzub, "zzub_audiodriver_enable", None, ("audiodriver", POINTE\
R(zzub_audiodriver_t)), ("state", c_int))

zzub_audiodriver_get_enabled

Value:
dlsym(libzzub, "zzub_audiodriver_get_enabled", c_int, ("audiodriver", \
POINTER(zzub_audiodriver_t)))

zzub_audiodriver_destroy

Value:
dlsym(libzzub, "zzub_audiodriver_destroy", None, ("audiodriver", POINT\
ER(zzub_audiodriver_t)))

zzub_audiodriver_destroy_device

Value:
dlsym(libzzub, "zzub_audiodriver_destroy_device", None, ("audiodriver"\
, POINTER(zzub_audiodriver_t)))

zzub_audiodriver_set_samplerate

Value:
dlsym(libzzub, "zzub_audiodriver_set_samplerate", None, ("audiodriver"\
, POINTER(zzub_audiodriver_t)), ("samplerate", c_uint))

zzub_audiodriver_get_samplerate

Value:
dlsym(libzzub, "zzub_audiodriver_get_samplerate", c_uint, ("audiodrive\
r", POINTER(zzub_audiodriver_t)))

zzub_audiodriver_set_buffersize

Value:
dlsym(libzzub, "zzub_audiodriver_set_buffersize", None, ("audiodriver"\
, POINTER(zzub_audiodriver_t)), ("buffersize", c_uint))

zzub_audiodriver_get_buffersize

Value:
dlsym(libzzub, "zzub_audiodriver_get_buffersize", c_uint, ("audiodrive\
r", POINTER(zzub_audiodriver_t)))

zzub_audiodriver_get_cpu_load

Value:
dlsym(libzzub, "zzub_audiodriver_get_cpu_load", c_double, ("audiodrive\
r", POINTER(zzub_audiodriver_t)))

zzub_audiodriver_is_output

Value:
dlsym(libzzub, "zzub_audiodriver_is_output", c_int, ("audiodriver", PO\
INTER(zzub_audiodriver_t)), ("index", c_int))

zzub_audiodriver_is_input

Value:
dlsym(libzzub, "zzub_audiodriver_is_input", c_int, ("audiodriver", POI\
NTER(zzub_audiodriver_t)), ("index", c_int))

zzub_audiodriver_get_master_channel

Value:
dlsym(libzzub, "zzub_audiodriver_get_master_channel", c_int, ("audiodr\
iver", POINTER(zzub_audiodriver_t)))

zzub_audiodriver_set_master_channel

Value:
dlsym(libzzub, "zzub_audiodriver_set_master_channel", None, ("audiodri\
ver", POINTER(zzub_audiodriver_t)), ("index", c_int))

zzub_mididriver_get_count

Value:
dlsym(libzzub, "zzub_mididriver_get_count", c_int, ("player", POINTER(\
zzub_player_t)))

zzub_mididriver_get_name

Value:
dlsym(libzzub, "zzub_mididriver_get_name", c_char_p, ("player", POINTE\
R(zzub_player_t)), ("index", c_int))

zzub_mididriver_is_input

Value:
dlsym(libzzub, "zzub_mididriver_is_input", c_int, ("player", POINTER(z\
zub_player_t)), ("index", c_int))

zzub_mididriver_is_output

Value:
dlsym(libzzub, "zzub_mididriver_is_output", c_int, ("player", POINTER(\
zzub_player_t)), ("index", c_int))

zzub_mididriver_open

Value:
dlsym(libzzub, "zzub_mididriver_open", c_int, ("player", POINTER(zzub_\
player_t)), ("index", c_int))

zzub_mididriver_close_all

Value:
dlsym(libzzub, "zzub_mididriver_close_all", c_int, ("player", POINTER(\
zzub_player_t)))

zzub_plugincollection_get_by_uri

Value:
dlsym(libzzub, "zzub_plugincollection_get_by_uri", POINTER(zzub_plugin\
collection_t), ("player", POINTER(zzub_player_t)), ("uri", c_char_p))

zzub_plugincollection_configure

Value:
dlsym(libzzub, "zzub_plugincollection_configure", None, ("plugincollec\
tion", POINTER(zzub_plugincollection_t)), ("key", c_char_p), ("value",\
 c_char_p))

zzub_input_open_file

Value:
dlsym(libzzub, "zzub_input_open_file", POINTER(zzub_input_t), ("filena\
me", c_char_p))

zzub_input_destroy

Value:
dlsym(libzzub, "zzub_input_destroy", None, ("input", POINTER(zzub_inpu\
t_t)))

zzub_input_read

Value:
dlsym(libzzub, "zzub_input_read", None, ("input", POINTER(zzub_input_t\
)), ("buffer", POINTER(c_char)), ("bytes", c_int))

zzub_input_size

Value:
dlsym(libzzub, "zzub_input_size", c_int, ("input", POINTER(zzub_input_\
t)))

zzub_input_position

Value:
dlsym(libzzub, "zzub_input_position", c_int, ("input", POINTER(zzub_in\
put_t)))

zzub_input_seek

Value:
dlsym(libzzub, "zzub_input_seek", None, ("input", POINTER(zzub_input_t\
)), ("pos", c_int), ("mode", c_int))

zzub_output_create_file

Value:
dlsym(libzzub, "zzub_output_create_file", POINTER(zzub_output_t), ("fi\
lename", c_char_p))

zzub_output_destroy

Value:
dlsym(libzzub, "zzub_output_destroy", None, ("output", POINTER(zzub_ou\
tput_t)))

zzub_output_write

Value:
dlsym(libzzub, "zzub_output_write", None, ("output", POINTER(zzub_outp\
ut_t)), ("buffer", POINTER(c_char)), ("bytes", c_int))

zzub_output_position

Value:
dlsym(libzzub, "zzub_output_position", c_int, ("output", POINTER(zzub_\
output_t)))

zzub_output_seek

Value:
dlsym(libzzub, "zzub_output_seek", None, ("output", POINTER(zzub_outpu\
t_t)), ("pos", c_int), ("mode", c_int))

zzub_archive_create_memory

Value:
dlsym(libzzub, "zzub_archive_create_memory", POINTER(zzub_archive_t))

zzub_archive_get_output

Value:
dlsym(libzzub, "zzub_archive_get_output", POINTER(zzub_output_t), ("ar\
chive", POINTER(zzub_archive_t)), ("path", c_char_p))

zzub_archive_get_input

Value:
dlsym(libzzub, "zzub_archive_get_input", POINTER(zzub_input_t), ("arch\
ive", POINTER(zzub_archive_t)), ("path", c_char_p))

zzub_archive_destroy

Value:
dlsym(libzzub, "zzub_archive_destroy", None, ("archive", POINTER(zzub_\
archive_t)))

zzub_midimapping_get_plugin

Value:
dlsym(libzzub, "zzub_midimapping_get_plugin", c_int, ("midimapping", P\
OINTER(zzub_midimapping_t)))

zzub_midimapping_get_group

Value:
dlsym(libzzub, "zzub_midimapping_get_group", c_int, ("midimapping", PO\
INTER(zzub_midimapping_t)))

zzub_midimapping_get_track

Value:
dlsym(libzzub, "zzub_midimapping_get_track", c_int, ("midimapping", PO\
INTER(zzub_midimapping_t)))

zzub_midimapping_get_column

Value:
dlsym(libzzub, "zzub_midimapping_get_column", c_int, ("midimapping", P\
OINTER(zzub_midimapping_t)))

zzub_midimapping_get_channel

Value:
dlsym(libzzub, "zzub_midimapping_get_channel", c_int, ("midimapping", \
POINTER(zzub_midimapping_t)))

zzub_midimapping_get_controller

Value:
dlsym(libzzub, "zzub_midimapping_get_controller", c_int, ("midimapping\
", POINTER(zzub_midimapping_t)))

zzub_pattern_destroy

Value:
dlsym(libzzub, "zzub_pattern_destroy", None, ("pattern", POINTER(zzub_\
pattern_t)))

zzub_pattern_get_name

Value:
dlsym(libzzub, "zzub_pattern_get_name", None, ("pattern", POINTER(zzub\
_pattern_t)), ("name", c_char_p), ("maxLen", c_int))

zzub_pattern_set_name

Value:
dlsym(libzzub, "zzub_pattern_set_name", None, ("pattern", POINTER(zzub\
_pattern_t)), ("name", c_char_p))

zzub_pattern_get_row_count

Value:
dlsym(libzzub, "zzub_pattern_get_row_count", c_int, ("pattern", POINTE\
R(zzub_pattern_t)))

zzub_pattern_get_group_count

Value:
dlsym(libzzub, "zzub_pattern_get_group_count", c_int, ("pattern", POIN\
TER(zzub_pattern_t)))

zzub_pattern_get_track_count

Value:
dlsym(libzzub, "zzub_pattern_get_track_count", c_int, ("pattern", POIN\
TER(zzub_pattern_t)), ("group", c_int))

zzub_pattern_get_column_count

Value:
dlsym(libzzub, "zzub_pattern_get_column_count", c_int, ("pattern", POI\
NTER(zzub_pattern_t)), ("group", c_int), ("track", c_int))

zzub_pattern_get_value

Value:
dlsym(libzzub, "zzub_pattern_get_value", c_int, ("pattern", POINTER(zz\
ub_pattern_t)), ("row", c_int), ("group", c_int), ("track", c_int), ("\
column", c_int))

zzub_pattern_set_value

Value:
dlsym(libzzub, "zzub_pattern_set_value", None, ("pattern", POINTER(zzu\
b_pattern_t)), ("row", c_int), ("group", c_int), ("track", c_int), ("c\
olumn", c_int), ("value", c_int))

zzub_pattern_interpolate

Value:
dlsym(libzzub, "zzub_pattern_interpolate", None, ("pattern", POINTER(z\
zub_pattern_t)))

zzub_parameter_get_type

Value:
dlsym(libzzub, "zzub_parameter_get_type", c_int, ("parameter", POINTER\
(zzub_parameter_t)))

zzub_parameter_get_name

Value:
dlsym(libzzub, "zzub_parameter_get_name", c_char_p, ("parameter", POIN\
TER(zzub_parameter_t)))

zzub_parameter_get_description

Value:
dlsym(libzzub, "zzub_parameter_get_description", c_char_p, ("parameter\
", POINTER(zzub_parameter_t)))

zzub_parameter_get_value_min

Value:
dlsym(libzzub, "zzub_parameter_get_value_min", c_int, ("parameter", PO\
INTER(zzub_parameter_t)))

zzub_parameter_get_value_max

Value:
dlsym(libzzub, "zzub_parameter_get_value_max", c_int, ("parameter", PO\
INTER(zzub_parameter_t)))

zzub_parameter_get_value_none

Value:
dlsym(libzzub, "zzub_parameter_get_value_none", c_int, ("parameter", P\
OINTER(zzub_parameter_t)))

zzub_parameter_get_value_default

Value:
dlsym(libzzub, "zzub_parameter_get_value_default", c_int, ("parameter"\
, POINTER(zzub_parameter_t)))

zzub_parameter_get_flags

Value:
dlsym(libzzub, "zzub_parameter_get_flags", c_int, ("parameter", POINTE\
R(zzub_parameter_t)))

zzub_attribute_get_name

Value:
dlsym(libzzub, "zzub_attribute_get_name", c_char_p, ("attribute", POIN\
TER(zzub_attribute_t)))

zzub_attribute_get_value_min

Value:
dlsym(libzzub, "zzub_attribute_get_value_min", c_int, ("attribute", PO\
INTER(zzub_attribute_t)))

zzub_attribute_get_value_max

Value:
dlsym(libzzub, "zzub_attribute_get_value_max", c_int, ("attribute", PO\
INTER(zzub_attribute_t)))

zzub_attribute_get_value_default

Value:
dlsym(libzzub, "zzub_attribute_get_value_default", c_int, ("attribute"\
, POINTER(zzub_attribute_t)))

zzub_pluginloader_get_name

Value:
dlsym(libzzub, "zzub_pluginloader_get_name", c_char_p, ("pluginloader"\
, POINTER(zzub_pluginloader_t)))

zzub_pluginloader_get_short_name

Value:
dlsym(libzzub, "zzub_pluginloader_get_short_name", c_char_p, ("pluginl\
oader", POINTER(zzub_pluginloader_t)))

zzub_pluginloader_get_parameter_count

Value:
dlsym(libzzub, "zzub_pluginloader_get_parameter_count", c_int, ("plugi\
nloader", POINTER(zzub_pluginloader_t)), ("group", c_int))

zzub_pluginloader_get_parameter

Value:
dlsym(libzzub, "zzub_pluginloader_get_parameter", POINTER(zzub_paramet\
er_t), ("pluginloader", POINTER(zzub_pluginloader_t)), ("group", c_int\
), ("index", c_int))

zzub_pluginloader_get_attribute_count

Value:
dlsym(libzzub, "zzub_pluginloader_get_attribute_count", c_int, ("plugi\
nloader", POINTER(zzub_pluginloader_t)))

zzub_pluginloader_get_attribute

Value:
dlsym(libzzub, "zzub_pluginloader_get_attribute", POINTER(zzub_attribu\
te_t), ("pluginloader", POINTER(zzub_pluginloader_t)), ("index", c_int\
))

zzub_pluginloader_get_loader_name

Value:
dlsym(libzzub, "zzub_pluginloader_get_loader_name", c_char_p, ("plugin\
loader", POINTER(zzub_pluginloader_t)))

zzub_pluginloader_get_flags

Value:
dlsym(libzzub, "zzub_pluginloader_get_flags", c_int, ("pluginloader", \
POINTER(zzub_pluginloader_t)))

zzub_pluginloader_get_uri

Value:
dlsym(libzzub, "zzub_pluginloader_get_uri", c_char_p, ("pluginloader",\
 POINTER(zzub_pluginloader_t)))

zzub_pluginloader_get_author

Value:
dlsym(libzzub, "zzub_pluginloader_get_author", c_char_p, ("pluginloade\
r", POINTER(zzub_pluginloader_t)))

zzub_pluginloader_get_instrument_list

Value:
dlsym(libzzub, "zzub_pluginloader_get_instrument_list", c_int, ("plugi\
nloader", POINTER(zzub_pluginloader_t)), ("result", POINTER(c_char)), \
("maxbytes", c_int))

zzub_pluginloader_get_tracks_min

Value:
dlsym(libzzub, "zzub_pluginloader_get_tracks_min", c_int, ("pluginload\
er", POINTER(zzub_pluginloader_t)))

zzub_pluginloader_get_tracks_max

Value:
dlsym(libzzub, "zzub_pluginloader_get_tracks_max", c_int, ("pluginload\
er", POINTER(zzub_pluginloader_t)))

zzub_pluginloader_get_stream_format_count

Value:
dlsym(libzzub, "zzub_pluginloader_get_stream_format_count", c_int, ("p\
luginloader", POINTER(zzub_pluginloader_t)))

zzub_pluginloader_get_stream_format_ext

Value:
dlsym(libzzub, "zzub_pluginloader_get_stream_format_ext", c_char_p, ("\
pluginloader", POINTER(zzub_pluginloader_t)), ("index", c_int))

zzub_plugin_destroy

Value:
dlsym(libzzub, "zzub_plugin_destroy", c_int, ("plugin", POINTER(zzub_p\
lugin_t)))

zzub_plugin_load

Value:
dlsym(libzzub, "zzub_plugin_load", c_int, ("plugin", POINTER(zzub_plug\
in_t)), ("input", POINTER(zzub_input_t)))

zzub_plugin_save

Value:
dlsym(libzzub, "zzub_plugin_save", c_int, ("plugin", POINTER(zzub_plug\
in_t)), ("ouput", POINTER(zzub_output_t)))

zzub_plugin_set_name

Value:
dlsym(libzzub, "zzub_plugin_set_name", c_int, ("plugin", POINTER(zzub_\
plugin_t)), ("name", c_char_p))

zzub_plugin_get_name

Value:
dlsym(libzzub, "zzub_plugin_get_name", c_int, ("plugin", POINTER(zzub_\
plugin_t)), ("name", c_char_p), ("maxlen", c_int))

zzub_plugin_get_id

Value:
dlsym(libzzub, "zzub_plugin_get_id", c_int, ("plugin", POINTER(zzub_pl\
ugin_t)))

zzub_plugin_get_position

Value:
dlsym(libzzub, "zzub_plugin_get_position", None, ("plugin", POINTER(zz\
ub_plugin_t)), ("x", POINTER(c_float)), ("y", POINTER(c_float)))

zzub_plugin_set_position

Value:
dlsym(libzzub, "zzub_plugin_set_position", None, ("plugin", POINTER(zz\
ub_plugin_t)), ("x", c_float), ("y", c_float))

zzub_plugin_set_position_direct

Value:
dlsym(libzzub, "zzub_plugin_set_position_direct", None, ("plugin", POI\
NTER(zzub_plugin_t)), ("x", c_float), ("y", c_float))

zzub_plugin_get_flags

Value:
dlsym(libzzub, "zzub_plugin_get_flags", c_int, ("plugin", POINTER(zzub\
_plugin_t)))

zzub_plugin_get_track_count

Value:
dlsym(libzzub, "zzub_plugin_get_track_count", c_int, ("plugin", POINTE\
R(zzub_plugin_t)))

zzub_plugin_set_track_count

Value:
dlsym(libzzub, "zzub_plugin_set_track_count", None, ("plugin", POINTER\
(zzub_plugin_t)), ("count", c_int))

zzub_plugin_get_group_track_count

Value:
dlsym(libzzub, "zzub_plugin_get_group_track_count", c_int, ("plugin", \
POINTER(zzub_plugin_t)), ("group", c_int))

zzub_plugin_get_mute

Value:
dlsym(libzzub, "zzub_plugin_get_mute", c_int, ("plugin", POINTER(zzub_\
plugin_t)))

zzub_plugin_set_mute

Value:
dlsym(libzzub, "zzub_plugin_set_mute", None, ("plugin", POINTER(zzub_p\
lugin_t)), ("muted", c_int))

zzub_plugin_get_bypass

Value:
dlsym(libzzub, "zzub_plugin_get_bypass", c_int, ("plugin", POINTER(zzu\
b_plugin_t)))

zzub_plugin_configure

Value:
dlsym(libzzub, "zzub_plugin_configure", None, ("plugin", POINTER(zzub_\
plugin_t)), ("key", c_char_p), ("value", c_char_p))

zzub_plugin_set_bypass

Value:
dlsym(libzzub, "zzub_plugin_set_bypass", None, ("plugin", POINTER(zzub\
_plugin_t)), ("muted", c_int))

zzub_plugin_get_commands

Value:
dlsym(libzzub, "zzub_plugin_get_commands", c_int, ("plugin", POINTER(z\
zub_plugin_t)), ("commands", c_char_p), ("maxlen", c_int))

zzub_plugin_get_sub_commands

Value:
dlsym(libzzub, "zzub_plugin_get_sub_commands", c_int, ("plugin", POINT\
ER(zzub_plugin_t)), ("i", c_int), ("commands", c_char_p), ("maxlen", c\
_int))

zzub_plugin_command

Value:
dlsym(libzzub, "zzub_plugin_command", None, ("plugin", POINTER(zzub_pl\
ugin_t)), ("i", c_int))

zzub_plugin_get_pluginloader

Value:
dlsym(libzzub, "zzub_plugin_get_pluginloader", POINTER(zzub_pluginload\
er_t), ("plugin", POINTER(zzub_plugin_t)))

zzub_plugin_get_midi_output_device_count

Value:
dlsym(libzzub, "zzub_plugin_get_midi_output_device_count", c_int, ("pl\
ugin", POINTER(zzub_plugin_t)))

zzub_plugin_get_midi_output_device

Value:
dlsym(libzzub, "zzub_plugin_get_midi_output_device", c_char_p, ("plugi\
n", POINTER(zzub_plugin_t)), ("index", c_int))

zzub_plugin_get_envelope_count

Value:
dlsym(libzzub, "zzub_plugin_get_envelope_count", c_int, ("plugin", POI\
NTER(zzub_plugin_t)))

zzub_plugin_get_envelope_flags

Value:
dlsym(libzzub, "zzub_plugin_get_envelope_flags", c_int, ("plugin", POI\
NTER(zzub_plugin_t)), ("index", c_int))

zzub_plugin_get_envelope_name

Value:
dlsym(libzzub, "zzub_plugin_get_envelope_name", c_char_p, ("plugin", P\
OINTER(zzub_plugin_t)), ("index", c_int))

zzub_plugin_set_stream_source

Value:
dlsym(libzzub, "zzub_plugin_set_stream_source", None, ("plugin", POINT\
ER(zzub_plugin_t)), ("resource", c_char_p))

zzub_plugin_set_instrument

Value:
dlsym(libzzub, "zzub_plugin_set_instrument", c_int, ("plugin", POINTER\
(zzub_plugin_t)), ("name", c_char_p))

zzub_plugin_create_range_pattern

Value:
dlsym(libzzub, "zzub_plugin_create_range_pattern", POINTER(zzub_patter\
n_t), ("player", POINTER(zzub_player_t)), ("columns", c_int), ("rows",\
 c_int))

zzub_plugin_create_pattern

Value:
dlsym(libzzub, "zzub_plugin_create_pattern", POINTER(zzub_pattern_t), \
("plugin", POINTER(zzub_plugin_t)), ("rows", c_int))

zzub_plugin_get_pattern_count

Value:
dlsym(libzzub, "zzub_plugin_get_pattern_count", c_int, ("plugin", POIN\
TER(zzub_plugin_t)))

zzub_plugin_add_pattern

Value:
dlsym(libzzub, "zzub_plugin_add_pattern", None, ("plugin", POINTER(zzu\
b_plugin_t)), ("pattern", POINTER(zzub_pattern_t)))

zzub_plugin_remove_pattern

Value:
dlsym(libzzub, "zzub_plugin_remove_pattern", None, ("plugin", POINTER(\
zzub_plugin_t)), ("pattern", c_int))

zzub_plugin_move_pattern

Value:
dlsym(libzzub, "zzub_plugin_move_pattern", None, ("plugin", POINTER(zz\
ub_plugin_t)), ("index", c_int), ("newIndex", c_int))

zzub_plugin_update_pattern

Value:
dlsym(libzzub, "zzub_plugin_update_pattern", None, ("plugin", POINTER(\
zzub_plugin_t)), ("index", c_int), ("pattern", POINTER(zzub_pattern_t)\
))

zzub_plugin_get_pattern

Value:
dlsym(libzzub, "zzub_plugin_get_pattern", POINTER(zzub_pattern_t), ("p\
lugin", POINTER(zzub_plugin_t)), ("index", c_int))

zzub_plugin_get_pattern_by_name

Value:
dlsym(libzzub, "zzub_plugin_get_pattern_by_name", c_int, ("plugin", PO\
INTER(zzub_plugin_t)), ("name", c_char_p))

zzub_plugin_get_pattern_name

Value:
dlsym(libzzub, "zzub_plugin_get_pattern_name", c_char_p, ("plugin", PO\
INTER(zzub_plugin_t)), ("index", c_int))

zzub_plugin_set_pattern_name

Value:
dlsym(libzzub, "zzub_plugin_set_pattern_name", None, ("plugin", POINTE\
R(zzub_plugin_t)), ("index", c_int), ("name", c_char_p))

zzub_plugin_get_pattern_length

Value:
dlsym(libzzub, "zzub_plugin_get_pattern_length", c_int, ("plugin", POI\
NTER(zzub_plugin_t)), ("index", c_int))

zzub_plugin_set_pattern_length

Value:
dlsym(libzzub, "zzub_plugin_set_pattern_length", None, ("plugin", POIN\
TER(zzub_plugin_t)), ("index", c_int), ("rows", c_int))

zzub_plugin_get_pattern_value

Value:
dlsym(libzzub, "zzub_plugin_get_pattern_value", c_int, ("plugin", POIN\
TER(zzub_plugin_t)), ("pattern", c_int), ("group", c_int), ("track", c\
_int), ("column", c_int), ("row", c_int))

zzub_plugin_set_pattern_value

Value:
dlsym(libzzub, "zzub_plugin_set_pattern_value", None, ("plugin", POINT\
ER(zzub_plugin_t)), ("pattern", c_int), ("group", c_int), ("track", c_\
int), ("column", c_int), ("row", c_int), ("value", c_int))

zzub_plugin_get_new_pattern_name

Value:
dlsym(libzzub, "zzub_plugin_get_new_pattern_name", None, ("plugin", PO\
INTER(zzub_plugin_t)), ("name", c_char_p), ("maxLen", c_int))

zzub_plugin_linear_to_pattern

Value:
dlsym(libzzub, "zzub_plugin_linear_to_pattern", c_int, ("plugin", POIN\
TER(zzub_plugin_t)), ("index", c_int), ("group", POINTER(c_int)), ("tr\
ack", POINTER(c_int)), ("column", POINTER(c_int)))

zzub_plugin_pattern_to_linear

Value:
dlsym(libzzub, "zzub_plugin_pattern_to_linear", c_int, ("plugin", POIN\
TER(zzub_plugin_t)), ("group", c_int), ("track", c_int), ("column", c_\
int), ("index", POINTER(c_int)))

zzub_plugin_get_pattern_column_count

Value:
dlsym(libzzub, "zzub_plugin_get_pattern_column_count", c_int, ("plugin\
", POINTER(zzub_plugin_t)))

zzub_plugin_insert_pattern_rows

Value:
dlsym(libzzub, "zzub_plugin_insert_pattern_rows", None, ("plugin", POI\
NTER(zzub_plugin_t)), ("pattern", c_int), ("column_indices", POINTER(c\
_int)), ("num_indices", c_int), ("start", c_int), ("rows", c_int))

zzub_plugin_remove_pattern_rows

Value:
dlsym(libzzub, "zzub_plugin_remove_pattern_rows", None, ("plugin", POI\
NTER(zzub_plugin_t)), ("pattern", c_int), ("column_indices", POINTER(c\
_int)), ("num_indices", c_int), ("start", c_int), ("rows", c_int))

zzub_plugin_describe_value

Value:
dlsym(libzzub, "zzub_plugin_describe_value", c_int, ("plugin", POINTER\
(zzub_plugin_t)), ("group", c_int), ("column", c_int), ("value", c_int\
), ("name", c_char_p), ("maxlen", c_int))

zzub_plugin_get_parameter_value

Value:
dlsym(libzzub, "zzub_plugin_get_parameter_value", c_int, ("plugin", PO\
INTER(zzub_plugin_t)), ("group", c_int), ("track", c_int), ("column", \
c_int))

zzub_plugin_set_parameter_value

Value:
dlsym(libzzub, "zzub_plugin_set_parameter_value", None, ("plugin", POI\
NTER(zzub_plugin_t)), ("group", c_int), ("track", c_int), ("column", c\
_int), ("value", c_int), ("record", c_int))

zzub_plugin_set_parameter_value_direct

Value:
dlsym(libzzub, "zzub_plugin_set_parameter_value_direct", None, ("plugi\
n", POINTER(zzub_plugin_t)), ("group", c_int), ("track", c_int), ("col\
umn", c_int), ("value", c_int), ("record", c_int))

zzub_plugin_get_parameter_count

Value:
dlsym(libzzub, "zzub_plugin_get_parameter_count", c_int, ("plugin", PO\
INTER(zzub_plugin_t)), ("group", c_int), ("track", c_int))

zzub_plugin_get_parameter

Value:
dlsym(libzzub, "zzub_plugin_get_parameter", POINTER(zzub_parameter_t),\
 ("plugin", POINTER(zzub_plugin_t)), ("group", c_int), ("track", c_int\
), ("column", c_int))

zzub_plugin_get_input_connection_count

Value:
dlsym(libzzub, "zzub_plugin_get_input_connection_count", c_int, ("plug\
in", POINTER(zzub_plugin_t)))

zzub_plugin_get_input_connection_by_type

Value:
dlsym(libzzub, "zzub_plugin_get_input_connection_by_type", c_int, ("pl\
ugin", POINTER(zzub_plugin_t)), ("from_plugin", POINTER(zzub_plugin_t)\
), ("type", c_int))

zzub_plugin_get_input_connection_type

Value:
dlsym(libzzub, "zzub_plugin_get_input_connection_type", c_int, ("plugi\
n", POINTER(zzub_plugin_t)), ("index", c_int))

zzub_plugin_get_input_connection_plugin

Value:
dlsym(libzzub, "zzub_plugin_get_input_connection_plugin", POINTER(zzub\
_plugin_t), ("plugin", POINTER(zzub_plugin_t)), ("index", c_int))

zzub_plugin_get_output_connection_count

Value:
dlsym(libzzub, "zzub_plugin_get_output_connection_count", c_int, ("plu\
gin", POINTER(zzub_plugin_t)))

zzub_plugin_get_output_connection_by_type

Value:
dlsym(libzzub, "zzub_plugin_get_output_connection_by_type", c_int, ("p\
lugin", POINTER(zzub_plugin_t)), ("from_plugin", POINTER(zzub_plugin_t\
)), ("type", c_int))

zzub_plugin_get_output_connection_type

Value:
dlsym(libzzub, "zzub_plugin_get_output_connection_type", c_int, ("plug\
in", POINTER(zzub_plugin_t)), ("index", c_int))

zzub_plugin_get_output_connection_plugin

Value:
dlsym(libzzub, "zzub_plugin_get_output_connection_plugin", POINTER(zzu\
b_plugin_t), ("plugin", POINTER(zzub_plugin_t)), ("index", c_int))

zzub_plugin_add_input

Value:
dlsym(libzzub, "zzub_plugin_add_input", c_int, ("plugin", POINTER(zzub\
_plugin_t)), ("from_plugin", POINTER(zzub_plugin_t)), ("type", c_int))

zzub_plugin_delete_input

Value:
dlsym(libzzub, "zzub_plugin_delete_input", None, ("plugin", POINTER(zz\
ub_plugin_t)), ("from_plugin", POINTER(zzub_plugin_t)), ("type", c_int\
))

zzub_plugin_get_mixbuffer

Value:
dlsym(libzzub, "zzub_plugin_get_mixbuffer", c_int, ("plugin", POINTER(\
zzub_plugin_t)), ("leftbuffer", POINTER(c_float)), ("rightbuffer", POI\
NTER(c_float)), ("size", POINTER(c_int)), ("samplepos", POINTER(c_long\
long)))

zzub_plugin_get_last_peak

Value:
dlsym(libzzub, "zzub_plugin_get_last_peak", None, ("plugin", POINTER(z\
zub_plugin_t)), ("maxL", POINTER(c_float)), ("maxR", POINTER(c_float))\
)

zzub_plugin_get_last_worktime

Value:
dlsym(libzzub, "zzub_plugin_get_last_worktime", c_double, ("plugin", P\
OINTER(zzub_plugin_t)))

zzub_plugin_get_last_cpu_load

Value:
dlsym(libzzub, "zzub_plugin_get_last_cpu_load", c_double, ("plugin", P\
OINTER(zzub_plugin_t)))

zzub_plugin_get_last_midi_result

Value:
dlsym(libzzub, "zzub_plugin_get_last_midi_result", c_int, ("plugin", P\
OINTER(zzub_plugin_t)))

zzub_plugin_get_last_audio_result

Value:
dlsym(libzzub, "zzub_plugin_get_last_audio_result", c_int, ("plugin", \
POINTER(zzub_plugin_t)))

zzub_plugin_invoke_event

Value:
dlsym(libzzub, "zzub_plugin_invoke_event", c_int, ("plugin", POINTER(z\
zub_plugin_t)), ("data", POINTER(zzub_event_data_t)), ("immediate", c_\
int))

zzub_plugin_tick

Value:
dlsym(libzzub, "zzub_plugin_tick", None, ("plugin", POINTER(zzub_plugi\
n_t)))

zzub_plugin_get_attribute_value

Value:
dlsym(libzzub, "zzub_plugin_get_attribute_value", c_int, ("plugin", PO\
INTER(zzub_plugin_t)), ("index", c_int))

zzub_plugin_set_attribute_value

Value:
dlsym(libzzub, "zzub_plugin_set_attribute_value", None, ("plugin", POI\
NTER(zzub_plugin_t)), ("index", c_int), ("value", c_int))

zzub_plugin_play_midi_note

Value:
dlsym(libzzub, "zzub_plugin_play_midi_note", None, ("plugin", POINTER(\
zzub_plugin_t)), ("note", c_int), ("prevNote", c_int), ("velocity", c_\
int))

zzub_plugin_play_pattern_row_ref

Value:
dlsym(libzzub, "zzub_plugin_play_pattern_row_ref", None, ("plugin", PO\
INTER(zzub_plugin_t)), ("pattern", c_int), ("row", c_int))

zzub_plugin_play_pattern_row

Value:
dlsym(libzzub, "zzub_plugin_play_pattern_row", None, ("plugin", POINTE\
R(zzub_plugin_t)), ("pattern", POINTER(zzub_pattern_t)), ("row", c_int\
))

zzub_plugin_set_midi_connection_device

Value:
dlsym(libzzub, "zzub_plugin_set_midi_connection_device", c_int, ("plug\
in", POINTER(zzub_plugin_t)), ("from_plugin", POINTER(zzub_plugin_t)),\
 ("name", c_char_p))

zzub_plugin_add_event_connection_binding

Value:
dlsym(libzzub, "zzub_plugin_add_event_connection_binding", None, ("plu\
gin", POINTER(zzub_plugin_t)), ("from_plugin", POINTER(zzub_plugin_t))\
, ("sourceparam", c_int), ("targetgroup", c_int), ("targettrack", c_in\
t), ("targetparam", c_int))

zzub_sequence_destroy

Value:
dlsym(libzzub, "zzub_sequence_destroy", None, ("sequence", POINTER(zzu\
b_sequence_t)))

zzub_sequence_move

Value:
dlsym(libzzub, "zzub_sequence_move", None, ("sequence", POINTER(zzub_s\
equence_t)), ("newIndex", c_int))

zzub_sequence_insert_events

Value:
dlsym(libzzub, "zzub_sequence_insert_events", c_int, ("sequence", POIN\
TER(zzub_sequence_t)), ("start", c_int), ("ticks", c_int))

zzub_sequence_remove_events

Value:
dlsym(libzzub, "zzub_sequence_remove_events", c_int, ("sequence", POIN\
TER(zzub_sequence_t)), ("start", c_int), ("ticks", c_int))

zzub_sequence_set_event

Value:
dlsym(libzzub, "zzub_sequence_set_event", None, ("sequence", POINTER(z\
zub_sequence_t)), ("pos", c_int), ("value", c_int))

zzub_sequence_get_plugin

Value:
dlsym(libzzub, "zzub_sequence_get_plugin", POINTER(zzub_plugin_t), ("s\
equence", POINTER(zzub_sequence_t)))

zzub_sequence_get_event_at

Value:
dlsym(libzzub, "zzub_sequence_get_event_at", c_int, ("sequence", POINT\
ER(zzub_sequence_t)), ("pos", c_int))

zzub_sequence_get_event_count

Value:
dlsym(libzzub, "zzub_sequence_get_event_count", c_int, ("sequence", PO\
INTER(zzub_sequence_t)))

zzub_sequence_get_event

Value:
dlsym(libzzub, "zzub_sequence_get_event", c_int, ("sequence", POINTER(\
zzub_sequence_t)), ("index", c_int), ("pos", POINTER(c_int)), ("value"\
, POINTER(c_int)))

zzub_sequence_get_type

Value:
dlsym(libzzub, "zzub_sequence_get_type", c_int, ("sequence", POINTER(z\
zub_sequence_t)))

zzub_wavelevel_get_wave

Value:
dlsym(libzzub, "zzub_wavelevel_get_wave", POINTER(zzub_wave_t), ("wave\
level", POINTER(zzub_wavelevel_t)))

zzub_wavelevel_clear

Value:
dlsym(libzzub, "zzub_wavelevel_clear", c_int, ("wavelevel", POINTER(zz\
ub_wavelevel_t)))

zzub_wavelevel_get_sample_count

Value:
dlsym(libzzub, "zzub_wavelevel_get_sample_count", c_int, ("wavelevel",\
 POINTER(zzub_wavelevel_t)))

zzub_wavelevel_set_sample_count

Value:
dlsym(libzzub, "zzub_wavelevel_set_sample_count", None, ("wavelevel", \
POINTER(zzub_wavelevel_t)), ("count", c_int))

zzub_wavelevel_get_root_note

Value:
dlsym(libzzub, "zzub_wavelevel_get_root_note", c_int, ("wavelevel", PO\
INTER(zzub_wavelevel_t)))

zzub_wavelevel_set_root_note

Value:
dlsym(libzzub, "zzub_wavelevel_set_root_note", None, ("wavelevel", POI\
NTER(zzub_wavelevel_t)), ("note", c_int))

zzub_wavelevel_get_samples_per_second

Value:
dlsym(libzzub, "zzub_wavelevel_get_samples_per_second", c_int, ("wavel\
evel", POINTER(zzub_wavelevel_t)))

zzub_wavelevel_set_samples_per_second

Value:
dlsym(libzzub, "zzub_wavelevel_set_samples_per_second", None, ("wavele\
vel", POINTER(zzub_wavelevel_t)), ("sps", c_int))

zzub_wavelevel_get_loop_start

Value:
dlsym(libzzub, "zzub_wavelevel_get_loop_start", c_int, ("wavelevel", P\
OINTER(zzub_wavelevel_t)))

zzub_wavelevel_set_loop_start

Value:
dlsym(libzzub, "zzub_wavelevel_set_loop_start", None, ("wavelevel", PO\
INTER(zzub_wavelevel_t)), ("pos", c_int))

zzub_wavelevel_get_loop_end

Value:
dlsym(libzzub, "zzub_wavelevel_get_loop_end", c_int, ("wavelevel", POI\
NTER(zzub_wavelevel_t)))

zzub_wavelevel_set_loop_end

Value:
dlsym(libzzub, "zzub_wavelevel_set_loop_end", None, ("wavelevel", POIN\
TER(zzub_wavelevel_t)), ("pos", c_int))

zzub_wavelevel_get_format

Value:
dlsym(libzzub, "zzub_wavelevel_get_format", c_int, ("wavelevel", POINT\
ER(zzub_wavelevel_t)))

zzub_wavelevel_remove_sample_range

Value:
dlsym(libzzub, "zzub_wavelevel_remove_sample_range", None, ("wavelevel\
", POINTER(zzub_wavelevel_t)), ("start", c_int), ("end", c_int))

zzub_wavelevel_get_samples_digest

Value:
dlsym(libzzub, "zzub_wavelevel_get_samples_digest", None, ("wavelevel"\
, POINTER(zzub_wavelevel_t)), ("channel", c_int), ("start", c_int), ("\
end", c_int), ("mindigest", POINTER(c_float)), ("maxdigest", POINTER(c\
_float)), ("ampdigest", POINTER(c_float)), ("digestsize", c_int))

zzub_envelope_get_attack

Value:
dlsym(libzzub, "zzub_envelope_get_attack", c_ushort, ("envelope", POIN\
TER(zzub_envelope_t)))

zzub_envelope_get_decay

Value:
dlsym(libzzub, "zzub_envelope_get_decay", c_ushort, ("envelope", POINT\
ER(zzub_envelope_t)))

zzub_envelope_get_sustain

Value:
dlsym(libzzub, "zzub_envelope_get_sustain", c_ushort, ("envelope", POI\
NTER(zzub_envelope_t)))

zzub_envelope_get_release

Value:
dlsym(libzzub, "zzub_envelope_get_release", c_ushort, ("envelope", POI\
NTER(zzub_envelope_t)))

zzub_envelope_set_attack

Value:
dlsym(libzzub, "zzub_envelope_set_attack", None, ("envelope", POINTER(\
zzub_envelope_t)), ("attack", c_ushort))

zzub_envelope_set_decay

Value:
dlsym(libzzub, "zzub_envelope_set_decay", None, ("envelope", POINTER(z\
zub_envelope_t)), ("decay", c_ushort))

zzub_envelope_set_sustain

Value:
dlsym(libzzub, "zzub_envelope_set_sustain", None, ("envelope", POINTER\
(zzub_envelope_t)), ("sustain", c_ushort))

zzub_envelope_set_release

Value:
dlsym(libzzub, "zzub_envelope_set_release", None, ("envelope", POINTER\
(zzub_envelope_t)), ("release", c_ushort))

zzub_envelope_get_subdivision

Value:
dlsym(libzzub, "zzub_envelope_get_subdivision", c_byte, ("envelope", P\
OINTER(zzub_envelope_t)))

zzub_envelope_set_subdivision

Value:
dlsym(libzzub, "zzub_envelope_set_subdivision", None, ("envelope", POI\
NTER(zzub_envelope_t)), ("subdiv", c_byte))

zzub_envelope_get_flags

Value:
dlsym(libzzub, "zzub_envelope_get_flags", c_byte, ("envelope", POINTER\
(zzub_envelope_t)))

zzub_envelope_set_flags

Value:
dlsym(libzzub, "zzub_envelope_set_flags", None, ("envelope", POINTER(z\
zub_envelope_t)), ("flags", c_byte))

zzub_envelope_is_enabled

Value:
dlsym(libzzub, "zzub_envelope_is_enabled", c_int, ("envelope", POINTER\
(zzub_envelope_t)))

zzub_envelope_enable

Value:
dlsym(libzzub, "zzub_envelope_enable", None, ("envelope", POINTER(zzub\
_envelope_t)), ("enable", c_int))

zzub_envelope_get_point_count

Value:
dlsym(libzzub, "zzub_envelope_get_point_count", c_int, ("envelope", PO\
INTER(zzub_envelope_t)))

zzub_envelope_get_point

Value:
dlsym(libzzub, "zzub_envelope_get_point", None, ("envelope", POINTER(z\
zub_envelope_t)), ("index", c_int), ("x", POINTER(c_ushort)), ("y", PO\
INTER(c_ushort)), ("flags", POINTER(c_byte)))

zzub_envelope_set_point

Value:
dlsym(libzzub, "zzub_envelope_set_point", None, ("envelope", POINTER(z\
zub_envelope_t)), ("index", c_int), ("x", c_ushort), ("y", c_ushort), \
("flags", c_byte))

zzub_envelope_insert_point

Value:
dlsym(libzzub, "zzub_envelope_insert_point", None, ("envelope", POINTE\
R(zzub_envelope_t)), ("index", c_int))

zzub_envelope_delete_point

Value:
dlsym(libzzub, "zzub_envelope_delete_point", None, ("envelope", POINTE\
R(zzub_envelope_t)), ("index", c_int))

zzub_wave_get_index

Value:
dlsym(libzzub, "zzub_wave_get_index", c_int, ("wave", POINTER(zzub_wav\
e_t)))

zzub_wave_load_sample

Value:
dlsym(libzzub, "zzub_wave_load_sample", c_int, ("wave", POINTER(zzub_w\
ave_t)), ("level", c_int), ("offset", c_int), ("clear", c_int), ("path\
", c_char_p), ("datastream", POINTER(zzub_input_t)))

zzub_wave_save_sample

Value:
dlsym(libzzub, "zzub_wave_save_sample", c_int, ("wave", POINTER(zzub_w\
ave_t)), ("level", c_int), ("datastream", POINTER(zzub_output_t)))

zzub_wave_save_sample_range

Value:
dlsym(libzzub, "zzub_wave_save_sample_range", c_int, ("wave", POINTER(\
zzub_wave_t)), ("level", c_int), ("datastream", POINTER(zzub_output_t)\
), ("start", c_int), ("end", c_int))

zzub_wave_clear

Value:
dlsym(libzzub, "zzub_wave_clear", c_int, ("wave", POINTER(zzub_wave_t)\
))

zzub_wave_get_name

Value:
dlsym(libzzub, "zzub_wave_get_name", c_char_p, ("wave", POINTER(zzub_w\
ave_t)))

zzub_wave_set_name

Value:
dlsym(libzzub, "zzub_wave_set_name", None, ("wave", POINTER(zzub_wave_\
t)), ("name", c_char_p))

zzub_wave_get_path

Value:
dlsym(libzzub, "zzub_wave_get_path", c_char_p, ("wave", POINTER(zzub_w\
ave_t)))

zzub_wave_set_path

Value:
dlsym(libzzub, "zzub_wave_set_path", None, ("wave", POINTER(zzub_wave_\
t)), ("path", c_char_p))

zzub_wave_get_flags

Value:
dlsym(libzzub, "zzub_wave_get_flags", c_int, ("wave", POINTER(zzub_wav\
e_t)))

zzub_wave_set_flags

Value:
dlsym(libzzub, "zzub_wave_set_flags", None, ("wave", POINTER(zzub_wave\
_t)), ("flags", c_int))

zzub_wave_get_volume

Value:
dlsym(libzzub, "zzub_wave_get_volume", c_float, ("wave", POINTER(zzub_\
wave_t)))

zzub_wave_set_volume

Value:
dlsym(libzzub, "zzub_wave_set_volume", None, ("wave", POINTER(zzub_wav\
e_t)), ("volume", c_float))

zzub_wave_get_envelope_count

Value:
dlsym(libzzub, "zzub_wave_get_envelope_count", c_int, ("wave", POINTER\
(zzub_wave_t)))

zzub_wave_set_envelope_count

Value:
dlsym(libzzub, "zzub_wave_set_envelope_count", None, ("wave", POINTER(\
zzub_wave_t)), ("count", c_int))

zzub_wave_get_envelope

Value:
dlsym(libzzub, "zzub_wave_get_envelope", POINTER(zzub_envelope_t), ("w\
ave", POINTER(zzub_wave_t)), ("index", c_int))

zzub_wave_set_envelope

Value:
dlsym(libzzub, "zzub_wave_set_envelope", None, ("wave", POINTER(zzub_w\
ave_t)), ("index", c_int), ("env", POINTER(zzub_envelope_t)))

zzub_wave_get_level_count

Value:
dlsym(libzzub, "zzub_wave_get_level_count", c_int, ("wave", POINTER(zz\
ub_wave_t)))

zzub_wave_get_level

Value:
dlsym(libzzub, "zzub_wave_get_level", POINTER(zzub_wavelevel_t), ("wav\
e", POINTER(zzub_wave_t)), ("index", c_int))

zzub_player_create

Value:
dlsym(libzzub, "zzub_player_create", POINTER(zzub_player_t))

zzub_player_destroy

Value:
dlsym(libzzub, "zzub_player_destroy", None, ("player", POINTER(zzub_pl\
ayer_t)))

zzub_player_add_plugin_path

Value:
dlsym(libzzub, "zzub_player_add_plugin_path", None, ("player", POINTER\
(zzub_player_t)), ("path", c_char_p))

zzub_player_blacklist_plugin

Value:
dlsym(libzzub, "zzub_player_blacklist_plugin", None, ("player", POINTE\
R(zzub_player_t)), ("uri", c_char_p))

zzub_player_initialize

Value:
dlsym(libzzub, "zzub_player_initialize", c_int, ("player", POINTER(zzu\
b_player_t)), ("samplesPerSecond", c_int))

zzub_player_load_bmx

Value:
dlsym(libzzub, "zzub_player_load_bmx", c_int, ("player", POINTER(zzub_\
player_t)), ("datastream", POINTER(zzub_input_t)), ("messages", c_char\
_p), ("maxLen", c_int), ("flags", c_int), ("x", c_float), ("y", c_floa\
t))

zzub_player_save_bmx

Value:
dlsym(libzzub, "zzub_player_save_bmx", c_int, ("player", POINTER(zzub_\
player_t)), ("plugins", POINTER(POINTER(zzub_plugin_t))), ("num_plugin\
s", c_int), ("save_waves", c_int), ("datastream", POINTER(zzub_output_\
t)))

zzub_player_load_ccm

Value:
dlsym(libzzub, "zzub_player_load_ccm", c_int, ("player", POINTER(zzub_\
player_t)), ("fileName", c_char_p))

zzub_player_save_ccm

Value:
dlsym(libzzub, "zzub_player_save_ccm", c_int, ("player", POINTER(zzub_\
player_t)), ("fileName", c_char_p))

zzub_player_get_state

Value:
dlsym(libzzub, "zzub_player_get_state", c_int, ("player", POINTER(zzub\
_player_t)))

zzub_player_set_state

Value:
dlsym(libzzub, "zzub_player_set_state", None, ("player", POINTER(zzub_\
player_t)), ("state", c_int))

zzub_player_get_bpm

Value:
dlsym(libzzub, "zzub_player_get_bpm", c_float, ("player", POINTER(zzub\
_player_t)))

zzub_player_get_tpb

Value:
dlsym(libzzub, "zzub_player_get_tpb", c_int, ("player", POINTER(zzub_p\
layer_t)))

zzub_player_set_bpm

Value:
dlsym(libzzub, "zzub_player_set_bpm", None, ("player", POINTER(zzub_pl\
ayer_t)), ("bpm", c_float))

zzub_player_set_tpb

Value:
dlsym(libzzub, "zzub_player_set_tpb", None, ("player", POINTER(zzub_pl\
ayer_t)), ("tpb", c_int))

zzub_player_get_pluginloader_count

Value:
dlsym(libzzub, "zzub_player_get_pluginloader_count", c_int, ("player",\
 POINTER(zzub_player_t)))

zzub_player_get_pluginloader

Value:
dlsym(libzzub, "zzub_player_get_pluginloader", POINTER(zzub_pluginload\
er_t), ("player", POINTER(zzub_player_t)), ("index", c_int))

zzub_player_get_pluginloader_by_name

Value:
dlsym(libzzub, "zzub_player_get_pluginloader_by_name", POINTER(zzub_pl\
uginloader_t), ("player", POINTER(zzub_player_t)), ("name", c_char_p))

zzub_player_get_plugin_count

Value:
dlsym(libzzub, "zzub_player_get_plugin_count", c_int, ("player", POINT\
ER(zzub_player_t)))

zzub_player_add_midimapping

Value:
dlsym(libzzub, "zzub_player_add_midimapping", POINTER(zzub_midimapping\
_t), ("plugin", POINTER(zzub_plugin_t)), ("group", c_int), ("track", c\
_int), ("param", c_int), ("channel", c_int), ("controller", c_int))

zzub_player_remove_midimapping

Value:
dlsym(libzzub, "zzub_player_remove_midimapping", c_int, ("plugin", POI\
NTER(zzub_plugin_t)), ("group", c_int), ("track", c_int), ("param", c_\
int))

zzub_player_get_plugin_by_name

Value:
dlsym(libzzub, "zzub_player_get_plugin_by_name", POINTER(zzub_plugin_t\
), ("player", POINTER(zzub_player_t)), ("name", c_char_p))

zzub_player_get_plugin_by_id

Value:
dlsym(libzzub, "zzub_player_get_plugin_by_id", POINTER(zzub_plugin_t),\
 ("player", POINTER(zzub_player_t)), ("id", c_int))

zzub_player_get_plugin

Value:
dlsym(libzzub, "zzub_player_get_plugin", POINTER(zzub_plugin_t), ("pla\
yer", POINTER(zzub_player_t)), ("index", c_int))

zzub_player_work_stereo

Value:
dlsym(libzzub, "zzub_player_work_stereo", POINTER(POINTER(c_float)), (\
"player", POINTER(zzub_player_t)), ("numSamples", POINTER(c_int)))

zzub_player_clear

Value:
dlsym(libzzub, "zzub_player_clear", None, ("player", POINTER(zzub_play\
er_t)))

zzub_player_get_position

Value:
dlsym(libzzub, "zzub_player_get_position", c_int, ("player", POINTER(z\
zub_player_t)))

zzub_player_set_position

Value:
dlsym(libzzub, "zzub_player_set_position", None, ("player", POINTER(zz\
ub_player_t)), ("pos", c_int))

zzub_player_get_loop_start

Value:
dlsym(libzzub, "zzub_player_get_loop_start", c_int, ("player", POINTER\
(zzub_player_t)))

zzub_player_get_loop_end

Value:
dlsym(libzzub, "zzub_player_get_loop_end", c_int, ("player", POINTER(z\
zub_player_t)))

zzub_player_set_loop_start

Value:
dlsym(libzzub, "zzub_player_set_loop_start", None, ("player", POINTER(\
zzub_player_t)), ("v", c_int))

zzub_player_set_loop_end

Value:
dlsym(libzzub, "zzub_player_set_loop_end", None, ("player", POINTER(zz\
ub_player_t)), ("v", c_int))

zzub_player_get_loop

Value:
dlsym(libzzub, "zzub_player_get_loop", None, ("player", POINTER(zzub_p\
layer_t)), ("begin", POINTER(c_int)), ("end", POINTER(c_int)))

zzub_player_set_loop

Value:
dlsym(libzzub, "zzub_player_set_loop", None, ("player", POINTER(zzub_p\
layer_t)), ("begin", c_int), ("end", c_int))

zzub_player_get_song_start

Value:
dlsym(libzzub, "zzub_player_get_song_start", c_int, ("player", POINTER\
(zzub_player_t)))

zzub_player_get_song_end

Value:
dlsym(libzzub, "zzub_player_get_song_end", c_int, ("player", POINTER(z\
zub_player_t)))

zzub_player_set_song_start

Value:
dlsym(libzzub, "zzub_player_set_song_start", None, ("player", POINTER(\
zzub_player_t)), ("v", c_int))

zzub_player_set_song_end

Value:
dlsym(libzzub, "zzub_player_set_song_end", None, ("player", POINTER(zz\
ub_player_t)), ("v", c_int))

zzub_player_set_loop_enabled

Value:
dlsym(libzzub, "zzub_player_set_loop_enabled", None, ("player", POINTE\
R(zzub_player_t)), ("enable", c_int))

zzub_player_get_loop_enabled

Value:
dlsym(libzzub, "zzub_player_get_loop_enabled", c_int, ("player", POINT\
ER(zzub_player_t)))

zzub_player_get_sequence_track_count

Value:
dlsym(libzzub, "zzub_player_get_sequence_track_count", c_int, ("player\
", POINTER(zzub_player_t)))

zzub_player_get_sequence

Value:
dlsym(libzzub, "zzub_player_get_sequence", POINTER(zzub_sequence_t), (\
"player", POINTER(zzub_player_t)), ("index", c_int))

zzub_player_get_currently_playing_pattern

Value:
dlsym(libzzub, "zzub_player_get_currently_playing_pattern", c_int, ("p\
lugin", POINTER(zzub_plugin_t)), ("pattern", POINTER(c_int)), ("row", \
POINTER(c_int)))

zzub_player_get_currently_playing_pattern_row

Value:
dlsym(libzzub, "zzub_player_get_currently_playing_pattern_row", c_int,\
 ("plugin", POINTER(zzub_plugin_t)), ("pattern", c_int), ("row", POINT\
ER(c_int)))

zzub_player_get_wave_count

Value:
dlsym(libzzub, "zzub_player_get_wave_count", c_int, ("player", POINTER\
(zzub_player_t)))

zzub_player_get_wave

Value:
dlsym(libzzub, "zzub_player_get_wave", POINTER(zzub_wave_t), ("player"\
, POINTER(zzub_player_t)), ("index", c_int))

zzub_player_get_next_event

Value:
dlsym(libzzub, "zzub_player_get_next_event", POINTER(zzub_event_data_t\
), ("player", POINTER(zzub_player_t)))

zzub_player_set_callback

Value:
dlsym(libzzub, "zzub_player_set_callback", None, ("player", POINTER(zz\
ub_player_t)), ("callback", zzub_callback_t), ("tag", c_void_p))

zzub_player_handle_events

Value:
dlsym(libzzub, "zzub_player_handle_events", None, ("player", POINTER(z\
zub_player_t)))

zzub_player_set_event_queue_state

Value:
dlsym(libzzub, "zzub_player_set_event_queue_state", None, ("player", P\
OINTER(zzub_player_t)), ("enable", c_int))

zzub_player_get_midimapping

Value:
dlsym(libzzub, "zzub_player_get_midimapping", POINTER(zzub_midimapping\
_t), ("player", POINTER(zzub_player_t)), ("index", c_int))

zzub_player_get_midimapping_count

Value:
dlsym(libzzub, "zzub_player_get_midimapping_count", c_int, ("player", \
POINTER(zzub_player_t)))

zzub_player_get_automation

Value:
dlsym(libzzub, "zzub_player_get_automation", c_int, ("player", POINTER\
(zzub_player_t)))

zzub_player_set_automation

Value:
dlsym(libzzub, "zzub_player_set_automation", None, ("player", POINTER(\
zzub_player_t)), ("enable", c_int))

zzub_player_get_midi_transport

Value:
dlsym(libzzub, "zzub_player_get_midi_transport", c_int, ("player", POI\
NTER(zzub_player_t)))

zzub_player_set_midi_transport

Value:
dlsym(libzzub, "zzub_player_set_midi_transport", None, ("player", POIN\
TER(zzub_player_t)), ("enable", c_int))

zzub_player_get_infotext

Value:
dlsym(libzzub, "zzub_player_get_infotext", c_char_p, ("player", POINTE\
R(zzub_player_t)))

zzub_player_set_infotext

Value:
dlsym(libzzub, "zzub_player_set_infotext", None, ("player", POINTER(zz\
ub_player_t)), ("text", c_char_p))

zzub_player_set_midi_plugin

Value:
dlsym(libzzub, "zzub_player_set_midi_plugin", None, ("player", POINTER\
(zzub_player_t)), ("plugin", POINTER(zzub_plugin_t)))

zzub_player_get_midi_plugin

Value:
dlsym(libzzub, "zzub_player_get_midi_plugin", POINTER(zzub_plugin_t), \
("player", POINTER(zzub_player_t)))

zzub_player_get_new_plugin_name

Value:
dlsym(libzzub, "zzub_player_get_new_plugin_name", None, ("player", POI\
NTER(zzub_player_t)), ("uri", c_char_p), ("name", c_char_p), ("maxLen"\
, c_int))

zzub_player_reset_keyjazz

Value:
dlsym(libzzub, "zzub_player_reset_keyjazz", None, ("player", POINTER(z\
zub_player_t)))

zzub_player_create_plugin

Value:
dlsym(libzzub, "zzub_player_create_plugin", POINTER(zzub_plugin_t), ("\
player", POINTER(zzub_player_t)), ("input", POINTER(zzub_input_t)), ("\
dataSize", c_int), ("instanceName", c_char_p), ("loader", POINTER(zzub\
_pluginloader_t)), ("flags", c_int))

zzub_player_create_sequence

Value:
dlsym(libzzub, "zzub_player_create_sequence", POINTER(zzub_sequence_t)\
, ("player", POINTER(zzub_player_t)), ("plugin", POINTER(zzub_plugin_t\
)), ("type", c_int))

zzub_player_flush

Value:
dlsym(libzzub, "zzub_player_flush", None, ("player", POINTER(zzub_play\
er_t)), ("redo_event", POINTER(zzub_event_data_t)), ("undo_event", POI\
NTER(zzub_event_data_t)))

zzub_player_undo

Value:
dlsym(libzzub, "zzub_player_undo", None, ("player", POINTER(zzub_playe\
r_t)))

zzub_player_redo

Value:
dlsym(libzzub, "zzub_player_redo", None, ("player", POINTER(zzub_playe\
r_t)))

zzub_player_history_commit

Value:
dlsym(libzzub, "zzub_player_history_commit", None, ("player", POINTER(\
zzub_player_t)), ("description", c_char_p))

zzub_player_history_get_uncomitted_operations

Value:
dlsym(libzzub, "zzub_player_history_get_uncomitted_operations", c_int,\
 ("player", POINTER(zzub_player_t)))

zzub_player_history_flush_last

Value:
dlsym(libzzub, "zzub_player_history_flush_last", None, ("player", POIN\
TER(zzub_player_t)))

zzub_player_history_flush

Value:
dlsym(libzzub, "zzub_player_history_flush", None, ("player", POINTER(z\
zub_player_t)))

zzub_player_history_get_size

Value:
dlsym(libzzub, "zzub_player_history_get_size", c_int, ("player", POINT\
ER(zzub_player_t)))

zzub_player_history_get_position

Value:
dlsym(libzzub, "zzub_player_history_get_position", c_int, ("player", P\
OINTER(zzub_player_t)))

zzub_player_history_get_description

Value:
dlsym(libzzub, "zzub_player_history_get_description", c_char_p, ("play\
er", POINTER(zzub_player_t)), ("position", c_int))

zzub_player_set_host_info

Value:
dlsym(libzzub, "zzub_player_set_host_info", None, ("player", POINTER(z\
zub_player_t)), ("id", c_int), ("version", c_int), ("host_ptr", c_void\
_p))