BSE Object Reference

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

SYNOPSIS

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

DESCRIPTION

BseBiquadFilter

class 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: Cutoff [Hz] (Range: 0.00005 .. 19999.9)
note: Note (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

class 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

class 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

BSE Synthesis (Filter) Network

BseConstant

class 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: Value [float] (Range: -1 .. 1)
frequency_1: Frequency (Range: 0 .. 24000)
note_1: Note (Range: 0 .. 131)
value_2: Value [float] (Range: -1 .. 1)
frequency_2: Frequency (Range: 0 .. 24000)
note_2: Note (Range: 0 .. 131)
value_3: Value [float] (Range: -1 .. 1)
frequency_3: Frequency (Range: 0 .. 24000)
note_3: Note (Range: 0 .. 131)
value_4: Value [float] (Range: -1 .. 1)
frequency_4: Frequency (Range: 0 .. 24000)
note_4: Note (Range: 0 .. 131)

BseContainer

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

BseContextMerger

class 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

BseDataPocket

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

BseDevice

Abstract device base type

BseEditableSample

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

BseEffect

BseEffect implements an abstract C++ effect base.

BseInstrumentInput

class 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

class 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

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

BseJanitor

class 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

LADSPA Module base type

BseMidiController

class 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

MIDI device base type

BseMidiDeviceNULL

MIDI device implementation that does nothing

BseMidiDeviceOSS

MIDI device implementation for OSS Lite /dev/midi*

BseMidiInput

class 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

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

BseMidiSynth

class 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

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

BseMidiVoiceSwitch

class 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

class 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

class 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

PCM device base type

BsePcmDeviceNull

Null PCM device implementation

BsePcmDeviceOSS

PCM device implementation for OSS Lite /dev/dsp

BsePcmInput

class 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

class 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

PCM writer

BseProject

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

BseSNet

class 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

class 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

class 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

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

Properties:
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

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

BseStandardOsc

class 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: Number of oscillator cycles per second (Range: 0.00005 .. 20000)
base_note: Musical notation corresponding to the oscillator frequency (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

Storage object for item serialization

BseSubIPort

class 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

class 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

class 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

class 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

class 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

class 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

class 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

BSE Wave Repository