BSE Interface Reference

/opt/src/beast/docs/psource/bse-interface.scad

SYNOPSIS

struct  BseCategory;
struct  BseCategorySeq;
struct  BseDot;
struct  BseDotSeq;
struct  BseGConfig;
struct  BseIcon;
struct  BseIntSeq;
struct  BseItemSeq;
struct  BseMessage;
struct  BseMidiChannelEvent;
struct  BseNoteDescription;
struct  BseNoteSeq;
struct  BseNoteSequence;
struct  BsePartControl;
struct  BsePartControlSeq;
struct  BsePartLink;
struct  BsePartLinkSeq;
struct  BsePartNote;
struct  BsePartNoteSeq;
struct  BseProbe;
struct  BseProbeFeatures;
struct  BseProbeRequest;
struct  BseProbeRequestSeq;
struct  BseProbeSeq;
struct  BsePropertyCandidates;
struct  BseSampleFileInfo;
struct  BseSongTiming;
struct  BseStringSeq;
struct  BseThreadInfo;
struct  BseThreadInfoSeq;
struct  BseThreadTotals;
struct  BseTrackPart;
struct  BseTrackPartSeq;
struct  BseTypeSeq;
   
BseErrorType  bse_bus_connect_bus  (sbus, bus);
BseErrorType  bse_bus_connect_track  (sbus, track);
BseErrorType  bse_bus_disconnect_bus  (sbus, bus);
BseErrorType  bse_bus_disconnect_track  (sbus, track);
BseErrorType  bse_bus_ensure_output  (bus);
BseCategorySeq*  bse_categories_match  (pattern);
BseCategorySeq*  bse_categories_match_method  (pattern, type);
BseCategorySeq*  bse_categories_match_typed  (pattern, type);
BseCategory*  bse_category_from_id  (category_id);
BseItem*  bse_container_get_item  (container, item_type, seq_id);
BseItemSeq*  bse_container_list_children  (container);
BseItem*  bse_container_lookup_item  (container, uname);
SfiInt  bse_data_pocket_create_entry  (data_pocket);
BseErrorType  bse_data_pocket_delete_entry  (data_pocket, entry_id);
SfiReal  bse_data_pocket_get_float  (data_pocket, entry_id, name);
SfiInt  bse_data_pocket_get_int  (data_pocket, entry_id, name);
SfiInt  bse_data_pocket_get_n_entries  (data_pocket);
SfiInt  bse_data_pocket_get_nth_entry_id  (data_pocket, entry_index);
BseItem*  bse_data_pocket_get_object  (data_pocket, entry_id, name);
const gchar*  bse_data_pocket_get_string  (data_pocket, entry_id, name);
BseErrorType  bse_data_pocket_set_float  (data_pocket, entry_id, name, number);
BseErrorType  bse_data_pocket_set_int  (data_pocket, entry_id, name, number);
BseErrorType  bse_data_pocket_set_object  (data_pocket, entry_id, name, item);
BseErrorType  bse_data_pocket_set_string  (data_pocket, entry_id, name, string);
void  bse_editable_sample_close  (esample);
SfiFBlock*  bse_editable_sample_collect_stats  (esample, voffset, offset_scale, block_size, stepping, max_pairs);
SfiInt  bse_editable_sample_get_length  (esample);
SfiInt  bse_editable_sample_get_n_channels  (esample);
SfiReal  bse_editable_sample_get_osc_freq  (esample);
BseErrorType  bse_editable_sample_open  (esample);
SfiFBlock*  bse_editable_sample_read_samples  (esample, voffset);
const gchar*  bse_error_blurb  (error);
const gchar*  bse_error_name  (error);
void  bse_item_add_parasite  (item, path, parasite);
SfiBool  bse_item_check_is_a  (item, type_name);
void  bse_item_clear_undo  (item);
BseItem*  bse_item_common_ancestor  (item, item2);
SfiBool  bse_item_editable_property  (item, property_name);
SfiFBlock*  bse_item_fixme_get_parasite  (item, name);
void  bse_item_fixme_set_parasite  (item, name, parasite);
BseIcon*  bse_item_get_icon  (item);
const gchar*  bse_item_get_name  (item);
const gchar*  bse_item_get_name_or_type  (item);
SfiRec*  bse_item_get_parasite  (item, path);
BseItem*  bse_item_get_parent  (item);
BseItem*  bse_item_get_project  (item);
BsePropertyCandidates*  bse_item_get_property_candidates  (item, property_name);
SfiInt  bse_item_get_seqid  (item);
const gchar*  bse_item_get_type  (item);
const gchar*  bse_item_get_type_authors  (item);
const gchar*  bse_item_get_type_blurb  (item);
const gchar*  bse_item_get_type_license  (item);
const gchar*  bse_item_get_type_name  (item);
const gchar*  bse_item_get_uname_path  (item);
void  bse_item_group_undo  (item, name);
SfiBool  bse_item_internal  (item);
BseStringSeq*  bse_item_list_parasites  (item, path);
void  bse_item_redo  (item);
SfiInt  bse_item_redo_depth  (item);
void  bse_item_set_name  (item, name);
void  bse_item_set_parasite  (item, path, parasite);
void  bse_item_undo  (item);
SfiInt  bse_item_undo_depth  (item);
void  bse_item_ungroup_undo  (item);
void  bse_item_unuse  (item);
BseItem*  bse_item_use  (item);
const gchar*  bse_janitor_get_action  (janitor, nth_action);
const gchar*  bse_janitor_get_action_blurb  (janitor, nth_action);
const gchar*  bse_janitor_get_action_name  (janitor, nth_action);
const gchar*  bse_janitor_get_proc_name  (janitor);
const gchar*  bse_janitor_get_script_name  (janitor);
void  bse_janitor_kill  (janitor);
SfiInt  bse_janitor_n_actions  (janitor);
void  bse_janitor_trigger_action  (janitor, action);
SfiInt  bse_midi_notifier_current_time  (midi_notifier);
BseNoteDescription*  bse_note_construct  (musical_tuning, semitone, octave, fine_tune);
BseNoteDescription*  bse_note_describe  (musical_tuning, note, fine_tune);
BseNoteDescription*  bse_note_describe_from_freq  (musical_tuning, freq);
SfiInt  bse_note_from_freq  (musical_tuning, frequency);
BseNoteDescription*  bse_note_from_string  (musical_tuning, name);
SfiReal  bse_note_to_freq  (musical_tuning, note, fine_tune);
BseErrorType  bse_part_change_control  (part, id, tick, control_type, value);
BseErrorType  bse_part_change_note  (part, id, tick, duration, note, fine_tune, velocity);
BsePartNoteSeq*  bse_part_check_overlap  (part, tick, duration, note);
BseErrorType  bse_part_delete_event  (part, id);
void  bse_part_deselect_controls  (part, tick, duration, control_type);
void  bse_part_deselect_event  (part, id);
void  bse_part_deselect_notes  (part, tick, duration, min_note, max_note);
BsePartControlSeq*  bse_part_get_channel_controls  (part, channel, tick, duration, control_type);
BsePartControlSeq*  bse_part_get_controls  (part, tick, control_type);
SfiInt  bse_part_get_max_note  (part);
SfiInt  bse_part_get_min_note  (part);
BsePartNoteSeq*  bse_part_get_notes  (part, tick, note);
BseSongTiming*  bse_part_get_timing  (part, tick);
SfiInt  bse_part_insert_control  (part, tick, control_type, value);
SfiInt  bse_part_insert_note  (part, channel, tick, duration, note, fine_tune, velocity);
SfiInt  bse_part_insert_note_auto  (part, tick, duration, note, fine_tune, velocity);
SfiBool  bse_part_is_event_selected  (part, id);
BsePartControlSeq*  bse_part_list_controls  (part, tick, duration, control_type);
BsePartLinkSeq*  bse_part_list_links  (part);
BsePartNoteSeq*  bse_part_list_notes_crossing  (part, tick, duration);
BsePartNoteSeq*  bse_part_list_notes_within  (part, channel, tick, duration);
BsePartControlSeq*  bse_part_list_selected_controls  (part, control_type);
BsePartNoteSeq*  bse_part_list_selected_notes  (part);
void  bse_part_queue_controls  (part, tick, duration);
void  bse_part_queue_notes  (part, tick, duration, min_note, max_note);
void  bse_part_select_controls  (part, tick, duration, control_type);
void  bse_part_select_controls_exclusive  (part, tick, duration, control_type);
void  bse_part_select_event  (part, id);
void  bse_part_select_notes  (part, tick, duration, min_note, max_note);
void  bse_part_select_notes_exclusive  (part, tick, duration, min_note, max_note);
BseErrorType  bse_project_activate  (project);
void  bse_project_auto_deactivate  (project, msec_delay);
SfiBool  bse_project_can_play  (project);
void  bse_project_change_name  (project, name);
void  bse_project_clean_dirty  (project);
void  bse_project_clear_undo  (project);
BseCSynth*  bse_project_create_csynth  (project, name);
BseMidiSynth*  bse_project_create_midi_synth  (project, name);
BseSong*  bse_project_create_song  (project, name);
void  bse_project_deactivate  (project);
BseItem*  bse_project_find_item  (project, uname_path);
BseDataPocket*  bse_project_get_data_pocket  (project, name);
BseMidiNotifier*  bse_project_get_midi_notifier  (project);
BseProjectState  bse_project_get_state  (project);
BseItemSeq*  bse_project_get_supers  (project);
BseWaveRepo*  bse_project_get_wave_repo  (project);
BseErrorType  bse_project_import_midi_file  (project, file_name);
void  bse_project_inject_midi_control  (project, midi_channel, midi_control, control_value);
SfiBool  bse_project_is_active  (project);
SfiBool  bse_project_is_dirty  (project);
SfiBool  bse_project_is_playing  (project);
BseStringSeq*  bse_project_list_uname_paths  (project, item_type);
BseItemSeq*  bse_project_match_items_by_uname  (project, item_type, uname);
BseErrorType  bse_project_play  (project);
void  bse_project_redo  (project);
SfiInt  bse_project_redo_depth  (project);
void  bse_project_remove_snet  (project, snet);
BseErrorType  bse_project_restore_from_file  (project, file_name);
void  bse_project_start_playback  (project);
void  bse_project_stop  (project);
void  bse_project_stop_playback  (project);
BseErrorType  bse_project_store_bse  (project, super, file_name, self_contained);
void  bse_project_undo  (project);
SfiInt  bse_project_undo_depth  (project);
SfiBool  bse_proxy_check  (item, type_name);
BseSampleFileInfo*  bse_sample_file_info  (file_name);
void  bse_script_add_action  (action, name, blurb);
BseJanitor*  bse_script_janitor  ();
void  bse_script_mixer_splitup_by_track  (song);
void  bse_script_modules2grid  (synth_net);
void  bse_script_part_harmonic_transposer  (part, harmony_sequence, transpose_down_starting_at);
void  bse_script_progress  (progress);
void  bse_script_progressor  (n_iterations, n_wait_spins, update_percentage);
void  bse_script_quit  ();
void  bse_script_record_midi  (part, start_now);
void  bse_script_remove_action  (action);
void  bse_script_send_message  (domain, msg_type, title, primary, secondary, details, config_check);
void  bse_script_set_status  (message);
void  bse_script_song_parts_crop  (song);
void  bse_script_song_parts_duplicate  (song);
SfiBool  bse_server_can_load  (server, file_name);
const gchar*  bse_server_get_custom_effect_dir  (server);
const gchar*  bse_server_get_custom_instrument_dir  (server);
const gchar*  bse_server_get_demo_path  (server);
const gchar*  bse_server_get_effect_path  (server);
const gchar*  bse_server_get_instrument_path  (server);
const gchar*  bse_server_get_ladspa_path  (server);
const gchar*  bse_server_get_mp3_version  (server);
const gchar*  bse_server_get_plugin_path  (server);
const gchar*  bse_server_get_sample_path  (server);
const gchar*  bse_server_get_script_path  (server);
const gchar*  bse_server_get_version  (server);
const gchar*  bse_server_get_vorbis_version  (server);
SfiInt  bse_server_n_scripts  (server);
SfiBool  bse_server_preferences_locked  (server);
void  bse_server_register_core_plugins  (server);
void  bse_server_register_ladspa_plugins  (server);
void  bse_server_register_scripts  (server);
void  bse_server_save_preferences  (server);
void  bse_server_start_recording  (server, wave_file, n_seconds);
BseProject*  bse_server_use_new_project  (server, name);
BseErrorType  bse_snet_can_create_source  (snet, module_type);
BseSource*  bse_snet_create_source  (snet, module_type);
BseErrorType  bse_snet_remove_source  (snet, module);
SfiBool  bse_snet_supports_user_synths  (snet);
BseBus*  bse_song_create_bus  (song);
BsePart*  bse_song_create_part  (song);
BseTrack*  bse_song_create_track  (song);
BseBus*  bse_song_ensure_master_bus  (song);
void  bse_song_ensure_track_links  (song);
BseTrack*  bse_song_find_any_track_for_part  (song, part);
BseTrack*  bse_song_find_track_for_part  (song, part);
BseBus*  bse_song_get_master_bus  (song);
BseSongTiming*  bse_song_get_timing  (song, tick);
void  bse_song_remove_bus  (song, bus);
void  bse_song_remove_part  (song, part);
void  bse_song_remove_track  (song, track);
void  bse_song_synthesize_note  (song, track, duration, note, fine_tune, velocity);
void  bse_source_clear_inputs  (module);
void  bse_source_clear_outputs  (module);
SfiInt  bse_source_get_automation_channel  (source, property_name);
BseMidiControlType  bse_source_get_automation_control  (source, property_name);
SfiBool  bse_source_has_output  (module, ochannel);
SfiBool  bse_source_has_outputs  (module);
const gchar*  bse_source_ichannel_blurb  (module, input_channel);
SfiInt  bse_source_ichannel_get_n_joints  (module, input_channel);
SfiInt  bse_source_ichannel_get_ochannel  (module, input_channel, input_joint);
BseSource*  bse_source_ichannel_get_osource  (module, input_channel, input_joint);
const gchar*  bse_source_ichannel_ident  (module, input_channel);
const gchar*  bse_source_ichannel_label  (module, input_channel);
SfiBool  bse_source_is_joint_ichannel  (module, input_channel);
SfiBool  bse_source_is_joint_ichannel_by_id  (module, input_channel);
SfiBool  bse_source_is_prepared  (source);
SfiInt  bse_source_n_ichannels  (module);
SfiInt  bse_source_n_ochannels  (module);
const gchar*  bse_source_ochannel_blurb  (module, output_channel);
const gchar*  bse_source_ochannel_ident  (module, output_channel);
const gchar*  bse_source_ochannel_label  (module, output_channel);
BseErrorType  bse_source_set_automation  (source, property_name, midi_channel, control_type);
BseErrorType  bse_source_set_input  (imodule, input_channel, omodule, output_channel);
BseErrorType  bse_source_set_input_by_id  (imodule, input_channel, omodule, output_channel);
void  bse_source_set_pos  (module, x_pos, y_pos);
BseErrorType  bse_source_unset_input  (module, input_channel, omodule, output_channel);
BseErrorType  bse_source_unset_input_by_id  (module, input_channel, omodule, output_channel);
SfiReal  bse_string_extract_number  (string, format, aux_base, dflt);
BseErrorType  bse_track_ensure_output  (track);
SfiInt  bse_track_get_last_tick  (track);
BseSource*  bse_track_get_output_source  (track);
BsePart*  bse_track_get_part  (track, tick);
BseSongTiming*  bse_track_get_timing  (track, tick);
SfiInt  bse_track_insert_part  (track, tick, part);
BseTrackPartSeq*  bse_track_list_parts  (track);
BseItemSeq*  bse_track_list_parts_uniq  (track);
void  bse_track_remove_link  (track, id);
void  bse_track_remove_tick  (track, tick);
const gchar*  bse_type_authors  (type);
const gchar*  bse_type_blurb  (type);
const gchar*  bse_type_license  (type);
const gchar*  bse_type_options  (type);
SfiReal  bse_wave_chunk_get_mix_freq  (wave, chunk_index);
SfiReal  bse_wave_chunk_get_osc_freq  (wave, chunk_index);
BseErrorType  bse_wave_load_wave  (wave, file_name, wave_name);
SfiInt  bse_wave_n_wave_chunks  (wave);
void  bse_wave_osc_mass_seek_perc  (wosc_seq, pos_perc);
void  bse_wave_osc_request_pcm_position  (wosc);
void  bse_wave_osc_set_from_editable_sample  (wosc, esample);
BseErrorType  bse_wave_repo_load_file  (wave_repo, file_name);
void  bse_wave_repo_remove_wave  (wave_repo, wave);
BseEditableSample*  bse_wave_use_editable  (wave, chunk_index);

