BSE Object Reference

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

SYNOPSIS

object  BseAdder;
object  BseAmplifier;
object  BseArtsCompressor;
object  BseAtanDistort;
object  BseBalance;
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  BseContribSampleAndHold;
object  BseCxxBase;
object  BseDataPocket {
 Signals:
  void  ::entry-added  (arg1);
  void  ::entry-removed  (arg1);
  void  ::entry-changed  (arg1);
};
object  BseDavBassFilter;
object  BseDavChorus;
object  BseDevice;
object  BseEditableSample {
 Signals:
  void  ::changed  ();
};
object  BseEffect;
object  BseFreeVerb;
object  BseIIRFilter;
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  BseMidiDeviceALSA;
object  BseMidiDeviceNULL;
object  BseMidiDeviceOSS;
object  BseMidiInput;
object  BseMidiNotifier {
 Signals:
  void  ::midi-event  (arg1);
};
object  BseMidiSynth;
object  BseMidiVoiceInput;
object  BseMidiVoiceSwitch;
object  BseMixer;
object  BseMult;
object  BseNoise;
object  BseObject {
 Signals:
  void  ::release  ();
  void  ::icon-changed  ();
};
object  BsePart {
 Signals:
  void  ::range-changed  (arg1, arg2, arg3, arg4);
  void  ::links-changed  ();
};
object  BsePcmDevice;
object  BsePcmDeviceALSA;
object  BsePcmDeviceNull;
object  BsePcmDeviceOSS;
object  BsePcmInput;
object  BsePcmOutput;
object  BsePcmWriter;
object  BseProject {
 Signals:
  void  ::state-changed  (arg1);
};
object  BseSNet {
 Signals:
  void  ::port-unregistered  ();
};
object  BseSequencer;
object  BseServer {
 Signals:
  void  ::registration  (arg1, arg2, arg3);
  void  ::message  (arg1);
  void  ::script-start  (arg1);
  void  ::script-error  (arg1, arg2, arg3);
};
object  BseSimpleADSR;
object  BseSnooper;
object  BseSong {
 Signals:
  void  ::pointer-changed  (arg1);
};
object  BseSource {
 Signals:
  void  ::io-changed  ();
  void  ::probes  (arg1);
};
object  BseStandardGusPatchEnvelope;
object  BseStandardOsc;
object  BseStandardQuantizer;
object  BseStandardSaturator;
object  BseStorage;
object  BseSubIPort;
object  BseSubOPort;
object  BseSubSynth;
object  BseSummation;
object  BseSuper;
object  BseTrack {
 Signals:
  void  ::changed  ();
};
object  BseWave;
object  BseWaveOsc {
 Signals:
  void  ::notify-pcm-position  (arg1, arg2);
};
object  BseWaveRepo;
object  DavCanyonDelay;
object  DavOrgan;
object  DavSynDrum;
object  DavXtalStrings;

DESCRIPTION

BseAdder

object BseAdder
{
 Channels:
  JointInput  ::audio-in1;
  JointInput  ::audio-in2;
  Output  ::audio-out;
 Properties:
  SfiBool  ::subtract;
};
The Adder is a very simplisitic prototype mixer that just sums up incoming signals (it does allow for switching to subtract mode though)

Channels:
audio-in1: Audio Input 1
audio-in2: Audio Input 2
audio-out: Audio Output


Properties:
subtract: Use subtraction to combine samplevalues (instead of addition)

BseAmplifier

object BseAmplifier
{
 Channels:
  Input  ::audio-in1;
  Input  ::audio-in2;
  Input  ::ctrl-in1;
  Input  ::ctrl-in2;
  Output  ::audio-out;
 Properties:
  SfiReal  ::alevel1;
  SfiReal  ::alevel2;
  SfiReal  ::abalance;
  SfiReal  ::clevel1;
  SfiReal  ::clevel2;
  SfiReal  ::cbalance;
  SfiBool  ::ctrl_mul;
  SfiBool  ::ctrl_exp;
  SfiReal  ::ostrength;
  SfiReal  ::base_level;
  SfiReal  ::master_volume;
};
BseAmplifier provides input signal controlled amplification or attenuation. It supports two control inputs and two audio inputs which are mixed together after balance and level adjustments. The gain setting controls preamplification of the mixed audio signal. The mixed control signal, weighted by a strength setting, determines additional amplification, allowing for external sources to modulate the overall volume (tremolo). The mixed control signal can influence the amplification linearly (to amplify other control signals) or exponentially (to amplify audio signals). Finally, the master volume controls amplification of the resulting output signal.

