Logo Search packages:      
Sourcecode: beast version File versions

bswgenapi.h

#include <sfi/sfi.h>


/*-------- begin ../sfi/sfidl generated code --------*/




#define bse_midi_signal_type_to_choice beast__bse_midi_signal_type_to_choice
#define bse_midi_signal_type_from_choice beast__bse_midi_signal_type_from_choice
#define bse_thread_state_to_choice beast__bse_thread_state_to_choice
#define bse_thread_state_from_choice beast__bse_thread_state_from_choice
#define bse_biquad_filter_type_to_choice beast__bse_biquad_filter_type_to_choice
#define bse_biquad_filter_type_from_choice beast__bse_biquad_filter_type_from_choice
#define bse_biquad_filter_norm_to_choice beast__bse_biquad_filter_norm_to_choice
#define bse_biquad_filter_norm_from_choice beast__bse_biquad_filter_norm_from_choice
#define bse_registration_type_to_choice beast__bse_registration_type_to_choice
#define bse_registration_type_from_choice beast__bse_registration_type_from_choice
#define bse_user_msg_type_to_choice beast__bse_user_msg_type_to_choice
#define bse_user_msg_type_from_choice beast__bse_user_msg_type_from_choice
#define bse_error_type_to_choice beast__bse_error_type_to_choice
#define bse_error_type_from_choice beast__bse_error_type_from_choice
#define bse_project_state_to_choice beast__bse_project_state_to_choice
#define bse_project_state_from_choice beast__bse_project_state_from_choice
#define bse_standard_osc_wave_type_to_choice beast__bse_standard_osc_wave_type_to_choice
#define bse_standard_osc_wave_type_from_choice beast__bse_standard_osc_wave_type_from_choice
#define bse_sniffer_type_to_choice beast__bse_sniffer_type_to_choice
#define bse_sniffer_type_from_choice beast__bse_sniffer_type_from_choice
#define bse_sniffer_time_type_to_choice beast__bse_sniffer_time_type_to_choice
#define bse_sniffer_time_type_from_choice beast__bse_sniffer_time_type_from_choice
#define bse_part_note_new beast__bse_part_note_new
#define bse_part_note_copy_shallow beast__bse_part_note_copy_shallow
#define bse_part_note_from_rec beast__bse_part_note_from_rec
#define bse_part_note_to_rec beast__bse_part_note_to_rec
#define bse_part_note_free beast__bse_part_note_free
#define bse_part_control_new beast__bse_part_control_new
#define bse_part_control_copy_shallow beast__bse_part_control_copy_shallow
#define bse_part_control_from_rec beast__bse_part_control_from_rec
#define bse_part_control_to_rec beast__bse_part_control_to_rec
#define bse_part_control_free beast__bse_part_control_free
#define bse_note_description_new beast__bse_note_description_new
#define bse_note_description_copy_shallow beast__bse_note_description_copy_shallow
#define bse_note_description_from_rec beast__bse_note_description_from_rec
#define bse_note_description_to_rec beast__bse_note_description_to_rec
#define bse_note_description_free beast__bse_note_description_free
#define bse_note_sequence_new beast__bse_note_sequence_new
#define bse_note_sequence_copy_shallow beast__bse_note_sequence_copy_shallow
#define bse_note_sequence_from_rec beast__bse_note_sequence_from_rec
#define bse_note_sequence_to_rec beast__bse_note_sequence_to_rec
#define bse_note_sequence_free beast__bse_note_sequence_free
#define bse_icon_new beast__bse_icon_new
#define bse_icon_copy_shallow beast__bse_icon_copy_shallow
#define bse_icon_from_rec beast__bse_icon_from_rec
#define bse_icon_to_rec beast__bse_icon_to_rec
#define bse_icon_free beast__bse_icon_free
#define bse_category_new beast__bse_category_new
#define bse_category_copy_shallow beast__bse_category_copy_shallow
#define bse_category_from_rec beast__bse_category_from_rec
#define bse_category_to_rec beast__bse_category_to_rec
#define bse_category_free beast__bse_category_free
#define bse_dot_new beast__bse_dot_new
#define bse_dot_copy_shallow beast__bse_dot_copy_shallow
#define bse_dot_from_rec beast__bse_dot_from_rec
#define bse_dot_to_rec beast__bse_dot_to_rec
#define bse_dot_free beast__bse_dot_free
#define bse_track_part_new beast__bse_track_part_new
#define bse_track_part_copy_shallow beast__bse_track_part_copy_shallow
#define bse_track_part_from_rec beast__bse_track_part_from_rec
#define bse_track_part_to_rec beast__bse_track_part_to_rec
#define bse_track_part_free beast__bse_track_part_free
#define bse_song_timing_new beast__bse_song_timing_new
#define bse_song_timing_copy_shallow beast__bse_song_timing_copy_shallow
#define bse_song_timing_from_rec beast__bse_song_timing_from_rec
#define bse_song_timing_to_rec beast__bse_song_timing_to_rec
#define bse_song_timing_free beast__bse_song_timing_free
#define bse_sample_file_info_new beast__bse_sample_file_info_new
#define bse_sample_file_info_copy_shallow beast__bse_sample_file_info_copy_shallow
#define bse_sample_file_info_from_rec beast__bse_sample_file_info_from_rec
#define bse_sample_file_info_to_rec beast__bse_sample_file_info_to_rec
#define bse_sample_file_info_free beast__bse_sample_file_info_free
#define bse_thread_info_new beast__bse_thread_info_new
#define bse_thread_info_copy_shallow beast__bse_thread_info_copy_shallow
#define bse_thread_info_from_rec beast__bse_thread_info_from_rec
#define bse_thread_info_to_rec beast__bse_thread_info_to_rec
#define bse_thread_info_free beast__bse_thread_info_free
#define bse_thread_totals_new beast__bse_thread_totals_new
#define bse_thread_totals_copy_shallow beast__bse_thread_totals_copy_shallow
#define bse_thread_totals_from_rec beast__bse_thread_totals_from_rec
#define bse_thread_totals_to_rec beast__bse_thread_totals_to_rec
#define bse_thread_totals_free beast__bse_thread_totals_free
#define bse_gconfig_new beast__bse_gconfig_new
#define bse_gconfig_copy_shallow beast__bse_gconfig_copy_shallow
#define bse_gconfig_from_rec beast__bse_gconfig_from_rec
#define bse_gconfig_to_rec beast__bse_gconfig_to_rec
#define bse_gconfig_free beast__bse_gconfig_free
#define bse_sniffer_request_new beast__bse_sniffer_request_new
#define bse_sniffer_request_copy_shallow beast__bse_sniffer_request_copy_shallow
#define bse_sniffer_request_from_rec beast__bse_sniffer_request_from_rec
#define bse_sniffer_request_to_rec beast__bse_sniffer_request_to_rec
#define bse_sniffer_request_free beast__bse_sniffer_request_free
#define bse_int_seq_new beast__bse_int_seq_new
#define bse_int_seq_append beast__bse_int_seq_append
#define bse_int_seq_copy_shallow beast__bse_int_seq_copy_shallow
#define bse_int_seq_from_seq beast__bse_int_seq_from_seq
#define bse_int_seq_to_seq beast__bse_int_seq_to_seq
#define bse_int_seq_resize beast__bse_int_seq_resize
#define bse_int_seq_free beast__bse_int_seq_free
#define bse_note_seq_new beast__bse_note_seq_new
#define bse_note_seq_append beast__bse_note_seq_append
#define bse_note_seq_copy_shallow beast__bse_note_seq_copy_shallow
#define bse_note_seq_from_seq beast__bse_note_seq_from_seq
#define bse_note_seq_to_seq beast__bse_note_seq_to_seq
#define bse_note_seq_resize beast__bse_note_seq_resize
#define bse_note_seq_free beast__bse_note_seq_free
#define bse_string_seq_new beast__bse_string_seq_new
#define bse_string_seq_append beast__bse_string_seq_append
#define bse_string_seq_copy_shallow beast__bse_string_seq_copy_shallow
#define bse_string_seq_from_seq beast__bse_string_seq_from_seq
#define bse_string_seq_to_seq beast__bse_string_seq_to_seq
#define bse_string_seq_resize beast__bse_string_seq_resize
#define bse_string_seq_free beast__bse_string_seq_free
#define bse_item_seq_new beast__bse_item_seq_new
#define bse_item_seq_append beast__bse_item_seq_append
#define bse_item_seq_copy_shallow beast__bse_item_seq_copy_shallow
#define bse_item_seq_from_seq beast__bse_item_seq_from_seq
#define bse_item_seq_to_seq beast__bse_item_seq_to_seq
#define bse_item_seq_resize beast__bse_item_seq_resize
#define bse_item_seq_free beast__bse_item_seq_free
#define bse_part_note_seq_new beast__bse_part_note_seq_new
#define bse_part_note_seq_append beast__bse_part_note_seq_append
#define bse_part_note_seq_copy_shallow beast__bse_part_note_seq_copy_shallow
#define bse_part_note_seq_from_seq beast__bse_part_note_seq_from_seq
#define bse_part_note_seq_to_seq beast__bse_part_note_seq_to_seq
#define bse_part_note_seq_resize beast__bse_part_note_seq_resize
#define bse_part_note_seq_free beast__bse_part_note_seq_free
#define bse_part_control_seq_new beast__bse_part_control_seq_new
#define bse_part_control_seq_append beast__bse_part_control_seq_append
#define bse_part_control_seq_copy_shallow beast__bse_part_control_seq_copy_shallow
#define bse_part_control_seq_from_seq beast__bse_part_control_seq_from_seq
#define bse_part_control_seq_to_seq beast__bse_part_control_seq_to_seq
#define bse_part_control_seq_resize beast__bse_part_control_seq_resize
#define bse_part_control_seq_free beast__bse_part_control_seq_free
#define bse_category_seq_new beast__bse_category_seq_new
#define bse_category_seq_append beast__bse_category_seq_append
#define bse_category_seq_copy_shallow beast__bse_category_seq_copy_shallow
#define bse_category_seq_from_seq beast__bse_category_seq_from_seq
#define bse_category_seq_to_seq beast__bse_category_seq_to_seq
#define bse_category_seq_resize beast__bse_category_seq_resize
#define bse_category_seq_free beast__bse_category_seq_free
#define bse_dot_seq_new beast__bse_dot_seq_new
#define bse_dot_seq_append beast__bse_dot_seq_append
#define bse_dot_seq_copy_shallow beast__bse_dot_seq_copy_shallow
#define bse_dot_seq_from_seq beast__bse_dot_seq_from_seq
#define bse_dot_seq_to_seq beast__bse_dot_seq_to_seq
#define bse_dot_seq_resize beast__bse_dot_seq_resize
#define bse_dot_seq_free beast__bse_dot_seq_free
#define bse_track_part_seq_new beast__bse_track_part_seq_new
#define bse_track_part_seq_append beast__bse_track_part_seq_append
#define bse_track_part_seq_copy_shallow beast__bse_track_part_seq_copy_shallow
#define bse_track_part_seq_from_seq beast__bse_track_part_seq_from_seq
#define bse_track_part_seq_to_seq beast__bse_track_part_seq_to_seq
#define bse_track_part_seq_resize beast__bse_track_part_seq_resize
#define bse_track_part_seq_free beast__bse_track_part_seq_free
#define bse_thread_info_seq_new beast__bse_thread_info_seq_new
#define bse_thread_info_seq_append beast__bse_thread_info_seq_append
#define bse_thread_info_seq_copy_shallow beast__bse_thread_info_seq_copy_shallow
#define bse_thread_info_seq_from_seq beast__bse_thread_info_seq_from_seq
#define bse_thread_info_seq_to_seq beast__bse_thread_info_seq_to_seq
#define bse_thread_info_seq_resize beast__bse_thread_info_seq_resize
#define bse_thread_info_seq_free beast__bse_thread_info_seq_free
#define bse_sniffer_request_seq_new beast__bse_sniffer_request_seq_new
#define bse_sniffer_request_seq_append beast__bse_sniffer_request_seq_append
#define bse_sniffer_request_seq_copy_shallow beast__bse_sniffer_request_seq_copy_shallow
#define bse_sniffer_request_seq_from_seq beast__bse_sniffer_request_seq_from_seq
#define bse_sniffer_request_seq_to_seq beast__bse_sniffer_request_seq_to_seq
#define bse_sniffer_request_seq_resize beast__bse_sniffer_request_seq_resize
#define bse_sniffer_request_seq_free beast__bse_sniffer_request_seq_free
#define bse_item_add_parasite beast__bse_item_add_parasite
#define bse_item_check_is_a beast__bse_item_check_is_a
#define bse_item_clear_undo beast__bse_item_clear_undo
#define bse_item_common_ancestor beast__bse_item_common_ancestor
#define bse_item_fixme_get_parasite beast__bse_item_fixme_get_parasite
#define bse_item_fixme_set_parasite beast__bse_item_fixme_set_parasite
#define bse_item_get_icon beast__bse_item_get_icon
#define bse_item_get_name beast__bse_item_get_name
#define bse_item_get_name_or_type beast__bse_item_get_name_or_type
#define bse_item_get_parasite beast__bse_item_get_parasite
#define bse_item_get_parent beast__bse_item_get_parent
#define bse_item_get_project beast__bse_item_get_project
#define bse_item_get_seqid beast__bse_item_get_seqid
#define bse_item_get_type beast__bse_item_get_type
#define bse_item_get_type_authors beast__bse_item_get_type_authors
#define bse_item_get_type_blurb beast__bse_item_get_type_blurb
#define bse_item_get_type_license beast__bse_item_get_type_license
#define bse_item_get_type_name beast__bse_item_get_type_name
#define bse_item_get_uname_path beast__bse_item_get_uname_path
#define bse_item_group_undo beast__bse_item_group_undo
#define bse_item_internal beast__bse_item_internal
#define bse_item_list_items beast__bse_item_list_items
#define bse_item_list_parasites beast__bse_item_list_parasites
#define bse_item_redo beast__bse_item_redo
#define bse_item_redo_depth beast__bse_item_redo_depth
#define bse_item_set_name beast__bse_item_set_name
#define bse_item_set_parasite beast__bse_item_set_parasite
#define bse_item_undo beast__bse_item_undo
#define bse_item_undo_depth beast__bse_item_undo_depth
#define bse_item_ungroup_undo beast__bse_item_ungroup_undo
#define bse_item_unuse beast__bse_item_unuse
#define bse_item_use beast__bse_item_use
#define bse_data_pocket_create_entry beast__bse_data_pocket_create_entry
#define bse_data_pocket_delete_entry beast__bse_data_pocket_delete_entry
#define bse_data_pocket_get_float beast__bse_data_pocket_get_float
#define bse_data_pocket_get_int beast__bse_data_pocket_get_int
#define bse_data_pocket_get_n_entries beast__bse_data_pocket_get_n_entries
#define bse_data_pocket_get_nth_entry_id beast__bse_data_pocket_get_nth_entry_id
#define bse_data_pocket_get_object beast__bse_data_pocket_get_object
#define bse_data_pocket_get_string beast__bse_data_pocket_get_string
#define bse_data_pocket_set_float beast__bse_data_pocket_set_float
#define bse_data_pocket_set_int beast__bse_data_pocket_set_int
#define bse_data_pocket_set_object beast__bse_data_pocket_set_object
#define bse_data_pocket_set_string beast__bse_data_pocket_set_string
#define bse_editable_sample_close beast__bse_editable_sample_close
#define bse_editable_sample_collect_stats beast__bse_editable_sample_collect_stats
#define bse_editable_sample_get_length beast__bse_editable_sample_get_length
#define bse_editable_sample_get_n_channels beast__bse_editable_sample_get_n_channels
#define bse_editable_sample_get_osc_freq beast__bse_editable_sample_get_osc_freq
#define bse_editable_sample_open beast__bse_editable_sample_open
#define bse_editable_sample_read_samples beast__bse_editable_sample_read_samples
#define bse_janitor_add_action beast__bse_janitor_add_action
#define bse_janitor_exit beast__bse_janitor_exit
#define bse_janitor_get_action beast__bse_janitor_get_action
#define bse_janitor_get_action_blurb beast__bse_janitor_get_action_blurb
#define bse_janitor_get_action_name beast__bse_janitor_get_action_name
#define bse_janitor_get_proc_name beast__bse_janitor_get_proc_name
#define bse_janitor_get_script_name beast__bse_janitor_get_script_name
#define bse_janitor_kill beast__bse_janitor_kill
#define bse_janitor_n_actions beast__bse_janitor_n_actions
#define bse_janitor_progress beast__bse_janitor_progress
#define bse_janitor_remove_action beast__bse_janitor_remove_action
#define bse_janitor_set_msg beast__bse_janitor_set_msg
#define bse_janitor_trigger_action beast__bse_janitor_trigger_action
#define bse_midi_notifier_current_time beast__bse_midi_notifier_current_time
#define bse_part_change_control beast__bse_part_change_control
#define bse_part_change_note beast__bse_part_change_note
#define bse_part_check_overlap beast__bse_part_check_overlap
#define bse_part_delete_event beast__bse_part_delete_event
#define bse_part_deselect_controls beast__bse_part_deselect_controls
#define bse_part_deselect_event beast__bse_part_deselect_event
#define bse_part_deselect_notes beast__bse_part_deselect_notes
#define bse_part_get_channel_controls beast__bse_part_get_channel_controls
#define bse_part_get_controls beast__bse_part_get_controls
#define bse_part_get_max_note beast__bse_part_get_max_note
#define bse_part_get_min_note beast__bse_part_get_min_note
#define bse_part_get_notes beast__bse_part_get_notes
#define bse_part_get_timing beast__bse_part_get_timing
#define bse_part_insert_control beast__bse_part_insert_control
#define bse_part_insert_note beast__bse_part_insert_note
#define bse_part_insert_note_auto beast__bse_part_insert_note_auto
#define bse_part_is_event_selected beast__bse_part_is_event_selected
#define bse_part_list_controls beast__bse_part_list_controls
#define bse_part_list_notes_crossing beast__bse_part_list_notes_crossing
#define bse_part_list_notes_within beast__bse_part_list_notes_within
#define bse_part_list_selected_controls beast__bse_part_list_selected_controls
#define bse_part_list_selected_notes beast__bse_part_list_selected_notes
#define bse_part_queue_controls beast__bse_part_queue_controls
#define bse_part_queue_notes beast__bse_part_queue_notes
#define bse_part_select_controls_exclusive beast__bse_part_select_controls_exclusive
#define bse_part_select_event beast__bse_part_select_event
#define bse_part_select_notes beast__bse_part_select_notes
#define bse_part_select_notes_exclusive beast__bse_part_select_notes_exclusive
#define bse_source_clear_inputs beast__bse_source_clear_inputs
#define bse_source_clear_outputs beast__bse_source_clear_outputs
#define bse_source_has_outputs beast__bse_source_has_outputs
#define bse_source_ichannel_blurb beast__bse_source_ichannel_blurb
#define bse_source_ichannel_get_n_joints beast__bse_source_ichannel_get_n_joints
#define bse_source_ichannel_get_ochannel beast__bse_source_ichannel_get_ochannel
#define bse_source_ichannel_get_osource beast__bse_source_ichannel_get_osource
#define bse_source_ichannel_ident beast__bse_source_ichannel_ident
#define bse_source_ichannel_label beast__bse_source_ichannel_label
#define bse_source_is_joint_ichannel beast__bse_source_is_joint_ichannel
#define bse_source_is_joint_ichannel_by_id beast__bse_source_is_joint_ichannel_by_id
#define bse_source_n_ichannels beast__bse_source_n_ichannels
#define bse_source_n_ochannels beast__bse_source_n_ochannels
#define bse_source_ochannel_blurb beast__bse_source_ochannel_blurb
#define bse_source_ochannel_ident beast__bse_source_ochannel_ident
#define bse_source_ochannel_label beast__bse_source_ochannel_label
#define bse_source_set_input beast__bse_source_set_input
#define bse_source_set_input_by_id beast__bse_source_set_input_by_id
#define bse_source_set_pos beast__bse_source_set_pos
#define bse_source_unset_input beast__bse_source_unset_input
#define bse_source_unset_input_by_id beast__bse_source_unset_input_by_id
#define bse_track_create_sniffer beast__bse_track_create_sniffer
#define bse_track_get_last_tick beast__bse_track_get_last_tick
#define bse_track_get_part beast__bse_track_get_part
#define bse_track_get_timing beast__bse_track_get_timing
#define bse_track_insert_part beast__bse_track_insert_part
#define bse_track_list_parts beast__bse_track_list_parts
#define bse_track_remove_link beast__bse_track_remove_link
#define bse_track_remove_tick beast__bse_track_remove_tick
#define bse_container_get_item beast__bse_container_get_item
#define bse_container_list_items beast__bse_container_list_items
#define bse_container_lookup_item beast__bse_container_lookup_item
#define bse_wave_chunk_get_mix_freq beast__bse_wave_chunk_get_mix_freq
#define bse_wave_chunk_get_osc_freq beast__bse_wave_chunk_get_osc_freq
#define bse_wave_load_wave beast__bse_wave_load_wave
#define bse_wave_n_wave_chunks beast__bse_wave_n_wave_chunks
#define bse_wave_use_editable beast__bse_wave_use_editable
#define bse_wave_osc_pcm_seek_perc beast__bse_wave_osc_pcm_seek_perc
#define bse_wave_osc_request_pcm_position beast__bse_wave_osc_request_pcm_position
#define bse_wave_osc_set_from_editable_sample beast__bse_wave_osc_set_from_editable_sample
#define bse_project_import_midi_file beast__bse_project_import_midi_file
#define bse_project_restore_from_file beast__bse_project_restore_from_file
#define bse_project_store_bse beast__bse_project_store_bse
#define bse_project_activate beast__bse_project_activate
#define bse_project_auto_deactivate beast__bse_project_auto_deactivate
#define bse_project_can_play beast__bse_project_can_play
#define bse_project_clear_undo beast__bse_project_clear_undo
#define bse_project_create_csynth beast__bse_project_create_csynth
#define bse_project_create_midi_synth beast__bse_project_create_midi_synth
#define bse_project_create_song beast__bse_project_create_song
#define bse_project_deactivate beast__bse_project_deactivate
#define bse_project_find_item beast__bse_project_find_item
#define bse_project_get_data_pocket beast__bse_project_get_data_pocket
#define bse_project_get_state beast__bse_project_get_state
#define bse_project_get_supers beast__bse_project_get_supers
#define bse_project_get_wave_repo beast__bse_project_get_wave_repo
#define bse_project_is_active beast__bse_project_is_active
#define bse_project_is_playing beast__bse_project_is_playing
#define bse_project_list_uname_paths beast__bse_project_list_uname_paths
#define bse_project_match_items_by_uname beast__bse_project_match_items_by_uname
#define bse_project_play beast__bse_project_play
#define bse_project_redo beast__bse_project_redo
#define bse_project_redo_depth beast__bse_project_redo_depth
#define bse_project_remove_snet beast__bse_project_remove_snet
#define bse_project_start_playback beast__bse_project_start_playback
#define bse_project_stop beast__bse_project_stop
#define bse_project_stop_playback beast__bse_project_stop_playback
#define bse_project_undo beast__bse_project_undo
#define bse_project_undo_depth beast__bse_project_undo_depth
#define bse_server_can_load beast__bse_server_can_load
#define bse_server_construct_note beast__bse_server_construct_note
#define bse_server_describe_note beast__bse_server_describe_note
#define bse_server_get_custom_effect_dir beast__bse_server_get_custom_effect_dir
#define bse_server_get_custom_instrument_dir beast__bse_server_get_custom_instrument_dir
#define bse_server_get_demo_path beast__bse_server_get_demo_path
#define bse_server_get_effect_path beast__bse_server_get_effect_path
#define bse_server_get_instrument_path beast__bse_server_get_instrument_path
#define bse_server_get_ladspa_path beast__bse_server_get_ladspa_path
#define bse_server_get_midi_notifier beast__bse_server_get_midi_notifier
#define bse_server_get_mp3_version beast__bse_server_get_mp3_version
#define bse_server_get_plugin_path beast__bse_server_get_plugin_path
#define bse_server_get_sample_path beast__bse_server_get_sample_path
#define bse_server_get_script_path beast__bse_server_get_script_path
#define bse_server_get_version beast__bse_server_get_version
#define bse_server_n_scripts beast__bse_server_n_scripts
#define bse_server_note_from_freq beast__bse_server_note_from_freq
#define bse_server_note_from_string beast__bse_server_note_from_string
#define bse_server_preferences_locked beast__bse_server_preferences_locked
#define bse_server_register_core_plugins beast__bse_server_register_core_plugins
#define bse_server_register_ladspa_plugins beast__bse_server_register_ladspa_plugins
#define bse_server_register_scripts beast__bse_server_register_scripts
#define bse_server_save_preferences beast__bse_server_save_preferences
#define bse_server_use_new_project beast__bse_server_use_new_project
#define bse_snet_can_create_source beast__bse_snet_can_create_source
#define bse_snet_create_source beast__bse_snet_create_source
#define bse_snet_remove_source beast__bse_snet_remove_source
#define bse_snet_supports_user_synths beast__bse_snet_supports_user_synths
#define bse_wave_repo_load_file beast__bse_wave_repo_load_file
#define bse_wave_repo_remove_wave beast__bse_wave_repo_remove_wave
#define bse_song_create_bus beast__bse_song_create_bus
#define bse_song_create_part beast__bse_song_create_part
#define bse_song_create_track beast__bse_song_create_track
#define bse_song_find_track_for_part beast__bse_song_find_track_for_part
#define bse_song_get_timing beast__bse_song_get_timing
#define bse_song_remove_bus beast__bse_song_remove_bus
#define bse_song_remove_part beast__bse_song_remove_part
#define bse_song_remove_track beast__bse_song_remove_track
#define bse_song_synthesize_note beast__bse_song_synthesize_note
#define bse_collect_thread_totals beast__bse_collect_thread_totals
#define bse_category_from_id beast__bse_category_from_id
#define bse_categories_match beast__bse_categories_match
#define bse_categories_match_method beast__bse_categories_match_method
#define bse_categories_match_typed beast__bse_categories_match_typed
#define bse_error_blurb beast__bse_error_blurb
#define bse_error_name beast__bse_error_name
#define bse_janitor_get_specific beast__bse_janitor_get_specific
#define bse_note_from_freq beast__bse_note_from_freq
#define bse_note_to_freq beast__bse_note_to_freq
#define bse_proxy_check beast__bse_proxy_check
#define bse_sample_file_info beast__bse_sample_file_info
#define bse_string_extract_number beast__bse_string_extract_number
#define bse_type_authors beast__bse_type_authors
#define bse_type_blurb beast__bse_type_blurb
#define bse_type_license beast__bse_type_license
#define bse_type_options beast__bse_type_options
#define bse_sniffer_request_samples beast__bse_sniffer_request_samples
#define bse_sniffer_get_tick_stamp beast__bse_sniffer_get_tick_stamp
#define bse_sniffer_get_mix_freq beast__bse_sniffer_get_mix_freq
#define bse_sniffer_request_combined beast__bse_sniffer_request_combined

