bse-procedures(3)

NAME

BSE-Procedures - BSE Procedures Reference

Document Revised: Wed May 25 23:38:24 2005

SYNOPSIS

bse_bus_connect_bus (sbus, bus);
bse_bus_connect_track (sbus, track);
bse_bus_disconnect_bus (sbus, bus);
bse_bus_disconnect_track (sbus, track);
bse_bus_ensure_output (bus);
bse_categories_match (pattern);
bse_categories_match_method (pattern, type);
bse_categories_match_typed (pattern, type);
bse_category_from_id (category-id);
bse_container_get_item (container, item-type, seq-id);
bse_container_list_children (container);
bse_container_lookup_item (container, uname);
bse_data_pocket_create_entry (data-pocket);
bse_data_pocket_delete_entry (data-pocket, entry-id);
bse_data_pocket_get_float (data-pocket, entry-id, name);
bse_data_pocket_get_int (data-pocket, entry-id, name);
bse_data_pocket_get_n_entries (data-pocket);
bse_data_pocket_get_nth_entry_id             (data-pocket,
entry-index);
bse_data_pocket_get_object (data-pocket, entry-id, name);
bse_data_pocket_get_string (data-pocket, entry-id, name);
bse_data_pocket_set_float  (data-pocket,  entry-id,  name,
number);
bse_data_pocket_set_int  (data-pocket,   entry-id,   name,
number);
bse_data_pocket_set_object  (data-pocket,  entry-id, name,
item);
bse_data_pocket_set_string (data-pocket,  entry-id,  name,
string);
bse_editable_sample_close (esample);
bse_editable_sample_collect_stats    (esample,    voffset,
offset-scale, block-size, stepping, max-pairs);
bse_editable_sample_get_length (esample);
bse_editable_sample_get_n_channels (esample);
bse_editable_sample_get_osc_freq (esample);
bse_editable_sample_open (esample);
bse_editable_sample_read_samples (esample, voffset);
bse_error_blurb (error);
bse_error_name (error);
bse_item_add_parasite (item, path, parasite);
bse_item_check_is_a (item, type-name);
bse_item_clear_undo (item);
bse_item_common_ancestor (item, item2);
bse_item_editable_property (item, property-name);
bse_item_fixme_get_parasite (item, name);
bse_item_fixme_set_parasite (item, name, parasite);
bse_item_get_icon (item);
bse_item_get_name (item);
bse_item_get_name_or_type (item);
bse_item_get_parasite (item, path);
bse_item_get_parent (item);
bse_item_get_project (item);
bse_item_get_property_candidates (item, property-name);
bse_item_get_seqid (item);
bse_item_get_type (item);
bse_item_get_type_authors (item);
bse_item_get_type_blurb (item);
bse_item_get_type_license (item);
bse_item_get_type_name (item);
bse_item_get_uname_path (item);
bse_item_group_undo (item, name);
bse_item_internal (item);
bse_item_list_parasites (item, path);
bse_item_redo (item);
bse_item_redo_depth (item);
bse_item_set_name (item, name);
bse_item_set_parasite (item, path, parasite);
bse_item_undo (item);
bse_item_undo_depth (item);
bse_item_ungroup_undo (item);
bse_item_unuse (item);
bse_item_use (item);
bse_janitor_get_action (janitor, nth-action);
bse_janitor_get_action_blurb (janitor, nth-action);
bse_janitor_get_action_name (janitor, nth-action);
bse_janitor_get_proc_name (janitor);
bse_janitor_get_script_name (janitor);
bse_janitor_kill (janitor);
bse_janitor_n_actions (janitor);
bse_janitor_trigger_action (janitor, action);
bse_midi_notifier_current_time (midi-notifier);
bse_note_from_freq (frequency);
bse_note_to_freq (note, fine-tune);
bse_part_change_control  (part,  id,  tick,  control-type,
value);
bse_part_change_note  (part,  id,  tick,  duration,  note,
fine-tune, velocity);
bse_part_check_overlap (part, tick, duration, note);
bse_part_delete_event (part, id);
bse_part_deselect_controls    (part,    tick,    duration,
control-type);
bse_part_deselect_event (part, id);
bse_part_deselect_notes  (part,  tick, duration, min-note,
max-note);
bse_part_get_channel_controls   (part,   channel,    tick,
duration, control-type);
bse_part_get_controls (part, tick, control-type);
bse_part_get_max_note (part);
bse_part_get_min_note (part);
bse_part_get_notes (part, tick, note);
bse_part_get_timing (part, tick);
bse_part_insert_control (part, tick, control-type, value);
bse_part_insert_note (part, channel, tick, duration, note,
fine-tune, velocity);
bse_part_insert_note_auto  (part,  tick,  duration,  note,
fine-tune, velocity);
bse_part_is_event_selected (part, id);
bse_part_list_controls     (part,     tick,      duration,
control-type);
bse_part_list_links (part);
bse_part_list_notes_crossing (part, tick, duration);
bse_part_list_notes_within     (part,    channel,    tick,
duration);
bse_part_list_selected_controls (part, control-type);
bse_part_list_selected_notes (part);
bse_part_queue_controls (part, tick, duration);
bse_part_queue_notes  (part,  tick,  duration,   min-note,
max-note);
bse_part_select_controls     (part,     tick,    duration,
control-type);
bse_part_select_controls_exclusive (part, tick,  duration,
control-type);
bse_part_select_event (part, id);
bse_part_select_notes  (part,  tick,  duration,  min-note,
max-note);
bse_part_select_notes_exclusive  (part,  tick,   duration,
min-note, max-note);
bse_project_activate (project);
bse_project_auto_deactivate (project, msec-delay);
bse_project_can_play (project);
bse_project_change_name (project, name);
bse_project_clean_dirty (project);
bse_project_clear_undo (project);
bse_project_create_csynth (project, name);
bse_project_create_midi_synth (project, name);
bse_project_create_song (project, name);
bse_project_deactivate (project);
bse_project_find_item (project, uname-path);
bse_project_get_data_pocket (project, name);
bse_project_get_midi_notifier (project);
bse_project_get_state (project);
bse_project_get_supers (project);
bse_project_get_wave_repo (project);
bse_project_import_midi_file (project, file-name);
bse_project_inject_midi_control   (project,  midi-channel,
midi-control, control-value);
bse_project_is_active (project);
bse_project_is_dirty (project);
bse_project_is_playing (project);
bse_project_list_uname_paths (project, item-type);
bse_project_match_items_by_uname   (project,    item-type,
uname);
bse_project_play (project);
bse_project_redo (project);
bse_project_redo_depth (project);
bse_project_remove_snet (project, snet);
bse_project_restore_from_file (project, file-name);
bse_project_start_playback (project);
bse_project_stop (project);
bse_project_stop_playback (project);
bse_project_store_bse    (project,    super,    file-name,
self-contained);
bse_project_undo (project);
bse_project_undo_depth (project);
bse_proxy_check (item, type-name);
bse_sample_file_info (file-name);
bse_script_add_action (action, name, blurb);
bse_script_janitor ();
bse_script_progress (progress);
bse_script_quit ();
bse_script_remove_action (action);
bse_script_send_message (domain, msg-type, title, primary,
secondary, details, config-check);
bse_script_set_status (message);
bse_server_can_load (server, file-name);
bse_server_construct_note   (server,   semitone,   octave,
fine-tune);
bse_server_describe_note (server, note, fine-tune);
bse_server_get_custom_effect_dir (server);
bse_server_get_custom_instrument_dir (server);
bse_server_get_demo_path (server);
bse_server_get_effect_path (server);
bse_server_get_instrument_path (server);
bse_server_get_ladspa_path (server);
bse_server_get_mp3_version (server);
bse_server_get_plugin_path (server);
bse_server_get_sample_path (server);
bse_server_get_script_path (server);
bse_server_get_version (server);
bse_server_n_scripts (server);
bse_server_note_from_freq (server, freq);
bse_server_note_from_string (server, name);
bse_server_preferences_locked (server);
bse_server_register_core_plugins (server);
bse_server_register_ladspa_plugins (server);
bse_server_register_scripts (server);
bse_server_save_preferences (server);
bse_server_use_new_project (server, name);
bse_snet_can_create_source (snet, module-type);
bse_snet_create_source (snet, module-type);
bse_snet_remove_source (snet, module);
bse_snet_supports_user_synths (snet);
bse_song_create_bus (song);
bse_song_create_part (song);
bse_song_create_track (song);
bse_song_ensure_master_bus (song);
bse_song_ensure_track_links (song);
bse_song_find_any_track_for_part (song, part);
bse_song_find_track_for_part (song, part);
bse_song_get_master_bus (song);
bse_song_get_timing (song, tick);
bse_song_remove_bus (song, bus);
bse_song_remove_part (song, part);
bse_song_remove_track (song, track);
bse_song_synthesize_note  (song,  track,  duration,  note,
fine-tune, velocity);
bse_source_clear_inputs (module);
bse_source_clear_outputs (module);
bse_source_get_automation_channel (source, property-name);
bse_source_get_automation_control (source, property-name);
bse_source_has_output (module, ochannel);
bse_source_has_outputs (module);
bse_source_ichannel_blurb (module, input-channel);
bse_source_ichannel_get_n_joints (module, input-channel);
bse_source_ichannel_get_ochannel  (module,  input-channel,
input-joint);
bse_source_ichannel_get_osource  (module,   input-channel,
input-joint);
bse_source_ichannel_ident (module, input-channel);
bse_source_ichannel_label (module, input-channel);
bse_source_is_joint_ichannel (module, input-channel);
bse_source_is_joint_ichannel_by_id                (module,
input-channel);
bse_source_is_prepared (source);
bse_source_n_ichannels (module);
bse_source_n_ochannels (module);
bse_source_ochannel_blurb (module, output-channel);
bse_source_ochannel_ident (module, output-channel);
bse_source_ochannel_label (module, output-channel);
bse_source_set_automation     (source,      property-name,
midi-channel, control-type);
bse_source_set_input   (imodule,  input-channel,  omodule,
output-channel);
bse_source_set_input_by_id    (imodule,     input-channel,
omodule, output-channel);
bse_source_set_pos (module, x-pos, y-pos);
bse_source_unset_input  (module,  input-channel,  omodule,
output-channel);
bse_source_unset_input_by_id    (module,    input-channel,
omodule, output-channel);
bse_string_extract_number   (string,   format,   aux-base,
dflt);
bse_track_ensure_output (track);
bse_track_get_last_tick (track);
bse_track_get_output_source (track);
bse_track_get_part (track, tick);
bse_track_get_timing (track, tick);
bse_track_insert_part (track, tick, part);
bse_track_list_parts (track);
bse_track_list_parts_uniq (track);
bse_track_remove_link (track, id);
bse_track_remove_tick (track, tick);
bse_type_authors (type);
bse_type_blurb (type);
bse_type_license (type);
bse_type_options (type);
bse_wave_chunk_get_mix_freq (wave, chunk-index);
bse_wave_chunk_get_osc_freq (wave, chunk-index);
bse_wave_load_wave (wave, file-name, wave-name);
bse_wave_n_wave_chunks (wave);
bse_wave_osc_mass_seek_perc (wosc-seq, pos-perc);
bse_wave_osc_request_pcm_position (wosc);
bse_wave_osc_set_from_editable_sample (wosc, esample);
bse_wave_repo_load_file (wave-repo, file-name);
bse_wave_repo_remove_wave (wave-repo, wave);
bse_wave_use_editable (wave, chunk-index);