Authors: Tim Janik

License: GNU Lesser General Public License

Channels:
audio-in1: First audio input
audio-in2: Second audio input
ctrl-in1: First control input
ctrl-in2: Second control input
audio-out: Amplified audio output


Properties:
alevel1: Attenuate the level of audio input 1 (Range: 0 .. 100)
alevel2: Attenuate the level of audio input 2 (Range: 0 .. 100)
abalance: Balance audio input levels (Range: -100 .. 100)
clevel1: Attenuate the level of control input 1 (Range: 0 .. 100)
clevel2: Attenuate the level of control input 2 (Range: 0 .. 100)
cbalance: Balance control input levels (Range: -100 .. 100)
ctrl_mul: Switch the two control inputs to work like a chain of gain controls, rather than mixing them together, weighted by balance.
ctrl_exp: Toggle exponential and linear control response
ostrength: Adjust how much the control signals affect the output volume (Range: 0 .. 100)
base_level: Base amplification (the control signal adds up to this) (Range: 0 .. 100)
master_volume: Output stage amplification in decibel (Range: 0.0000158 .. 15.8489319)

BseArtsCompressor

object BseArtsCompressor
{
 Channels:
  Input  ::audio-in1;
  Input  ::audio-in2;
  Output  ::audio-out1;
  Output  ::audio-out2;
 Properties:
  SfiReal  ::attack;
  SfiReal  ::release;
  SfiReal  ::threshold_db;
  SfiReal  ::ratio_to_one;
  SfiReal  ::output_db;
  SfiBool  ::auto_output;
};
ArtsCompressor compresses the sound.

Compression is a dynamic operation that consists of two parts: (1) the current input volume of the signal is detected (2) if it exceeds a given theshold, the volume of the output signal will be reduced

The input volume detection has an attack and a release half-life time which can be specified - in milliseconds - with the corresponding properties. This envelope causes the compressor to adapt slowly to the actual input signal level.

The ratio specifies how the volume of a signal should be reduced, if it exceeds the threshold. A compression ratio of 2:1 means for instance that if the input volume is 2 dB over the threshold, the output volume will be 1 dB over the threshold. Example (threshold = -10, ratio 2:1): input = -20 dB => output = -20 dB input = -10 dB => output = -10 dB input = 0 dB => output = -5 dB input = 10 dB => output = 0 dB input = 20 dB => output = 5 dB

Compression is often thought off as an operation to make music "sound louder". To achieve this, the first step is to reduce the dynamic range like in the example above. As the loud parts of the music have been reduced in volume, we can now amplify everything, without risking distortion or clipping. This has the overall effect of the music sounding louder. In our example, an output amplification of 5 dB would be okay, if the input signal never exceeded 0 dB.

Authors: Matthias Kretz, Stefan Westerfeld

License: GNU General Public License

Channels:
audio-in1: Audio input 1
audio-in2: Audio input 2
audio-out1: Compressed audio output 1
audio-out2: Compressed audio output 2


Properties:
attack: Set the attack time in milliseconds (Range: 0.1 .. 250)
release: Set the release time in milliseconds (Range: 0.1 .. 250)
threshold_db: Only parts louder than threshold are compressed (Range: -100 .. 0)
ratio_to_one: Set the compression ratio to x:1 (Range: 1 .. 20)
output_db: Set the output amplification (Range: -20 .. 20)
auto_output: Adjust the output amplification automatically according to threshold and ratio

BseAtanDistort