typedef struct _BsePartNote BsePartNote;
typedef struct _BsePartControl BsePartControl;
typedef struct _BseNoteDescription BseNoteDescription;
typedef struct _BseNoteSequence BseNoteSequence;
typedef struct _BseIcon BseIcon;
typedef struct _BseCategory BseCategory;
typedef struct _BseDot BseDot;
typedef struct _BseTrackPart BseTrackPart;
typedef struct _BseSongTiming BseSongTiming;
typedef struct _BseSampleFileInfo BseSampleFileInfo;
typedef struct _BseThreadInfo BseThreadInfo;
typedef struct _BseThreadTotals BseThreadTotals;
typedef struct _BseGConfig BseGConfig;
typedef struct _BseSnifferRequest BseSnifferRequest;
typedef struct _BseIntSeq BseIntSeq;
typedef struct _BseNoteSeq BseNoteSeq;
typedef struct _BseStringSeq BseStringSeq;
typedef struct _BseItemSeq BseItemSeq;
typedef struct _BsePartNoteSeq BsePartNoteSeq;
typedef struct _BsePartControlSeq BsePartControlSeq;
typedef struct _BseCategorySeq BseCategorySeq;
typedef struct _BseDotSeq BseDotSeq;
typedef struct _BseTrackPartSeq BseTrackPartSeq;
typedef struct _BseThreadInfoSeq BseThreadInfoSeq;
typedef struct _BseSnifferRequestSeq BseSnifferRequestSeq;