DESCRIPTION

BseCategory (record)

structures/BseCategory
struct BseCategory
{
  SfiInt       category_id;
  const gchar *category;
  SfiInt       mindex;
  SfiInt       lindex;
  const gchar *type;
  BseIcon     *icon;
};

category_id: Category ID (Range: 1 .. 2147483647)
mindex: (Range: -2147483648 .. 2147483647)
lindex: (Range: -2147483648 .. 2147483647)

BseCategorySeq (sequence)

structures/BseCategorySeq
struct BseCategorySeq
{
  guint         n_cats;
  BseCategory **cats;
};

n_cats: Number of elements (C specific)

BseDot (record)

structures/BseDot
struct BseDot
{
  SfiReal x;
  SfiReal y;
};

x: (Range: -1.797693e+308 .. 1.797693e+308)
y: (Range: -1.797693e+308 .. 1.797693e+308)

BseDotSeq (sequence)

structures/BseDotSeq
struct BseDotSeq
{
  guint    n_dots;
  BseDot **dots;
};

n_dots: Number of elements (C specific)

BseGConfig (record)

structures/BseGConfig
struct BseGConfig
{
  SfiInt       synth_latency;
  SfiInt       synth_mixing_freq;
  SfiInt       synth_control_freq;
  SfiBool      invert_sustain;
  const gchar *author_default;
  const gchar *license_default;
  const gchar *sample_path;
  const gchar *effect_path;
  const gchar *instrument_path;
  const gchar *script_path;
  const gchar *plugin_path;
  const gchar *ladspa_path;
};

synth_latency: Processing duration between input and output of a single sample, smaller values increase CPU load (Range: 1 .. 2000)
synth_mixing_freq: Synthesis mixing frequency, common values are: 22050, 44100, 48000 (Range: 8000 .. 192000)
synth_control_freq: Frequency at which control values are evaluated, should be much smaller than Synth Mixing Frequency to reduce CPU load (Range: 1 .. 192000)
invert_sustain: Invert the state of sustain (damper) pedal so on/off meanings are reversed
author_default: Default value for 'Author' fields
license_default: Default value for 'License' fields
sample_path: Search path of directories, seperated by ":", used to find audio samples.
effect_path: Search path of directories, seperated by ":", used to find BSE effect files.
instrument_path: Search path of directories, seperated by ":", used to find BSE instrument files.
script_path: Search path of directories, seperated by ":", used to find BSE scheme scripts.
plugin_path: Search path of directories, seperated by ":", used to find BSE plugins. This path is searched for in addition to the standard BSE plugin location on this system.
ladspa_path: Search path of directories, seperated by ":", used to find LADSPA plugins. This path is searched for in addition to the standard LADSPA location on this system. LADSPA is the Linux Audio Developer's Simple Plugin API, more informations about LADSPA plugins can be found at http://www.ladspa.org/.

BseIcon (record)

structures/BseIcon
struct BseIcon
{
  SfiInt     bytes_per_pixel;
  SfiInt     width;
  SfiInt     height;
  SfiBBlock *pixels;
};
BSE icon representation.
bytes_per_pixel: Bytes Per Pixel (3:RGB, 4:RGBA, 0:NONE) (Range: 3 .. 4)
width: Width in pixels or 0 for no icon (Range: 0 .. 2147483647)
height: Height in pixels or 0 for no icon (Range: 0 .. 2147483647)
pixels: Pixel array of width*height*bytes_per_pixel bytes

BseIntSeq (sequence)

structures/BseIntSeq
struct BseIntSeq
{
  guint   n_ints;
  SfiInt *ints;
};

n_ints: Number of elements (C specific)
ints: (Range: -2147483648 .. 2147483647)

BseItemSeq (sequence)

structures/BseItemSeq
struct BseItemSeq
{
  guint     n_items;
  SfiProxy *items;
};
A list of BSE items or derived types.
n_items: Number of elements (C specific)

BseMessage (record)

structures/BseMessage
struct BseMessage
{
  const gchar *log_domain;
  SfiChoice    type;
  const gchar *ident;
  const gchar *label;
  const gchar *title;
  const gchar *primary;
  const gchar *secondary;
  const gchar *details;
  const gchar *config_check;
  SfiProxy     janitor;
  const gchar *process;
  SfiInt       pid;
};

pid: (Range: -2147483648 .. 2147483647)

BseMidiChannelEvent (record)

structures/BseMidiChannelEvent
struct BseMidiChannelEvent
{
  SfiChoice event_type;
  SfiInt    channel;
  SfiNum    tick_stamp;
  SfiReal   frequency;
  SfiReal   velocity;
  SfiInt    control;
  SfiReal   value;
  SfiInt    program;
  SfiReal   intensity;
  SfiReal   pitch_bend;
  SfiInt    song_pointer;
  SfiInt    song_number;
};

channel: Channel (Range: 0 .. 99)
tick_stamp: Time Stamp
frequency: Frequency (Range: 0.00005 .. 20000)
velocity: Velocity (Range: 0 .. 1)
control: Control Number (Range: 0 .. 1024)
value: Value (Range: -1 .. 1)
program: Program (Range: 0 .. 127)
intensity: Intensity (Range: 0 .. 1)
pitch_bend: Pitch Bend (Range: -1 .. 1)
song_pointer: Song Pointer (Range: 0 .. 16383)
song_number: Song Number (Range: 0 .. 127)

BseNoteDescription (record)

structures/BseNoteDescription
struct BseNoteDescription
{
  SfiChoice    musical_tuning;
  SfiInt       note;
  SfiInt       octave;
  SfiReal      freq;
  SfiInt       fine_tune;
  SfiInt       semitone;
  SfiBool      upshift;
  SfiInt       letter;
  const gchar *name;
  SfiInt       max_fine_tune;
  SfiInt       kammer_note;
};
A note description provides all necessary details about a specific note. Various procedures exist to retrieve a note description; given different key values. The max_fine_tune and kammer_note fields are constants, which are provided for compatibility reasons and will vanish in future APIs.
note: Note (Range: 0 .. 131)
octave: Octave (Range: -4 .. 6)
freq: Frequency (Range: 0.00005 .. 20000)
fine_tune: Fine Tune (Range: -100 .. 100)
semitone: Semitone (Range: 0 .. 11)
letter: International abbreviation letter for this note (Range: 32 .. 126)
name: Name
max_fine_tune: Max Fine Tune (Range: 100 .. 100)
kammer_note: Kammer Note (Range: 69 .. 69)

BseNoteSeq (sequence)

structures/BseNoteSeq
struct BseNoteSeq
{
  guint   n_notes;
  SfiInt *notes;
};

n_notes: Number of elements (C specific)
notes: Note (Range: 0 .. 131)

BseNoteSequence (record)

structures/BseNoteSequence
struct BseNoteSequence
{
  SfiInt      offset;
  BseNoteSeq *notes;
};

offset: Center/base note (Range: 0 .. 131)
notes: Sequence of notes

BsePartControl (record)

structures/BsePartControl
struct BsePartControl
{
  SfiInt    id;
  SfiInt    tick;
  SfiChoice control_type;
  SfiReal   value;
  SfiBool   selected;
};
Part specific control event representation
id: ID (Range: 0 .. 2147483647)
tick: Tick (Range: 0 .. 2147483647)
value: Value (Range: -1 .. 1)
selected: Selected

BsePartControlSeq (sequence)

