BSE Object Reference

/usr/src/RPM/BUILD/beast-0.7.2/docs/psource/bse-objects.scad

SYNOPSIS

object  BseBiquadFilter;
object  BseBus;
object  BseBusModule;
object  BseCSynth;
object  BseConstant;
object  BseContainer {
 Signals:
  void  ::item-added  (arg1);
  void  ::item-remove  (arg1, arg2);
};
object  BseContextMerger;
object  BseCxxBase;
object  BseDataPocket {
 Signals:
  void  ::entry-added  (arg1);
  void  ::entry-removed  (arg1);
  void  ::entry-changed  (arg1);
};
object  BseDevice;
object  BseEditableSample {
 Signals:
  void  ::changed  ();
};
object  BseEffect;
object  BseInstrumentInput;
object  BseInstrumentOutput;
object  BseItem {
 Signals:
  void  ::parasites-added  (arg1);
  void  ::parasite-changed  (arg1);
};
object  BseJanitor {
 Signals:
  void  ::progress  (arg1);
  void  ::action-changed  (arg1, arg2);
  void  ::action  (arg1, arg2);
  void  ::shutdown  ();
};
object  BseLadspaModule;
object  BseMidiController;
object  BseMidiDevice;
object  BseMidiDeviceNULL;
object  BseMidiDeviceOSS;
object  BseMidiInput;
object  BseMidiNotifier {
 Signals:
  void  ::midi-event  (arg1);
};
object  BseMidiSynth;
object  BseMidiVoiceInput;
object  BseMidiVoiceSwitch;
object  BseObject {
 Signals:
  void  ::release  ();
  void  ::icon-changed  ();
};
object  BsePart {
 Signals:
  void  ::range-changed  (arg1, arg2, arg3, arg4);
  void  ::links-changed  ();
};
object  BsePcmDevice;
object  BsePcmDeviceNull;
object  BsePcmDeviceOSS;
object  BsePcmInput;
object  BsePcmOutput;
object  BsePcmWriter;
object  BseProject {
 Signals:
  void  ::state-changed  (arg1);
};
object  BseSNet {
 Signals:
  void  ::port-unregistered  ();
};
object  BseServer {
 Signals:
  void  ::registration  (arg1, arg2, arg3);
  void  ::message  (arg1);
  void  ::script-start  (arg1);
  void  ::script-error  (arg1, arg2, arg3);
};
object  BseSnooper;
object  BseSong {
 Signals:
  void  ::pointer-changed  (arg1);
};
object  BseSource {
 Signals:
  void  ::probes  (arg1);
  void  ::io-changed  ();
};
object  BseStandardOsc;
object  BseStorage;
object  BseSubIPort;
object  BseSubOPort;
object  BseSubSynth;
object  BseSuper;
object  BseTrack {
 Signals:
  void  ::changed  ();
};
object  BseWave;
object  BseWaveOsc {
 Signals:
  void  ::notify-pcm-position  (arg1, arg2);
};
object  BseWaveRepo;

DESCRIPTION

BseBiquadFilter