typedef enum {
  BSE_MIDI_SIGNAL_PROGRAM = 1,
  BSE_MIDI_SIGNAL_PRESSURE = 2,
  BSE_MIDI_SIGNAL_PITCH_BEND = 3,
  BSE_MIDI_SIGNAL_VELOCITY = 4,
  BSE_MIDI_SIGNAL_FINE_TUNE = 5,
  BSE_MIDI_SIGNAL_CONTINUOUS_0 = 6,
  BSE_MIDI_SIGNAL_CONTINUOUS_1 = 7,
  BSE_MIDI_SIGNAL_CONTINUOUS_2 = 8,
  BSE_MIDI_SIGNAL_CONTINUOUS_3 = 9,
  BSE_MIDI_SIGNAL_CONTINUOUS_4 = 10,
  BSE_MIDI_SIGNAL_CONTINUOUS_5 = 11,
  BSE_MIDI_SIGNAL_CONTINUOUS_6 = 12,
  BSE_MIDI_SIGNAL_CONTINUOUS_7 = 13,
  BSE_MIDI_SIGNAL_CONTINUOUS_8 = 14,
  BSE_MIDI_SIGNAL_CONTINUOUS_9 = 15,
  BSE_MIDI_SIGNAL_CONTINUOUS_10 = 16,
  BSE_MIDI_SIGNAL_CONTINUOUS_11 = 17,
  BSE_MIDI_SIGNAL_CONTINUOUS_12 = 18,
  BSE_MIDI_SIGNAL_CONTINUOUS_13 = 19,
  BSE_MIDI_SIGNAL_CONTINUOUS_14 = 20,
  BSE_MIDI_SIGNAL_CONTINUOUS_15 = 21,
  BSE_MIDI_SIGNAL_CONTINUOUS_16 = 22,
  BSE_MIDI_SIGNAL_CONTINUOUS_17 = 23,
  BSE_MIDI_SIGNAL_CONTINUOUS_18 = 24,
  BSE_MIDI_SIGNAL_CONTINUOUS_19 = 25,
  BSE_MIDI_SIGNAL_CONTINUOUS_20 = 26,
  BSE_MIDI_SIGNAL_CONTINUOUS_21 = 27,
  BSE_MIDI_SIGNAL_CONTINUOUS_22 = 28,
  BSE_MIDI_SIGNAL_CONTINUOUS_23 = 29,
  BSE_MIDI_SIGNAL_CONTINUOUS_24 = 30,
  BSE_MIDI_SIGNAL_CONTINUOUS_25 = 31,
  BSE_MIDI_SIGNAL_CONTINUOUS_26 = 32,
  BSE_MIDI_SIGNAL_CONTINUOUS_27 = 33,
  BSE_MIDI_SIGNAL_CONTINUOUS_28 = 34,
  BSE_MIDI_SIGNAL_CONTINUOUS_29 = 35,
  BSE_MIDI_SIGNAL_CONTINUOUS_30 = 36,
  BSE_MIDI_SIGNAL_CONTINUOUS_31 = 37,
  BSE_MIDI_SIGNAL_CONSTANT_HIGH = 38,
  BSE_MIDI_SIGNAL_CONSTANT_CENTER = 39,
  BSE_MIDI_SIGNAL_CONSTANT_LOW = 40,
  BSE_MIDI_SIGNAL_CONSTANT_NEGATIVE_CENTER = 41,
  BSE_MIDI_SIGNAL_CONSTANT_NEGATIVE_HIGH = 42,
  BSE_MIDI_SIGNAL_PARAMETER = 43,
  BSE_MIDI_SIGNAL_NON_PARAMETER = 44,
  BSE_MIDI_SIGNAL_CONTROL_0 = 45,
  BSE_MIDI_SIGNAL_CONTROL_1 = 46,
  BSE_MIDI_SIGNAL_CONTROL_2 = 47,
  BSE_MIDI_SIGNAL_CONTROL_3 = 48,
  BSE_MIDI_SIGNAL_CONTROL_4 = 49,
  BSE_MIDI_SIGNAL_CONTROL_5 = 50,
  BSE_MIDI_SIGNAL_CONTROL_6 = 51,
  BSE_MIDI_SIGNAL_CONTROL_7 = 52,
  BSE_MIDI_SIGNAL_CONTROL_8 = 53,
  BSE_MIDI_SIGNAL_CONTROL_9 = 54,
  BSE_MIDI_SIGNAL_CONTROL_10 = 55,
  BSE_MIDI_SIGNAL_CONTROL_11 = 56,
  BSE_MIDI_SIGNAL_CONTROL_12 = 57,
  BSE_MIDI_SIGNAL_CONTROL_13 = 58,
  BSE_MIDI_SIGNAL_CONTROL_14 = 59,
  BSE_MIDI_SIGNAL_CONTROL_15 = 60,
  BSE_MIDI_SIGNAL_CONTROL_16 = 61,
  BSE_MIDI_SIGNAL_CONTROL_17 = 62,
  BSE_MIDI_SIGNAL_CONTROL_18 = 63,
  BSE_MIDI_SIGNAL_CONTROL_19 = 64,
  BSE_MIDI_SIGNAL_CONTROL_20 = 65,
  BSE_MIDI_SIGNAL_CONTROL_21 = 66,
  BSE_MIDI_SIGNAL_CONTROL_22 = 67,
  BSE_MIDI_SIGNAL_CONTROL_23 = 68,
  BSE_MIDI_SIGNAL_CONTROL_24 = 69,
  BSE_MIDI_SIGNAL_CONTROL_25 = 70,
  BSE_MIDI_SIGNAL_CONTROL_26 = 71,
  BSE_MIDI_SIGNAL_CONTROL_27 = 72,
  BSE_MIDI_SIGNAL_CONTROL_28 = 73,
  BSE_MIDI_SIGNAL_CONTROL_29 = 74,
  BSE_MIDI_SIGNAL_CONTROL_30 = 75,
  BSE_MIDI_SIGNAL_CONTROL_31 = 76,
  BSE_MIDI_SIGNAL_CONTROL_32 = 77,
  BSE_MIDI_SIGNAL_CONTROL_33 = 78,
  BSE_MIDI_SIGNAL_CONTROL_34 = 79,
  BSE_MIDI_SIGNAL_CONTROL_35 = 80,
  BSE_MIDI_SIGNAL_CONTROL_36 = 81,
  BSE_MIDI_SIGNAL_CONTROL_37 = 82,
  BSE_MIDI_SIGNAL_CONTROL_38 = 83,
  BSE_MIDI_SIGNAL_CONTROL_39 = 84,
  BSE_MIDI_SIGNAL_CONTROL_40 = 85,
  BSE_MIDI_SIGNAL_CONTROL_41 = 86,
  BSE_MIDI_SIGNAL_CONTROL_42 = 87,
  BSE_MIDI_SIGNAL_CONTROL_43 = 88,
  BSE_MIDI_SIGNAL_CONTROL_44 = 89,
  BSE_MIDI_SIGNAL_CONTROL_45 = 90,
  BSE_MIDI_SIGNAL_CONTROL_46 = 91,
  BSE_MIDI_SIGNAL_CONTROL_47 = 92,
  BSE_MIDI_SIGNAL_CONTROL_48 = 93,
  BSE_MIDI_SIGNAL_CONTROL_49 = 94,
  BSE_MIDI_SIGNAL_CONTROL_50 = 95,
  BSE_MIDI_SIGNAL_CONTROL_51 = 96,
  BSE_MIDI_SIGNAL_CONTROL_52 = 97,
  BSE_MIDI_SIGNAL_CONTROL_53 = 98,
  BSE_MIDI_SIGNAL_CONTROL_54 = 99,
  BSE_MIDI_SIGNAL_CONTROL_55 = 100,
  BSE_MIDI_SIGNAL_CONTROL_56 = 101,
  BSE_MIDI_SIGNAL_CONTROL_57 = 102,
  BSE_MIDI_SIGNAL_CONTROL_58 = 103,
  BSE_MIDI_SIGNAL_CONTROL_59 = 104,
  BSE_MIDI_SIGNAL_CONTROL_60 = 105,
  BSE_MIDI_SIGNAL_CONTROL_61 = 106,
  BSE_MIDI_SIGNAL_CONTROL_62 = 107,
  BSE_MIDI_SIGNAL_CONTROL_63 = 108,
  BSE_MIDI_SIGNAL_CONTROL_64 = 109,
  BSE_MIDI_SIGNAL_CONTROL_65 = 110,
  BSE_MIDI_SIGNAL_CONTROL_66 = 111,
  BSE_MIDI_SIGNAL_CONTROL_67 = 112,
  BSE_MIDI_SIGNAL_CONTROL_68 = 113,
  BSE_MIDI_SIGNAL_CONTROL_69 = 114,
  BSE_MIDI_SIGNAL_CONTROL_70 = 115,
  BSE_MIDI_SIGNAL_CONTROL_71 = 116,
  BSE_MIDI_SIGNAL_CONTROL_72 = 117,
  BSE_MIDI_SIGNAL_CONTROL_73 = 118,
  BSE_MIDI_SIGNAL_CONTROL_74 = 119,
  BSE_MIDI_SIGNAL_CONTROL_75 = 120,
  BSE_MIDI_SIGNAL_CONTROL_76 = 121,
  BSE_MIDI_SIGNAL_CONTROL_77 = 122,
  BSE_MIDI_SIGNAL_CONTROL_78 = 123,
  BSE_MIDI_SIGNAL_CONTROL_79 = 124,
  BSE_MIDI_SIGNAL_CONTROL_80 = 125,
  BSE_MIDI_SIGNAL_CONTROL_81 = 126,
  BSE_MIDI_SIGNAL_CONTROL_82 = 127,
  BSE_MIDI_SIGNAL_CONTROL_83 = 128,
  BSE_MIDI_SIGNAL_CONTROL_84 = 129,
  BSE_MIDI_SIGNAL_CONTROL_85 = 130,
  BSE_MIDI_SIGNAL_CONTROL_86 = 131,
  BSE_MIDI_SIGNAL_CONTROL_87 = 132,
  BSE_MIDI_SIGNAL_CONTROL_88 = 133,
  BSE_MIDI_SIGNAL_CONTROL_89 = 134,
  BSE_MIDI_SIGNAL_CONTROL_90 = 135,
  BSE_MIDI_SIGNAL_CONTROL_91 = 136,
  BSE_MIDI_SIGNAL_CONTROL_92 = 137,
  BSE_MIDI_SIGNAL_CONTROL_93 = 138,
  BSE_MIDI_SIGNAL_CONTROL_94 = 139,
  BSE_MIDI_SIGNAL_CONTROL_95 = 140,
  BSE_MIDI_SIGNAL_CONTROL_96 = 141,
  BSE_MIDI_SIGNAL_CONTROL_97 = 142,
  BSE_MIDI_SIGNAL_CONTROL_98 = 143,
  BSE_MIDI_SIGNAL_CONTROL_99 = 144,
  BSE_MIDI_SIGNAL_CONTROL_100 = 145,
  BSE_MIDI_SIGNAL_CONTROL_101 = 146,
  BSE_MIDI_SIGNAL_CONTROL_102 = 147,
  BSE_MIDI_SIGNAL_CONTROL_103 = 148,
  BSE_MIDI_SIGNAL_CONTROL_104 = 149,
  BSE_MIDI_SIGNAL_CONTROL_105 = 150,
  BSE_MIDI_SIGNAL_CONTROL_106 = 151,
  BSE_MIDI_SIGNAL_CONTROL_107 = 152,
  BSE_MIDI_SIGNAL_CONTROL_108 = 153,
  BSE_MIDI_SIGNAL_CONTROL_109 = 154,
  BSE_MIDI_SIGNAL_CONTROL_110 = 155,
  BSE_MIDI_SIGNAL_CONTROL_111 = 156,
  BSE_MIDI_SIGNAL_CONTROL_112 = 157,
  BSE_MIDI_SIGNAL_CONTROL_113 = 158,
  BSE_MIDI_SIGNAL_CONTROL_114 = 159,
  BSE_MIDI_SIGNAL_CONTROL_115 = 160,
  BSE_MIDI_SIGNAL_CONTROL_116 = 161,
  BSE_MIDI_SIGNAL_CONTROL_117 = 162,
  BSE_MIDI_SIGNAL_CONTROL_118 = 163,
  BSE_MIDI_SIGNAL_CONTROL_119 = 164,
  BSE_MIDI_SIGNAL_CONTROL_120 = 165,
  BSE_MIDI_SIGNAL_CONTROL_121 = 166,
  BSE_MIDI_SIGNAL_CONTROL_122 = 167,
  BSE_MIDI_SIGNAL_CONTROL_123 = 168,
  BSE_MIDI_SIGNAL_CONTROL_124 = 169,
  BSE_MIDI_SIGNAL_CONTROL_125 = 170,
  BSE_MIDI_SIGNAL_CONTROL_126 = 171,
  BSE_MIDI_SIGNAL_CONTROL_127 = 172,
} BseMidiSignalType;