structures/BsePartControlSeq
struct BsePartControlSeq
{
  guint            n_pcontrols;
  BsePartControl **pcontrols;
};
A list of part control events
n_pcontrols: Number of elements (C specific)

BsePartLink (record)

structures/BsePartLink
struct BsePartLink
{
  SfiProxy track;
  SfiInt   tick;
  SfiProxy part;
  SfiInt   duration;
};

tick: Tick (Range: 0 .. 2147483647)
duration: Duration (Range: 0 .. 2147483647)

BsePartLinkSeq (sequence)

structures/BsePartLinkSeq
struct BsePartLinkSeq
{
  guint         n_plinks;
  BsePartLink **plinks;
};

n_plinks: Number of elements (C specific)

BsePartNote (record)

structures/BsePartNote
struct BsePartNote
{
  SfiInt  id;
  SfiInt  channel;
  SfiInt  tick;
  SfiInt  duration;
  SfiInt  note;
  SfiInt  fine_tune;
  SfiReal velocity;
  SfiBool selected;
};
Part specific note representation
id: ID (Range: 0 .. 2147483647)
channel: Channel (Range: 0 .. 2147483647)
tick: Tick (Range: 0 .. 2147483647)
duration: Duration in number of ticks (Range: 0 .. 2147483647)
note: Note (Range: 0 .. 131)
fine_tune: Fine Tune (Range: -100 .. 100)
velocity: Velocity (Range: 0 .. 1)
selected: Selected

BsePartNoteSeq (sequence)

structures/BsePartNoteSeq
struct BsePartNoteSeq
{
  guint         n_pnotes;
  BsePartNote **pnotes;
};
A list of part notes
n_pnotes: Number of elements (C specific)

BseProbe (record)

structures/BseProbe
struct BseProbe
{
  SfiInt            channel_id;
  SfiNum            block_stamp;
  SfiReal           mix_freq;
  BseProbeFeatures *probe_features;
  SfiReal           min;
  SfiReal           max;
  SfiReal           energie;
  SfiFBlock        *sample_data;
  SfiFBlock        *fft_data;
};

channel_id: (Range: -2147483648 .. 2147483647)
mix_freq: (Range: -1.797693e+308 .. 1.797693e+308)
min: (Range: -1.797693e+308 .. 1.797693e+308)
max: (Range: -1.797693e+308 .. 1.797693e+308)
energie: (Range: -1.797693e+308 .. 1.797693e+308)

BseProbeFeatures (record)

structures/BseProbeFeatures
struct BseProbeFeatures
{
  SfiBool probe_range;
  SfiBool probe_energie;
  SfiBool probe_samples;
  SfiBool probe_fft;
};

BseProbeRequest (record)

structures/BseProbeRequest
struct BseProbeRequest
{
  SfiProxy          source;
  SfiInt            channel_id;
  SfiReal           frequency;
  BseProbeFeatures *probe_features;
};

channel_id: (Range: -2147483648 .. 2147483647)
frequency: (Range: -1.797693e+308 .. 1.797693e+308)

BseProbeRequestSeq (sequence)

structures/BseProbeRequestSeq
struct BseProbeRequestSeq
{
  guint             n_probe_requests;
  BseProbeRequest **probe_requests;
};

n_probe_requests: Number of elements (C specific)

BseProbeSeq (sequence)

structures/BseProbeSeq
struct BseProbeSeq
{
  guint      n_probes;
  BseProbe **probes;
};

n_probes: Number of elements (C specific)

BsePropertyCandidates (record)

structures/BsePropertyCandidates
struct BsePropertyCandidates
{
  const gchar *label;
  const gchar *tooltip;
  BseItemSeq  *items;
  BseTypeSeq  *partitions;
};
A strcuture describing tentative property values.
partitions: List of types which may logically partition the list of items by type discrimination

BseSampleFileInfo (record)

structures/BseSampleFileInfo
struct BseSampleFileInfo
{
  const gchar  *file;
  SfiInt        size;
  SfiNum        mtime;
  const gchar  *loader;
  BseStringSeq *waves;
  SfiInt        error;
};

file: Filename
size: File Size (Range: 0 .. 2147483647)
mtime: Modification Time
loader: Loader
error: BseErrorType (Range: 0 .. 2147483647)

BseSongTiming (record)

structures/BseSongTiming
struct BseSongTiming
{
  SfiInt  tick;
  SfiReal bpm;
  SfiInt  numerator;
  SfiInt  denominator;
  SfiInt  tpqn;
  SfiInt  tpt;
  SfiReal stamp_ticks;
};

tick: Current tick (Range: 0 .. 2147483647)
bpm: Beats per minute (Range: 1 .. 1024)
numerator: Number of notes per measure (Range: 1 .. 256)
denominator: Type of notes counted per measure (Range: 1 .. 256)
tpqn: Ticks per quarter note (Range: 1 .. 2147483647)
tpt: Ticks per tact (Range: 1 .. 2147483647)
stamp_ticks: Ticks per stamp increment (valid only during playback) (Range: 1 .. 2147483647)

BseStringSeq (sequence)

structures/BseStringSeq
struct BseStringSeq
{
  guint         n_strings;
  const gchar **strings;
};

n_strings: Number of elements (C specific)

BseThreadInfo (record)

structures/BseThreadInfo
struct BseThreadInfo
{
  const gchar *name;
  SfiChoice    state;
  SfiInt       thread_id;
  SfiInt       priority;
  SfiInt       processor;
  SfiInt       utime;
  SfiInt       stime;
  SfiInt       cutime;
  SfiInt       cstime;
};

name: Thread Name
state: The execution state of the thread
thread_id: A unique number identifying this thread (Range: 0 .. 2147483647)
priority: The nice value of a thread, -20 indicates a high priority thread and +19 a low priority one that is 'nice' to others (Range: -20 .. 19)
processor: The processor that this thread is currently being executed on (Range: 0 .. 2147483647)
utime: The CPU time spent executing instructions of this thread (Range: 0 .. 2147483647)
stime: The CPU time spent in the system for this thread (Range: 0 .. 2147483647)
cutime: The CPU time spent executing instructions of children of this thread (Range: 0 .. 2147483647)
cstime: The CPU time spent in the system for children of this thread (Range: 0 .. 2147483647)

BseThreadInfoSeq (sequence)

structures/BseThreadInfoSeq
struct BseThreadInfoSeq
{
  guint           n_thread_infos;
  BseThreadInfo **thread_infos;
};

n_thread_infos: Number of elements (C specific)

BseThreadTotals (record)

structures/BseThreadTotals
struct BseThreadTotals
{
  BseThreadInfo    *main;
  BseThreadInfo    *sequencer;
  BseThreadInfoSeq *synthesis;
};

BseTrackPart (record)

structures/BseTrackPart
struct BseTrackPart
{
  SfiInt   tick;
  SfiProxy part;
  SfiInt   duration;
};

tick: Tick (Range: 0 .. 2147483647)
duration: Duration (Range: 0 .. 2147483647)

BseTrackPartSeq (sequence)

structures/BseTrackPartSeq
struct BseTrackPartSeq
{
  guint          n_tparts;
  BseTrackPart **tparts;
};

n_tparts: Number of elements (C specific)

BseTypeSeq (sequence)

structures/BseTypeSeq
struct BseTypeSeq
{
  guint         n_types;
  const gchar **types;
};

n_types: Number of elements (C specific)

bse_bus_connect_bus

bse/bsebus.proc:104
BseErrorType  bse_bus_connect_bus 
(BseBus *sbus,
 BseBus *bus);
Add a bus to the input list of a bus.

bse_bus_connect_track

bse/bsebus.proc:32
BseErrorType  bse_bus_connect_track 
(BseBus   *sbus,
 BseTrack *track);
Add a track to the input list of a bus.

bse_bus_disconnect_bus

bse/bsebus.proc:140
BseErrorType  bse_bus_disconnect_bus 
(BseBus *sbus,
 BseBus *bus);
Remove a bus from the input list of a bus.

bse_bus_disconnect_track

bse/bsebus.proc:68
BseErrorType  bse_bus_disconnect_track 
(BseBus   *sbus,
 BseTrack *track);
Remove a track from the input list of a bus.

bse_bus_ensure_output

bse/bsebus.proc:176
BseErrorType  bse_bus_ensure_output 
(BseBus *bus);
Ensure that a bus has an output connection.

bse_categories_match

bse/bsecategories.proc:61
List BSE categories according to a pattern match.
pattern: Pattern to match category, supports '*' and '?' wildcards.

bse_categories_match_method

bse/bsecategories.proc:129
List BSE categories according to a pattern, of type procedure and applying to a certain object type.
pattern: Pattern to match category, supports '*' and '?' wildcards.
type: Object base type for methods to conform to.

bse_categories_match_typed

bse/bsecategories.proc:28
List BSE categories according to a pattern and type match.
pattern: Pattern to match category, supports '*' and '?' wildcards.
type: Base type for categories to conform to.

bse_category_from_id

bse/bsecategories.proc:89
BseCategory*  bse_category_from_id 
(SfiInt category_id);
Find a BSE category from it's unique ID.
category_id: Category ID (Range: 1 .. 2147483647)

bse_container_get_item

bse/bsecontainer.proc:74
BseItem*  bse_container_get_item 
(BseContainer *container,
 const gchar  *item_type,
 SfiInt        seq_id);
Retrieve a containers immediate child from it's sequential id.
item_type: Type of the item to retrieve
seq_id: Sequential ID (Range: 0 .. 2147483647)

bse_container_list_children

bse/bsecontainer.proc:29
BseItemSeq*  bse_container_list_children 
(BseContainer *container);
Retrieve all immediate children of a container

bse_container_lookup_item

bse/bsecontainer.proc:50
BseItem*  bse_container_lookup_item 
(BseContainer *container,
 const gchar  *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).
container: The Container
uname: Unique item name

bse_data_pocket_create_entry

bse/bsedatapocket.proc:28
SfiInt  bse_data_pocket_create_entry 
(BseDataPocket *data_pocket);
Create a new entry in a data pocket. Entries have a unique ID which is required to set values in a data pocket.
data_pocket: Data Pocket

bse_data_pocket_delete_entry

bse/bsedatapocket.proc:56
BseErrorType  bse_data_pocket_delete_entry 
(BseDataPocket *data_pocket,
 SfiInt         entry_id);
Delete an existing entry from a data pocket
data_pocket: Data Pocket
entry_id: The unique pocket entry ID (Range: 1 .. 2147483647)

bse_data_pocket_get_float

bse/bsedatapocket.proc:304
SfiReal  bse_data_pocket_get_float 
(BseDataPocket *data_pocket,
 SfiInt         entry_id,
 const gchar   *name);
Retrieve a previously set floating point value from a data pocket entry.
data_pocket: The data pocket storing values
entry_id: The unique pocket entry ID (Range: 1 .. 2147483647)
name: Name for the value

bse_data_pocket_get_int

bse/bsedatapocket.proc:338
SfiInt  bse_data_pocket_get_int 
(BseDataPocket *data_pocket,
 SfiInt         entry_id,
 const gchar   *name);
Retrieve a previously set integer value from a data pocket entry.
data_pocket: The data pocket storing values
entry_id: The unique pocket entry ID (Range: 1 .. 2147483647)
name: Name for the value

bse_data_pocket_get_n_entries

bse/bsedatapocket.proc:88
SfiInt  bse_data_pocket_get_n_entries 
(BseDataPocket *data_pocket);
Retrieve the number of entries created in a data pocket.
data_pocket: The data pocket storing values

bse_data_pocket_get_nth_entry_id

bse/bsedatapocket.proc:111
SfiInt  bse_data_pocket_get_nth_entry_id 
(BseDataPocket *data_pocket,
 SfiInt         entry_index);
Retrieve the ID of an entry in the data pocket by sequential index.
data_pocket: The data pocket storing values
entry_index: index into number of entries present (Range: 0 .. 2147483647)

bse_data_pocket_get_object

bse/bsedatapocket.proc:372
BseItem*  bse_data_pocket_get_object 
(BseDataPocket *data_pocket,
 SfiInt         entry_id,
 const gchar   *name);
Retrieve a previously set object reference from a data pocket entry.
data_pocket: The data pocket storing values
entry_id: The unique pocket entry ID (Range: 1 .. 2147483647)
name: Name for the value