object BseAtanDistort
{
 Channels:
  Input  ::audio-in;
  Output  ::audio-out;
 Properties:
  SfiReal  ::boost_amount;
};
BseAtanDistort compresses or expands the input signal with distortion (in a manner similar to the atan(3) mathematical function, thus it's name). The strength with which the input signal is treated is adjustable from maximum attenuation to maximum boost.

Channels:
audio-in: Audio Input Signal
audio-out: Distorted Audio Output


Properties:
boost_amount: The atan distortion boost amount (strength) ranges from maximum attenuation (0%) to maximum boost (100%). (Range: 0 .. 100)

BseBalance

object BseBalance
{
 Channels:
  Input  ::audio-in1;
  Input  ::audio-in2;
  Input  ::ctrl-in1;
  Input  ::ctrl-in2;
  Output  ::left-out;
  Output  ::mix-out;
  Output  ::right-out;
 Properties:
  SfiReal  ::alevel1;
  SfiReal  ::alevel2;
  SfiReal  ::abalance;
  SfiReal  ::clevel1;
  SfiReal  ::clevel2;
  SfiReal  ::cbalance;
  SfiReal  ::ostrength;
  SfiReal  ::lowpass;
  SfiReal  ::obalance;
};
BseBalance is a stereo panning module with two audio and two control inputs, each of which can be seperately level adjusted. The resulting output balance is controlled by a balance adjustment and the sum of the control inputs. To avoid aliasing artefacts for rapid balance changes, the control signal is preprocessed by a simple lowpass filter with adjustable cutoff frequency.

Authors: Tim Janik

License: GNU Lesser General Public License

Channels:
audio-in1: First audio input
audio-in2: Second audio input
ctrl-in1: First control input
ctrl-in2: Second control input
left-out: Left audio output
mix-out: Mixed audio output
right-out: Right audio output


Properties:
alevel1: Attenuate the level of audio input 1 (Range: 0 .. 100)
alevel2: Attenuate the level of audio input 2 (Range: 0 .. 100)
abalance: Balance audio input levels (Range: -100 .. 100)
clevel1: Attenuate the level of control input 1 (Range: 0 .. 100)
clevel2: Attenuate the level of control input 2 (Range: 0 .. 100)
cbalance: Balance control input levels (Range: -100 .. 100)
ostrength: Adjust how much the control signals affect the output balance (Range: 0 .. 100)
lowpass: Lowpass filter frequency for the control signal (Range: 100 .. 1000)
obalance: Adjust output balance between left and right (Range: -100 .. 100)

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)

BseContribSampleAndHold

object BseContribSampleAndHold
{
 Channels:
  Input  ::audio-in;
  Input  ::trigger-in;
  Output  ::audio-out;
};
SampleAndHold samples the input signal when triggered and holds it until triggered again.

Authors: Artem Popov

License: GNU General Public License

Channels:
audio-in: Audio Input
trigger-in: Trigger Input
audio-out: Audio Output

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

BseDavBassFilter

object BseDavBassFilter
{
 Channels:
  Input  ::audio-in;
  Input  ::trigger-in;
  Output  ::audio-out;
 Properties:
  SfiReal  ::cutoff_perc;
  SfiReal  ::reso_perc;
  SfiReal  ::env_mod;
  SfiReal  ::env_decay;
  SfiBool  ::trigger;
};
DavBassFilter is a low-pass resonant TB-303 style filter based on the VCF303 portions of gsyn v0.2. The filter algorithm is partly based on the one described in "Musical Applications of Microprocessors" by Hal Chamberlin.

Authors: David A. Bartold, Tim Janik

License: GNU Lesser General Public License

Channels:
audio-in: Audio input
trigger-in: Trigger input
audio-out: Filtered audio output


Properties:
cutoff_perc: Set the cutoff frequency percentage (Range: 0 .. 100)
reso_perc: Set the amount of resonance in percent (Range: 0 .. 100)
env_mod: Set the envelope magnitude in percent (Range: 0 .. 100)
env_decay: Set the decay length in percent (Range: 0 .. 100)
trigger: Trigger filter

BseDavChorus

object BseDavChorus
{
 Channels:
  Input  ::audio-in;
  Output  ::audio-out;
 Properties:
  SfiReal  ::wet_out;
};
DavChorus adds more depth to sounds

Authors: David A. Bartold

License: GNU Lesser General Public License

Channels:
audio-in: Audio input
audio-out: Chorus audio output


Properties:
wet_out: Set the amount of modified data to mix (Range: 0 .. 100)

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.

BseFreeVerb