typedef enum {
  BSE_THREAD_STATE_UNKNOWN = 1,
  BSE_THREAD_STATE_RUNNING = 2,
  BSE_THREAD_STATE_SLEEPING = 3,
  BSE_THREAD_STATE_DISKWAIT = 4,
  BSE_THREAD_STATE_TRACED = 5,
  BSE_THREAD_STATE_PAGING = 6,
  BSE_THREAD_STATE_ZOMBIE = 7,
  BSE_THREAD_STATE_DEAD = 8,
} BseThreadState;

typedef enum {
  BSE_BIQUAD_FILTER_RESONANT_LOWPASS = 1,
  BSE_BIQUAD_FILTER_RESONANT_HIGHPASS = 2,
} BseBiquadFilterType;

typedef enum {
  BSE_BIQUAD_FILTER_NORM_PASSBAND = 1,
  BSE_BIQUAD_FILTER_NORM_RESONANCE_GAIN = 2,
  BSE_BIQUAD_FILTER_NORM_PEAK_GAIN = 3,
} BseBiquadFilterNorm;

typedef enum {
  BSE_REGISTER_PLUGIN = 1,
  BSE_REGISTER_SCRIPT = 2,
  BSE_REGISTER_DONE = 3,
} BseRegistrationType;

typedef enum {
  BSE_USER_MSG_UNSPECIFIED = 1,
  BSE_USER_MSG_DEBUG = 2,
  BSE_USER_MSG_DIAG = 3,
  BSE_USER_MSG_INFO = 4,
  BSE_USER_MSG_WARNING = 5,
  BSE_USER_MSG_ERROR = 6,
} BseUserMsgType;

typedef enum {
  BSE_ERROR_NONE = 0,
  BSE_ERROR_INTERNAL = 1,
  BSE_ERROR_UNKNOWN = 2,
  BSE_ERROR_FILE_IO = 3,
  BSE_ERROR_FILE_PERMS = 4,
  BSE_ERROR_FILE_BUSY = 5,
  BSE_ERROR_FILE_EXISTS = 6,
  BSE_ERROR_FILE_EOF = 7,
  BSE_ERROR_FILE_NOT_FOUND = 8,
  BSE_ERROR_FILE_IS_DIR = 9,
  BSE_ERROR_FILE_OPEN_FAILED = 10,
  BSE_ERROR_FILE_SEEK_FAILED = 11,
  BSE_ERROR_FILE_READ_FAILED = 12,
  BSE_ERROR_FILE_WRITE_FAILED = 13,
  BSE_ERROR_MANY_FILES = 14,
  BSE_ERROR_NO_FILES = 15,
  BSE_ERROR_NO_SPACE = 16,
  BSE_ERROR_NO_MEMORY = 17,
  BSE_ERROR_NO_HEADER = 18,
  BSE_ERROR_NO_SEEK_INFO = 19,
  BSE_ERROR_NO_DATA = 20,
  BSE_ERROR_DATA_CORRUPT = 21,
  BSE_ERROR_FORMAT_INVALID = 22,
  BSE_ERROR_FORMAT_UNKNOWN = 23,
  BSE_ERROR_TEMP = 24,
  BSE_ERROR_WAVE_NOT_FOUND = 25,
  BSE_ERROR_CODEC_FAILURE = 26,
  BSE_ERROR_UNIMPLEMENTED = 27,
  BSE_ERROR_DEVICE_NOT_AVAILABLE = 28,
  BSE_ERROR_DEVICE_ASYNC = 29,
  BSE_ERROR_DEVICE_BUSY = 30,
  BSE_ERROR_DEVICE_GET_CAPS = 31,
  BSE_ERROR_DEVICE_CAPS_MISMATCH = 32,
  BSE_ERROR_DEVICE_SET_CAPS = 33,
  BSE_ERROR_SOURCE_NO_SUCH_MODULE = 34,
  BSE_ERROR_SOURCE_NO_SUCH_ICHANNEL = 35,
  BSE_ERROR_SOURCE_NO_SUCH_OCHANNEL = 36,
  BSE_ERROR_SOURCE_NO_SUCH_CONNECTION = 37,
  BSE_ERROR_SOURCE_ICHANNEL_IN_USE = 38,
  BSE_ERROR_SOURCE_CHANNELS_CONNECTED = 39,
  BSE_ERROR_SOURCE_PARENT_MISMATCH = 40,
  BSE_ERROR_SOURCE_BAD_LOOPBACK = 41,
  BSE_ERROR_SOURCE_BUSY = 42,
  BSE_ERROR_SOURCE_TYPE_INVALID = 43,
  BSE_ERROR_PROC_NOT_FOUND = 44,
  BSE_ERROR_PROC_BUSY = 45,
  BSE_ERROR_PROC_PARAM_INVAL = 46,
  BSE_ERROR_PROC_EXECUTION = 47,
  BSE_ERROR_PROC_ABORT = 48,
  BSE_ERROR_PARSE_ERROR = 49,
  BSE_ERROR_SPAWN = 50,
  BSE_ERROR_NO_ENTRY = 51,
  BSE_ERROR_NO_EVENT = 52,
  BSE_ERROR_NO_TARGET = 53,
  BSE_ERROR_NOT_OWNER = 54,
  BSE_ERROR_INVALID_OFFSET = 55,
  BSE_ERROR_INVALID_DURATION = 56,
  BSE_ERROR_INVALID_OVERLAP = 57,
} BseErrorType;