bse_data_pocket_get_string

bse/bsedatapocket.proc:406
const gchar*  bse_data_pocket_get_string 
(BseDataPocket *data_pocket,
 SfiInt         entry_id,
 const gchar   *name);
Retrieve a previously set string from a data pocket entry.
data_pocket: The data pocket storing values
entry_id: The unique pocket entry ID (Range: 1 .. 2147483647)
name: Name for the value

bse_data_pocket_set_float

bse/bsedatapocket.proc:137
BseErrorType  bse_data_pocket_set_float 
(BseDataPocket *data_pocket,
 SfiInt         entry_id,
 const gchar   *name,
 SfiReal        number);
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.
data_pocket: The data pocket storing values
entry_id: The unique pocket entry ID (Range: 1 .. 2147483647)
name: Name for the value
number: The value to store in the data pocket entry (Range: -1.797693e+308 .. 1.797693e+308)

bse_data_pocket_set_int

bse/bsedatapocket.proc:179
BseErrorType  bse_data_pocket_set_int 
(BseDataPocket *data_pocket,
 SfiInt         entry_id,
 const gchar   *name,
 SfiInt         number);
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.
data_pocket: The data pocket storing values
entry_id: The unique pocket entry ID (Range: 1 .. 2147483647)
name: Name for the value
number: The value to store in the data pocket entry (Range: -2147483648 .. 2147483647)

bse_data_pocket_set_object

bse/bsedatapocket.proc:221
BseErrorType  bse_data_pocket_set_object 
(BseDataPocket *data_pocket,
 SfiInt         entry_id,
 const gchar   *name,
 BseItem       *item);
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
data_pocket: The data pocket storing values
entry_id: The unique pocket entry ID (Range: 1 .. 2147483647)
name: Name for the value
item: The value to store in the data pocket entry

bse_data_pocket_set_string

bse/bsedatapocket.proc:264
BseErrorType  bse_data_pocket_set_string 
(BseDataPocket *data_pocket,
 SfiInt         entry_id,
 const gchar   *name,
 const gchar   *string);
Set a named string in a data pocket entry.
data_pocket: The data pocket storing values
entry_id: The unique pocket entry ID (Range: 1 .. 2147483647)
name: Name for the value
string: The value to store in the data pocket entry

bse_editable_sample_close

bse/bseeditablesample.proc:69
void  bse_editable_sample_close 
(BseEditableSample *esample);
Close an opened sample.
esample: Editable Sample

bse_editable_sample_collect_stats

bse/bseeditablesample.proc:208
SfiFBlock*  bse_editable_sample_collect_stats 
(BseEditableSample *esample,
 SfiInt             voffset,
 SfiReal            offset_scale,
 SfiInt             block_size,
 SfiInt             stepping,
 SfiInt             max_pairs);
Collect statistics from sample blocks as (minimum, maximum) pairs.
esample: Editable Sample
voffset: Offset of first stat block (Range: 0 .. 2147483647)
offset_scale: Factor to scale voffset increments with (Range: 0 .. 2147483647)
block_size: Block size to compute stat pairs from (Range: 0 .. 2147483647)
stepping: Stepping within a stat block (Range: 0 .. 2147483647)
max_pairs: Maximum number of (min, max) pairs to collect (Range: 0 .. 2147483647)

bse_editable_sample_get_length

bse/bseeditablesample.proc:92
SfiInt  bse_editable_sample_get_length 
(BseEditableSample *esample);
Return the number of values in the sample.
esample: Editable Sample

bse_editable_sample_get_n_channels

bse/bseeditablesample.proc:118
SfiInt  bse_editable_sample_get_n_channels 
(BseEditableSample *esample);
Return the number of channels in the sample.
esample: Editable Sample

bse_editable_sample_get_osc_freq

bse/bseeditablesample.proc:141
SfiReal  bse_editable_sample_get_osc_freq 
(BseEditableSample *esample);
Return the oscillator frequency for the sample.
esample: Editable Sample

bse_editable_sample_open

bse/bseeditablesample.proc:29
BseErrorType  bse_editable_sample_open 
(BseEditableSample *esample);
Open the sample for reading.
esample: Editable Sample

bse_editable_sample_read_samples

bse/bseeditablesample.proc:164
SfiFBlock*  bse_editable_sample_read_samples 
(BseEditableSample *esample,
 SfiInt             voffset);
Read a set of samples from a specific offset.
esample: Editable Sample
voffset: Value offset (Range: 0 .. 2147483647)

bse_error_blurb

bse/bseenums.proc:53
const gchar*  bse_error_blurb 
(BseErrorType error);
Retrieve the description of an error value
error: Error

bse_error_name

bse/bseenums.proc:29
const gchar*  bse_error_name 
(BseErrorType error);
Retrieve the name of an error value
error: Error

bse_item_add_parasite

bse/bseparasite.proc:88
void  bse_item_add_parasite 
(BseItem     *item,
 const gchar *path,
 SfiRec      *parasite);
Add a new parasite to an item.
item: Item
path: Path
parasite: Parasite

bse_item_check_is_a

bse/bseitem.proc:425
SfiBool  bse_item_check_is_a 
(BseItem     *item,
 const gchar *type_name);
Check whether an item has a certain type.
item: The Item
type_name: Type Name

bse_item_clear_undo

bse/bseitem.proc:631
void  bse_item_clear_undo 
(BseItem *item);
Call the clear-undo function of the project corresponding to this item if any.

bse_item_common_ancestor

bse/bseitem.proc:374
BseItem*  bse_item_common_ancestor 
(BseItem *item,
 BseItem *item2);
Retrieve the common ancestor of two items if there's any.
item: First item
item2: Second item

bse_item_editable_property

bse/bseitem.proc:488
SfiBool  bse_item_editable_property 
(BseItem     *item,
 const gchar *property_name);
Test whether a property is editable according to object state and property options.
property_name: Item property name

bse_item_fixme_get_parasite

procedures/BseItem+fixme-get-parasite
SfiFBlock*  bse_item_fixme_get_parasite 
(BseItem     *item,
 const gchar *name);

bse_item_fixme_set_parasite

procedures/BseItem+fixme-set-parasite
void  bse_item_fixme_set_parasite 
(BseItem     *item,
 const gchar *name,
 SfiFBlock   *parasite);

bse_item_get_icon

bse/bseitem.proc:513
BseIcon*  bse_item_get_icon 
(BseItem *item);
Get the current icon of an item.

bse_item_get_name

bse/bseitem.proc:323
const gchar*  bse_item_get_name 
(BseItem *item);
Retrieve an item's name.
item: Item

bse_item_get_name_or_type

bse/bseitem.proc:346
const gchar*  bse_item_get_name_or_type 
(BseItem *item);
Retrieve an item's name or type if it has no name.
item: Item

bse_item_get_parasite

bse/bseparasite.proc:51
SfiRec*  bse_item_get_parasite 
(BseItem     *item,
 const gchar *path);
Retrieve a parasite from an item.
item: Item
path: Path

bse_item_get_parent

bse/bseitem.proc:151
BseItem*  bse_item_get_parent 
(BseItem *item);
Retrieve an item's parent.
item: Item

bse_item_get_project

bse/bseitem.proc:174
BseItem*  bse_item_get_project 
(BseItem *item);
Retrieve an item's project.
item: Item

bse_item_get_property_candidates

bse/bseitem.proc:457
BsePropertyCandidates*  bse_item_get_property_candidates 
(BseItem     *item,
 const gchar *property_name);
Retrieve tentative values for an item or item sequence property.
property_name: Item property name

bse_item_get_seqid

bse/bseitem.proc:400
SfiInt  bse_item_get_seqid 
(BseItem *item);
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.
item: Item

bse_item_get_type

bse/bseitem.proc:32
const gchar*  bse_item_get_type 
(BseItem *item);
Retrieve an item's type name.
item: Item

bse_item_get_type_authors

bse/bseitem.proc:103
const gchar*  bse_item_get_type_authors 
(BseItem *item);
Retrieve authors of an item's type implementation.
item: Item

bse_item_get_type_blurb

bse/bseitem.proc:79
const gchar*  bse_item_get_type_blurb 
(BseItem *item);
Retrieve an item's type description.
item: Item

bse_item_get_type_license

bse/bseitem.proc:127
const gchar*  bse_item_get_type_license 
(BseItem *item);
Retrieve the license for an item's type implementation.
item: Item

bse_item_get_type_name

bse/bseitem.proc:55
const gchar*  bse_item_get_type_name 
(BseItem *item);
Retrieve an item's type name.
item: Item

bse_item_get_uname_path

bse/bseitem.proc:197
const gchar*  bse_item_get_uname_path 
(BseItem *item);
Retrieve the project relative uname path for this item.

bse_item_group_undo

bse/bseitem.proc:536
void  bse_item_group_undo 
(BseItem     *item,
 const gchar *name);
Request multiple modifying actions on an item to be grouped together as single undo operation.
name: A name for the undo group to be created

bse_item_internal

bse/bseitem.proc:224
SfiBool  bse_item_internal 
(BseItem *item);
Check whether an item is internal, i.e. owned by another non-internal item.
item: Item

bse_item_list_parasites

bse/bseparasite.proc:27
BseStringSeq*  bse_item_list_parasites 
(BseItem     *item,
 const gchar *path);
List parasites within a parasite path segment.
item: Item
path: Path

bse_item_redo

bse/bseitem.proc:608
void  bse_item_redo 
(BseItem *item);
Call the redo function of the project corresponding to this item if any.

bse_item_redo_depth

bse/bseitem.proc:683
SfiInt  bse_item_redo_depth 
(BseItem *item);
Call the redo-depth function of the project corresponding to this item if any.

bse_item_set_name

bse/bseitem.proc:297
void  bse_item_set_name 
(BseItem     *item,
 const gchar *name);
Set an item's name.
item: Item
name: Name

bse_item_set_parasite

bse/bseparasite.proc:69
void  bse_item_set_parasite 
(BseItem     *item,
 const gchar *path,
 SfiRec      *parasite);
Set or change a parasite on an item.
item: Item
path: Path
parasite: Parasite

bse_item_undo

bse/bseitem.proc:585
void  bse_item_undo 
(BseItem *item);
Call the undo function of the project corresponding to this item if any.

bse_item_undo_depth

bse/bseitem.proc:654
SfiInt  bse_item_undo_depth 
(BseItem *item);
Call the undo-depth function of the project corresponding to this item if any.

bse_item_ungroup_undo

bse/bseitem.proc:562
void  bse_item_ungroup_undo 
(BseItem *item);
Ends the undo grouping opened up by a previous group-undo() call.

bse_item_unuse

bse/bseitem.proc:273
void  bse_item_unuse 
(BseItem *item);
Decrement use count for when an item is not needed anymore.
item: Item

bse_item_use

bse/bseitem.proc:247
BseItem*  bse_item_use 
(BseItem *item);
Increment use count to keep an item alive.
item: Item

bse_janitor_get_action

bse/bsejanitor.proc:127
const gchar*  bse_janitor_get_action 
(BseJanitor *janitor,
 SfiInt      nth_action);
Retrieve an action of this janitor.
janitor: Janitor
nth_action: Nth Action (Range: 0 .. 2147483647)

bse_janitor_get_action_blurb

bse/bsejanitor.proc:187
const gchar*  bse_janitor_get_action_blurb 
(BseJanitor *janitor,
 SfiInt      nth_action);
Retrieve the help string of an action of this janitor.
janitor: Janitor
nth_action: Nth Action (Range: 0 .. 2147483647)

bse_janitor_get_action_name

bse/bsejanitor.proc:157
const gchar*  bse_janitor_get_action_name 
(BseJanitor *janitor,
 SfiInt      nth_action);
Retrieve the name of an action of this janitor.
janitor: Janitor
nth_action: Nth Action (Range: 0 .. 2147483647)

bse_janitor_get_proc_name

bse/bsejanitor.proc:79
const gchar*  bse_janitor_get_proc_name 
(BseJanitor *janitor);
Retrieve the procedure name of this janitor.
janitor: Janitor

bse_janitor_get_script_name