object BseBiquadFilter
{
 Channels:
  Input  ::audio-in;
  Input  ::freq-in;
  Input  ::freq-mod-in;
  Input  ::gain-mod-in;
  Output  ::audio-out;
 Properties:
  BseBiquadFilterType  ::filter_type;
  SfiReal  ::freq;
  SfiInt  ::note;
  SfiReal  ::gain;
  SfiReal  ::fm_perc;
  SfiBool  ::exponential_fm;
  SfiReal  ::fm_n_octaves;
  SfiReal  ::gain_perc;
};
BseBiquadFilter - an infinite impulse response filter, consisting of 2-zeros/2-poles segments (thus it's name: bi-quadratic). Various types of filters are supported with modulatable center (Cut-Off) frequency and gain input signals.

Channels:
audio-in: Unfiltered Audio Signal
freq-in: Center Frequency Input
freq-mod-in: Frequency Modulation Input
gain-mod-in: Gain Modulation Input
audio-out: Filtered Audio Signal


Properties:
filter_type: The filter design type
freq: Filter cutoff frequency in Hertz (Range: 0.00005 .. 19999.9)
note: Filter cutoff frequency as note, converted to Hertz according to the current musical tuning (Range: 0 .. 131)
gain: Gain [dB] (Range: -48 .. 48)
fm_perc: Strength of linear frequency modulation (Range: 0 .. 100)
exponential_fm: Perform exponential frequency modulation instead of linear
fm_n_octaves: Number of octaves to be affected by exponential frequency modulation (Range: 0 .. 5)
gain_perc: Strength of gain modulation (Range: 0 .. 100)

BseBus

object BseBus
{
 Channels:
  Input  ::left-audio-in;
  Input  ::right-audio-in;
  Output  ::left-audio-out;
  Output  ::right-audio-out;
 Properties:
  BseItemSeq*  ::inputs;
  BseItemSeq*  ::outputs;
  SfiBool  ::mute;
  SfiBool  ::solo;
  SfiBool  ::sync;
  SfiReal  ::left_volume;
  SfiReal  ::right_volume;
};
Bus implementation for songs, used to route track audio signals to the master output.

Channels:
left-audio-in: Left channel input
right-audio-in: Right channel input
left-audio-out: Left channel output
right-audio-out: Right channel output


Properties:
inputs: Synthesis signals (from tracks and busses) used as bus input
outputs: Mixer busses used as output for synthesis signals
mute: Mute: turn off the bus volume
solo: Solo: mute all other busses
sync: Syncronize left and right volume
left_volume: Volume adjustment in decibel of left bus channel (Range: 0.0000158 .. 15.8489319)
right_volume: Volume adjustment in decibel of right bus channel (Range: 0.0000158 .. 15.8489319)

BseBusModule

object BseBusModule
{
 Channels:
  Input  ::audio-in1;
  Input  ::audio-in2;
  Output  ::audio-out1;
  Output  ::audio-out2;
 Properties:
  SfiReal  ::volume1;
  SfiReal  ::volume2;
};
Synthesis module used internally by BseBus

Authors: Tim Janik

License: GNU Lesser General Public License

Channels:
audio-in1: First audio input
audio-in2: Second audio input
audio-out1: First audio output
audio-out2: Second audio output


Properties:
volume1: (Range: 0 .. 1000)
volume2: (Range: 0 .. 1000)

BseCSynth

object BseCSynth
{
};
BSE Synthesis (Filter) Network

BseConstant

object BseConstant
{
 Channels:
  Output  ::const-out1;
  Output  ::const-out2;
  Output  ::const-out3;
  Output  ::const-out4;
 Properties:
  SfiReal  ::value_1;
  SfiReal  ::frequency_1;
  SfiInt  ::note_1;
  SfiReal  ::value_2;
  SfiReal  ::frequency_2;
  SfiInt  ::note_2;
  SfiReal  ::value_3;
  SfiReal  ::frequency_3;
  SfiInt  ::note_3;
  SfiReal  ::value_4;
  SfiReal  ::frequency_4;
  SfiInt  ::note_4;
};
This module provides constant signal outputs

Channels:
const-out1: Constant Output 1
const-out2: Constant Output 2
const-out3: Constant Output 3
const-out4: Constant Output 4


Properties:
value_1: Constant signal value (Range: -1 .. 1)
frequency_1: Constant signal value interpreted as frequency value in Hertz (Range: 0 .. 24000)
note_1: Constant signal value as note, converted to Hertz according to the current musical tuning (Range: 0 .. 131)
value_2: Constant signal value (Range: -1 .. 1)
frequency_2: Constant signal value interpreted as frequency value in Hertz (Range: 0 .. 24000)
note_2: Constant signal value as note, converted to Hertz according to the current musical tuning (Range: 0 .. 131)
value_3: Constant signal value (Range: -1 .. 1)
frequency_3: Constant signal value interpreted as frequency value in Hertz (Range: 0 .. 24000)
note_3: Constant signal value as note, converted to Hertz according to the current musical tuning (Range: 0 .. 131)
value_4: Constant signal value (Range: -1 .. 1)
frequency_4: Constant signal value interpreted as frequency value in Hertz (Range: 0 .. 24000)
note_4: Constant signal value as note, converted to Hertz according to the current musical tuning (Range: 0 .. 131)

BseContainer

object BseContainer
{
 Signals:
  void  ::item-added 
(BseItem arg1);
  void  ::item-remove 
(BseItem arg1,
 gint    arg2);
};
Base type to manage BSE items

BseContextMerger

object BseContextMerger
{
 Channels:
  JointInput  ::input-1;
  JointInput  ::input-2;
  JointInput  ::input-3;
  JointInput  ::input-4;
  JointInput  ::input-5;
  JointInput  ::input-6;
  JointInput  ::input-7;
  JointInput  ::input-8;
  Output  ::output-1;
  Output  ::output-2;
  Output  ::output-3;
  Output  ::output-4;
  Output  ::output-5;
  Output  ::output-6;
  Output  ::output-7;
  Output  ::output-8;
};
Internal CONTEXT Voice glue object (merger)

BseCxxBase

object BseCxxBase
{
};

BseDataPocket

object BseDataPocket
{
 Signals:
  void  ::entry-added 
(gint arg1);
  void  ::entry-removed 
(gint arg1);
  void  ::entry-changed 
(gint arg1);
};
Data pocket type

BseDevice

object BseDevice
{
};
Abstract device base type

BseEditableSample

object BseEditableSample
{
 Signals:
  void  ::changed 
();
};
Editable sample type

BseEffect

object BseEffect
{
};
BseEffect implements an abstract C++ effect base.

BseInstrumentInput

object BseInstrumentInput
{
 Channels:
  Output  ::frequency;
  Output  ::gate;
  Output  ::velocity;
  Output  ::aftertouch;
};
Virtual input module for synthesis networks which implement instruments

Channels:
frequency: Note Frequency
gate: High if the note is currently being pressed
velocity: Velocity of the note press
aftertouch: Velocity while the note is pressed

BseInstrumentOutput

object BseInstrumentOutput
{
 Channels:
  Input  ::left-audio;
  Input  ::right-audio;
  Input  ::unused;
  Input  ::synth-done;
};
Virtual output module for synthesis networks which implement instruments

Channels:
left-audio: Left Channel Output
right-audio: Right Channel Output
synth-done: High indicates the instrument is done synthesizing

BseItem

object BseItem
{
 Signals:
  void  ::parasites-added 
(gchararray arg1);
  void  ::parasite-changed 
(gchararray arg1);
};
Base type for objects managed by a container

BseJanitor

object BseJanitor
{
 Properties:
  const gchar*  ::ident;
  SfiBool  ::connected;
  const gchar*  ::status_message;
  SfiInt  ::exit_code;
  const gchar*  ::exit_reason;
 Signals:
  void  ::progress 
(gfloat arg1);
  void  ::action-changed 
(gchararray arg1,
 gint       arg2);
  void  ::action 
(gchararray arg1,
 gint       arg2);
  void  ::shutdown 
();
};
BSE connection interface object

Properties:
ident: Script Identifier
connected: Connected
status_message: Status Message
exit_code: Exit Code (Range: -256 .. 256)
exit_reason: Exit Reason

BseLadspaModule

object BseLadspaModule
{
};
LADSPA Module base type

BseMidiController

object BseMidiController
{
 Channels:
  Output  ::ctrl-out1;
  Output  ::ctrl-out2;
  Output  ::ctrl-out3;
  Output  ::ctrl-out4;
 Properties:
  SfiInt  ::midi_channel;
  BseMidiSignalType  ::control_1;
  BseMidiSignalType  ::control_2;
  BseMidiSignalType  ::control_3;
  BseMidiSignalType  ::control_4;
};
MIDI controller input module. With this module, MIDI control signals can be used in synthesis networks.

Channels:
ctrl-out1: MIDI Signal 1
ctrl-out2: MIDI Signal 2
ctrl-out3: MIDI Signal 3
ctrl-out4: MIDI Signal 4


Properties:
midi_channel: Input MIDI channel, 0 uses network's default channel (Range: 0 .. 99)
control_1: Signal 1
control_2: Signal 2
control_3: Signal 3
control_4: Signal 4

BseMidiDevice

object BseMidiDevice
{
};
MIDI device base type

BseMidiDeviceNULL

object BseMidiDeviceNULL
{
};
MIDI device implementation that does nothing

BseMidiDeviceOSS

object BseMidiDeviceOSS
{
};
MIDI device implementation for OSS Lite /dev/midi*

BseMidiInput

object BseMidiInput
{
 Channels:
  Output  ::frequency;
  Output  ::gate;
  Output  ::velocity;
  Output  ::aftertouch;
 Properties:
  SfiInt  ::midi_channel;
};
Monophonic MIDI input module. With this module, monophonic keyboard control signals can be used in synthesis networks.

Channels:
frequency: Note Frequency
gate: High if the note is currently being pressed
velocity: Velocity of the note press
aftertouch: Velocity while the note is pressed


Properties:
midi_channel: Input MIDI channel, 0 uses network's default channel (Range: 0 .. 99)

BseMidiNotifier

object BseMidiNotifier
{
 Signals:
  void  ::midi-event 
(BseMidiChannelEvent arg1);
};
MIDI Event Notifier

BseMidiSynth

object BseMidiSynth
{
 Properties:
  SfiInt  ::midi_channel;
  SfiInt  ::n_voices;
  BseCSynth*  ::snet;
  BseCSynth*  ::pnet;
  SfiReal  ::volume_d_b;
  SfiInt  ::volume_perc;
};
BSE Midi Synthesizer

Properties:
midi_channel: MIDI Channel (Range: 1 .. 99)
n_voices: Maximum number of voices for simultaneous playback (Range: 1 .. 256)
snet: Synthesis network to be used as MIDI instrument
pnet: Synthesis network to be used as postprocessor
volume_d_b: Master [dB] (Range: -144 .. 24)
volume_perc: Master [%] (Range: 0 .. 1584)

BseMidiVoiceInput

object BseMidiVoiceInput
{
 Channels:
  Output  ::freq-out;
  Output  ::gate-out;
  Output  ::velocity-out;
  Output  ::aftertouch-out;
};
Internal MIDI Voice glue object (input)

BseMidiVoiceSwitch

object BseMidiVoiceSwitch
{
 Channels:
  Input  ::left-in;
  Input  ::right-in;
  Input  ::disconnect-in;
  Output  ::left-out;
  Output  ::right-out;
  Output  ::disconnect-out;
};
Internal MIDI Voice glue object (switch)

BseObject

object BseObject
{
 Properties:
  const gchar*  ::uname;
  const gchar*  ::blurb;
 Signals:
  void  ::release 
();
  void  ::icon-changed 
();
};
BSE Object Hierarchy base type

Properties:
uname: Unique name of this object
blurb: Free form comment or description

BsePart

object BsePart
{
 Properties:
  SfiInt  ::n_channels;
  SfiInt  ::last_tick;
 Signals:
  void  ::range-changed 
(gint arg1,
 gint arg2,
 gint arg3,
 gint arg4);
  void  ::links-changed 
();
};
BSE part type

Properties:
n_channels: Channels (Range: 1 .. 4132)
last_tick: Last Tick (Range: 0 .. 2147483647)

BsePcmDevice

object BsePcmDevice
{
};
PCM device base type

BsePcmDeviceNull

object BsePcmDeviceNull
{
};
Null PCM device implementation

BsePcmDeviceOSS

object BsePcmDeviceOSS
{
};
PCM device implementation for OSS Lite /dev/dsp

BsePcmInput

object BsePcmInput
{
 Channels:
  Output  ::left-audio-out;
  Output  ::right-audio-out;
 Properties:
  SfiReal  ::gain_volume_d_b;
  SfiInt  ::gain_volume_perc;
};
Stereo PCM sound input module, per default, signals from this module originate from recording on the standard soundcard

Channels:
left-audio-out: Left channel output
right-audio-out: Right channel output


Properties:
gain_volume_d_b: Input Gain [dB] (Range: -144 .. 24)
gain_volume_perc: input Gain [%] (Range: 0 .. 1584)

BsePcmOutput

object BsePcmOutput
{
 Channels:
  Input  ::left-audio-in;
  Input  ::right-audio-in;
 Properties:
  SfiReal  ::master_volume_d_b;
  SfiInt  ::master_volume_perc;
};
Stereo PCM sound output module, per default, signals routed into this module are played back on the standard soundcard

Channels:
left-audio-in: Left channel input
right-audio-in: Right channel Input


Properties:
master_volume_d_b: Master [dB] (Range: -144 .. 24)
master_volume_perc: Master [%] (Range: 0 .. 1584)

BsePcmWriter

object BsePcmWriter
{
};
PCM writer

BseProject

object BseProject
{
 Signals:
  void  ::state-changed 
(BseProjectState arg1);
};
BSE Super container type

BseSNet

object BseSNet
{
 Properties:
  SfiBool  ::auto_activate;
 Signals:
  void  ::port-unregistered 
();
};
BSE Synthesis (Filter) Network

Properties:
auto_activate: Automatic activation only needs to be enabled for synthesis networks that don't use virtual ports for their input and output

BseServer

object BseServer
{
 Properties:
  BseGConfig*  ::bse_preferences;
  const gchar*  ::wave_file;
  SfiBool  ::log_messages;
 Signals:
  void  ::registration 
(BseRegistrationType arg1,
 gchararray          arg2,
 gchararray          arg3);
  void  ::message 
(BseMessage arg1);
  void  ::script-start 
(BseJanitor arg1);
  void  ::script-error 
(gchararray arg1,
 gchararray arg2,
 gchararray arg3);
};
BSE Server type

Properties:
wave_file: Name of the WAVE file used for recording BSE sound output
log_messages: Log messages through the log system

BseSnooper

object BseSnooper
{
 Channels:
  Input  ::signal-in;
 Properties:
  SfiInt  ::context_id;
};
The Snooper module prints statistics about the incoming signal

Channels:
signal-in: Snoop Signal


Properties:
context_id: If the snooper module is created multiple times, this is the context id, which is used to actually snoop data. (Range: 0 .. 65535)

BseSong

object BseSong
{
 Properties:
  BseMusicalTuningType  ::musical_tuning;
  SfiInt  ::tpqn;
  SfiInt  ::numerator;
  SfiInt  ::denominator;
  SfiReal  ::bpm;
  BseCSynth*  ::pnet;
 Signals:
  void  ::pointer-changed 
(gint arg1);
};
BSE Song type

Properties:
musical_tuning: The tuning system which specifies the tones or pitches to be used. Due to the psychoacoustic properties of tones, various pitch combinations can sound "natural" or "pleasing" when used in combination, the musical tuning system defines the number and spacing of frequency values applied.
tpqn: Number of ticks per quarter note (Range: 384 .. 384)
numerator: Measure numerator (Range: 1 .. 256)
denominator: Measure denominator, must be a power of 2 (Range: 1 .. 256)
bpm: Beats per minute (Range: 1 .. 1024)
pnet: Synthesis network to be used as postprocessor

BseSource

object BseSource
{
 Signals:
  void  ::probes 
(BseProbeSeq arg1);
  void  ::io-changed 
();
};
Base type for sound sources

BseStandardOsc

object BseStandardOsc
{
 Channels:
  Input  ::freq-in;
  Input  ::freq-mod-in;
  Input  ::pwm-in;
  Input  ::sync-in;
  Output  ::audio-out;
  Output  ::sync-out;
 Properties:
  BseStandardOscWaveType  ::wave_form;
  SfiReal  ::phase;
  SfiReal  ::base_freq;
  SfiInt  ::base_note;
  SfiInt  ::transpose;
  SfiInt  ::fine_tune;
  SfiReal  ::fm_perc;
  SfiBool  ::exponential_fm;
  SfiReal  ::fm_n_octaves;
  SfiReal  ::self_perc;
  SfiReal  ::pulse_width;
  SfiReal  ::pulse_mod_perc;
};
StandardOsc is the BSE basis oscillator which supports various types of wave forms and modulation inputs.

Channels:
freq-in: Oscillating Frequency Input
freq-mod-in: Frequency Modulation Input
pwm-in: Pulse Width Modulation Input
sync-in: Syncronization Input
audio-out: Oscillated Output
sync-out: Syncronization Output


Properties:
wave_form: Oscillator wave form
phase: Initial phase of the oscillator wave form (cycle offset in degree) (Range: -180 .. 180)
base_freq: Oscillator frequency in Hertz, i.e. the number of oscillator cycles per second (Range: 0.00005 .. 20000)
base_note: Oscillator frequency as note, converted to Hertz according to the current musical tuning (Range: 0 .. 131)
transpose: Transposition of the oscillator frequency in semitones (Range: -72 .. 72)
fine_tune: Amount of detuning in cent (hundredth part of a semitone) (Range: -100 .. 100)
fm_perc: Strength of linear frequency modulation (Range: 0 .. 100)
exponential_fm: Perform exponential frequency modulation instead of linear
fm_n_octaves: Number of octaves to be affected by exponential frequency modulation (Range: 0 .. 5)
self_perc: Strength of self modulation (Range: 0 .. 100)
pulse_width: Proportion of the positive component duration of the pulse wave form (Pulse has to be selected as wave form for this to take effect) (Range: 0 .. 100)
pulse_mod_perc: Strength of pulse width modulation input (Pulse has to be selected as wave form for this to take effect) (Range: 0 .. 100)

BseStorage

object BseStorage
{
};
Storage object for item serialization

BseSubIPort

object BseSubIPort
{
 Channels:
  Output  ::output-1;
  Output  ::output-2;
  Output  ::output-3;
  Output  ::output-4;
 Properties:
  const gchar*  ::in_port_1;
  const gchar*  ::in_port_2;
  const gchar*  ::in_port_3;
  const gchar*  ::in_port_4;
};
Virtual input port connector, used to provide a synthesis network with input signals from other synthesis networks

Properties:
in_port_1: The port name is a unique name to establish input<->output port relationships
in_port_2: The port name is a unique name to establish input<->output port relationships
in_port_3: The port name is a unique name to establish input<->output port relationships
in_port_4: The port name is a unique name to establish input<->output port relationships

BseSubOPort

object BseSubOPort
{
 Channels:
  Input  ::input-1;
  Input  ::input-2;
  Input  ::input-3;
  Input  ::input-4;
 Properties:
  const gchar*  ::out_port_1;
  const gchar*  ::out_port_2;
  const gchar*  ::out_port_3;
  const gchar*  ::out_port_4;
};
Virtual output port connector, used to provide a synthesis network with output signals from other synthesis networks

Properties:
out_port_1: The port name is a unique name to establish input<->output port relationships
out_port_2: The port name is a unique name to establish input<->output port relationships
out_port_3: The port name is a unique name to establish input<->output port relationships
out_port_4: The port name is a unique name to establish input<->output port relationships

BseSubSynth

object BseSubSynth
{
 Channels:
  Input  ::input-1;
  Input  ::input-2;
  Input  ::input-3;
  Input  ::input-4;
  Input  ::input-5;
  Input  ::input-6;
  Input  ::input-7;
  Input  ::input-8;
  Output  ::output-1;
  Output  ::output-2;
  Output  ::output-3;
  Output  ::output-4;
  Output  ::output-5;
  Output  ::output-6;
  Output  ::output-7;
  Output  ::output-8;
 Properties:
  BseCSynth*  ::snet;
  const gchar*  ::in_port_1;
  const gchar*  ::out_port_1;
  const gchar*  ::in_port_2;
  const gchar*  ::out_port_2;
  const gchar*  ::in_port_3;
  const gchar*  ::out_port_3;
  const gchar*  ::in_port_4;
  const gchar*  ::out_port_4;
  const gchar*  ::in_port_5;
  const gchar*  ::out_port_5;
  const gchar*  ::in_port_6;
  const gchar*  ::out_port_6;
  const gchar*  ::in_port_7;
  const gchar*  ::out_port_7;
  const gchar*  ::in_port_8;
  const gchar*  ::out_port_8;
};
This module encapsulates whole synthesizer networks, by interfacing to/from their virtual input and output ports

Properties:
snet: Synthesis network to use as embedded sub network
in_port_1: Output port name to interface from
out_port_1: Input port name to interface to
in_port_2: Output port name to interface from
out_port_2: Input port name to interface to
in_port_3: Output port name to interface from
out_port_3: Input port name to interface to
in_port_4: Output port name to interface from
out_port_4: Input port name to interface to
in_port_5: Output port name to interface from
out_port_5: Input port name to interface to
in_port_6: Output port name to interface from
out_port_6: Input port name to interface to
in_port_7: Output port name to interface from
out_port_7: Input port name to interface to
in_port_8: Output port name to interface from
out_port_8: Input port name to interface to

BseSuper

object BseSuper
{
 Properties:
  const gchar*  ::author;
  const gchar*  ::license;
  SfiNum  ::creation_time;
  SfiNum  ::modification_time;
};
Base type for item managers

Properties:
author: Person changing or creating this object
license: Copyright license applying to this object
creation_time: Creation Time
modification_time: Last modification time

BseTrack

object BseTrack
{
 Channels:
  JointInput  ::input-1;
  JointInput  ::input-2;
  JointInput  ::input-3;
  JointInput  ::input-4;
  JointInput  ::input-5;
  JointInput  ::input-6;
  JointInput  ::input-7;
  JointInput  ::input-8;
  Output  ::output-1;
  Output  ::output-2;
  Output  ::output-3;
  Output  ::output-4;
  Output  ::output-5;
  Output  ::output-6;
  Output  ::output-7;
  Output  ::output-8;
 Properties:
  SfiBool  ::muted;
  BseCSynth*  ::snet;
  BseWave*  ::wave;
  SfiInt  ::midi_channel;
  SfiInt  ::n_voices;
  BseCSynth*  ::pnet;
  BseItemSeq*  ::outputs;
 Signals:
  void  ::changed 
();
};
BSE track type

Properties:
muted: Muted
snet: Synthesis network to be used as instrument
wave: Wave to be used as instrument
midi_channel: Midi channel assigned to this track, 0 uses internal per-track channel (Range: 0 .. 99)
n_voices: Maximum number of voices for simultaneous playback (Range: 1 .. 256)
pnet: Synthesis network to be used as postprocessor
outputs: Mixer busses used as output for this track

BseWave

object BseWave
{
 Properties:
  SfiBool  ::locator_set;
  const gchar*  ::file_name;
  const gchar*  ::wave_name;
};
BSE wave type

Properties:
locator_set: Locator Set
file_name: File Name
wave_name: Wave Name

BseWaveOsc

object BseWaveOsc
{
 Channels:
  Input  ::freq-in;
  Input  ::sync-in;
  Input  ::mod-in;
  Output  ::audio-out;
  Output  ::gate-out;
  Output  ::done-out;
 Properties:
  BseWave*  ::wave;
  SfiInt  ::channel;
  SfiReal  ::fm_perc;
  SfiBool  ::exponential_fm;
  SfiReal  ::fm_n_octaves;
 Signals:
  void  ::notify-pcm-position 
(gint64 arg1,
 gint   arg2);
};
BseWaveOsc is a wave based oscillator module. It plays waves at arbitrary frequency with little to no aliasing artefacts by using a tschbyscheff type II resampling filter. The plaback frequency can be specified through a frequency input, and be modulated by another control signal with linear or exponential frequency response.

Channels:
freq-in: Frequency Input
sync-in: Syncronization Input
mod-in: Modulation Input
audio-out: Wave Output
gate-out: Gate Output
done-out: Done Output


Properties:
wave: Wave used as oscillator source
channel: The audio channel to play, usually 1 is left, 2 is right (Range: 1 .. 256)
fm_perc: Modulation Strength for linear frequency modulation (Range: 0 .. 100)
exponential_fm: Perform exponential frequency modulation instead of linear
fm_n_octaves: Number of octaves to be affected by exponential frequency modulation (Range: 0 .. 3)

BseWaveRepo

object BseWaveRepo
{
};
BSE Wave Repository