typedef enum {
  BSE_PROJECT_INACTIVE = 1,
  BSE_PROJECT_ACTIVE = 2,
  BSE_PROJECT_PLAYING = 3,
} BseProjectState;

typedef enum {
  BSE_STANDARD_OSC_SINE = 1,
  BSE_STANDARD_OSC_TRIANGLE = 2,
  BSE_STANDARD_OSC_SAW_RISE = 3,
  BSE_STANDARD_OSC_SAW_FALL = 4,
  BSE_STANDARD_OSC_PEAK_RISE = 5,
  BSE_STANDARD_OSC_PEAK_FALL = 6,
  BSE_STANDARD_OSC_MOOG_SAW = 7,
  BSE_STANDARD_OSC_SQUARE = 8,
  BSE_STANDARD_OSC_PULSE = 9,
} BseStandardOscWaveType;

typedef enum {
  BSE_SNIFFER_REQUIRE_SINGLE_INPUT = 1,
  BSE_SNIFFER_PICK_FIRST_INPUT = 2,
  BSE_SNIFFER_AVERAGE_INPUTS = 3,
} BseSnifferType;

typedef enum {
  BSE_SNIFFER_TIME_ABSOLUTE_TICK_STAMP = 1,
  BSE_SNIFFER_TIME_RELATIVE_TICK_STAMP = 2,
  BSE_SNIFFER_TIME_RELATIVE_USECS = 3,
} BseSnifferTimeType;

struct _BsePartNote {
  SfiInt id;
  SfiInt channel;
  SfiInt tick;
  SfiInt duration;
  SfiInt note;
  SfiInt fine_tune;
  SfiReal velocity;
  SfiBool selected;
};
struct _BsePartControl {
  SfiInt id;
  SfiInt tick;
  BseMidiSignalType control_type;
  SfiReal value;
  SfiBool selected;
};
struct _BseNoteDescription {
  SfiInt note;
  SfiInt octave;
  SfiReal freq;
  SfiInt fine_tune;
  SfiInt semitone;
  SfiBool upshift;
  SfiInt letter;
  gchar* name;
  SfiInt max_fine_tune;
  SfiInt kammer_note;
};
struct _BseNoteSequence {
  SfiInt offset;
  BseNoteSeq* notes;
};
struct _BseIcon {
  SfiInt bytes_per_pixel;
  SfiInt width;
  SfiInt height;
  SfiBBlock* pixels;
};
struct _BseCategory {
  SfiInt category_id;
  gchar* category;
  SfiInt mindex;
  SfiInt lindex;
  gchar* type;
  BseIcon* icon;
};
struct _BseDot {
  SfiReal x;
  SfiReal y;
};
struct _BseTrackPart {
  SfiInt tick;
  SfiProxy part;
  SfiInt duration;
};
struct _BseSongTiming {
  SfiInt tick;
  SfiReal bpm;
  SfiInt numerator;
  SfiInt denominator;
  SfiInt tpqn;
  SfiInt tpt;
};
struct _BseSampleFileInfo {
  gchar* file;
  SfiInt size;
  SfiNum mtime;
  gchar* loader;
  BseStringSeq* waves;
  SfiInt error;
};
struct _BseThreadInfo {
  gchar* name;
  BseThreadState state;
  SfiInt priority;
  SfiInt processor;
  SfiInt utime;
  SfiInt stime;
  SfiInt cutime;
  SfiInt cstime;
};
struct _BseThreadTotals {
  BseThreadInfo* main;
  BseThreadInfo* sequencer;
  BseThreadInfoSeq* synthesis;
};
struct _BseGConfig {
  gchar* sample_path;
  gchar* effect_path;
  gchar* instrument_path;
  gchar* script_path;
  gchar* plugin_path;
  gchar* ladspa_path;
  SfiInt synth_latency;
  SfiInt synth_mixing_freq;
  SfiInt synth_control_freq;
  SfiBool invert_sustain;
  SfiReal step_volume_dB;
  SfiInt step_bpm;
};
struct _BseSnifferRequest {
  SfiProxy sniffer;
  BseSnifferTimeType time_type;
  SfiNum variable_time;
  SfiInt n_samples;
  BseSnifferType sniffer_type;
};

struct _BseIntSeq {
  guint n_ints;
  SfiInt* ints;
};
struct _BseNoteSeq {
  guint n_notes;
  SfiInt* notes;
};
struct _BseStringSeq {
  guint n_strings;
  gchar** strings;
};
struct _BseItemSeq {
  guint n_items;
  SfiProxy* items;
};
struct _BsePartNoteSeq {
  guint n_pnotes;
  BsePartNote** pnotes;
};
struct _BsePartControlSeq {
  guint n_pcontrols;
  BsePartControl** pcontrols;
};
struct _BseCategorySeq {
  guint n_cats;
  BseCategory** cats;
};
struct _BseDotSeq {
  guint n_dots;
  BseDot** dots;
};
struct _BseTrackPartSeq {
  guint n_tparts;
  BseTrackPart** tparts;
};
struct _BseThreadInfoSeq {
  guint n_thread_infos;
  BseThreadInfo** thread_infos;
};
struct _BseSnifferRequestSeq {
  guint n_requests;
  BseSnifferRequest** requests;
};
BsePartNote* bse_part_note_new (void);
BsePartNote* bse_part_note_copy_shallow (BsePartNote* rec);
BsePartNote* bse_part_note_from_rec (SfiRec *sfi_rec);
SfiRec *bse_part_note_to_rec (BsePartNote* rec);
void bse_part_note_free (BsePartNote* rec);

BsePartControl* bse_part_control_new (void);
BsePartControl* bse_part_control_copy_shallow (BsePartControl* rec);
BsePartControl* bse_part_control_from_rec (SfiRec *sfi_rec);
SfiRec *bse_part_control_to_rec (BsePartControl* rec);
void bse_part_control_free (BsePartControl* rec);

BseNoteDescription* bse_note_description_new (void);
BseNoteDescription* bse_note_description_copy_shallow (BseNoteDescription* rec);
BseNoteDescription* bse_note_description_from_rec (SfiRec *sfi_rec);
SfiRec *bse_note_description_to_rec (BseNoteDescription* rec);
void bse_note_description_free (BseNoteDescription* rec);

BseNoteSequence* bse_note_sequence_new (void);
BseNoteSequence* bse_note_sequence_copy_shallow (BseNoteSequence* rec);
BseNoteSequence* bse_note_sequence_from_rec (SfiRec *sfi_rec);
SfiRec *bse_note_sequence_to_rec (BseNoteSequence* rec);
void bse_note_sequence_free (BseNoteSequence* rec);

BseIcon* bse_icon_new (void);
BseIcon* bse_icon_copy_shallow (BseIcon* rec);
BseIcon* bse_icon_from_rec (SfiRec *sfi_rec);
SfiRec *bse_icon_to_rec (BseIcon* rec);
void bse_icon_free (BseIcon* rec);

BseCategory* bse_category_new (void);
BseCategory* bse_category_copy_shallow (BseCategory* rec);
BseCategory* bse_category_from_rec (SfiRec *sfi_rec);
SfiRec *bse_category_to_rec (BseCategory* rec);
void bse_category_free (BseCategory* rec);

BseDot* bse_dot_new (void);
BseDot* bse_dot_copy_shallow (BseDot* rec);
BseDot* bse_dot_from_rec (SfiRec *sfi_rec);
SfiRec *bse_dot_to_rec (BseDot* rec);
void bse_dot_free (BseDot* rec);

BseTrackPart* bse_track_part_new (void);
BseTrackPart* bse_track_part_copy_shallow (BseTrackPart* rec);
BseTrackPart* bse_track_part_from_rec (SfiRec *sfi_rec);
SfiRec *bse_track_part_to_rec (BseTrackPart* rec);
void bse_track_part_free (BseTrackPart* rec);

BseSongTiming* bse_song_timing_new (void);
BseSongTiming* bse_song_timing_copy_shallow (BseSongTiming* rec);
BseSongTiming* bse_song_timing_from_rec (SfiRec *sfi_rec);
SfiRec *bse_song_timing_to_rec (BseSongTiming* rec);
void bse_song_timing_free (BseSongTiming* rec);

BseSampleFileInfo* bse_sample_file_info_new (void);
BseSampleFileInfo* bse_sample_file_info_copy_shallow (BseSampleFileInfo* rec);
BseSampleFileInfo* bse_sample_file_info_from_rec (SfiRec *sfi_rec);
SfiRec *bse_sample_file_info_to_rec (BseSampleFileInfo* rec);
void bse_sample_file_info_free (BseSampleFileInfo* rec);

BseThreadInfo* bse_thread_info_new (void);
BseThreadInfo* bse_thread_info_copy_shallow (BseThreadInfo* rec);
BseThreadInfo* bse_thread_info_from_rec (SfiRec *sfi_rec);
SfiRec *bse_thread_info_to_rec (BseThreadInfo* rec);
void bse_thread_info_free (BseThreadInfo* rec);

BseThreadTotals* bse_thread_totals_new (void);
BseThreadTotals* bse_thread_totals_copy_shallow (BseThreadTotals* rec);
BseThreadTotals* bse_thread_totals_from_rec (SfiRec *sfi_rec);
SfiRec *bse_thread_totals_to_rec (BseThreadTotals* rec);
void bse_thread_totals_free (BseThreadTotals* rec);

BseGConfig* bse_gconfig_new (void);
BseGConfig* bse_gconfig_copy_shallow (BseGConfig* rec);
BseGConfig* bse_gconfig_from_rec (SfiRec *sfi_rec);
SfiRec *bse_gconfig_to_rec (BseGConfig* rec);
void bse_gconfig_free (BseGConfig* rec);

BseSnifferRequest* bse_sniffer_request_new (void);
BseSnifferRequest* bse_sniffer_request_copy_shallow (BseSnifferRequest* rec);
BseSnifferRequest* bse_sniffer_request_from_rec (SfiRec *sfi_rec);
SfiRec *bse_sniffer_request_to_rec (BseSnifferRequest* rec);
void bse_sniffer_request_free (BseSnifferRequest* rec);


BseIntSeq* bse_int_seq_new (void);
void bse_int_seq_append (BseIntSeq* seq, SfiInt element);
BseIntSeq* bse_int_seq_copy_shallow (BseIntSeq* seq);
BseIntSeq* bse_int_seq_from_seq (SfiSeq *sfi_seq);
SfiSeq *bse_int_seq_to_seq (BseIntSeq* seq);
void bse_int_seq_resize (BseIntSeq* seq, guint new_size);
void bse_int_seq_free (BseIntSeq* seq);

