bse-procs3

Usage

Overview

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