bse/bsejanitor.proc:55
const gchar*  bse_janitor_get_script_name 
(BseJanitor *janitor);
Retrieve the script name of this janitor.
janitor: Janitor

bse_janitor_kill

bse/bsejanitor.proc:217
void  bse_janitor_kill 
(BseJanitor *janitor);
Kill a currently running janitor.
janitor: Janitor

bse_janitor_n_actions

bse/bsejanitor.proc:103
SfiInt  bse_janitor_n_actions 
(BseJanitor *janitor);
Retrieve number of user actions of this janitor.
janitor: Janitor

bse_janitor_trigger_action

bse/bsejanitor.proc:30
void  bse_janitor_trigger_action 
(BseJanitor  *janitor,
 const gchar *action);
Trigger an installed user action of this janitor.
janitor: Janitor
action: Action

bse_midi_notifier_current_time

bse/bsemidinotifier.proc:28
SfiInt  bse_midi_notifier_current_time 
(BseMidiNotifier *midi_notifier);
Test
midi_notifier: Midi Notifier

bse_note_construct

bse/bseprocedure.proc:164
BseNoteDescription*  bse_note_construct 
(BseMusicalTuningType musical_tuning,
 SfiInt               semitone,
 SfiInt               octave,
 SfiInt               fine_tune);
Describe a note, given its semitone, octave and fine tune.
musical_tuning: Musical Tuning
semitone: (Range: 0 .. 11)
octave: (Range: -4 .. 6)
fine_tune: Fine Tune (Range: -100 .. 100)

bse_note_describe

bse/bseprocedure.proc:88
BseNoteDescription*  bse_note_describe 
(BseMusicalTuningType musical_tuning,
 SfiInt               note,
 SfiInt               fine_tune);
Describe a note, providing information about its octave, semitone, frequency, etc.
musical_tuning: Musical Tuning
note: Note (Range: 0 .. 131)
fine_tune: Fine Tune (Range: -100 .. 100)

bse_note_describe_from_freq

bse/bseprocedure.proc:112
BseNoteDescription*  bse_note_describe_from_freq 
(BseMusicalTuningType musical_tuning,
 SfiReal              freq);
Describe a note, given its frequency.
musical_tuning: Musical Tuning
freq: Frequency (Range: 0 .. 24000)

bse_note_from_freq

bse/bseprocedure.proc:66
SfiInt  bse_note_from_freq 
(BseMusicalTuningType musical_tuning,
 SfiReal              frequency);
Retrieve the note of a certain frequency.
musical_tuning: Musical Tuning
frequency: Frequency (Range: 0 .. 24000)

bse_note_from_string

bse/bseprocedure.proc:139
BseNoteDescription*  bse_note_from_string 
(BseMusicalTuningType musical_tuning,
 const gchar         *name);
Describe a note, given its name and octave offset.
musical_tuning: Musical Tuning
name: Name

bse_note_to_freq

bse/bseprocedure.proc:32
SfiReal  bse_note_to_freq 
(BseMusicalTuningType musical_tuning,
 SfiInt               note,
 SfiInt               fine_tune);
Retrieve the frequency of a certain note.
musical_tuning: Musical Tuning
note: Note (Range: 0 .. 131)
fine_tune: Fine Tune (Range: -100 .. 100)

bse_part_change_control

bse/bsepart.proc:235
BseErrorType  bse_part_change_control 
(BsePart          *part,
 SfiInt            id,
 SfiInt            tick,
 BseMidiSignalType control_type,
 SfiReal           value);
Change an existing control event within a part.
part: Part
id: ID (Range: 0 .. 2147483647)
tick: Start Tick (Range: 0 .. 2147483646)
control_type: Control Type
value: Value (Range: -1 .. 1)

bse_part_change_note

bse/bsepart.proc:172
BseErrorType  bse_part_change_note 
(BsePart *part,
 SfiInt   id,
 SfiInt   tick,
 SfiInt   duration,
 SfiInt   note,
 SfiInt   fine_tune,
 SfiReal  velocity);
Change an existing note within a part.
part: Part
id: ID (Range: 0 .. 2147483647)
tick: Start Tick (Range: 0 .. 2147483646)
duration: Tick Duration (Range: 1 .. 2147483647)
note: Note (Range: 0 .. 131)
fine_tune: Fine tune in cents per semitone (Range: -100 .. 100)
velocity: Velocity (Range: 0 .. 1)

bse_part_check_overlap

bse/bsepart.proc:606
BsePartNoteSeq*  bse_part_check_overlap 
(BsePart *part,
 SfiInt   tick,
 SfiInt   duration,
 SfiInt   note);
Check whether a note would overlap with neighbours.
part: Part
tick: Start Tick (Range: 0 .. 2147483646)
duration: Tick Duration (Range: 0 .. 2147483647)
note: Note (Range: 0 .. 131)

bse_part_delete_event

bse/bsepart.proc:312
BseErrorType  bse_part_delete_event 
(BsePart *part,
 SfiInt   id);
Delete an existing event from a part.
part: Part
id: ID (Range: 0 .. 2147483647)

bse_part_deselect_controls

bse/bsepart.proc:945
void  bse_part_deselect_controls 
(BsePart          *part,
 SfiInt            tick,
 SfiInt            duration,
 BseMidiSignalType control_type);
Deselect all controls within given range.
part: Part
tick: Selection Tick (Range: 0 .. 2147483646)
duration: Selection Duration (Range: 0 .. 2147483647)
control_type: Control Type

bse_part_deselect_event

bse/bsepart.proc:1007
void  bse_part_deselect_event 
(BsePart *part,
 SfiInt   id);
Deselect an existing event.
part: Part
id: ID (Range: 0 .. 2147483647)

bse_part_deselect_notes

bse/bsepart.proc:912
void  bse_part_deselect_notes 
(BsePart *part,
 SfiInt   tick,
 SfiInt   duration,
 SfiInt   min_note,
 SfiInt   max_note);
Deselect all notes within rectangle.
part: Part
tick: Selection Tick (Range: 0 .. 2147483646)
duration: Selection Duration (Range: 0 .. 2147483647)
min_note: Minimum Selection Note (Range: 0 .. 131)
max_note: Maximum Selection Note (Range: 0 .. 131)

bse_part_get_channel_controls

bse/bsepart.proc:699
BsePartControlSeq*  bse_part_get_channel_controls 
(BsePart          *part,
 SfiInt            channel,
 SfiInt            tick,
 SfiInt            duration,
 BseMidiSignalType control_type);
Retrieve all control events of a specific type within range of a channel.
part: Part
channel: Channel (Range: 0 .. 4132)
tick: Tick (Range: 0 .. 2147483646)
duration: Tick Duration (Range: 1 .. 2147483647)
control_type: Control Type

bse_part_get_controls

bse/bsepart.proc:668
BsePartControlSeq*  bse_part_get_controls 
(BsePart          *part,
 SfiInt            tick,
 BseMidiSignalType control_type);
Retrieve all control events of a specific type at specified tick.
part: Part
tick: Tick (Range: 0 .. 2147483646)
control_type: Control Type

bse_part_get_max_note

bse/bsepart.proc:760
SfiInt  bse_part_get_max_note 
(BsePart *part);
Retrieve the maximum note supported in this part.
part: Part

bse_part_get_min_note

bse/bsepart.proc:736
SfiInt  bse_part_get_min_note 
(BsePart *part);
Retrieve the minimum note supported in this part.
part: Part

bse_part_get_notes

bse/bsepart.proc:638
BsePartNoteSeq*  bse_part_get_notes 
(BsePart *part,
 SfiInt   tick,
 SfiInt   note);
Retrieve all notes of specific frequency at or crossing a specific tick.
part: Part
tick: Tick (Range: 0 .. 2147483646)
note: Note (Range: 0 .. 131)

bse_part_get_timing

bse/bsepart.proc:1038
BseSongTiming*  bse_part_get_timing 
(BsePart *part,
 SfiInt   tick);
Retrieve song timing information at a specific tick.
part: Part
tick: Tick to retrieve timing info about (Range: 0 .. 2147483647)

bse_part_insert_control

bse/bsepart.proc:128
SfiInt  bse_part_insert_control 
(BsePart          *part,
 SfiInt            tick,
 BseMidiSignalType control_type,
 SfiReal           value);
Insert a new control event into a part.
part: Part
tick: Start Tick (Range: 0 .. 2147483646)
control_type: Control Type
value: Value (Range: -1 .. 1)

bse_part_insert_note

bse/bsepart.proc:77
SfiInt  bse_part_insert_note 
(BsePart *part,
 SfiInt   channel,
 SfiInt   tick,
 SfiInt   duration,
 SfiInt   note,
 SfiInt   fine_tune,
 SfiReal  velocity);
Insert a new note into a part.
part: Part
channel: Channel (Range: 0 .. 4132)
tick: Start Tick (Range: 0 .. 2147483646)
duration: Tick Duration (Range: 1 .. 2147483647)
note: Note (Range: 0 .. 131)
fine_tune: Fine tune in cents per semitone (Range: -100 .. 100)
velocity: Velocity (Range: 0 .. 1)

bse_part_insert_note_auto

bse/bsepart.proc:29
SfiInt  bse_part_insert_note_auto 
(BsePart *part,
 SfiInt   tick,
 SfiInt   duration,
 SfiInt   note,
 SfiInt   fine_tune,
 SfiReal  velocity);
Insert a new note into a part with automatic channel selection.
part: Part
tick: Start Tick (Range: 0 .. 2147483646)
duration: Tick Duration (Range: 1 .. 2147483647)
note: Note (Range: 0 .. 131)
fine_tune: Fine tune in cents per semitone (Range: -100 .. 100)
velocity: Velocity (Range: 0 .. 1)

bse_part_is_event_selected

bse/bsepart.proc:362
SfiBool  bse_part_is_event_selected 
(BsePart *part,
 SfiInt   id);
Check whether an event is selected.
part: Part
id: ID (Range: 0 .. 2147483647)

bse_part_list_controls

bse/bsepart.proc:458
BsePartControlSeq*  bse_part_list_controls 
(BsePart          *part,
 SfiInt            tick,
 SfiInt            duration,
 BseMidiSignalType control_type);
List all control events within a tick range.
part: Part
tick: Start Tick (Range: 0 .. 2147483646)
duration: Tick Duration (Range: 1 .. 2147483647)
control_type: Control Type

bse_part_list_links

bse/bsepart.proc:1070
BsePartLinkSeq*  bse_part_list_links 
(BsePart *part);
List all places where parts are used (linked) from tracks, sorted by tick.
part: Part

bse_part_list_notes_crossing

bse/bsepart.proc:395
BsePartNoteSeq*  bse_part_list_notes_crossing 
(BsePart *part,
 SfiInt   tick,
 SfiInt   duration);
List all notes within or crossing a tick range.
part: Part
tick: Start Tick (Range: 0 .. 2147483646)
duration: Tick Duration (Range: 1 .. 2147483647)

bse_part_list_notes_within

bse/bsepart.proc:425
BsePartNoteSeq*  bse_part_list_notes_within 
(BsePart *part,
 SfiInt   channel,
 SfiInt   tick,
 SfiInt   duration);
List all notes within a tick range.
part: Part
channel: Channel (Range: 0 .. 4132)
tick: Start Tick (Range: 0 .. 2147483646)
duration: Tick Duration (Range: 1 .. 2147483647)

bse_part_list_selected_controls

bse/bsepart.proc:578
BsePartControlSeq*  bse_part_list_selected_controls 
(BsePart          *part,
 BseMidiSignalType control_type);
List all currently selected control events of a specific type.
part: Part
control_type: Control Type

bse_part_list_selected_notes

bse/bsepart.proc:554
List all currently selected notes.
part: Part

bse_part_queue_controls

bse/bsepart.proc:526
void  bse_part_queue_controls 
(BsePart *part,
 SfiInt   tick,
 SfiInt   duration);
Queue updates for all control events and notes starting within the given range.
part: Part
tick: Start Tick (Range: 0 .. 2147483646)
duration: Tick Duration (Range: 1 .. 2147483647)

bse_part_queue_notes