BseNoteSeq* bse_note_seq_new (void);
void bse_note_seq_append (BseNoteSeq* seq, SfiInt element);
BseNoteSeq* bse_note_seq_copy_shallow (BseNoteSeq* seq);
BseNoteSeq* bse_note_seq_from_seq (SfiSeq *sfi_seq);
SfiSeq *bse_note_seq_to_seq (BseNoteSeq* seq);
void bse_note_seq_resize (BseNoteSeq* seq, guint new_size);
void bse_note_seq_free (BseNoteSeq* seq);

BseStringSeq* bse_string_seq_new (void);
void bse_string_seq_append (BseStringSeq* seq, const gchar* element);
BseStringSeq* bse_string_seq_copy_shallow (BseStringSeq* seq);
BseStringSeq* bse_string_seq_from_seq (SfiSeq *sfi_seq);
SfiSeq *bse_string_seq_to_seq (BseStringSeq* seq);
void bse_string_seq_resize (BseStringSeq* seq, guint new_size);
void bse_string_seq_free (BseStringSeq* seq);

BseItemSeq* bse_item_seq_new (void);
void bse_item_seq_append (BseItemSeq* seq, SfiProxy element);
BseItemSeq* bse_item_seq_copy_shallow (BseItemSeq* seq);
BseItemSeq* bse_item_seq_from_seq (SfiSeq *sfi_seq);
SfiSeq *bse_item_seq_to_seq (BseItemSeq* seq);
void bse_item_seq_resize (BseItemSeq* seq, guint new_size);
void bse_item_seq_free (BseItemSeq* seq);

BsePartNoteSeq* bse_part_note_seq_new (void);
void bse_part_note_seq_append (BsePartNoteSeq* seq, BsePartNote* element);
BsePartNoteSeq* bse_part_note_seq_copy_shallow (BsePartNoteSeq* seq);
BsePartNoteSeq* bse_part_note_seq_from_seq (SfiSeq *sfi_seq);
SfiSeq *bse_part_note_seq_to_seq (BsePartNoteSeq* seq);
void bse_part_note_seq_resize (BsePartNoteSeq* seq, guint new_size);
void bse_part_note_seq_free (BsePartNoteSeq* seq);

BsePartControlSeq* bse_part_control_seq_new (void);
void bse_part_control_seq_append (BsePartControlSeq* seq, BsePartControl* element);
BsePartControlSeq* bse_part_control_seq_copy_shallow (BsePartControlSeq* seq);
BsePartControlSeq* bse_part_control_seq_from_seq (SfiSeq *sfi_seq);
SfiSeq *bse_part_control_seq_to_seq (BsePartControlSeq* seq);
void bse_part_control_seq_resize (BsePartControlSeq* seq, guint new_size);
void bse_part_control_seq_free (BsePartControlSeq* seq);

BseCategorySeq* bse_category_seq_new (void);
void bse_category_seq_append (BseCategorySeq* seq, BseCategory* element);
BseCategorySeq* bse_category_seq_copy_shallow (BseCategorySeq* seq);
BseCategorySeq* bse_category_seq_from_seq (SfiSeq *sfi_seq);
SfiSeq *bse_category_seq_to_seq (BseCategorySeq* seq);
void bse_category_seq_resize (BseCategorySeq* seq, guint new_size);
void bse_category_seq_free (BseCategorySeq* seq);

BseDotSeq* bse_dot_seq_new (void);
void bse_dot_seq_append (BseDotSeq* seq, BseDot* element);
BseDotSeq* bse_dot_seq_copy_shallow (BseDotSeq* seq);
BseDotSeq* bse_dot_seq_from_seq (SfiSeq *sfi_seq);
SfiSeq *bse_dot_seq_to_seq (BseDotSeq* seq);
void bse_dot_seq_resize (BseDotSeq* seq, guint new_size);
void bse_dot_seq_free (BseDotSeq* seq);

BseTrackPartSeq* bse_track_part_seq_new (void);
void bse_track_part_seq_append (BseTrackPartSeq* seq, BseTrackPart* element);
BseTrackPartSeq* bse_track_part_seq_copy_shallow (BseTrackPartSeq* seq);
BseTrackPartSeq* bse_track_part_seq_from_seq (SfiSeq *sfi_seq);
SfiSeq *bse_track_part_seq_to_seq (BseTrackPartSeq* seq);
void bse_track_part_seq_resize (BseTrackPartSeq* seq, guint new_size);
void bse_track_part_seq_free (BseTrackPartSeq* seq);

BseThreadInfoSeq* bse_thread_info_seq_new (void);
void bse_thread_info_seq_append (BseThreadInfoSeq* seq, BseThreadInfo* element);
BseThreadInfoSeq* bse_thread_info_seq_copy_shallow (BseThreadInfoSeq* seq);
BseThreadInfoSeq* bse_thread_info_seq_from_seq (SfiSeq *sfi_seq);
SfiSeq *bse_thread_info_seq_to_seq (BseThreadInfoSeq* seq);
void bse_thread_info_seq_resize (BseThreadInfoSeq* seq, guint new_size);
void bse_thread_info_seq_free (BseThreadInfoSeq* seq);

BseSnifferRequestSeq* bse_sniffer_request_seq_new (void);
void bse_sniffer_request_seq_append (BseSnifferRequestSeq* seq, BseSnifferRequest* element);
BseSnifferRequestSeq* bse_sniffer_request_seq_copy_shallow (BseSnifferRequestSeq* seq);
BseSnifferRequestSeq* bse_sniffer_request_seq_from_seq (SfiSeq *sfi_seq);
SfiSeq *bse_sniffer_request_seq_to_seq (BseSnifferRequestSeq* seq);
void bse_sniffer_request_seq_resize (BseSnifferRequestSeq* seq, guint new_size);
void bse_sniffer_request_seq_free (BseSnifferRequestSeq* seq);

const gchar* bse_midi_signal_type_to_choice (BseMidiSignalType value);
BseMidiSignalType bse_midi_signal_type_from_choice (const gchar *choice);
const gchar* bse_thread_state_to_choice (BseThreadState value);
BseThreadState bse_thread_state_from_choice (const gchar *choice);
const gchar* bse_biquad_filter_type_to_choice (BseBiquadFilterType value);
BseBiquadFilterType bse_biquad_filter_type_from_choice (const gchar *choice);
const gchar* bse_biquad_filter_norm_to_choice (BseBiquadFilterNorm value);
BseBiquadFilterNorm bse_biquad_filter_norm_from_choice (const gchar *choice);
const gchar* bse_registration_type_to_choice (BseRegistrationType value);
BseRegistrationType bse_registration_type_from_choice (const gchar *choice);
const gchar* bse_user_msg_type_to_choice (BseUserMsgType value);
BseUserMsgType bse_user_msg_type_from_choice (const gchar *choice);
const gchar* bse_error_type_to_choice (BseErrorType value);
BseErrorType bse_error_type_from_choice (const gchar *choice);
const gchar* bse_project_state_to_choice (BseProjectState value);
BseProjectState bse_project_state_from_choice (const gchar *choice);
const gchar* bse_standard_osc_wave_type_to_choice (BseStandardOscWaveType value);
BseStandardOscWaveType bse_standard_osc_wave_type_from_choice (const gchar *choice);
const gchar* bse_sniffer_type_to_choice (BseSnifferType value);
BseSnifferType bse_sniffer_type_from_choice (const gchar *choice);
const gchar* bse_sniffer_time_type_to_choice (BseSnifferTimeType value);
BseSnifferTimeType bse_sniffer_time_type_from_choice (const gchar *choice);

