bse-procs(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 sequential 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 uname

Find an immediate child of a container from its uname (the uname is the name of the item, unique between all immediate 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 entries 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 other 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 entry. 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 Sample
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 number of (min, max) pairs to collect
RETURNS:
SfiFBlock*	sample_block;	Block of samples

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 channels

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 Frequency

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 Sample
SfiInt	voffset;	Value offset
RETURNS:
SfiFBlock*	sample_block;	Block of samples

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 corresponding 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 sequence 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 implementation.

(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 corresponding 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 corresponding 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 janitor.

(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 Duration
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 channel 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 Duration
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 Duration
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 possible 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 possible 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 references 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 super 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 playback.

(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/activation 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 synthesis 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 network

(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 Connections

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;	Frequency
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 property 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 connected.

(bse-source-has-outputs module)

bse_source_has_outputs (module);

BseSource*	module;	Module
RETURNS:
SfiBool	has_outputs;

Check whether a module has output channel connections.

(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-connect) 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-connect) 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 property name
SfiInt	midi_channel;	The MIDI Channel from which automation events should be received, 0 designates 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.