object BseFreeVerb
{
 Channels:
  Input  ::left-audio-in;
  Input  ::right-audio-in;
  Output  ::left-audio-out;
  Output  ::right-audio-out;
 Properties:
  SfiReal  ::room_size;
  SfiReal  ::damping;
  SfiReal  ::wet_level;
  SfiReal  ::dry_level;
  SfiReal  ::width;
};
BseFreeVerb - Free, studio-quality reverb (SOURCE CODE in the public domain) Written by Jezar at Dreampoint - http://www.dreampoint.co.uk

Channels:
left-audio-in: Left Input
right-audio-in: Right Input
left-audio-out: Left Output
right-audio-out: Right Output


Properties:
room_size: Room Size (Range: 0.7 .. 0.98)
damping: Damping [%] (Range: 0 .. 100)
wet_level: Wet Level [dB] (Range: 0 .. 3)
dry_level: Dry Level [dB] (Range: 0 .. 2)
width: Width [%] (Range: 0 .. 100)

BseIIRFilter

object BseIIRFilter
{
 Channels:
  Input  ::audio-in;
  Output  ::audio-out;
 Properties:
  BseIIRFilterAlgorithm  ::filter_algorithm;
  BseIIRFilterType  ::filter_type;
  SfiInt  ::order;
  SfiReal  ::epsilon;
  SfiReal  ::cut_off_freq;
  SfiInt  ::cut_off_note;
  SfiReal  ::cut_off_freq_2;
  SfiInt  ::cut_off_note_2;
};
BseIIRFilter is an infinite impulse response filter of variable order

Channels:
audio-in: Unfiltered Input
audio-out: Filtered Output


Properties:
filter_algorithm: The filter design type
filter_type: The type of filter to use
order: Order of Filter (Range: 1 .. 18)
epsilon: Passband falloff at cutoff frequency (Range: 0 .. 0.98)
cut_off_freq: Filter cutoff frequency (Range: 0.00005 .. 20000)
cut_off_note: Filter cutoff frequency as note, converted to Hertz according to the current musical tuning (Range: 0 .. 131)
cut_off_freq_2: Second filter cutoff frequency (Range: 0.00005 .. 20000)
cut_off_note_2: Filter cutoff frequency as note, converted to Hertz according to the current musical tuning (Range: 0 .. 131)

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

BseMidiDeviceALSA

object BseMidiDeviceALSA
{
};
MIDI driver implementation for the Advanced Linux Sound Architecture (http://alsa-project.org/alsa-doc/alsa-lib/midi.html)

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)

BseMixer

object BseMixer
{
 Channels:
  Input  ::audio-in1;
  Input  ::audio-in2;
  Input  ::audio-in3;
  Input  ::audio-in4;
  Output  ::audio-out;
 Properties:
  SfiReal  ::master_volume_d_b;
  SfiInt  ::master_volume_perc;
  SfiReal  ::volume_d_b1;
  SfiInt  ::volume_perc1;
  SfiReal  ::volume_d_b2;
  SfiInt  ::volume_perc2;
  SfiReal  ::volume_d_b3;
  SfiInt  ::volume_perc3;
  SfiReal  ::volume_d_b4;
  SfiInt  ::volume_perc4;
};
The Mixer module sums up incomming signals, and allowes for fine adjusted weighting (volume setting) of the input sources

Channels:
audio-in1: Input Channel 1
audio-in2: Input Channel 2
audio-in3: Input Channel 3
audio-in4: Input Channel 4
audio-out: Sole Output


Properties:
master_volume_d_b: Master [dB] (Range: -144 .. 24)
master_volume_perc: Master [%] (Range: 0 .. 1584)
volume_d_b1: Channel1 [dB] (Range: -144 .. 24)
volume_perc1: Channel1 [%] (Range: 0 .. 1584)
volume_d_b2: Channel2 [dB] (Range: -144 .. 24)
volume_perc2: Channel2 [%] (Range: 0 .. 1584)
volume_d_b3: Channel3 [dB] (Range: -144 .. 24)
volume_perc3: Channel3 [%] (Range: 0 .. 1584)
volume_d_b4: Channel4 [dB] (Range: -144 .. 24)
volume_perc4: Channel4 [%] (Range: 0 .. 1584)

BseMult

object BseMult
{
 Channels:
  Input  ::audio-in1;
  Input  ::audio-in2;
  Input  ::audio-in3;
  Input  ::audio-in4;
  Output  ::audio-out;
};
Mult is a channel multiplier for ring-modulating incoming signals