DESCRIPTION

(bse-bus-connect-bus sbus bus) bse_bus_connect_bus (sbus, bus);: BseBus* sbus; sbus
BseBus* bus; bus
RETURNS:: BseErrorType error;; Add a bus to the input list of a bus.
(bse-bus-connect-track sbus track) bse_bus_connect_track (sbus, track);: BseBus* sbus; sbus
BseTrack* track; track
RETURNS:: BseErrorType error;; Add a track to the input list of a bus.
(bse-bus-disconnect-bus sbus bus) bse_bus_disconnect_bus (sbus, bus);: BseBus* sbus; sbus
BseBus* bus; bus
RETURNS:: BseErrorType error;; Remove a bus from the input list of a bus.
(bse-bus-disconnect-track sbus track) bse_bus_disconnect_track (sbus, track);: BseBus* sbus; sbus
BseTrack* track; track
RETURNS:: BseErrorType error;; Remove a track from the input list of a bus.
(bse-bus-ensure-output bus) bse_bus_ensure_output (bus);: BseBus* bus; bus
RETURNS:: BseErrorType error;; Ensure that a bus has an output connection.
(bse-container-get-item container item-type seq-id) bse_container_get_item (container, item_type, seq_id);: BseContainer* container; container const gchar* item_type; Type of the item to; retrieve
SfiInt seq_id; Sequential ID
RETURNS:: BseItem* item; The item with seqid; as requested; Retrieve a containers immediate child from it's se; quential id.
(bse-container-list-children container) bse_container_list_children (container);: BseContainer* container; container
RETURNS:: BseItemSeq* item_list;; Retrieve all immediate children of a container
(bse-container-lookup-item container uname) bse_container_lookup_item (container, uname);: BseContainer* container; The Container const gchar* uname; Unique item name
RETURNS:: BseItem* item; The item named by un; ame; Find an immediate child of a container from its un; ame (the uname is the name of the item, unique between all imme; diate children of a container).
(bse-data-pocket-create-entry data-pocket) bse_data_pocket_create_entry (data_pocket);: BseDataPocket* data_pocket; Data Pocket
RETURNS:: SfiInt entry_id; The unique pocket; entry ID; Create a new entry in a data pocket. Entries have a; unique ID which is required to set values in a data pocket.
(bse-data-pocket-delete-entry data-pocket entry-id) bse_data_pocket_delete_entry (data_pocket, entry_id);: BseDataPocket* data_pocket; Data Pocket SfiInt entry_id; The unique pocket; entry ID
RETURNS:: BseErrorType error; BSE error code; Delete an existing entry from a data pocket
(bse-data-pocket-get-float data-pocket entry-id name) bse_data_pocket_get_float (data_pocket, entry_id, name);: BseDataPocket* data_pocket; The data pocket; storing values
SfiInt entry_id; The unique pocket; entry ID
const gchar* name; Name for the value
RETURNS:: SfiReal number; The value stored; in the data pocket entry; Retrieve a previously set floating point value from; a data pocket entry.
(bse-data-pocket-get-int data-pocket entry-id name) bse_data_pocket_get_int (data_pocket, entry_id, name);: BseDataPocket* data_pocket; The data pocket; storing values
SfiInt entry_id; The unique pocket; entry ID
const gchar* name; Name for the value
RETURNS:: SfiInt number; The value stored; in the data pocket entry; Retrieve a previously set integer value from a data; pocket entry.
(bse-data-pocket-get-n-entries data-pocket) bse_data_pocket_get_n_entries (data_pocket);: BseDataPocket* data_pocket; The data pocket; storing values
RETURNS:: SfiInt n_entries; The number of en; tries in use; Retrieve the number of entries created in a data; pocket.
(bse-data-pocket-get-nth-entry-id data-pocket entry-index) bse_data_pocket_get_nth_entry_id (data_pocket,
entry_index);: BseDataPocket* data_pocket; The data pocket; storing values
SfiInt entry_index; index into number; of entries present
RETURNS:: SfiInt entry_id; The unique pocket; entry ID (or 0 if there's no such entry); Retrieve the ID of an entry in the data pocket by; sequential index.
(bse-data-pocket-get-object data-pocket entry-id name) bse_data_pocket_get_object (data_pocket, entry_id, name);: BseDataPocket* data_pocket; The data pocket; storing values
SfiInt entry_id; The unique pocket; entry ID
const gchar* name; Name for the value
RETURNS:: BseItem* item; The value stored; in the data pocket entry; Retrieve a previously set object reference from a; data pocket entry.
(bse-data-pocket-get-string data-pocket entry-id name) bse_data_pocket_get_string (data_pocket, entry_id, name);: BseDataPocket* data_pocket; The data pocket; storing values
SfiInt entry_id; The unique pocket; entry ID
const gchar* name; Name for the value
RETURNS:: const gchar* string; The value stored; in the data pocket entry; Retrieve a previously set string from a data pocket; entry.
(bse-data-pocket-set-float data-pocket entry-id name
number)
bse_data_pocket_set_float (data_pocket, entry_id, name,
number);: BseDataPocket* data_pocket; The data pocket; storing values
SfiInt entry_id; The unique pocket; entry ID
const gchar* name; Name for the value SfiReal number; The value to store; in the data pocket entry
RETURNS:: BseErrorType error; BSE error code; Set a named floating point value in a data pocket; entry. Names are required to distinguish different values from; each other when accessing values in a data pocket.
(bse-data-pocket-set-int data-pocket entry-id name number) bse_data_pocket_set_int (data_pocket, entry_id, name,
number);: BseDataPocket* data_pocket; The data pocket; storing values
SfiInt entry_id; The unique pocket; entry ID
const gchar* name; Name for the value SfiInt number; The value to store; in the data pocket entry
RETURNS:: BseErrorType error; BSE error code; Set a named integer value in a data pocket entry.; Names are required to distinguish different values from each oth; er when accessing values in a data pocket.
(bse-data-pocket-set-object data-pocket entry-id name
item)
bse_data_pocket_set_object (data_pocket, entry_id, name,
item);: BseDataPocket* data_pocket; The data pocket; storing values
SfiInt entry_id; The unique pocket; entry ID
const gchar* name; Name for the value BseItem* item; The value to store; in the data pocket entry
RETURNS:: BseErrorType error; BSE error code; Set a named object reference in a data pocket en; try. Object references stored in a data pocket must exist within; the same project that the data pocket belongs to
(bse-data-pocket-set-string data-pocket entry-id name
string)
bse_data_pocket_set_string (data_pocket, entry_id, name,
string);: BseDataPocket* data_pocket; The data pocket; storing values
SfiInt entry_id; The unique pocket; entry ID
const gchar* name; Name for the value const gchar* string; The value to store; in the data pocket entry
RETURNS:: BseErrorType error; BSE error code; Set a named string in a data pocket entry.
(bse-editable-sample-close esample) bse_editable_sample_close (esample);: BseEditableSample* esample; Editable Sample; Close an opened sample.
(bse-editable-sample-collect-stats esample voffset
offset-scale block-size stepping max-pairs) bse_editable_sample_collect_stats (esample, voffset,
offset_scale, block_size, stepping, max_pairs);: BseEditableSample* esample; Editable Sam; ple
SfiInt voffset; Offset of; first stat block
SfiReal offset_scale; Factor to; scale voffset increments with
SfiInt block_size; Block size to; compute stat pairs from
SfiInt stepping; Stepping; within a stat block
SfiInt max_pairs; Maximum num; ber of (min, max) pairs to collect
RETURNS:: SfiFBlock* sample_block; Block of sam; ples; Collect statistics from sample blocks as (minimum,; maximum) pairs.
(bse-editable-sample-get-length esample) bse_editable_sample_get_length (esample);: BseEditableSample* esample; Editable Sample
RETURNS:: SfiInt length; Number of values; Return the number of values in the sample.
(bse-editable-sample-get-n-channels esample) bse_editable_sample_get_n_channels (esample);: BseEditableSample* esample; Editable Sample
RETURNS:: SfiInt n_channels; Number of chan; nels; Return the number of channels in the sample.
(bse-editable-sample-get-osc-freq esample) bse_editable_sample_get_osc_freq (esample);: BseEditableSample* esample; Editable Sample
RETURNS:: SfiReal osc_freq; Oscillator Fre; quency; Return the oscillator frequency for the sample.
(bse-editable-sample-open esample) bse_editable_sample_open (esample);: BseEditableSample* esample; Editable Sample
RETURNS:: BseErrorType error;; Open the sample for reading.
(bse-editable-sample-read-samples esample voffset) bse_editable_sample_read_samples (esample, voffset);: BseEditableSample* esample; Editable Sam; ple
SfiInt voffset; Value offset
RETURNS:: SfiFBlock* sample_block; Block of sam; ples; Read a set of samples from a specific offset.
(bse-item-add-parasite item path parasite) bse_item_add_parasite (item, path, parasite);: BseItem* item; Item
const gchar* path; Path
SfiRec* parasite; Parasite; Add a new parasite to an item.
(bse-item-check-is-a item type-name) bse_item_check_is_a (item, type_name);: BseItem* item; The Item
const gchar* type_name; Type Name
RETURNS:: SfiBool is_a;; Check whether an item has a certain type.
(bse-item-clear-undo item) bse_item_clear_undo (item);: BseItem* item; item; Call the clear-undo function of the project corre; sponding to this item if any.
(bse-item-common-ancestor item item2) bse_item_common_ancestor (item, item2);: BseItem* item; First item
BseItem* item2; Second item
RETURNS:: BseItem* ancestor; Common ancestor of both; items; Retrieve the common ancestor of two items if; there's any.
(bse-item-editable-property item property-name) bse_item_editable_property (item, property_name);: BseItem* item; item
const gchar* property_name; Item property name
RETURNS:: SfiBool editable;; Test whether a property is editable according to; object state and property options.
(bse-item-fixme-get-parasite item name) bse_item_fixme_get_parasite (item, name);: BseItem* item; item
const gchar* name; name
RETURNS:: SfiFBlock* parasite;
(bse-item-fixme-set-parasite item name parasite) bse_item_fixme_set_parasite (item, name, parasite);: BseItem* item; item
const gchar* name; name
SfiFBlock* parasite; parasite
(bse-item-get-icon item)
bse_item_get_icon (item);: BseItem* item; item
RETURNS:: BseIcon* icon;; Get the current icon of an item.
(bse-item-get-name item)
bse_item_get_name (item);: BseItem* item; Item
RETURNS:: const gchar* name;; Retrieve an item's name.
(bse-item-get-name-or-type item) bse_item_get_name_or_type (item);: BseItem* item; Item
RETURNS:: const gchar* name;; Retrieve an item's name or type if it has no name.
(bse-item-get-parasite item path) bse_item_get_parasite (item, path);: BseItem* item; Item
const gchar* path; Path
RETURNS:: SfiRec* parasite;; Retrieve a parasite from an item.
(bse-item-get-parent item) bse_item_get_parent (item);: BseItem* item; Item
RETURNS:: BseItem* parent;; Retrieve an item's parent.
(bse-item-get-project item) bse_item_get_project (item);: BseItem* item; Item
RETURNS:: BseItem* project;; Retrieve an item's project.
(bse-item-get-property-candidates item property-name) bse_item_get_property_candidates (item, property_name);: BseItem* item; item const gchar* property_name; Item; property name
RETURNS:: BsePropertyCandidates* candidates;; Retrieve tentative values for an item or item se; quence property.
(bse-item-get-seqid item)
bse_item_get_seqid (item);: BseItem* item; Item
RETURNS:: SfiInt seq_id;; Retrieve an item's sequential ID. The sequential ID; depends on the item's type an it's position inbetween siblings of; the same type within it's immediate container.
(bse-item-get-type item)
bse_item_get_type (item);: BseItem* item; Item
RETURNS:: const gchar* string;; Retrieve an item's type name.
(bse-item-get-type-authors item) bse_item_get_type_authors (item);: BseItem* item; Item
RETURNS:: const gchar* string;; Retrieve authors of an item's type implementation.
(bse-item-get-type-blurb item) bse_item_get_type_blurb (item);: BseItem* item; Item
RETURNS:: const gchar* string;; Retrieve an item's type description.
(bse-item-get-type-license item) bse_item_get_type_license (item);: BseItem* item; Item
RETURNS:: const gchar* string;; Retrieve the license for an item's type implementa; tion.
(bse-item-get-type-name item) bse_item_get_type_name (item);: BseItem* item; Item
RETURNS:: const gchar* string;; Retrieve an item's type name.
(bse-item-get-uname-path item) bse_item_get_uname_path (item);: BseItem* item; item
RETURNS:: const gchar* uname_path;; Retrieve the project relative uname path for this; item.
(bse-item-group-undo item name) bse_item_group_undo (item, name);: BseItem* item; item
const gchar* name; A name for the undo group; to be created; Request multiple modifying actions on an item to be; grouped together as single undo operation.
(bse-item-internal item)
bse_item_internal (item);: BseItem* item; Item
RETURNS:: SfiBool internal;; Check whether an item is internal, i.e. owned by; another non-internal item.
(bse-item-list-parasites item path) bse_item_list_parasites (item, path);: BseItem* item; Item
const gchar* path; Path
RETURNS:: BseStringSeq* paths;; List parasites within a parasite path segment.
(bse-item-redo item)
bse_item_redo (item);: BseItem* item; item; Call the redo function of the project corresponding; to this item if any.
(bse-item-redo-depth item) bse_item_redo_depth (item);: BseItem* item; item
RETURNS:: SfiInt redo_depth; Number of times redo can; be called; Call the redo-depth function of the project corre; sponding to this item if any.
(bse-item-set-name item name) bse_item_set_name (item, name);: BseItem* item; Item
const gchar* name; Name; Set an item's name.
(bse-item-set-parasite item path parasite) bse_item_set_parasite (item, path, parasite);: BseItem* item; Item
const gchar* path; Path
SfiRec* parasite; Parasite; Set or change a parasite on an item.
(bse-item-undo item)
bse_item_undo (item);: BseItem* item; item; Call the undo function of the project corresponding; to this item if any.
(bse-item-undo-depth item) bse_item_undo_depth (item);: BseItem* item; item
RETURNS:: SfiInt undo_depth; Number of times undo can; be called; Call the undo-depth function of the project corre; sponding to this item if any.
(bse-item-ungroup-undo item) bse_item_ungroup_undo (item);: BseItem* item; item; Ends the undo grouping opened up by a previous; group-undo() call.
(bse-item-unuse item)
bse_item_unuse (item);: BseItem* item; Item; Decrement use count for when an item is not needed; anymore.
(bse-item-use item)
bse_item_use (item);: BseItem* item; Item
RETURNS:: BseItem* used_item;; Increment use count to keep an item alive.
(bse-janitor-get-action janitor nth-action) bse_janitor_get_action (janitor, nth_action);: BseJanitor* janitor; Janitor SfiInt nth_action; Nth Action
RETURNS:: const gchar* action;; Retrieve an action of this janitor.
(bse-janitor-get-action-blurb janitor nth-action) bse_janitor_get_action_blurb (janitor, nth_action);: BseJanitor* janitor; Janitor SfiInt nth_action; Nth Action
RETURNS:: const gchar* action_blurb;; Retrieve the help string of an action of this jani; tor.
(bse-janitor-get-action-name janitor nth-action) bse_janitor_get_action_name (janitor, nth_action);: BseJanitor* janitor; Janitor SfiInt nth_action; Nth Action
RETURNS:: const gchar* action_name;; Retrieve the name of an action of this janitor.
(bse-janitor-get-proc-name janitor) bse_janitor_get_proc_name (janitor);: BseJanitor* janitor; Janitor
RETURNS:: const gchar* proc_name;; Retrieve the procedure name of this janitor.
(bse-janitor-get-script-name janitor) bse_janitor_get_script_name (janitor);: BseJanitor* janitor; Janitor
RETURNS:: const gchar* script_name;; Retrieve the script name of this janitor.
(bse-janitor-kill janitor) bse_janitor_kill (janitor);: BseJanitor* janitor; Janitor; Kill a currently running janitor.
(bse-janitor-n-actions janitor) bse_janitor_n_actions (janitor);: BseJanitor* janitor; Janitor
RETURNS:: SfiInt n_actions;; Retrieve number of user actions of this janitor.
(bse-janitor-trigger-action janitor action) bse_janitor_trigger_action (janitor, action);: BseJanitor* janitor; Janitor const gchar* action; Action; Trigger an installed user action of this janitor.
(bse-midi-notifier-current-time midi-notifier) bse_midi_notifier_current_time (midi_notifier);: BseMidiNotifier* midi_notifier; Midi Notifier
RETURNS:: SfiInt msec_time;; Test
(bse-part-change-control part id tick control-type value) bse_part_change_control (part, id, tick, control_type,
value);: BsePart* part; Part SfiInt id; ID
SfiInt tick; Start Tick BseMidiSignalType control_type; Control Type SfiReal value; Value
RETURNS:: BseErrorType error;; Change an existing control event within a part.
(bse-part-change-note part id tick duration note fine-tune
velocity)
bse_part_change_note (part, id, tick, duration, note,
fine_tune, velocity);: BsePart* part; Part
SfiInt id; ID
SfiInt tick; Start Tick
SfiInt duration; Tick Duration SfiInt note; Note
SfiInt fine_tune; Fine tune in cents per; semitone
SfiReal velocity; Velocity
RETURNS:: BseErrorType error;; Change an existing note within a part.
(bse-part-check-overlap part tick duration note) bse_part_check_overlap (part, tick, duration, note);: BsePart* part; Part
SfiInt tick; Start Tick
SfiInt duration; Tick Duration SfiInt note; Note
RETURNS:: BsePartNoteSeq* note_list;; Check whether a note would overlap with neighbours.
(bse-part-delete-event part id) bse_part_delete_event (part, id);: BsePart* part; Part
SfiInt id; ID
RETURNS:: BseErrorType error;; Delete an existing event from a part.
(bse-part-deselect-controls part tick duration
control-type)
bse_part_deselect_controls (part, tick, duration,
control_type);: BsePart* part; Part SfiInt tick; Selection Tick SfiInt duration; Selection Du; ration
BseMidiSignalType control_type; Control Type; Deselect all controls within given range.
(bse-part-deselect-event part id) bse_part_deselect_event (part, id);: BsePart* part; Part
SfiInt id; ID; Deselect an existing event.
(bse-part-deselect-notes part tick duration min-note
max-note)
bse_part_deselect_notes (part, tick, duration, min_note,
max_note);: BsePart* part; Part
SfiInt tick; Selection Tick
SfiInt duration; Selection Duration SfiInt min_note; Minimum Selection Note SfiInt max_note; Maximum Selection Note; Deselect all notes within rectangle.
(bse-part-get-channel-controls part channel tick duration
control-type)
bse_part_get_channel_controls (part, channel, tick,
duration, control_type);: BsePart* part; Part SfiInt channel; Channel SfiInt tick; Tick
SfiInt duration; Tick Duration BseMidiSignalType control_type; Control Type
RETURNS:: BsePartControlSeq* control_list;; Retrieve all control events of a specific type; within range of a channel.
(bse-part-get-controls part tick control-type) bse_part_get_controls (part, tick, control_type);: BsePart* part; Part SfiInt tick; Tick
BseMidiSignalType control_type; Control Type
RETURNS:: BsePartControlSeq* control_list;; Retrieve all control events of a specific type at; specified tick.
(bse-part-get-max-note part) bse_part_get_max_note (part);: BsePart* part; Part
RETURNS:: SfiInt note;; Retrieve the maximum note supported in this part.
(bse-part-get-min-note part) bse_part_get_min_note (part);: BsePart* part; Part
RETURNS:: SfiInt note;; Retrieve the minimum note supported in this part.
(bse-part-get-notes part tick note) bse_part_get_notes (part, tick, note);: BsePart* part; Part
SfiInt tick; Tick
SfiInt note; Note
RETURNS:: BsePartNoteSeq* note_list;; Retrieve all notes of specific frequency at or; crossing a specific tick.
(bse-part-get-timing part tick) bse_part_get_timing (part, tick);: BsePart* part; Part
SfiInt tick; Tick to retrieve timing; info about
RETURNS:: BseSongTiming* timing; Song Timing; Retrieve song timing information at a specific; tick.
(bse-part-insert-control part tick control-type value) bse_part_insert_control (part, tick, control_type, value);: BsePart* part; Part SfiInt tick; Start Tick BseMidiSignalType control_type; Control Type SfiReal value; Value
RETURNS:: SfiInt id;; Insert a new control event into a part.
(bse-part-insert-note part channel tick duration note
fine-tune velocity)
bse_part_insert_note (part, channel, tick, duration, note,
fine_tune, velocity);: BsePart* part; Part
SfiInt channel; Channel
SfiInt tick; Start Tick
SfiInt duration; Tick Duration SfiInt note; Note
SfiInt fine_tune; Fine tune in cents per; semitone
SfiReal velocity; Velocity
RETURNS:: SfiInt id;; Insert a new note into a part.
(bse-part-insert-note-auto part tick duration note
fine-tune velocity)
bse_part_insert_note_auto (part, tick, duration, note,
fine_tune, velocity);: BsePart* part; Part
SfiInt tick; Start Tick
SfiInt duration; Tick Duration SfiInt note; Note
SfiInt fine_tune; Fine tune in cents per; semitone
SfiReal velocity; Velocity
RETURNS:: SfiInt id;; Insert a new note into a part with automatic chan; nel selection.
(bse-part-is-event-selected part id) bse_part_is_event_selected (part, id);: BsePart* part; Part
SfiInt id; ID
RETURNS:: SfiBool selected;; Check whether an event is selected.
(bse-part-list-controls part tick duration control-type) bse_part_list_controls (part, tick, duration,
control_type);: BsePart* part; Part SfiInt tick; Start Tick SfiInt duration; Tick Duration BseMidiSignalType control_type; Control Type
RETURNS:: BsePartControlSeq* control_list;; List all control events within a tick range.
(bse-part-list-links part) bse_part_list_links (part);: BsePart* part; Part
RETURNS:: BsePartLinkSeq* link_list;; List all places where parts are used (linked) from; tracks, sorted by tick.
(bse-part-list-notes-crossing part tick duration) bse_part_list_notes_crossing (part, tick, duration);: BsePart* part; Part
SfiInt tick; Start Tick
SfiInt duration; Tick Duration
RETURNS:: BsePartNoteSeq* note_list;; List all notes within or crossing a tick range.
(bse-part-list-notes-within part channel tick duration) bse_part_list_notes_within (part, channel, tick,
duration);: BsePart* part; Part
SfiInt channel; Channel SfiInt tick; Start Tick
SfiInt duration; Tick Duration
RETURNS:: BsePartNoteSeq* note_list;; List all notes within a tick range.
(bse-part-list-selected-controls part control-type) bse_part_list_selected_controls (part, control_type);: BsePart* part; Part BseMidiSignalType control_type; Control Type
RETURNS:: BsePartControlSeq* control_list;; List all currently selected control events of a; specific type.
(bse-part-list-selected-notes part) bse_part_list_selected_notes (part);: BsePart* part; Part
RETURNS:: BsePartNoteSeq* note_list;; List all currently selected notes.
(bse-part-queue-controls part tick duration) bse_part_queue_controls (part, tick, duration);: BsePart* part; Part
SfiInt tick; Start Tick
SfiInt duration; Tick Duration; Queue updates for all control events and notes; starting within the given range.
(bse-part-queue-notes part tick duration min-note
max-note)
bse_part_queue_notes (part, tick, duration, min_note,
max_note);: BsePart* part; Part
SfiInt tick; Start Tick
SfiInt duration; Tick Duration SfiInt min_note; Minimum Note SfiInt max_note; Maximum Note; Queue updates for all notes starting within the; given rectangle.
(bse-part-select-controls part tick duration control-type) bse_part_select_controls (part, tick, duration,
control_type);: BsePart* part; Part SfiInt tick; Selection Tick SfiInt duration; Selection Du; ration
BseMidiSignalType control_type; Control Type; Select all control events within range.
(bse-part-select-controls-exclusive part tick duration
control-type)
bse_part_select_controls_exclusive (part, tick, duration,
control_type);: BsePart* part; Part SfiInt tick; Selection Tick SfiInt duration; Selection Du; ration
BseMidiSignalType control_type; Control Type; Select all control events within range and deselect; all others.
(bse-part-select-event part id) bse_part_select_event (part, id);: BsePart* part; Part
SfiInt id; ID; Select an existing event.
(bse-part-select-notes part tick duration min-note
max-note)
bse_part_select_notes (part, tick, duration, min_note,
max_note);: BsePart* part; Part
SfiInt tick; Selection Tick
SfiInt duration; Selection Duration SfiInt min_note; Minimum Selection Note SfiInt max_note; Maximum Selection Note; Select all notes within rectangle.
(bse-part-select-notes-exclusive part tick duration
min-note max-note)
bse_part_select_notes_exclusive (part, tick, duration,
min_note, max_note);: BsePart* part; Part
SfiInt tick; Selection Tick
SfiInt duration; Selection Duration SfiInt min_note; Minimum Selection Note SfiInt max_note; Maximum Selection Note; Select all notes within rectangle and deselect all; others.
(bse-project-import-midi-file project file-name) bse_project_import_midi_file (project, file_name);: BseProject* project; The project const gchar* file_name; MIDI file name
RETURNS:: BseErrorType error; Error indicating pos; sible failures; Import a song from a MIDI file.
(bse-project-restore-from-file project file-name) bse_project_restore_from_file (project, file_name);: BseProject* project; The project const gchar* file_name; Source file name
RETURNS:: BseErrorType error; Error indicating pos; sible failures; Load a project from file
(bse-project-store-bse project super file-name
self-contained)
bse_project_store_bse (project, super, file_name,
self_contained);: BseProject* project; Project BseSuper* super; Super const gchar* file_name; Destination file; name
SfiBool self_contained; Whether refer; ences to other objects (e.g. samples) should be stored or whether; to include everything in a self-contained .bse file
RETURNS:: BseErrorType error; Error indicating; possible failures; Save supers of a project into a BSE file. If no su; per is specified, the project itself is stored.
(bse-project-activate project) bse_project_activate (project);: BseProject* project; The project
RETURNS:: BseErrorType error;; Activate a project, precondition to start playback.
(bse-project-auto-deactivate project msec-delay) bse_project_auto_deactivate (project, msec_delay);: BseProject* project; The project SfiInt msec_delay; Delay for deactivation; in milliseconds; Automatically deactivate a project once playback; stopped.
(bse-project-can-play project) bse_project_can_play (project);: BseProject* project; The project
RETURNS:: SfiBool can_play; Whether project playback; makes sense; Check whether project playback would makes sense.
(bse-project-change-name project name) bse_project_change_name (project, name);: BseProject* project; The project const gchar* name; name; Change a project name without recording undo steps.
(bse-project-clean-dirty project) bse_project_clean_dirty (project);: BseProject* project; Project; Clear a projects dirty flags.
(bse-project-clear-undo project) bse_project_clear_undo (project);: BseProject* project; Project; Delete all recorded undo or redo steps.
(bse-project-create-csynth project name) bse_project_create_csynth (project, name);: BseProject* project; The project const gchar* name; Synth network name
RETURNS:: BseCSynth* csynth; New synth network; Create a synthsizer network for this project.
(bse-project-create-midi-synth project name) bse_project_create_midi_synth (project, name);: BseProject* project; The project const gchar* name; MIDI synth name
RETURNS:: BseMidiSynth* midi_synth; New MIDI synth; Create a MIDI synthesizer network for this project.
(bse-project-create-song project name) bse_project_create_song (project, name);: BseProject* project; The project const gchar* name; Song name
RETURNS:: BseSong* song; The new song; Create a song for this project.
(bse-project-deactivate project) bse_project_deactivate (project);: BseProject* project; The project; Deactivate the project, automatically stop play; back.
(bse-project-find-item project uname-path) bse_project_find_item (project, uname_path);: BseProject* project; project const gchar* uname_path; uname-path
RETURNS:: BseItem* item;; Find an item within a project, given its uname; path.
(bse-project-get-data-pocket project name) bse_project_get_data_pocket (project, name);: BseProject* project; The project const gchar* name; Name of the data; pocket
RETURNS:: BseDataPocket* data_pocket; The data pocket; Retrieve a specifically named data pocket for this; project
(bse-project-get-midi-notifier project) bse_project_get_midi_notifier (project);: BseProject* project; Project
RETURNS:: BseMidiNotifier* midi_notifier;; Retrieve the project's midi notifier object.
(bse-project-get-state project) bse_project_get_state (project);: BseProject* project; The project
RETURNS:: BseProjectState state; Project playback/ac; tivation state; Retrieve the current project state.
(bse-project-get-supers project) bse_project_get_supers (project);: BseProject* project; project
RETURNS:: BseItemSeq* super_list;; Retrieve all supers of this project.
(bse-project-get-wave-repo project) bse_project_get_wave_repo (project);: BseProject* project; The project
RETURNS:: BseWaveRepo* wrepo; The project's unique; wave repo; Ensure the project has a wave repository
(bse-project-inject-midi-control project midi-channel
midi-control control-value) bse_project_inject_midi_control (project, midi_channel,
midi_control, control_value);: BseProject* project; project SfiInt midi_channel; midi-channel SfiInt midi_control; midi-control SfiReal control_value; control-value; Inject a MIDI control event into the project's MIDI; receiver.
(bse-project-is-active project) bse_project_is_active (project);: BseProject* project; The project
RETURNS:: SfiBool is_active; Whether the project is; currently producing sound; Check whether a project is active
(bse-project-is-dirty project) bse_project_is_dirty (project);: BseProject* project; The project
RETURNS:: SfiBool dirty;; Check whether a project is dirty (needs saving).
(bse-project-is-playing project) bse_project_is_playing (project);: BseProject* project; The project
RETURNS:: SfiBool is_playing; Whether the project is; currently playing songs or synths; Check whether a project is currently playing
(bse-project-list-uname-paths project item-type) bse_project_list_uname_paths (project, item_type);: BseProject* project; project const gchar* item_type; item-type
RETURNS:: BseStringSeq* uname_paths;; List uname paths for all items of a specified type; within this project. By their uname paths, items are uniquely; identifyable within a project.
(bse-project-match-items-by-uname project item-type uname) bse_project_match_items_by_uname (project, item_type,
uname);: BseProject* project; project const gchar* item_type; item-type const gchar* uname; uname
RETURNS:: BseItemSeq* item_list;; Retrieve all items of a specific type within a; project with matching uname
(bse-project-play project) bse_project_play (project);: BseProject* project; The project
RETURNS:: BseErrorType error;; Activate a project and start project playback (and; already playing project is first halted).
(bse-project-redo project) bse_project_redo (project);: BseProject* project; The project; Redo a previously undone operaiton in a project
(bse-project-redo-depth project) bse_project_redo_depth (project);: BseProject* project; The project
RETURNS:: SfiInt redo_depth; Number of times redo; can be called on the project; Check whether a project can perform redo steps
(bse-project-remove-snet project snet) bse_project_remove_snet (project, snet);: BseProject* project; The project BseSNet* snet; Synthesizer Network; Remove an existing synthesizer network from this; project.
(bse-project-start-playback project) bse_project_start_playback (project);: BseProject* project; The project; Start playback in an activated project.
(bse-project-stop project) bse_project_stop (project);: BseProject* project; The project; Stop project playback and deactivate project.
(bse-project-stop-playback project) bse_project_stop_playback (project);: BseProject* project; The project; Stop project playback.
(bse-project-undo project) bse_project_undo (project);: BseProject* project; The project; Undo a previous operation in a project
(bse-project-undo-depth project) bse_project_undo_depth (project);: BseProject* project; The project
RETURNS:: SfiInt undo_depth; Number of times undo; can be called on the project; Check whether a project can perform undo steps
(bse-snet-can-create-source snet module-type) bse_snet_can_create_source (snet, module_type);: BseSNet* snet; Synth Net const gchar* module_type; Module Type
RETURNS:: BseErrorType error;; Check whether inserting a new module into a synthe; sis network is possible
(bse-snet-create-source snet module-type) bse_snet_create_source (snet, module_type);: BseSNet* snet; Synth Net const gchar* module_type; Module Type
RETURNS:: BseSource* module;; Insert a new module into a synthesis network
(bse-snet-remove-source snet module) bse_snet_remove_source (snet, module);: BseSNet* snet; Synth Net
BseSource* module; Module
RETURNS:: BseErrorType error;; Remove an existing module from its synthesis net; work
(bse-snet-supports-user-synths snet) bse_snet_supports_user_synths (snet);: BseSNet* snet; Synth Net
RETURNS:: SfiBool user_synth;; Check whether users may edit synthesis modules of; this network
(bse-server-can-load server file-name) bse_server_can_load (server, file_name);: BseServer* server; Server const gchar* file_name; The file to find a; loader for
RETURNS:: SfiBool can_load;; Check whether a loader can be found for a wave file
(bse-server-construct-note server semitone octave
fine-tune)
bse_server_construct_note (server, semitone, octave,
fine_tune);: BseServer* server; Server SfiInt semitone; semitone SfiInt octave; octave SfiInt fine_tune; Fine; Tune
RETURNS:: BseNoteDescription* note_description;; Describe a note, given its semitone, octave and; fine tune.
(bse-server-describe-note server note fine-tune) bse_server_describe_note (server, note, fine_tune);: BseServer* server; Server SfiInt note; Note SfiInt fine_tune; Fine; Tune
RETURNS:: BseNoteDescription* note_description;; Describe a note, providing information about its; octave, semitone, frequency, etc.
(bse-server-get-custom-effect-dir server) bse_server_get_custom_effect_dir (server);: BseServer* server; Server
RETURNS:: const gchar* directory;; Retrieve user specific effects directory.
(bse-server-get-custom-instrument-dir server) bse_server_get_custom_instrument_dir (server);: BseServer* server; Server
RETURNS:: const gchar* directory;; Retrieve user specific instruments directory.
(bse-server-get-demo-path server) bse_server_get_demo_path (server);: BseServer* server; Server
RETURNS:: const gchar* path;; Retrieve demo search path.
(bse-server-get-effect-path server) bse_server_get_effect_path (server);: BseServer* server; Server
RETURNS:: const gchar* path;; Retrieve effect search path.
(bse-server-get-instrument-path server) bse_server_get_instrument_path (server);: BseServer* server; Server
RETURNS:: const gchar* path;; Retrieve instrument search path.
(bse-server-get-ladspa-path server) bse_server_get_ladspa_path (server);: BseServer* server; Server
RETURNS:: const gchar* path;; Retrieve ladspa search path.
(bse-server-get-mp3-version server) bse_server_get_mp3_version (server);: BseServer* server; Server
RETURNS:: const gchar* version;; Retrieve BSE MP3 handler version.
(bse-server-get-plugin-path server) bse_server_get_plugin_path (server);: BseServer* server; Server
RETURNS:: const gchar* path;; Retrieve plugin search path.
(bse-server-get-sample-path server) bse_server_get_sample_path (server);: BseServer* server; Server
RETURNS:: const gchar* path;; Retrieve sample search path.
(bse-server-get-script-path server) bse_server_get_script_path (server);: BseServer* server; Server
RETURNS:: const gchar* path;; Retrieve script search path.
(bse-server-get-version server) bse_server_get_version (server);: BseServer* server; Server
RETURNS:: const gchar* version;; Retrieve BSE version.
(bse-server-n-scripts server) bse_server_n_scripts (server);: BseServer* server; Server
RETURNS:: SfiInt n_connections; Number of Connec; tions; Return the number of scripts currently running on; this server.
(bse-server-note-from-freq server freq) bse_server_note_from_freq (server, freq);: BseServer* server; Server SfiReal freq; Frequen; cy
RETURNS:: BseNoteDescription* note_description;; Describe a note, given its frequency.
(bse-server-note-from-string server name) bse_server_note_from_string (server, name);: BseServer* server; Server const gchar* name; Name
RETURNS:: BseNoteDescription* note_description;; Describe a note, given its name and octave offset.
(bse-server-preferences-locked server) bse_server_preferences_locked (server);: BseServer* server; Server
RETURNS:: SfiBool locked;; Returns whether the bse-preferences property is; currently locked against modifications or not.
(bse-server-register-core-plugins server) bse_server_register_core_plugins (server);: BseServer* server; Server; Register core plugins.
(bse-server-register-ladspa-plugins server) bse_server_register_ladspa_plugins (server);: BseServer* server; Server; Register LADSPA (Linux Audio Developer's Simple; Plugin API) plugins.
(bse-server-register-scripts server) bse_server_register_scripts (server);: BseServer* server; Server; Register external scripts.
(bse-server-save-preferences server) bse_server_save_preferences (server);: BseServer* server; Server; Request the bse-preferences property to be saved; into BSE's configuration file.
(bse-server-use-new-project server name) bse_server_use_new_project (server, name);: BseServer* server; Server const gchar* name; Project Name
RETURNS:: BseProject* project;; Create a new project, owned by the caller (name is; modified to be unique if necessary)
(bse-song-create-bus song) bse_song_create_bus (song);: BseSong* song; song
RETURNS:: BseBus* bus;; Create a new mixer bus for a Song.
(bse-song-create-part song) bse_song_create_part (song);: BseSong* song; song
RETURNS:: BsePart* part;; Create a new Part in a Song.
(bse-song-create-track song) bse_song_create_track (song);: BseSong* song; Song
RETURNS:: BseTrack* track;; Create a new Track for a Song.
(bse-song-ensure-master-bus song) bse_song_ensure_master_bus (song);: BseSong* song; song
RETURNS:: BseBus* bus;; Retrieve master output bus of a song, will create; one if it doesn't exist.
(bse-song-ensure-track-links song) bse_song_ensure_track_links (song);: BseSong* song; song; Ensure that each part in a song is inserted into at; least one track.
(bse-song-find-any-track-for-part song part) bse_song_find_any_track_for_part (song, part);: BseSong* song; Song
BsePart* part; Part
RETURNS:: BseTrack* track;; Find the first track that contains part, suitable; to check for orphan parts.
(bse-song-find-track-for-part song part) bse_song_find_track_for_part (song, part);: BseSong* song; Song
BsePart* part; Part
RETURNS:: BseTrack* track;; Find a track suitable for playing notes of a given; part.
(bse-song-get-master-bus song) bse_song_get_master_bus (song);: BseSong* song; song
RETURNS:: BseBus* bus;; Retrieve master output bus of a song if it exists.
(bse-song-get-timing song tick) bse_song_get_timing (song, tick);: BseSong* song; Song
SfiInt tick; Tick to retrieve timing; info about
RETURNS:: BseSongTiming* timing; Song Timing; Retrieve song timing information at a specific; tick.
(bse-song-remove-bus song bus) bse_song_remove_bus (song, bus);: BseSong* song; song
BseBus* bus; bus; Delete a mixer bus from a Song.
(bse-song-remove-part song part) bse_song_remove_part (song, part);: BseSong* song; Song
BsePart* part; Part; Delete a Part from a Song.
(bse-song-remove-track song track) bse_song_remove_track (song, track);: BseSong* song; Song
BseTrack* track; Track; Delete a Track from a Song.
(bse-song-synthesize-note song track duration note
fine-tune velocity)
bse_song_synthesize_note (song, track, duration, note,
fine_tune, velocity);: BseSong* song; Song
BseTrack* track; Track
SfiInt duration; Tick Duration SfiInt note; Note
SfiInt fine_tune; Fine tune in cents per; semitone
SfiReal velocity; Velocity; Synthesize a note on a song of an active project.
(bse-source-clear-inputs module) bse_source_clear_inputs (module);: BseSource* module; Module; Disconnect all module inputs.
(bse-source-clear-outputs module) bse_source_clear_outputs (module);: BseSource* module; Module; Disconnect all module outputs.
(bse-source-get-automation-channel source property-name) bse_source_get_automation_channel (source, property_name);: BseSource* source; source const gchar* property_name; Item property name
RETURNS:: SfiInt midi_channel;; Get MIDI channel from an automation property.
(bse-source-get-automation-control source property-name) bse_source_get_automation_control (source, property_name);: BseSource* source; source const gchar* property_name; Item proper; ty name
RETURNS:: BseMidiControlType control_type;; Get control type from an automation property.
(bse-source-has-output module ochannel) bse_source_has_output (module, ochannel);: BseSource* module; module SfiInt ochannel; ochannel
RETURNS:: SfiBool has_outputs;; Check whether a module's output channel is connect; ed.
(bse-source-has-outputs module) bse_source_has_outputs (module);: BseSource* module; Module
RETURNS:: SfiBool has_outputs;; Check whether a module has output channel connec; tions.
(bse-source-ichannel-blurb module input-channel) bse_source_ichannel_blurb (module, input_channel);: BseSource* module; Module SfiInt input_channel; Input Channel
RETURNS:: const gchar* channel_blurb;; Get input channel description.
(bse-source-ichannel-get-n-joints module input-channel) bse_source_ichannel_get_n_joints (module, input_channel);: BseSource* module; Module SfiInt input_channel; Input Channel
RETURNS:: SfiInt n_joints;; Retrieve the number of inputs connected to an input; channel.
(bse-source-ichannel-get-ochannel module input-channel
input-joint)
bse_source_ichannel_get_ochannel (module, input_channel,
input_joint);: BseSource* module; Module SfiInt input_channel; Input Channel SfiInt input_joint; Input Joint
RETURNS:: SfiInt ochannel;; Retrieve output channel of the module connected to; a specific joint of an input channel.
(bse-source-ichannel-get-osource module input-channel
input-joint)
bse_source_ichannel_get_osource (module, input_channel,
input_joint);: BseSource* module; Module SfiInt input_channel; Input Channel SfiInt input_joint; Input Joint
RETURNS:: BseSource* osource;; Retrieve output module connected to a specific; joint of an input channel
(bse-source-ichannel-ident module input-channel) bse_source_ichannel_ident (module, input_channel);: BseSource* module; Module SfiInt input_channel; Input Channel
RETURNS:: const gchar* channel_ident;; Get canonical input channel name.
(bse-source-ichannel-label module input-channel) bse_source_ichannel_label (module, input_channel);: BseSource* module; Module SfiInt input_channel; Input Channel
RETURNS:: const gchar* channel_label;; Get input channel name.
(bse-source-is-joint-ichannel module input-channel) bse_source_is_joint_ichannel (module, input_channel);: BseSource* module; Module const gchar* input_channel; Input Channel
RETURNS:: SfiBool is_jchannel;; Check if an input channel is a joint (multi-con; nect) channel.
(bse-source-is-joint-ichannel-by-id module input-channel) bse_source_is_joint_ichannel_by_id (module,
input_channel);: BseSource* module; Module SfiInt input_channel; Input Channel
RETURNS:: SfiBool is_jchannel;; Check if an input channel is a joint (multi-con; nect) channel.
(bse-source-is-prepared source) bse_source_is_prepared (source);: BseSource* source; source
RETURNS:: SfiBool is_prepared;; Check whether a source is prepared for synthesis; processing.
(bse-source-n-ichannels module) bse_source_n_ichannels (module);: BseSource* module; Module
RETURNS:: SfiInt n_channels;; Get the number of input channels of a module.
(bse-source-n-ochannels module) bse_source_n_ochannels (module);: BseSource* module; Module
RETURNS:: SfiInt n_channels;; Get the number of output channels of a module.
(bse-source-ochannel-blurb module output-channel) bse_source_ochannel_blurb (module, output_channel);: BseSource* module; Module SfiInt output_channel; Input Channel
RETURNS:: const gchar* channel_blurb;; Get output channel description.
(bse-source-ochannel-ident module output-channel) bse_source_ochannel_ident (module, output_channel);: BseSource* module; Module SfiInt output_channel; Input Channel
RETURNS:: const gchar* channel_ident;; Get canonical output channel name.
(bse-source-ochannel-label module output-channel) bse_source_ochannel_label (module, output_channel);: BseSource* module; Module SfiInt output_channel; Input Channel
RETURNS:: const gchar* channel_label;; Get output channel name.
(bse-source-set-automation source property-name
midi-channel control-type)
bse_source_set_automation (source, property_name,
midi_channel, control_type);: BseSource* source; source const gchar* property_name; Item proper; ty name
SfiInt midi_channel; The MIDI; Channel from which automation events should be received, 0 desig; nates the default MIDI channel
BseMidiControlType control_type; The type of; control events used for automation
RETURNS:: BseErrorType error;; Setup automation parameters for a property.
(bse-source-set-input imodule input-channel omodule
output-channel)
bse_source_set_input (imodule, input_channel, omodule,
output_channel);: BseSource* imodule; Input Module const gchar* input_channel; Input Channel BseSource* omodule; Output Module const gchar* output_channel; Output Channel
RETURNS:: BseErrorType error;; Connect a module input to another module's output.
(bse-source-set-input-by-id imodule input-channel omodule
output-channel)
bse_source_set_input_by_id (imodule, input_channel,
omodule, output_channel);: BseSource* imodule; Input Module SfiInt input_channel; Input Channel BseSource* omodule; Output Module SfiInt output_channel; Output Channel
RETURNS:: BseErrorType error;; Connect a module input to another module's output.
(bse-source-set-pos module x-pos y-pos) bse_source_set_pos (module, x_pos, y_pos);: BseSource* module; Module
SfiReal x_pos; X Position
SfiReal y_pos; Y Position; Set the x and y position of a module. In contrast; to setting the position through ordinary object property setters,; this function will not update the module position if the passed; in arguments are sufficiently equal to the values already set on; the object. As such, it does not record an extra undo step for; setting properties to values they already have and if necessary; turns setting of x and y positions into an atomic undo operation.
(bse-source-unset-input module input-channel omodule
output-channel)
bse_source_unset_input (module, input_channel, omodule,
output_channel);: BseSource* module; Module const gchar* input_channel; Input Channel BseSource* omodule; Output Module const gchar* output_channel; Output Channel
RETURNS:: BseErrorType error;; Disconnect a module input.
(bse-source-unset-input-by-id module input-channel omodule
output-channel)
bse_source_unset_input_by_id (module, input_channel,
omodule, output_channel);: BseSource* module; Module SfiInt input_channel; Input Channel BseSource* omodule; Output Module SfiInt output_channel; Output Channel
RETURNS:: BseErrorType error;; Disconnect a module input.
(bse-track-ensure-output track) bse_track_ensure_output (track);: BseTrack* track; Track
RETURNS:: BseErrorType error;; Ensure the track has an output connection to a bus.
(bse-track-get-last-tick track) bse_track_get_last_tick (track);: BseTrack* track; Track
RETURNS:: SfiInt last_tick;; Retrieve the last tick for this track.
(bse-track-get-output-source track) bse_track_get_output_source (track);: BseTrack* track; track
RETURNS:: BseSource* source;; Get the output module for this track. The output of; this module is the merged result from all polyphonic voices and; has all track specific alterations applied.
(bse-track-get-part track tick) bse_track_get_part (track, tick);: BseTrack* track; Track
SfiInt tick; Tick
RETURNS:: BsePart* part;; Get the part starting at a specific tick position.
(bse-track-get-timing track tick) bse_track_get_timing (track, tick);: BseTrack* track; Track
SfiInt tick; Tick to retrieve timing; info about
RETURNS:: BseSongTiming* timing; Song Timing; Retrieve song timing information at a specific; tick.
(bse-track-insert-part track tick part) bse_track_insert_part (track, tick, part);: BseTrack* track; Track
SfiInt tick; Tick
BsePart* part; Part
RETURNS:: SfiInt id;; Insert a part into a track and retrieve the corre; sponding link id.
(bse-track-list-parts track) bse_track_list_parts (track);: BseTrack* track; Track
RETURNS:: BseTrackPartSeq* part_list;; List parts scheduled in a track, sorted by tick.
(bse-track-list-parts-uniq track) bse_track_list_parts_uniq (track);: BseTrack* track; Track
RETURNS:: BseItemSeq* part_list;; List all parts contained in a track.
(bse-track-remove-link track id) bse_track_remove_link (track, id);: BseTrack* track; Track
SfiInt id; Link ID; Remove a specific part link by ID from a track.
(bse-track-remove-tick track tick) bse_track_remove_tick (track, tick);: BseTrack* track; Track
SfiInt tick; Tick; Remove a part at specified tick from a track.
(bse-wave-chunk-get-mix-freq wave chunk-index) bse_wave_chunk_get_mix_freq (wave, chunk_index);: BseWave* wave; Wave
SfiInt chunk_index; Index of chunk
RETURNS:: SfiReal mix_freq;; Retrieve mixing frequency of a wave chunk.
(bse-wave-chunk-get-osc-freq wave chunk-index) bse_wave_chunk_get_osc_freq (wave, chunk_index);: BseWave* wave; Wave
SfiInt chunk_index; Index of chunk
RETURNS:: SfiReal osc_freq;; Retrieve oscillating frequency of a wave chunk.
(bse-wave-load-wave wave file-name wave-name) bse_wave_load_wave (wave, file_name, wave_name);: BseWave* wave; Wave object to store; loaded contents
const gchar* file_name; The wave file to read; wave chunks from
const gchar* wave_name; The name of the wave; to read wave chunks from
RETURNS:: BseErrorType error; BSE error type; Load sample chunks from a wave file
(bse-wave-n-wave-chunks wave) bse_wave_n_wave_chunks (wave);: BseWave* wave; Wave
RETURNS:: SfiInt n_chunks;; Get the number of wave chunks of a wave
(bse-wave-use-editable wave chunk-index) bse_wave_use_editable (wave, chunk_index);: BseWave* wave; Wave SfiInt chunk_index; Index of chunk; to edit
RETURNS:: BseEditableSample* esample; Editable sam; ple; Retrieve an editable sample object for a wave; chunk.
(bse-wave-osc-request-pcm-position wosc) bse_wave_osc_request_pcm_position (wosc);: BseWaveOsc* wosc; Wave Oscilator; Request emission of the ::notify_pcm_position sig; nal.
(bse-wave-osc-set-from-editable-sample wosc esample) bse_wave_osc_set_from_editable_sample (wosc, esample);: BseWaveOsc* wosc; Wave Oscilator BseEditableSample* esample; Editable Sample; Set wave to play from editable sample, bypassing; undo and storage mechanisms.
(bse-wave-repo-load-file wave-repo file-name) bse_wave_repo_load_file (wave_repo, file_name);: BseWaveRepo* wave_repo; Wave Repo const gchar* file_name; The file to import; waves from
RETURNS:: BseErrorType error;; Load wave from file
(bse-wave-repo-remove-wave wave-repo wave) bse_wave_repo_remove_wave (wave_repo, wave);: BseWaveRepo* wave_repo; Wave Repo BseWave* wave; Wave; Remove a wave from repository
(bse-category-from-id category-id) bse_category_from_id (category_id);: SfiInt category_id; Category ID
RETURNS:: BseCategory* category;; Find a BSE category from it's unique ID.
(bse-categories-match pattern) bse_categories_match (pattern);: const gchar* pattern; Pattern to match; category, supports '*' and '?' wildcards.
RETURNS:: BseCategorySeq* categories;; List BSE categories according to a pattern match.
(bse-categories-match-method pattern type) bse_categories_match_method (pattern, type);: const gchar* pattern; Pattern to match; category, supports '*' and '?' wildcards.
const gchar* type; Object base type; for methods to conform to.
RETURNS:: BseCategorySeq* categories;; List BSE categories according to a pattern, of type; procedure and applying to a certain object type.
(bse-categories-match-typed pattern type) bse_categories_match_typed (pattern, type);: const gchar* pattern; Pattern to match; category, supports '*' and '?' wildcards.
const gchar* type; Base type for cat; egories to conform to.
RETURNS:: BseCategorySeq* categories;; List BSE categories according to a pattern and type; match.
(bse-error-blurb error)
bse_error_blurb (error);: BseErrorType error; Error
RETURNS:: const gchar* blurb;; Retrieve the description of an error value
(bse-error-name error)
bse_error_name (error);: BseErrorType error; Error
RETURNS:: const gchar* name;; Retrieve the name of an error value
(bse-note-from-freq frequency) bse_note_from_freq (frequency);: SfiReal frequency; Frequency
RETURNS:: SfiInt note;; Retrieve the note of a certain frequency.
(bse-note-to-freq note fine-tune) bse_note_to_freq (note, fine_tune);: SfiInt note; Note
SfiInt fine_tune; Fine Tune
RETURNS:: SfiReal frequency;; Retrieve the frequency of a certain note.
(bse-proxy-check item type-name) bse_proxy_check (item, type_name);: BseItem* item; The Item
const gchar* type_name; Type Name
RETURNS:: SfiBool is_a;; Check whether a proxy has a certain type.
(bse-sample-file-info file-name) bse_sample_file_info (file_name);: const gchar* file_name; The file; to load info from
RETURNS:: BseSampleFileInfo* sample_file_info;; Load sample file info from file
(bse-script-add-action action name blurb) bse_script_add_action (action, name, blurb);: const gchar* action; Action const gchar* name; Name
const gchar* blurb; Blurb; Install a user action for script control.
(bse-script-janitor )
bse_script_janitor ();: RETURNS:
BseJanitor* janitor;

Retrieve the connection dependant janitor object.; (bse-script-send-message domain msg-type title primary; secondary details config-check) bse_script_send_message (domain, msg_type, title, primary,; secondary, details, config_check);
const gchar* domain; domain const gchar* msg_type; msg-type const gchar* title; title const gchar* primary; primary const gchar* secondary; secondary const gchar* details; details const gchar* config_check; config-check

Send a message from a script.; (bse-script-progress progress) bse_script_progress (progress);
SfiReal progress; Progress

Indicate progress (from 0.0 to 1.0 or -1 for un

known amount).; (bse-script-quit )
bse_script_quit ();
Exit a script succesfully (server side).; (bse-script-remove-action action) bse_script_remove_action (action);
const gchar* action; Action

Remove a previously installed user action from

script control.; (bse-script-set-status message) bse_script_set_status (message);
const gchar* message; Message

Alter script status message.; (bse-wave-osc-mass-seek-perc wosc-seq pos-perc) bse_wave_osc_mass_seek_perc (wosc_seq, pos_perc);
BseItemSeq* wosc_seq; Wave Oscilators SfiReal pos_perc; pos-perc

Seek a list of wave oscillators to a pcm position

given in percentage. The oscillators will seek to the given posi

tion syncronously.; (bse-string-extract-number string format aux-base dflt) bse_string_extract_number (string, format, aux_base,; dflt);
const gchar* string; string const gchar* format; format SfiReal aux_base; aux-base SfiReal dflt; dflt; RETURNS:
SfiReal number;

Retrieve numbers from a string.; (bse-type-authors type)
bse_type_authors (type);
const gchar* type; type; RETURNS:
const gchar* string;

Retrieve the authors who implemented a specific

type.; (bse-type-blurb type)
bse_type_blurb (type);
const gchar* type; type; RETURNS:
const gchar* string;

Retrieve the description of a specific type.; (bse-type-license type)
bse_type_license (type);
const gchar* type; type; RETURNS:
const gchar* string;

Retrieve the license of a type impementation.; (bse-type-options type)
bse_type_options (type);
const gchar* type; type; RETURNS:
const gchar* string;

Retrieve the options of a specific type.

docs.sk

comprehensive documentation repository

See also

bse-procedures(3)

NAME

SYNOPSIS

DESCRIPTION

SEE ALSO