bse/bsepart.proc:492
void  bse_part_queue_notes 
(BsePart *part,
 SfiInt   tick,
 SfiInt   duration,
 SfiInt   min_note,
 SfiInt   max_note);
Queue updates for all notes starting within the given rectangle.
part: Part
tick: Start Tick (Range: 0 .. 2147483646)
duration: Tick Duration (Range: 1 .. 2147483647)
min_note: Minimum Note (Range: 0 .. 131)
max_note: Maximum Note (Range: 0 .. 131)

bse_part_select_controls

bse/bsepart.proc:848
void  bse_part_select_controls 
(BsePart          *part,
 SfiInt            tick,
 SfiInt            duration,
 BseMidiSignalType control_type);
Select all control events within range.
part: Part
tick: Selection Tick (Range: 0 .. 2147483646)
duration: Selection Duration (Range: 0 .. 2147483647)
control_type: Control Type

bse_part_select_controls_exclusive

bse/bsepart.proc:817
void  bse_part_select_controls_exclusive 
(BsePart          *part,
 SfiInt            tick,
 SfiInt            duration,
 BseMidiSignalType control_type);
Select all control events within range and deselect all others.
part: Part
tick: Selection Tick (Range: 0 .. 2147483646)
duration: Selection Duration (Range: 0 .. 2147483647)
control_type: Control Type

bse_part_select_event

bse/bsepart.proc:976
void  bse_part_select_event 
(BsePart *part,
 SfiInt   id);
Select an existing event.
part: Part
id: ID (Range: 0 .. 2147483647)

bse_part_select_notes

bse/bsepart.proc:879
void  bse_part_select_notes 
(BsePart *part,
 SfiInt   tick,
 SfiInt   duration,
 SfiInt   min_note,
 SfiInt   max_note);
Select all notes within rectangle.
part: Part
tick: Selection Tick (Range: 0 .. 2147483646)
duration: Selection Duration (Range: 0 .. 2147483647)
min_note: Minimum Selection Note (Range: 0 .. 131)
max_note: Maximum Selection Note (Range: 0 .. 131)

bse_part_select_notes_exclusive

bse/bsepart.proc:784
void  bse_part_select_notes_exclusive 
(BsePart *part,
 SfiInt   tick,
 SfiInt   duration,
 SfiInt   min_note,
 SfiInt   max_note);
Select all notes within rectangle and deselect all others.
part: Part
tick: Selection Tick (Range: 0 .. 2147483646)
duration: Selection Duration (Range: 0 .. 2147483647)
min_note: Minimum Selection Note (Range: 0 .. 131)
max_note: Maximum Selection Note (Range: 0 .. 131)

bse_project_activate

bse/bseproject.proc:617
BseErrorType  bse_project_activate 
(BseProject *project);
Activate a project, precondition to start playback.
project: The project

bse_project_auto_deactivate

bse/bseproject.proc:776
void  bse_project_auto_deactivate 
(BseProject *project,
 SfiInt      msec_delay);
Automatically deactivate a project once playback stopped.
project: The project
msec_delay: Delay for deactivation in milliseconds (Range: -1 .. 2147483647)

bse_project_can_play

bse/bseproject.proc:569
SfiBool  bse_project_can_play 
(BseProject *project);
Check whether project playback would makes sense.
project: The project

bse_project_change_name

bse/bseproject.proc:837
void  bse_project_change_name 
(BseProject  *project,
 const gchar *name);
Change a project name without recording undo steps.
project: The project

bse_project_clean_dirty

bse/bseproject.proc:991
void  bse_project_clean_dirty 
(BseProject *project);
Clear a projects dirty flags.
project: Project

bse_project_clear_undo

bse/bseproject.proc:970
void  bse_project_clear_undo 
(BseProject *project);
Delete all recorded undo or redo steps.
project: Project

bse_project_create_csynth

bse/bseproject.proc:337
BseCSynth*  bse_project_create_csynth 
(BseProject  *project,
 const gchar *name);
Create a synthsizer network for this project.
project: The project
name: Synth network name

bse_project_create_midi_synth

bse/bseproject.proc:373
BseMidiSynth*  bse_project_create_midi_synth 
(BseProject  *project,
 const gchar *name);
Create a MIDI synthesizer network for this project.
project: The project
name: MIDI synth name

bse_project_create_song

bse/bseproject.proc:240
BseSong*  bse_project_create_song 
(BseProject  *project,
 const gchar *name);
Create a song for this project.
project: The project
name: Song name

bse_project_deactivate

bse/bseproject.proc:716
void  bse_project_deactivate 
(BseProject *project);
Deactivate the project, automatically stop playback.
project: The project

bse_project_find_item

bse/bseproject.proc:472
BseItem*  bse_project_find_item 
(BseProject  *project,
 const gchar *uname_path);
Find an item within a project, given its uname path.

bse_project_get_data_pocket

bse/bseproject.proc:303
BseDataPocket*  bse_project_get_data_pocket 
(BseProject  *project,
 const gchar *name);
Retrieve a specifically named data pocket for this project
project: The project
name: Name of the data pocket

bse_project_get_midi_notifier

bse/bseproject.proc:89
BseMidiNotifier*  bse_project_get_midi_notifier 
(BseProject *project);
Retrieve the project's midi notifier object.
project: Project

bse_project_get_state

bse/bseproject.proc:594
BseProjectState  bse_project_get_state 
(BseProject *project);
Retrieve the current project state.
project: The project

bse_project_get_supers

bse/bseproject.proc:540
BseItemSeq*  bse_project_get_supers 
(BseProject *project);
Retrieve all supers of this project.

bse_project_get_wave_repo

bse/bseproject.proc:276
BseWaveRepo*  bse_project_get_wave_repo 
(BseProject *project);
Ensure the project has a wave repository
project: The project

bse_project_import_midi_file

bse/bseproject.proc:112
BseErrorType  bse_project_import_midi_file 
(BseProject  *project,
 const gchar *file_name);
Import a song from a MIDI file.
project: The project
file_name: MIDI file name

bse_project_inject_midi_control

bse/bseproject.proc:799
void  bse_project_inject_midi_control 
(BseProject *project,
 SfiInt      midi_channel,
 SfiInt      midi_control,
 SfiReal     control_value);
Inject a MIDI control event into the project's MIDI receiver.
midi_channel: (Range: 1 .. 99)
midi_control: (Range: 0 .. 127)
control_value: (Range: -1 .. 1)

bse_project_is_active

bse/bseproject.proc:64
SfiBool  bse_project_is_active 
(BseProject *project);
Check whether a project is active
project: The project

bse_project_is_dirty

bse/bseproject.proc:1012
SfiBool  bse_project_is_dirty 
(BseProject *project);
Check whether a project is dirty (needs saving).
project: The project

bse_project_is_playing

bse/bseproject.proc:39
SfiBool  bse_project_is_playing 
(BseProject *project);
Check whether a project is currently playing
project: The project

bse_project_list_uname_paths

bse/bseproject.proc:445
BseStringSeq*  bse_project_list_uname_paths 
(BseProject  *project,
 const gchar *item_type);
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

bse/bseproject.proc:498
BseItemSeq*  bse_project_match_items_by_uname 
(BseProject  *project,
 const gchar *item_type,
 const gchar *uname);
Retrieve all items of a specific type within a project with matching uname

bse_project_play

bse/bseproject.proc:677
BseErrorType  bse_project_play 
(BseProject *project);
Activate a project and start project playback (and already playing project is first halted).
project: The project

bse_project_redo

bse/bseproject.proc:938
void  bse_project_redo 
(BseProject *project);
Redo a previously undone operaiton in a project
project: The project

bse_project_redo_depth

bse/bseproject.proc:915
SfiInt  bse_project_redo_depth 
(BseProject *project);
Check whether a project can perform redo steps
project: The project

bse_project_remove_snet

bse/bseproject.proc:409
void  bse_project_remove_snet 
(BseProject *project,
 BseSNet    *snet);
Remove an existing synthesizer network from this project.
project: The project
snet: Synthesizer Network

bse_project_restore_from_file

bse/bseproject.proc:157
BseErrorType  bse_project_restore_from_file 
(BseProject  *project,
 const gchar *file_name);
Load a project from file
project: The project
file_name: Source file name

bse_project_start_playback

bse/bseproject.proc:650
void  bse_project_start_playback 
(BseProject *project);
Start playback in an activated project.
project: The project

bse_project_stop

bse/bseproject.proc:756
void  bse_project_stop 
(BseProject *project);
Stop project playback and deactivate project.
project: The project

bse_project_stop_playback

bse/bseproject.proc:736
void  bse_project_stop_playback 
(BseProject *project);
Stop project playback.
project: The project

bse_project_store_bse

bse/bseproject.proc:199
BseErrorType  bse_project_store_bse 
(BseProject  *project,
 BseSuper    *super,
 const gchar *file_name,
 SfiBool      self_contained);
Save supers of a project into a BSE file. If no super is specified, the project itself is stored.
project: Project
super: Super
file_name: Destination file name
self_contained: Whether references to other objects (e.g. samples) should be stored or whether to include everything in a self-contained .bse file

bse_project_undo

bse/bseproject.proc:883
void  bse_project_undo 
(BseProject *project);
Undo a previous operation in a project
project: The project

bse_project_undo_depth

bse/bseproject.proc:860
SfiInt  bse_project_undo_depth 
(BseProject *project);
Check whether a project can perform undo steps
project: The project

bse_proxy_check

bse/bsescripthelper.proc:29
SfiBool  bse_proxy_check 
(BseItem     *item,
 const gchar *type_name);
Check whether a proxy has a certain type.
item: The Item
type_name: Type Name

bse_sample_file_info

bse/bsewaverepo.proc:134
Load sample file info from file
file_name: The file to load info from

bse_script_add_action

bse/bsejanitor.proc:260
void  bse_script_add_action 
(const gchar *action,
 const gchar *name,
 const gchar *blurb);
Install a user action for script control.
action: Action
name: Name
blurb: Blurb

bse_script_janitor

bse/bsejanitor.proc:239
BseJanitor*  bse_script_janitor 
();
Retrieve the connection dependant janitor object.

bse_script_mixer_splitup_by_track

scripts/mixer-splitup-by-track.scm:23
This script creates a new Mixer Bus for each track in the song that is currently using the Master Bus as output.
song: Parameter "song" to function <mixer-splitup-by-track> in script "/opt/share/bse/v0.7.1/scripts/mixer-splitup-by-track.scm"

bse_script_modules2grid

scripts/modules2grid.scm:19
void  bse_script_modules2grid 
(BseSNet *synth_net);
Round module positions to their nearest grid position, so to align all modules within a synthesis network.
synth_net: Parameter "synth-net" to function <modules2grid> in script "/opt/share/bse/v0.7.1/scripts/modules2grid.scm"

bse_script_part_harmonic_transposer

scripts/part-harmonic-transposer.scm:23
void  bse_script_part_harmonic_transposer 
(BsePart     *part,
 const gchar *harmony_sequence,
 const gchar *transpose_down_starting_at);
The harmonic transposer takes the selection of a part and transposes it to different harmonies. If you for instance have selected a measure filled with C major chords, and enter "C,Am,F,G" as harmonic sequence, the result will be four measures, filled with C major, A minor, F major and G major chords.

This also works for melodies, so you can transpose a whole melody written in G major to D minor. The standard scales used in church music (ionian, dorian, phrygian, lydian, mixolydian, aeolian, locrian) are also supported: it is for instance possible to write Ddorian or Caeolian. The aeolian scale is equivalent to minor and the ionian scale is equivalent to major.

Since musically, there is no preference on whether to transpose up or down it is possible to specify the first harmony that will be transposed down (all harmonies below this will be transposed up). It is possible to omit this value. Then all notes will be transposed up.
part: Parameter "part" to function <part-harmonic-transposer> in script "/opt/share/bse/v0.7.1/scripts/part-harmonic-transposer.scm"
harmony_sequence: Parameter "harmony-sequence" to function <part-harmonic-transposer> in script "/opt/share/bse/v0.7.1/scripts/part-harmonic-transposer.scm"
transpose_down_starting_at: Parameter "transpose-down-starting-at" to function <part-harmonic-transposer> in script "/opt/share/bse/v0.7.1/scripts/part-harmonic-transposer.scm"