Channels:
audio-in1: Audio Input 1
audio-in2: Audio Input 2
audio-in3: Audio Input 3
audio-in4: Audio Input 4
audio-out: Audio Output

BseNoise

object BseNoise
{
 Channels:
  Output  ::noise-out;
};
Noise is a generator of (supposedly) white noise

Authors: Tim Janik

License: GNU Lesser General Public License

Channels:
noise-out: Noise Output

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

BsePcmDeviceALSA

object BsePcmDeviceALSA
{
};
PCM driver implementation for the Advanced Linux Sound Architecture (http://alsa-project.org/alsa-doc/alsa-lib/pcm.html)

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

BseSequencer

object BseSequencer
{
 Channels:
  Output  ::freq-out;
  Output  ::note-sync;
 Properties:
  BseNoteSequence*  ::notes;
  SfiInt  ::length;
  SfiInt  ::transpose;
  SfiReal  ::counter;
};
The Sequencer produces a frequency signal according to a sequence of notes

Channels:
freq-out: Frequency Signal
note-sync: Note Sync Signal


Properties:
notes: Notes
length: Length (Range: 1 .. 128)
transpose: Transpose (Range: -36 .. 36)
counter: Timing [ms] (Range: 0 .. 1000)

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

BseSimpleADSR

object BseSimpleADSR
{
 Channels:
  Input  ::gate-in;
  Input  ::retrigger-in;
  Output  ::ctrl-out;
  Output  ::done-out;
 Properties:
  SfiReal  ::attack_time;
  SfiReal  ::decay_time;
  SfiReal  ::sustain_level;
  SfiReal  ::release_time;
  BseTimeRangeType  ::time_range;
};
Simple ADSR envelope generator

Channels:
gate-in: Gate input (activates/deactivates envelope)
retrigger-in: Retrigger input (raising edge retriggers envelope)
ctrl-out: Attack-Decay-Sustain-Release envelope output
done-out: This signal goes high after the release phase has completed


Properties:
attack_time: Attack Time [%] (Range: 0 .. 100)
decay_time: Decay Time [%] (Range: 0 .. 100)
sustain_level: Sustain Level [%] (Range: 0 .. 100)
release_time: Release Time [%] (Range: 0 .. 100)
time_range: Time ranges in seconds: 0.5 10.0 200.0

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  ::io-changed 
();
  void  ::probes 
(BseProbeSeq arg1);
};
Base type for sound sources

BseStandardGusPatchEnvelope

object BseStandardGusPatchEnvelope
{
 Channels:
  Input  ::frequency;
  Input  ::gate-in;
  Input  ::retrigger-in;
  Input  ::audio-in;
  Input  ::audio-gate;
  Output  ::audio-out1;
  Output  ::audio-out2;
  Output  ::done-out;
 Properties:
  BseWave*  ::wave;
};
StandardGusPatchEnvelope is an Envelope for GUS Patches

GUS Patches contain different volume settings and tremolo settings for different notes, and the envelopes are of a non-standard form, thus using a BseWaveOsc alone is not enough to produce the sound of the GUS Patches; to accomplish the playing, you thus need to connect one (or for stereo two) BseWaveOsc(s) and their Gate Output Signal to this module.

Authors: Stefan Westerfeld

License: GNU Lesser General Public License

Channels:
frequency: Frequency Input
gate-in: Gate input (activates/deactivates envelope)
retrigger-in: Retrigger input (raising edge retriggers envelope)
audio-in: Audio Input of the WaveOsc playing the patch
audio-gate: Gate Output of the WaveOsc playing the patch
audio-out1: Envelope audio output 1 (left output signal)
audio-out2: Envelope audio output 2 (right output signal)
done-out: This signal goes high after the release phase has completed

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)

BseStandardQuantizer

object BseStandardQuantizer
{
 Channels:
  Input  ::audio-in1;
  Input  ::audio-in2;
  Output  ::audio-out1;
  Output  ::audio-out2;
 Properties:
  SfiReal  ::qsteps;
  SfiReal  ::qstep_powers;
};
The Quantizer plugin quantizes the input signals according to a configurable step setting. This simulates low quality digital signal transfer paths or ancient computer hardware.

Authors: Tim Janik

Channels:
audio-in1: Audio Input 1
audio-in2: Audio Input 2
audio-out1: Audio Output 1
audio-out2: Audio Output 2