void bse_item_add_parasite (SfiProxy bse_item_object, const gchar* path, SfiRec* parasite);
SfiBool bse_item_check_is_a (SfiProxy bse_item_object, const gchar* type_name);
void bse_item_clear_undo (SfiProxy bse_item_object);
SfiProxy bse_item_common_ancestor (SfiProxy bse_item_object, SfiProxy item2);
SfiFBlock* bse_item_fixme_get_parasite (SfiProxy bse_item_object, const gchar* name);
void bse_item_fixme_set_parasite (SfiProxy bse_item_object, const gchar* name, SfiFBlock* parasite);
BseIcon* bse_item_get_icon (SfiProxy bse_item_object);
const gchar* bse_item_get_name (SfiProxy bse_item_object);
const gchar* bse_item_get_name_or_type (SfiProxy bse_item_object);
SfiRec* bse_item_get_parasite (SfiProxy bse_item_object, const gchar* path);
SfiProxy bse_item_get_parent (SfiProxy bse_item_object);
SfiProxy bse_item_get_project (SfiProxy bse_item_object);
SfiInt bse_item_get_seqid (SfiProxy bse_item_object);
const gchar* bse_item_get_type (SfiProxy bse_item_object);
const gchar* bse_item_get_type_authors (SfiProxy bse_item_object);
const gchar* bse_item_get_type_blurb (SfiProxy bse_item_object);
const gchar* bse_item_get_type_license (SfiProxy bse_item_object);
const gchar* bse_item_get_type_name (SfiProxy bse_item_object);
const gchar* bse_item_get_uname_path (SfiProxy bse_item_object);
void bse_item_group_undo (SfiProxy bse_item_object, const gchar* name);
SfiBool bse_item_internal (SfiProxy bse_item_object);
BseItemSeq* bse_item_list_items (SfiProxy bse_item_object, const gchar* property_name);
BseStringSeq* bse_item_list_parasites (SfiProxy bse_item_object, const gchar* path);
void bse_item_redo (SfiProxy bse_item_object);
SfiInt bse_item_redo_depth (SfiProxy bse_item_object);
void bse_item_set_name (SfiProxy bse_item_object, const gchar* name);
void bse_item_set_parasite (SfiProxy bse_item_object, const gchar* path, SfiRec* parasite);
void bse_item_undo (SfiProxy bse_item_object);
SfiInt bse_item_undo_depth (SfiProxy bse_item_object);
void bse_item_ungroup_undo (SfiProxy bse_item_object);
void bse_item_unuse (SfiProxy bse_item_object);
SfiProxy bse_item_use (SfiProxy bse_item_object);
SfiInt bse_data_pocket_create_entry (SfiProxy bse_data_pocket_object);
BseErrorType bse_data_pocket_delete_entry (SfiProxy bse_data_pocket_object, SfiInt entry_id);
SfiReal bse_data_pocket_get_float (SfiProxy bse_data_pocket_object, SfiInt entry_id, const gchar* name);
SfiInt bse_data_pocket_get_int (SfiProxy bse_data_pocket_object, SfiInt entry_id, const gchar* name);
SfiInt bse_data_pocket_get_n_entries (SfiProxy bse_data_pocket_object);
SfiInt bse_data_pocket_get_nth_entry_id (SfiProxy bse_data_pocket_object, SfiInt entry_index);
SfiProxy bse_data_pocket_get_object (SfiProxy bse_data_pocket_object, SfiInt entry_id, const gchar* name);
const gchar* bse_data_pocket_get_string (SfiProxy bse_data_pocket_object, SfiInt entry_id, const gchar* name);
BseErrorType bse_data_pocket_set_float (SfiProxy bse_data_pocket_object, SfiInt entry_id, const gchar* name, SfiReal number);
BseErrorType bse_data_pocket_set_int (SfiProxy bse_data_pocket_object, SfiInt entry_id, const gchar* name, SfiInt number);
BseErrorType bse_data_pocket_set_object (SfiProxy bse_data_pocket_object, SfiInt entry_id, const gchar* name, SfiProxy item);
BseErrorType bse_data_pocket_set_string (SfiProxy bse_data_pocket_object, SfiInt entry_id, const gchar* name, const gchar* string);
void bse_editable_sample_close (SfiProxy bse_editable_sample_object);
SfiFBlock* bse_editable_sample_collect_stats (SfiProxy bse_editable_sample_object, SfiInt voffset, SfiReal offset_scale, SfiInt block_size, SfiInt stepping, SfiInt max_pairs);
SfiInt bse_editable_sample_get_length (SfiProxy bse_editable_sample_object);
SfiInt bse_editable_sample_get_n_channels (SfiProxy bse_editable_sample_object);
SfiReal bse_editable_sample_get_osc_freq (SfiProxy bse_editable_sample_object);
BseErrorType bse_editable_sample_open (SfiProxy bse_editable_sample_object);
SfiFBlock* bse_editable_sample_read_samples (SfiProxy bse_editable_sample_object, SfiInt voffset);
void bse_janitor_add_action (SfiProxy bse_janitor_object, const gchar* action, const gchar* name, const gchar* blurb);
void bse_janitor_exit (SfiProxy bse_janitor_object, BseUserMsgType msg_type, const gchar* message);
const gchar* bse_janitor_get_action (SfiProxy bse_janitor_object, SfiInt nth_action);
const gchar* bse_janitor_get_action_blurb (SfiProxy bse_janitor_object, SfiInt nth_action);
const gchar* bse_janitor_get_action_name (SfiProxy bse_janitor_object, SfiInt nth_action);
const gchar* bse_janitor_get_proc_name (SfiProxy bse_janitor_object);
const gchar* bse_janitor_get_script_name (SfiProxy bse_janitor_object);
void bse_janitor_kill (SfiProxy bse_janitor_object);
SfiInt bse_janitor_n_actions (SfiProxy bse_janitor_object);
void bse_janitor_progress (SfiProxy bse_janitor_object, SfiReal progress);
void bse_janitor_remove_action (SfiProxy bse_janitor_object, const gchar* action);
void bse_janitor_set_msg (SfiProxy bse_janitor_object, BseUserMsgType msg_type, const gchar* message);
void bse_janitor_trigger_action (SfiProxy bse_janitor_object, const gchar* action);
SfiInt bse_midi_notifier_current_time (SfiProxy bse_midi_notifier_object);
BseErrorType bse_part_change_control (SfiProxy bse_part_object, SfiInt id, SfiInt tick, BseMidiSignalType control_type, SfiReal value);
BseErrorType bse_part_change_note (SfiProxy bse_part_object, SfiInt id, SfiInt tick, SfiInt duration, SfiInt note, SfiInt fine_tune, SfiReal velocity);
BsePartNoteSeq* bse_part_check_overlap (SfiProxy bse_part_object, SfiInt tick, SfiInt duration, SfiInt note);
BseErrorType bse_part_delete_event (SfiProxy bse_part_object, SfiInt id);
void bse_part_deselect_controls (SfiProxy bse_part_object, SfiInt tick, SfiInt duration, BseMidiSignalType control_type);
void bse_part_deselect_event (SfiProxy bse_part_object, SfiInt id);
void bse_part_deselect_notes (SfiProxy bse_part_object, SfiInt tick, SfiInt duration, SfiInt min_note, SfiInt max_note);
BsePartControlSeq* bse_part_get_channel_controls (SfiProxy bse_part_object, SfiInt channel, SfiInt tick, SfiInt duration, BseMidiSignalType control_type);
BsePartControlSeq* bse_part_get_controls (SfiProxy bse_part_object, SfiInt tick, BseMidiSignalType control_type);
SfiInt bse_part_get_max_note (SfiProxy bse_part_object);
SfiInt bse_part_get_min_note (SfiProxy bse_part_object);
BsePartNoteSeq* bse_part_get_notes (SfiProxy bse_part_object, SfiInt tick, SfiInt note);
BseSongTiming* bse_part_get_timing (SfiProxy bse_part_object, SfiInt tick);
SfiInt bse_part_insert_control (SfiProxy bse_part_object, SfiInt tick, BseMidiSignalType control_type, SfiReal value);
SfiInt bse_part_insert_note (SfiProxy bse_part_object, SfiInt channel, SfiInt tick, SfiInt duration, SfiInt note, SfiInt fine_tune, SfiReal velocity);
SfiInt bse_part_insert_note_auto (SfiProxy bse_part_object, SfiInt tick, SfiInt duration, SfiInt note, SfiInt fine_tune, SfiReal velocity);
SfiBool bse_part_is_event_selected (SfiProxy bse_part_object, SfiInt id);
BsePartControlSeq* bse_part_list_controls (SfiProxy bse_part_object, SfiInt tick, SfiInt duration, BseMidiSignalType control_type);
BsePartNoteSeq* bse_part_list_notes_crossing (SfiProxy bse_part_object, SfiInt tick, SfiInt duration);
BsePartNoteSeq* bse_part_list_notes_within (SfiProxy bse_part_object, SfiInt channel, SfiInt tick, SfiInt duration);
BsePartControlSeq* bse_part_list_selected_controls (SfiProxy bse_part_object, BseMidiSignalType control_type);
BsePartNoteSeq* bse_part_list_selected_notes (SfiProxy bse_part_object);
void bse_part_queue_controls (SfiProxy bse_part_object, SfiInt tick, SfiInt duration);
void bse_part_queue_notes (SfiProxy bse_part_object, SfiInt tick, SfiInt duration, SfiInt min_note, SfiInt max_note);
void bse_part_select_controls_exclusive (SfiProxy bse_part_object, SfiInt tick, SfiInt duration, BseMidiSignalType control_type);
void bse_part_select_event (SfiProxy bse_part_object, SfiInt id);
void bse_part_select_notes (SfiProxy bse_part_object, SfiInt tick, SfiInt duration, SfiInt min_note, SfiInt max_note);
void bse_part_select_notes_exclusive (SfiProxy bse_part_object, SfiInt tick, SfiInt duration, SfiInt min_note, SfiInt max_note);
void bse_source_clear_inputs (SfiProxy bse_source_object);
void bse_source_clear_outputs (SfiProxy bse_source_object);
SfiBool bse_source_has_outputs (SfiProxy bse_source_object);
const gchar* bse_source_ichannel_blurb (SfiProxy bse_source_object, SfiInt input_channel);
SfiInt bse_source_ichannel_get_n_joints (SfiProxy bse_source_object, SfiInt input_channel);
SfiInt bse_source_ichannel_get_ochannel (SfiProxy bse_source_object, SfiInt input_channel, SfiInt input_joint);
SfiProxy bse_source_ichannel_get_osource (SfiProxy bse_source_object, SfiInt input_channel, SfiInt input_joint);
const gchar* bse_source_ichannel_ident (SfiProxy bse_source_object, SfiInt input_channel);
const gchar* bse_source_ichannel_label (SfiProxy bse_source_object, SfiInt input_channel);
SfiBool bse_source_is_joint_ichannel (SfiProxy bse_source_object, const gchar* input_channel);
SfiBool bse_source_is_joint_ichannel_by_id (SfiProxy bse_source_object, SfiInt input_channel);
SfiInt bse_source_n_ichannels (SfiProxy bse_source_object);
SfiInt bse_source_n_ochannels (SfiProxy bse_source_object);
const gchar* bse_source_ochannel_blurb (SfiProxy bse_source_object, SfiInt input_channel);
const gchar* bse_source_ochannel_ident (SfiProxy bse_source_object, SfiInt input_channel);
const gchar* bse_source_ochannel_label (SfiProxy bse_source_object, SfiInt input_channel);
BseErrorType bse_source_set_input (SfiProxy bse_source_object, const gchar* input_channel, SfiProxy omodule, const gchar* output_channel);
BseErrorType bse_source_set_input_by_id (SfiProxy bse_source_object, SfiInt input_channel, SfiProxy omodule, SfiInt output_channel);
void bse_source_set_pos (SfiProxy bse_source_object, SfiReal x_pos, SfiReal y_pos);
BseErrorType bse_source_unset_input (SfiProxy bse_source_object, const gchar* input_channel, SfiProxy omodule, const gchar* output_channel);
BseErrorType bse_source_unset_input_by_id (SfiProxy bse_source_object, SfiInt input_channel, SfiProxy omodule, SfiInt output_channel);
SfiProxy bse_track_create_sniffer (SfiProxy bse_track_object);
SfiInt bse_track_get_last_tick (SfiProxy bse_track_object);
SfiProxy bse_track_get_part (SfiProxy bse_track_object, SfiInt tick);
BseSongTiming* bse_track_get_timing (SfiProxy bse_track_object, SfiInt tick);
SfiInt bse_track_insert_part (SfiProxy bse_track_object, SfiInt tick, SfiProxy part);
BseTrackPartSeq* bse_track_list_parts (SfiProxy bse_track_object);
void bse_track_remove_link (SfiProxy bse_track_object, SfiInt id);
void bse_track_remove_tick (SfiProxy bse_track_object, SfiInt tick);
SfiProxy bse_container_get_item (SfiProxy bse_container_object, const gchar* item_type, SfiInt seq_id);
BseItemSeq* bse_container_list_items (SfiProxy bse_container_object);
SfiProxy bse_container_lookup_item (SfiProxy bse_container_object, const gchar* uname);
SfiReal bse_wave_chunk_get_mix_freq (SfiProxy bse_wave_object, SfiInt chunk_index);
SfiReal bse_wave_chunk_get_osc_freq (SfiProxy bse_wave_object, SfiInt chunk_index);
BseErrorType bse_wave_load_wave (SfiProxy bse_wave_object, const gchar* file_name, const gchar* wave_name);
SfiInt bse_wave_n_wave_chunks (SfiProxy bse_wave_object);
SfiProxy bse_wave_use_editable (SfiProxy bse_wave_object, SfiInt chunk_index);
void bse_wave_osc_pcm_seek_perc (SfiProxy bse_wave_osc_object, SfiReal pos_perc);
void bse_wave_osc_request_pcm_position (SfiProxy bse_wave_osc_object);
void bse_wave_osc_set_from_editable_sample (SfiProxy bse_wave_osc_object, SfiProxy esample);
BseErrorType bse_project_import_midi_file (SfiProxy bse_project_object, const gchar* file_name);
BseErrorType bse_project_restore_from_file (SfiProxy bse_project_object, const gchar* file_name);
BseErrorType bse_project_store_bse (SfiProxy bse_project_object, SfiProxy super, const gchar* file_name, SfiBool self_contained);
BseErrorType bse_project_activate (SfiProxy bse_project_object);
void bse_project_auto_deactivate (SfiProxy bse_project_object, SfiInt msec_delay);
SfiBool bse_project_can_play (SfiProxy bse_project_object);
void bse_project_clear_undo (SfiProxy bse_project_object);
SfiProxy bse_project_create_csynth (SfiProxy bse_project_object, const gchar* name);
SfiProxy bse_project_create_midi_synth (SfiProxy bse_project_object, const gchar* name);
SfiProxy bse_project_create_song (SfiProxy bse_project_object, const gchar* name);
void bse_project_deactivate (SfiProxy bse_project_object);
SfiProxy bse_project_find_item (SfiProxy bse_project_object, const gchar* uname_path);
SfiProxy bse_project_get_data_pocket (SfiProxy bse_project_object, const gchar* name);
BseProjectState bse_project_get_state (SfiProxy bse_project_object);
BseItemSeq* bse_project_get_supers (SfiProxy bse_project_object);
SfiProxy bse_project_get_wave_repo (SfiProxy bse_project_object);
SfiBool bse_project_is_active (SfiProxy bse_project_object);
SfiBool bse_project_is_playing (SfiProxy bse_project_object);
BseStringSeq* bse_project_list_uname_paths (SfiProxy bse_project_object, const gchar* item_type);
BseItemSeq* bse_project_match_items_by_uname (SfiProxy bse_project_object, const gchar* item_type, const gchar* uname);
BseErrorType bse_project_play (SfiProxy bse_project_object);
void bse_project_redo (SfiProxy bse_project_object);
SfiInt bse_project_redo_depth (SfiProxy bse_project_object);
void bse_project_remove_snet (SfiProxy bse_project_object, SfiProxy snet);
void bse_project_start_playback (SfiProxy bse_project_object);
void bse_project_stop (SfiProxy bse_project_object);
void bse_project_stop_playback (SfiProxy bse_project_object);
void bse_project_undo (SfiProxy bse_project_object);
SfiInt bse_project_undo_depth (SfiProxy bse_project_object);
SfiBool bse_server_can_load (SfiProxy bse_server_object, const gchar* file_name);
BseNoteDescription* bse_server_construct_note (SfiProxy bse_server_object, SfiInt semitone, SfiInt octave, SfiInt fine_tune);
BseNoteDescription* bse_server_describe_note (SfiProxy bse_server_object, SfiInt note, SfiInt fine_tune);
const gchar* bse_server_get_custom_effect_dir (SfiProxy bse_server_object);
const gchar* bse_server_get_custom_instrument_dir (SfiProxy bse_server_object);
const gchar* bse_server_get_demo_path (SfiProxy bse_server_object);
const gchar* bse_server_get_effect_path (SfiProxy bse_server_object);
const gchar* bse_server_get_instrument_path (SfiProxy bse_server_object);
const gchar* bse_server_get_ladspa_path (SfiProxy bse_server_object);
SfiProxy bse_server_get_midi_notifier (SfiProxy bse_server_object);
const gchar* bse_server_get_mp3_version (SfiProxy bse_server_object);
const gchar* bse_server_get_plugin_path (SfiProxy bse_server_object);
const gchar* bse_server_get_sample_path (SfiProxy bse_server_object);
const gchar* bse_server_get_script_path (SfiProxy bse_server_object);
const gchar* bse_server_get_version (SfiProxy bse_server_object);
SfiInt bse_server_n_scripts (SfiProxy bse_server_object);
BseNoteDescription* bse_server_note_from_freq (SfiProxy bse_server_object, SfiReal freq);
BseNoteDescription* bse_server_note_from_string (SfiProxy bse_server_object, const gchar* name);
SfiBool bse_server_preferences_locked (SfiProxy bse_server_object);
void bse_server_register_core_plugins (SfiProxy bse_server_object);
void bse_server_register_ladspa_plugins (SfiProxy bse_server_object);
void bse_server_register_scripts (SfiProxy bse_server_object);
void bse_server_save_preferences (SfiProxy bse_server_object);
SfiProxy bse_server_use_new_project (SfiProxy bse_server_object, const gchar* name);
BseErrorType bse_snet_can_create_source (SfiProxy bse_snet_object, const gchar* module_type);
SfiProxy bse_snet_create_source (SfiProxy bse_snet_object, const gchar* module_type);
BseErrorType bse_snet_remove_source (SfiProxy bse_snet_object, SfiProxy module);
SfiBool bse_snet_supports_user_synths (SfiProxy bse_snet_object);
BseErrorType bse_wave_repo_load_file (SfiProxy bse_wave_repo_object, const gchar* file_name);
void bse_wave_repo_remove_wave (SfiProxy bse_wave_repo_object, SfiProxy wave);
SfiProxy bse_song_create_bus (SfiProxy bse_song_object);
SfiProxy bse_song_create_part (SfiProxy bse_song_object);
SfiProxy bse_song_create_track (SfiProxy bse_song_object);
SfiProxy bse_song_find_track_for_part (SfiProxy bse_song_object, SfiProxy part);
BseSongTiming* bse_song_get_timing (SfiProxy bse_song_object, SfiInt tick);
void bse_song_remove_bus (SfiProxy bse_song_object, SfiProxy bus);
void bse_song_remove_part (SfiProxy bse_song_object, SfiProxy part);
void bse_song_remove_track (SfiProxy bse_song_object, SfiProxy track);
void bse_song_synthesize_note (SfiProxy bse_song_object, SfiProxy track, SfiInt duration, SfiInt note, SfiInt fine_tune, SfiReal velocity);
BseThreadTotals* bse_collect_thread_totals (void);
BseCategory* bse_category_from_id (SfiInt category_id);
BseCategorySeq* bse_categories_match (const gchar* pattern);
BseCategorySeq* bse_categories_match_method (const gchar* pattern, const gchar* type);
BseCategorySeq* bse_categories_match_typed (const gchar* pattern, const gchar* type);
const gchar* bse_error_blurb (BseErrorType error);
const gchar* bse_error_name (BseErrorType error);
SfiProxy bse_janitor_get_specific (void);
SfiInt bse_note_from_freq (SfiReal frequency);
SfiReal bse_note_to_freq (SfiInt note, SfiInt fine_tune);
SfiBool bse_proxy_check (SfiProxy item, const gchar* type_name);
BseSampleFileInfo* bse_sample_file_info (const gchar* file_name);
SfiReal bse_string_extract_number (const gchar* string, const gchar* format, SfiReal aux_base, SfiReal dflt);
const gchar* bse_type_authors (const gchar* type);
const gchar* bse_type_blurb (const gchar* type);
const gchar* bse_type_license (const gchar* type);
const gchar* bse_type_options (const gchar* type);
void bse_sniffer_request_samples (SfiProxy obj, SfiNum tick_stamp, SfiInt n_samples, BseSnifferType stype);
SfiNum bse_sniffer_get_tick_stamp (SfiProxy obj);
SfiInt bse_sniffer_get_mix_freq (SfiProxy obj);
void bse_sniffer_request_combined (BseSnifferRequestSeq* srs);
#define BSE_IS_ITEM(proxy) bse_proxy_is_a ((proxy), "BseItem")
#define BSE_IS_DATA_POCKET(proxy) bse_proxy_is_a ((proxy), "BseDataPocket")
#define BSE_IS_EDITABLE_SAMPLE(proxy) bse_proxy_is_a ((proxy), "BseEditableSample")
#define BSE_IS_JANITOR(proxy) bse_proxy_is_a ((proxy), "BseJanitor")
#define BSE_IS_MIDI_NOTIFIER(proxy) bse_proxy_is_a ((proxy), "BseMidiNotifier")
#define BSE_IS_PART(proxy) bse_proxy_is_a ((proxy), "BsePart")
#define BSE_IS_PCM_DEVICE(proxy) bse_proxy_is_a ((proxy), "BsePcmDevice")
#define BSE_IS_PCM_WRITER(proxy) bse_proxy_is_a ((proxy), "BsePcmWriter")
#define BSE_IS_SOURCE(proxy) bse_proxy_is_a ((proxy), "BseSource")
#define BSE_IS_TRACK(proxy) bse_proxy_is_a ((proxy), "BseTrack")
#define BSE_IS_BIQUAD_FILTER(proxy) bse_proxy_is_a ((proxy), "BseBiquadFilter")
#define BSE_IS_CONSTANT(proxy) bse_proxy_is_a ((proxy), "BseConstant")
#define BSE_IS_CONTAINER(proxy) bse_proxy_is_a ((proxy), "BseContainer")
#define BSE_IS_CONTEXT_MERGER(proxy) bse_proxy_is_a ((proxy), "BseContextMerger")
#define BSE_IS_CXX_BASE(proxy) bse_proxy_is_a ((proxy), "BseCxxBase")
#define BSE_IS_LADSPA_MODULE(proxy) bse_proxy_is_a ((proxy), "BseLadspaModule")
#define BSE_IS_MIDI_CONTROLLER(proxy) bse_proxy_is_a ((proxy), "BseMidiController")
#define BSE_IS_MIDI_INPUT(proxy) bse_proxy_is_a ((proxy), "BseMidiInput")
#define BSE_IS_MIDI_VOICE_INPUT(proxy) bse_proxy_is_a ((proxy), "BseMidiVoiceInput")
#define BSE_IS_MIDI_VOICE_SWITCH(proxy) bse_proxy_is_a ((proxy), "BseMidiVoiceSwitch")
#define BSE_IS_PCM_DEVICE_OSS(proxy) bse_proxy_is_a ((proxy), "BsePcmDeviceOSS")
#define BSE_IS_PCM_INPUT(proxy) bse_proxy_is_a ((proxy), "BsePcmInput")
#define BSE_IS_PCM_OUTPUT(proxy) bse_proxy_is_a ((proxy), "BsePcmOutput")
#define BSE_IS_SNOOPER(proxy) bse_proxy_is_a ((proxy), "BseSnooper")
#define BSE_IS_STANDARD_OSC(proxy) bse_proxy_is_a ((proxy), "BseStandardOsc")
#define BSE_IS_SUB_IPORT(proxy) bse_proxy_is_a ((proxy), "BseSubIPort")
#define BSE_IS_SUB_OPORT(proxy) bse_proxy_is_a ((proxy), "BseSubOPort")
#define BSE_IS_SUB_SYNTH(proxy) bse_proxy_is_a ((proxy), "BseSubSynth")
#define BSE_IS_WAVE(proxy) bse_proxy_is_a ((proxy), "BseWave")
#define BSE_IS_WAVE_OSC(proxy) bse_proxy_is_a ((proxy), "BseWaveOsc")
#define BSE_IS_EFFECT(proxy) bse_proxy_is_a ((proxy), "BseEffect")
#define BSE_IS_INSTRUMENT_INPUT(proxy) bse_proxy_is_a ((proxy), "BseInstrumentInput")
#define BSE_IS_INSTRUMENT_OUTPUT(proxy) bse_proxy_is_a ((proxy), "BseInstrumentOutput")
#define BSE_IS_PROJECT(proxy) bse_proxy_is_a ((proxy), "BseProject")
#define BSE_IS_SERVER(proxy) bse_proxy_is_a ((proxy), "BseServer")
#define BSE_IS_SONG_BUS(proxy) bse_proxy_is_a ((proxy), "BseSongBus")
#define BSE_IS_SUPER(proxy) bse_proxy_is_a ((proxy), "BseSuper")
#define BSE_IS_AMPLIFIER(proxy) bse_proxy_is_a ((proxy), "BseAmplifier")
#define BSE_IS_SNET(proxy) bse_proxy_is_a ((proxy), "BseSNet")
#define BSE_IS_SNIFFER(proxy) bse_proxy_is_a ((proxy), "BseSniffer")
#define BSE_IS_WAVE_REPO(proxy) bse_proxy_is_a ((proxy), "BseWaveRepo")
#define BSE_IS_CSYNTH(proxy) bse_proxy_is_a ((proxy), "BseCSynth")
#define BSE_IS_MIDI_SYNTH(proxy) bse_proxy_is_a ((proxy), "BseMidiSynth")
#define BSE_IS_SONG(proxy) bse_proxy_is_a ((proxy), "BseSong")


/*-------- end ../sfi/sfidl generated code --------*/



Generated by  Doxygen 1.6.0   Back to index