bse_script_progress

bse/bsejanitor.proc:348
void  bse_script_progress 
(SfiReal progress);
Indicate progress (from 0.0 to 1.0 or -1 for unknown amount).
progress: Progress (Range: -1 .. 1)

bse_script_progressor

scripts/progressor-example.scm:30
void  bse_script_progressor 
(SfiInt  n_iterations,
 SfiInt  n_wait_spins,
 SfiBool update_percentage);
Progressor takes two seed values and then starts progressing. It doesn't do anything particularly usefull, other than ticking the main program from time to time. It is a funny example though.
n_iterations: Parameter "n-iterations" to function <progressor> in script "/opt/share/bse/v0.7.1/scripts/progressor-example.scm" (Range: 0 .. 65536)
n_wait_spins: Parameter "n-wait-spins" to function <progressor> in script "/opt/share/bse/v0.7.1/scripts/progressor-example.scm" (Range: 0 .. 65536)
update_percentage: Parameter "update-percentage" to function <progressor> in script "/opt/share/bse/v0.7.1/scripts/progressor-example.scm"

bse_script_quit

bse/bsejanitor.proc:414
Exit a script succesfully (server side).

bse_script_record_midi

scripts/record-midi.scm:18
void  bse_script_record_midi 
(BsePart *part,
 SfiBool  start_now);
Record midi events, currently being played on the default external midi device, into a given song part. The MIDI recorder is still work in progress.
part: Parameter "part" to function <record-midi> in script "/opt/share/bse/v0.7.1/scripts/record-midi.scm"
start_now: Parameter "start-now" to function <record-midi> in script "/opt/share/bse/v0.7.1/scripts/record-midi.scm"

bse_script_remove_action

bse/bsejanitor.proc:293
Remove a previously installed user action from script control.
action: Action

bse_script_send_message

bse/bsejanitor.proc:375
void  bse_script_send_message 
(const gchar *domain,
 const gchar *msg_type,
 const gchar *title,
 const gchar *primary,
 const gchar *secondary,
 const gchar *details,
 const gchar *config_check);
Send a message from a script.

bse_script_set_status

bse/bsejanitor.proc:320
Alter script status message.
message: Message

bse_script_song_parts_crop

scripts/song-parts-operations.scm:23
void  bse_script_song_parts_crop 
(BseSong *song);
Crops all parts within the loop range and moves parts after the loop range backwards accordingly.
song: Parameter "song" to function <song-parts-crop> in script "/opt/share/bse/v0.7.1/scripts/song-parts-operations.scm"

bse_script_song_parts_duplicate

scripts/song-parts-operations.scm:32
void  bse_script_song_parts_duplicate 
(BseSong *song);
Duplicate all parts within the loop range and moves parts after the loop range forward accordingly.
song: Parameter "song" to function <song-parts-duplicate> in script "/opt/share/bse/v0.7.1/scripts/song-parts-operations.scm"

bse_server_can_load

bse/bseserver.proc:82
SfiBool  bse_server_can_load 
(BseServer   *server,
 const gchar *file_name);
Check whether a loader can be found for a wave file
server: Server
file_name: The file to find a loader for

bse_server_get_custom_effect_dir

bse/bseserver.proc:494
const gchar*  bse_server_get_custom_effect_dir 
(BseServer *server);
Retrieve user specific effects directory.
server: Server

bse_server_get_custom_instrument_dir

bse/bseserver.proc:524
const gchar*  bse_server_get_custom_instrument_dir 
(BseServer *server);
Retrieve user specific instruments directory.
server: Server

bse_server_get_demo_path

bse/bseserver.proc:466
const gchar*  bse_server_get_demo_path 
(BseServer *server);
Retrieve demo search path.
server: Server

bse_server_get_effect_path

bse/bseserver.proc:510
const gchar*  bse_server_get_effect_path 
(BseServer *server);
Retrieve effect search path.
server: Server

bse_server_get_instrument_path

bse/bseserver.proc:540
const gchar*  bse_server_get_instrument_path 
(BseServer *server);
Retrieve instrument search path.
server: Server

bse_server_get_ladspa_path

bse/bseserver.proc:582
const gchar*  bse_server_get_ladspa_path 
(BseServer *server);
Retrieve ladspa search path.
server: Server

bse_server_get_mp3_version

bse/bseserver.proc:621
const gchar*  bse_server_get_mp3_version 
(BseServer *server);
Retrieve BSE MP3 handler version.
server: Server

bse_server_get_plugin_path

bse/bseserver.proc:568
const gchar*  bse_server_get_plugin_path 
(BseServer *server);
Retrieve plugin search path.
server: Server

bse_server_get_sample_path

bse/bseserver.proc:480
const gchar*  bse_server_get_sample_path 
(BseServer *server);
Retrieve sample search path.
server: Server

bse_server_get_script_path

bse/bseserver.proc:554
const gchar*  bse_server_get_script_path 
(BseServer *server);
Retrieve script search path.
server: Server

bse_server_get_version

bse/bseserver.proc:452
const gchar*  bse_server_get_version 
(BseServer *server);
Retrieve BSE version.
server: Server

bse_server_get_vorbis_version

bse/bseserver.proc:598
const gchar*  bse_server_get_vorbis_version 
(BseServer *server);
Retrieve BSE Vorbis handler version.
server: Server

bse_server_n_scripts

bse/bseserver.proc:113
SfiInt  bse_server_n_scripts 
(BseServer *server);
Return the number of scripts currently running on this server.
server: Server

bse_server_preferences_locked

bse/bseserver.proc:145
SfiBool  bse_server_preferences_locked 
(BseServer *server);
Returns whether the bse-preferences property is currently locked against modifications or not.
server: Server

bse_server_register_core_plugins

bse/bseserver.proc:278
void  bse_server_register_core_plugins 
(BseServer *server);
Register core plugins.
server: Server

bse_server_register_ladspa_plugins