Properties:
qsteps: The number of different steps the output signal is quantized to. (Range: 1 .. 4294967296)
qstep_powers: The number of bits the quantization steps correspond to. (Range: 0 .. 32)

BseStandardSaturator

object BseStandardSaturator
{
 Channels:
  Input  ::audio-in1;
  Input  ::audio-in2;
  Output  ::audio-out1;
  Output  ::audio-out2;
 Properties:
  BseStandardSaturationType  ::saturation;
  SfiReal  ::level;
  SfiBool  ::auto_output;
  SfiReal  ::output_volume;
};
This is 2-channel saturation module. Various saturation types are supported. The 'Level' parameter adjusts the maximum saturation stage output for a normalized input signal. Some saturartion types simply clip signals beyond this threshold, while others (notably TANH and ATAN) allow overdrive signals to pass through the saturation stage up to a certain amount. The output volume allows for extra amplification after the saturation stage. For saturation types that allow overdrive signals past the saturation stage, an output volume greater than 0dB may result in overdrive signals as output of this module.

Authors: Tim Janik

Channels:
audio-in1: First Audio Input
audio-in2: Second Audio Input
audio-out1: First Audio Output
audio-out2: Second Audio Output


Properties:
saturation: The type of saturation to be used
level: Normalization level of the saturation curve in percent, some saturation types still allow overdrive signals beyond this level (Range: 0 .. 100)
auto_output: Automatically adapt the output volume according to changes in saturation level
output_volume: Output stage amplification in decibel (Range: 1 .. 125.8925412)

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

BseSummation

object BseSummation
{
 Channels:
  JointInput  ::audio-in1;
  JointInput  ::audio-in2;
  Output  ::audio-out1;
  Output  ::audio-diff;
  Output  ::audio-out2;
};
The Summation module adds up all inputs connected to its multi-connect input streams. The sum of all inputs connected to 'Audio In1' is available at 'Audio Sum1', and similarly, 'Audio Sum2' is the accumulatiuon signal of all streams connected to 'Audio In2'. A difference signal between 'Audio Sum1' and 'Audio Sum2' is also generated and is available at 'Audio Diff'.

Authors: Tim Janik

License: GNU Lesser General Public License

Channels:
audio-in1: Audio input 1
audio-in2: Audio input 2
audio-out1: Accumulated audio output 1
audio-diff: Difference between audio outputs 1 and 2
audio-out2: Accumulated audio output 2

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;
 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


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

DavCanyonDelay

object DavCanyonDelay
{
 Channels:
  Input  ::left-in;
  Input  ::right-in;
  Output  ::left-out;
  Output  ::right-out;
 Properties:
  SfiReal  ::left_to_right_time;
  SfiReal  ::left_to_right_feedback;
  SfiReal  ::right_to_left_time;
  SfiReal  ::right_to_left_feedback;
  SfiReal  ::filter_freq;
  SfiInt  ::filter_note;
};
DavCanyonDelay adds deep and long canyon-alike echos to stereo signals.

Channels:
left-in: Left Audio Input
right-in: Right Audio Input
left-out: Left Audio Output
right-out: Right Audio Output


Properties:
left_to_right_time: The time for the left to right delay (Range: 0.01 .. 0.99)
left_to_right_feedback: The feedback amount; a negative feedback inverts the signal (Range: -100 .. 100)
right_to_left_time: The time for the right to left delay (Range: 0.01 .. 0.99)
right_to_left_feedback: Set the feedback amount; a negative feedback inverts the signal (Range: -100 .. 100)
filter_freq: Reflection cutoff frequency (Range: 0.00005 .. 20000)
filter_note: Filter cutoff frequency as note, converted to Hertz according to the current musical tuning (Range: 0 .. 131)

DavOrgan

object DavOrgan
{
 Channels:
  Input  ::freq-in;
  Output  ::audio-out;
 Properties:
  SfiReal  ::base_freq;
  SfiInt  ::base_note;
  SfiInt  ::transpose;
  SfiInt  ::fine_tune;
  SfiReal  ::harm0;
  SfiReal  ::harm1;
  SfiReal  ::harm2;
  SfiReal  ::harm3;
  SfiReal  ::harm4;
  SfiReal  ::harm5;
  SfiBool  ::brass;
  SfiBool  ::flute;
  SfiBool  ::reed;
};
DavOrgan is a modifiable additive organ synthesizer