bse/bseserver.proc:340
void  bse_server_register_ladspa_plugins 
(BseServer *server);
Register LADSPA (Linux Audio Developer's Simple Plugin API) plugins.
server: Server

bse_server_register_scripts

bse/bseserver.proc:213
void  bse_server_register_scripts 
(BseServer *server);
Register external scripts.
server: Server

bse_server_save_preferences

bse/bseserver.proc:378
void  bse_server_save_preferences 
(BseServer *server);
Request the bse-preferences property to be saved into BSE's configuration file.
server: Server

bse_server_start_recording

bse/bseserver.proc:427
void  bse_server_start_recording 
(BseServer   *server,
 const gchar *wave_file,
 SfiReal      n_seconds);
Start recording to a WAV file.
server: Server
n_seconds: Maximum number of recorded seconds (Range: 0 .. 9223372036854775808)

bse_server_use_new_project

bse/bseserver.proc:38
BseProject*  bse_server_use_new_project 
(BseServer   *server,
 const gchar *name);
Create a new project, owned by the caller (name is modified to be unique if necessary)
server: Server
name: Project Name

bse_snet_can_create_source

bse/bsesnet.proc:53
BseErrorType  bse_snet_can_create_source 
(BseSNet     *snet,
 const gchar *module_type);
Check whether inserting a new module into a synthesis network is possible
snet: Synth Net
module_type: Module Type

bse_snet_create_source

bse/bsesnet.proc:89
BseSource*  bse_snet_create_source 
(BseSNet     *snet,
 const gchar *module_type);
Insert a new module into a synthesis network
snet: Synth Net
module_type: Module Type

bse_snet_remove_source

bse/bsesnet.proc:127
BseErrorType  bse_snet_remove_source 
(BseSNet   *snet,
 BseSource *module);
Remove an existing module from its synthesis network
snet: Synth Net
module: Module

bse_snet_supports_user_synths

bse/bsesnet.proc:30
SfiBool  bse_snet_supports_user_synths 
(BseSNet *snet);
Check whether users may edit synthesis modules of this network
snet: Synth Net

bse_song_create_bus

bse/bsesong.proc:37
BseBus*  bse_song_create_bus 
(BseSong *song);
Create a new mixer bus for a Song.

bse_song_create_part

bse/bsesong.proc:245
BsePart*  bse_song_create_part 
(BseSong *song);
Create a new Part in a Song.

bse_song_create_track

bse/bsesong.proc:314
BseTrack*  bse_song_create_track 
(BseSong *song);
Create a new Track for a Song.
song: Song

bse_song_ensure_master_bus

bse/bsesong.proc:114
BseBus*  bse_song_ensure_master_bus 
(BseSong *song);
Retrieve master output bus of a song, will create one if it doesn't exist.

bse_song_ensure_track_links

bse/bsesong.proc:210
void  bse_song_ensure_track_links 
(BseSong *song);
Ensure that each part in a song is inserted into at least one track.

bse_song_find_any_track_for_part

bse/bsesong.proc:432
BseTrack*  bse_song_find_any_track_for_part 
(BseSong *song,
 BsePart *part);
Find the first track that contains part, suitable to check for orphan parts.
song: Song
part: Part

bse_song_find_track_for_part

bse/bsesong.proc:389
BseTrack*  bse_song_find_track_for_part 
(BseSong *song,
 BsePart *part);
Find a track suitable for playing notes of a given part.
song: Song
part: Part

bse_song_get_master_bus

bse/bsesong.proc:141
BseBus*  bse_song_get_master_bus 
(BseSong *song);
Retrieve master output bus of a song if it exists.

bse_song_get_timing

bse/bsesong.proc:508
BseSongTiming*  bse_song_get_timing 
(BseSong *song,
 SfiInt   tick);
Retrieve song timing information at a specific tick.
song: Song
tick: Tick to retrieve timing info about (Range: 0 .. 2147483647)

bse_song_remove_bus

bse/bsesong.proc:74
void  bse_song_remove_bus 
(BseSong *song,
 BseBus  *bus);
Delete a mixer bus from a Song.

bse_song_remove_part

bse/bsesong.proc:276
void  bse_song_remove_part 
(BseSong *song,
 BsePart *part);
Delete a Part from a Song.
song: Song
part: Part

bse_song_remove_track

bse/bsesong.proc:350
void  bse_song_remove_track 
(BseSong  *song,
 BseTrack *track);
Delete a Track from a Song.
song: Song
track: Track

bse_song_synthesize_note

bse/bsesong.proc:459
void  bse_song_synthesize_note 
(BseSong  *song,
 BseTrack *track,
 SfiInt    duration,
 SfiInt    note,
 SfiInt    fine_tune,
 SfiReal   velocity);
Synthesize a note on a song of an active project.
song: Song
track: Track
duration: Tick Duration (Range: 1 .. 2147483647)
note: Note (Range: 0 .. 131)
fine_tune: Fine tune in cents per semitone (Range: -100 .. 100)
velocity: Velocity (Range: 0 .. 1)

bse_source_clear_inputs

bse/bsesource.proc:213
void  bse_source_clear_inputs 
(BseSource *module);
Disconnect all module inputs.
module: Module

bse_source_clear_outputs

bse/bsesource.proc:240
void  bse_source_clear_outputs 
(BseSource *module);
Disconnect all module outputs.
module: Module

bse_source_get_automation_channel

bse/bsesource.proc:775
SfiInt  bse_source_get_automation_channel 
(BseSource   *source,
 const gchar *property_name);
Get MIDI channel from an automation property.
property_name: Item property name

bse_source_get_automation_control

bse/bsesource.proc:804
BseMidiControlType  bse_source_get_automation_control 
(BseSource   *source,
 const gchar *property_name);
Get control type from an automation property.
property_name: Item property name

bse_source_has_output

bse/bsesource.proc:267
SfiBool  bse_source_has_output 
(BseSource *module,
 SfiInt     ochannel);
Check whether a module's output channel is connected.
ochannel: (Range: 0 .. 2147483647)

bse_source_has_outputs

bse/bsesource.proc:291
SfiBool  bse_source_has_outputs 
(BseSource *module);
Check whether a module has output channel connections.
module: Module

bse_source_ichannel_blurb

bse/bsesource.proc:393
const gchar*  bse_source_ichannel_blurb 
(BseSource *module,
 SfiInt     input_channel);
Get input channel description.
module: Module
input_channel: Input Channel (Range: 0 .. 2147483647)

bse_source_ichannel_get_n_joints

bse/bsesource.proc:477
SfiInt  bse_source_ichannel_get_n_joints 
(BseSource *module,
 SfiInt     input_channel);
Retrieve the number of inputs connected to an input channel.
module: Module
input_channel: Input Channel (Range: 0 .. 2147483647)

bse_source_ichannel_get_ochannel

bse/bsesource.proc:546
SfiInt  bse_source_ichannel_get_ochannel 
(BseSource *module,
 SfiInt     input_channel,
 SfiInt     input_joint);
Retrieve output channel of the module connected to a specific joint of an input channel.
module: Module
input_channel: Input Channel (Range: 0 .. 2147483647)
input_joint: Input Joint (Range: 0 .. 2147483647)

bse_source_ichannel_get_osource

bse/bsesource.proc:509
BseSource*  bse_source_ichannel_get_osource 
(BseSource *module,
 SfiInt     input_channel,
 SfiInt     input_joint);
Retrieve output module connected to a specific joint of an input channel
module: Module
input_channel: Input Channel (Range: 0 .. 2147483647)
input_joint: Input Joint (Range: 0 .. 2147483647)

bse_source_ichannel_ident

bse/bsesource.proc:366
const gchar*  bse_source_ichannel_ident 
(BseSource *module,
 SfiInt     input_channel);
Get canonical input channel name.
module: Module
input_channel: Input Channel (Range: 0 .. 2147483647)

bse_source_ichannel_label

bse/bsesource.proc:339
const gchar*  bse_source_ichannel_label 
(BseSource *module,
 SfiInt     input_channel);
Get input channel name.
module: Module
input_channel: Input Channel (Range: 0 .. 2147483647)

bse_source_is_joint_ichannel

bse/bsesource.proc:447
SfiBool  bse_source_is_joint_ichannel 
(BseSource   *module,
 const gchar *input_channel);
Check if an input channel is a joint (multi-connect) channel.
module: Module
input_channel: Input Channel

bse_source_is_joint_ichannel_by_id

bse/bsesource.proc:420
SfiBool  bse_source_is_joint_ichannel_by_id 
(BseSource *module,
 SfiInt     input_channel);
Check if an input channel is a joint (multi-connect) channel.
module: Module
input_channel: Input Channel (Range: 0 .. 2147483647)

bse_source_is_prepared

bse/bsesource.proc:833
SfiBool  bse_source_is_prepared 
(BseSource *source);
Check whether a source is prepared for synthesis processing.

bse_source_n_ichannels

bse/bsesource.proc:315
SfiInt  bse_source_n_ichannels 
(BseSource *module);
Get the number of input channels of a module.
module: Module

bse_source_n_ochannels

bse/bsesource.proc:583
SfiInt  bse_source_n_ochannels 
(BseSource *module);
Get the number of output channels of a module.
module: Module

bse_source_ochannel_blurb

bse/bsesource.proc:661
const gchar*  bse_source_ochannel_blurb 
(BseSource *module,
 SfiInt     output_channel);
Get output channel description.
module: Module
output_channel: Input Channel (Range: 0 .. 2147483647)

bse_source_ochannel_ident

bse/bsesource.proc:634
const gchar*  bse_source_ochannel_ident 
(BseSource *module,
 SfiInt     output_channel);
Get canonical output channel name.
module: Module
output_channel: Input Channel (Range: 0 .. 2147483647)

bse_source_ochannel_label

bse/bsesource.proc:607
const gchar*  bse_source_ochannel_label 
(BseSource *module,
 SfiInt     output_channel);
Get output channel name.
module: Module
output_channel: Input Channel (Range: 0 .. 2147483647)

bse_source_set_automation

bse/bsesource.proc:731
BseErrorType  bse_source_set_automation 
(BseSource         *source,
 const gchar       *property_name,
 SfiInt             midi_channel,
 BseMidiControlType control_type);
Setup automation parameters for a property.
property_name: Item property name
midi_channel: The MIDI Channel from which automation events should be received, 0 designates the default MIDI channel (Range: 0 .. 99)
control_type: The type of control events used for automation

bse_source_set_input

bse/bsesource.proc:72
BseErrorType  bse_source_set_input 
(BseSource   *imodule,
 const gchar *input_channel,
 BseSource   *omodule,
 const gchar *output_channel);
Connect a module input to another module's output.
imodule: Input Module
input_channel: Input Channel
omodule: Output Module
output_channel: Output Channel

bse_source_set_input_by_id

bse/bsesource.proc:31
BseErrorType  bse_source_set_input_by_id 
(BseSource *imodule,
 SfiInt     input_channel,
 BseSource *omodule,
 SfiInt     output_channel);
Connect a module input to another module's output.
imodule: Input Module
input_channel: Input Channel (Range: 0 .. 2147483647)
omodule: Output Module
output_channel: Output Channel (Range: 0 .. 2147483647)

bse_source_set_pos

bse/bsesource.proc:688
void  bse_source_set_pos 
(BseSource *module,
 SfiReal    x_pos,
 SfiReal    y_pos);
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.
module: Module
x_pos: X Position (Range: -1.797693e+308 .. 1.797693e+308)
y_pos: Y Position (Range: -1.797693e+308 .. 1.797693e+308)

bse_source_unset_input

bse/bsesource.proc:163
BseErrorType  bse_source_unset_input 
(BseSource   *module,
 const gchar *input_channel,
 BseSource   *omodule,
 const gchar *output_channel);
Disconnect a module input.
module: Module
input_channel: Input Channel
omodule: Output Module
output_channel: Output Channel

bse_source_unset_input_by_id

bse/bsesource.proc:117
BseErrorType  bse_source_unset_input_by_id 
(BseSource *module,
 SfiInt     input_channel,
 BseSource *omodule,
 SfiInt     output_channel);
Disconnect a module input.
module: Module
input_channel: Input Channel (Range: 0 .. 2147483647)
omodule: Output Module
output_channel: Output Channel (Range: 0 .. 2147483647)

bse_string_extract_number

bse/bseprocedure.proc:313
SfiReal  bse_string_extract_number 
(const gchar *string,
 const gchar *format,
 SfiReal      aux_base,
 SfiReal      dflt);
Retrieve numbers from a string.
aux_base: (Range: -9223372036854775808 .. 9223372036854775808)
dflt: (Range: -9223372036854775808 .. 9223372036854775808)

bse_track_ensure_output

bse/bsetrack.proc:303
BseErrorType  bse_track_ensure_output 
(BseTrack *track);
Ensure the track has an output connection to a bus.
track: Track

bse_track_get_last_tick

bse/bsetrack.proc:280
SfiInt  bse_track_get_last_tick 
(BseTrack *track);
Retrieve the last tick for this track.
track: Track

bse_track_get_output_source

bse/bsetrack.proc:252
BseSource*  bse_track_get_output_source 
(BseTrack *track);
Get the output module for this track. The output of this module is the merged result from all polyphonic voices and has all track specific alterations applied.

bse_track_get_part

bse/bsetrack.proc:191
BsePart*  bse_track_get_part 
(BseTrack *track,
 SfiInt    tick);
Get the part starting at a specific tick position.
track: Track
tick: Tick (Range: 0 .. 2147483646)

bse_track_get_timing

bse/bsetrack.proc:220
BseSongTiming*  bse_track_get_timing 
(BseTrack *track,
 SfiInt    tick);
Retrieve song timing information at a specific tick.
track: Track
tick: Tick to retrieve timing info about (Range: 0 .. 2147483647)

bse_track_insert_part

bse/bsetrack.proc:32
SfiInt  bse_track_insert_part 
(BseTrack *track,
 SfiInt    tick,
 BsePart  *part);
Insert a part into a track and retrieve the corresponding link id.
track: Track
tick: Tick (Range: 0 .. 2147483646)
part: Part

bse_track_list_parts

bse/bsetrack.proc:134
BseTrackPartSeq*  bse_track_list_parts 
(BseTrack *track);
List parts scheduled in a track, sorted by tick.
track: Track

bse_track_list_parts_uniq

bse/bsetrack.proc:158
BseItemSeq*  bse_track_list_parts_uniq 
(BseTrack *track);
List all parts contained in a track.
track: Track

bse_track_remove_link

bse/bsetrack.proc:104
void  bse_track_remove_link 
(BseTrack *track,
 SfiInt    id);
Remove a specific part link by ID from a track.
track: Track
id: Link ID (Range: 0 .. 2147483647)

bse_track_remove_tick

bse/bsetrack.proc:73
void  bse_track_remove_tick 
(BseTrack *track,
 SfiInt    tick);
Remove a part at specified tick from a track.
track: Track
tick: Tick (Range: 0 .. 2147483646)

bse_type_authors

bse/bseprocedure.proc:242
Retrieve the authors who implemented a specific type.

bse_type_blurb

bse/bseprocedure.proc:218
Retrieve the description of a specific type.

bse_type_license

bse/bseprocedure.proc:266
Retrieve the license of a type impementation.

bse_type_options

bse/bseprocedure.proc:194
Retrieve the options of a specific type.

bse_wave_chunk_get_mix_freq

bse/bsewave.proc:155
SfiReal  bse_wave_chunk_get_mix_freq 
(BseWave *wave,
 SfiInt   chunk_index);
Retrieve mixing frequency of a wave chunk.
wave: Wave
chunk_index: Index of chunk (Range: 0 .. 2147483647)

bse_wave_chunk_get_osc_freq

bse/bsewave.proc:125
SfiReal  bse_wave_chunk_get_osc_freq 
(BseWave *wave,
 SfiInt   chunk_index);
Retrieve oscillating frequency of a wave chunk.
wave: Wave
chunk_index: Index of chunk (Range: 0 .. 2147483647)

bse_wave_load_wave

bse/bsewave.proc:29
BseErrorType  bse_wave_load_wave 
(BseWave     *wave,
 const gchar *file_name,
 const gchar *wave_name);
Load sample chunks from a wave file
wave: Wave object to store loaded contents
file_name: The wave file to read wave chunks from
wave_name: The name of the wave to read wave chunks from

bse_wave_n_wave_chunks

bse/bsewave.proc:63
SfiInt  bse_wave_n_wave_chunks 
(BseWave *wave);
Get the number of wave chunks of a wave
wave: Wave

bse_wave_osc_mass_seek_perc

bse/bsewaveosc.proc:48
void  bse_wave_osc_mass_seek_perc 
(BseItemSeq *wosc_seq,
 SfiReal     pos_perc);
Seek a list of wave oscillators to a pcm position given in percentage. The oscillators will seek to the given position syncronously.
wosc_seq: Wave Oscilators
pos_perc: (Range: 0 .. 100)

bse_wave_osc_request_pcm_position

bse/bsewaveosc.proc:28
void  bse_wave_osc_request_pcm_position 
(BseWaveOsc *wosc);
Request emission of the ::notify_pcm_position signal.
wosc: Wave Oscilator

bse_wave_osc_set_from_editable_sample

bse/bsewaveosc.proc:74
void  bse_wave_osc_set_from_editable_sample 
(BseWaveOsc        *wosc,
 BseEditableSample *esample);
Set wave to play from editable sample, bypassing undo and storage mechanisms.
wosc: Wave Oscilator
esample: Editable Sample

bse_wave_repo_load_file

bse/bsewaverepo.proc:63
BseErrorType  bse_wave_repo_load_file 
(BseWaveRepo *wave_repo,
 const gchar *file_name);
Load wave from file
wave_repo: Wave Repo
file_name: The file to import waves from

bse_wave_repo_remove_wave

bse/bsewaverepo.proc:100
void  bse_wave_repo_remove_wave 
(BseWaveRepo *wave_repo,
 BseWave     *wave);
Remove a wave from repository
wave_repo: Wave Repo
wave: Wave

bse_wave_use_editable

bse/bsewave.proc:87
BseEditableSample*  bse_wave_use_editable 
(BseWave *wave,
 SfiInt   chunk_index);
Retrieve an editable sample object for a wave chunk.
wave: Wave
chunk_index: Index of chunk to edit (Range: 0 .. 2147483647)