Channels:
freq-in: Frequency Input
audio-out: Organ Output


Properties:
base_freq: Organ frequency in Hertz, i.e. the pitch of the base tone (Range: 0.00005 .. 20000)
base_note: Organ frequency as note, converted to Hertz according to the current musical tuning (Range: 0 .. 131)
transpose: Transposition of the frequency in semitones (Range: -72 .. 72)
fine_tune: Amount of detuning in cent (hundredth part of a semitone) (Range: -100 .. 100)
harm0: 16th Harmonic (Range: 0 .. 100)
harm1: 8th Harmonic (Range: 0 .. 100)
harm2: 5 1/3rd Harmonic (Range: 0 .. 100)
harm3: 4th Harmonic (Range: 0 .. 100)
harm4: 2 2/3rd Harmonic (Range: 0 .. 100)
harm5: 2nd Harmonic (Range: 0 .. 100)
brass: Changes the organ to sound more brassy
flute: Adds flute sounds
reed: Adds reeds sound

DavSynDrum

object DavSynDrum
{
 Channels:
  Input  ::freq-in;
  Input  ::ratio-in;
  Input  ::trigger-in;
  Output  ::audio-out;
 Properties:
  SfiReal  ::base_freq;
  SfiInt  ::base_note;
  SfiReal  ::trigger_vel;
  SfiBool  ::force_trigger;
  SfiReal  ::res;
  SfiReal  ::ratio;
};
DavSynDrum produces synthesized drums. It accepts the drum frequency as input channel or parameter setting. Drums are triggered through a trigger parameter or via a trigger input channel which detects raising edges. The initial frequency shift is controllable through the "Ratio In" input channel, and adjustable through a parameter.

Channels:
freq-in: Drum Frequency Input
ratio-in: Frequency shift ratio (assumed 1.0 if not connected)
trigger-in: Hit the drum on raising edges
audio-out: SynDrum Output


Properties:
base_freq: Drum frequency in Hertz (Range: 0.00005 .. 20000)
base_note: Drum frequency as note, converted to Hertz according to the current musical tuning (Range: 0 .. 131)
trigger_vel: The velocity of the drum hit (Range: 0 .. 1000)
force_trigger: Manual trigger for the drum
res: The resonance half life in number of milli seconds (Range: 1 .. 1000)
ratio: The ratio of frequency shift. (i.e. 1.0 means shift equal to the drum's base frequency) (Range: 0 .. 10)

DavXtalStrings

object DavXtalStrings
{
 Channels:
  Input  ::freq-in;
  Input  ::trigger-in;
  Output  ::audio-out;
 Properties:
  SfiReal  ::base_freq;
  SfiInt  ::base_note;
  SfiInt  ::transpose;
  SfiInt  ::fine_tune;
  SfiReal  ::trigger_vel;
  SfiBool  ::trigger_pulse;
  SfiReal  ::note_decay;
  SfiReal  ::tension_decay;
  SfiReal  ::metallic_factor;
  SfiReal  ::snap_factor;
};
DavXtalStrings is a plucked string synthesizer, using the Karplus-Strong Algorithm. Commercial use of this module until 2004 requires a license from Stanford University.

Channels:
freq-in: Pluck frequency input
trigger-in: Pluck strings on raising edge
audio-out: XtalStrings Output


Properties:
base_freq: String oscillation frequency in Hertz (Range: 0.00005 .. 20000)
base_note: String oscillation frequency as note, converted to Hertz according to the current musical tuning (Range: 0 .. 131)
transpose: Transposition of the frequency in semitones (Range: -72 .. 72)
fine_tune: Amount of detuning in cent (hundredth part of a semitone) (Range: -100 .. 100)
trigger_vel: Velocity of the string pluck (Range: 0 .. 100)
trigger_pulse: Pluck the string
note_decay: Note decay is the 'half-life' of the note's decay in seconds (Range: 0.001 .. 4)
tension_decay: Tension of the string (Range: 0.001 .. 1)
metallic_factor: Metallicness of the string (Range: 0 .. 100)
snap_factor: Snappiness of the string (Range: 0 .. 100)