Bidule v0.5701 user manual

Sebastien Beaulieu

seb@plogue.com

Vincent Trussart

vincent@plogue.com

David Viens

davidv@plogue.com

Copyright © 2003 Plogue Art et Technologie Inc.

Table of Contents

1. Introduction : Bidule's Concepts
2. User Interface
Palette
Bidules
History
Patchbay
Modules (aka 'bidules')
Connectors
Basic Bidules Connections
Advanced Bidules Connections
Context Menu
Mouse Usage and Hot Keys
Toolbar Features
Go up a level (up arrow)
Parameter Linking
MediaPool
Palette (Gear icon)
Edit Menu
3. Bidules
Sample-based Bidules
Audio Buffer
Audio File Granulator
Audio File Looper
Audio File Output
Effects Bidules
Buffer Granulator
Deconcrisseur
Moog VCF
Time Domain Convolver
Instrument Bidules
Boboche Sampler
MIDI Bidules
CC To Params
CC Value Scaler
CC Filter
Channel Filter
Message Filter
Note Filter
MIDI To Sync
MIDI To Value
Note Number To Param
Note Shuffler
Note Transposer
Note Velocity To Params
Particle Arpegiator
CC Remapper
Channel Remapper
Note Remapper
Splitter
Step Sequencer
Velocity Scaler
Misc Bidules
Comment
Parameter Modulator
Mixing Bidules
Crossfader
Gain
Mixer
Pan
Stereo Squeezer
Routing Bidules
Audio Switcher
MIDI Switcher
Spectral Bidules
FFT
Freeze
Frequency Binary Operator
Frequency Breeder
Frequency Buffer
Frequency Gate
Frequency Inversion
Frequency Logic Gate
Frequency Shifter
Frequency Stretcher
Frequency Variable
iFFT
Magnitude Binary Operator
Magnitude Breeder
Magnitude Buffer
Magnitude Gate
Magnitude Logic Gate
Magnitude Scaler
Magnitude Shifter
Magnitude Stretcher
Magnitude Variable
Pitch Scaler
Spectral Freezer
Spectral Cherizer
Spectral Crossfader
Spectral Resynthesizer
Spectral To MIDI
Devices
MIDI Device
Audio Device
Building Blocks
Basic Audio File Player
Delay Line
ADSR Envelope
Basic ADSR Envelope
Envelope Follower
Exponential Envelope
Basic Exponential Envelope
Allpass Filter
Basic Filter
Biquad Filter
Comb Filter
Crossover Filter
FIR
Accum
Binary Operator
Change
Clip
Constant
Counter
Function
Function (Recursive)
Logic Gate
Binary Logic Operator
Unary Operator
Unit Converter
Value List
Variable
MIDI CC Creator
MIDI Note Creator
MIDI Note Extractor
Audio Monitor
MIDI Monitor
Oscillator
Random
Sample And Hold
Sync Extractor
Trigger
Trigger Clock
4. VST and VSTi support
Input/outputs configurations
Plugins availability
VST banks and parameters vs MIDI CCs and program changes
VST errors reported by Bidule
Yet to be implemented VST Features
5. ReWire support
Bidule ReWire support.
Basics
ReWire Sync
Sending MIDI to ReWire Devices
6. Groups
Creating a new group
Creating a new group from a selection of bidules and links
Group navigation
Exporting group parameters
Editing group properties
Saving Groups
Group Manager
Grouping Submenu
7. Building Synthesizer Groups
Making a voice Group
Polyphonic Adapter
Advanced Polyphonic synth topics
8. Troubleshooting
9. Acknowledgements
10. Plogue Bidule Revision History


Chapter 1. Introduction : Bidule's Concepts

Plogue Bidule is a real-time modular creation studio aimed mainly at artists seeking a new creative environment in which to experiment.

With Bidule, you create your own live music creation environment, inserting audio and MIDI devices, VST instruments and effects, ReWire devices, and the like. Patching them any way you like, in real-time, while it plays. In Bidule. there is no "Edit mode" for your patches, you simply build them while they play!

Please take the time to read through this help document and then open and play the tutorial patches included in the "layouts" directory, we feel they give a good idea of the kind of patches you can make.


Chapter 2. User Interface

Table of Contents

Palette
Bidules
History
Patchbay
Modules (aka 'bidules')
Connectors
Basic Bidules Connections
Advanced Bidules Connections
Context Menu
Mouse Usage and Hot Keys
Toolbar Features
Go up a level (up arrow)
Parameter Linking
MediaPool
Palette (Gear icon)
Edit Menu

Palette

The Palette window allows you to create a patch by dragging and dropping bidules on the patchbay. It has two panes: the Bidules pane and the History pane.

Bidules

This pane contains a list of all available bidules grouped according to your preferences. To add a bidule to the patchbay, drag it from the Palette and drop it on the patchbay.

History

Plogue Bidule keeps track of the bidules you use most. The History pane shows these bidules in a sorted list. To add a frequently-used bidule to the patchbay, drag it from the History list and drop it on the patchbay.


Patchbay

The patchbay is the black canvas that you can see in Bidule. This is where you build the layout/patch to create/manipulate sounds and songs.

Modules (aka 'bidules')

Right-click in the patchbay to pop up a menu that contains all available bidules (modules) you can use. The bidules are classified into different categories: Audio Devices, Audio File, Building Blocks, Effects, Groups, Instruments, MIDI, MIDI Devices, Misc, Mixing, Routing, Spectral, VST and VST Instruments.

Once the bidule is in the patchbay, you can double-click it to pop up its GUI (only available if the bidule has any realtime parameters)

Connectors

A bidule has input and output connectors. The little squares on the top of the bidule are the input connectors and the one at the bottom are the output connectors.

Each connector/cable colour specifies a different type of signal.

  • Blue is for audio/data signals
  • White is for MIDI signals.
  • Yellow (frequency vector) and Orange (amplitude vector): Spectral Processing. These contain not the raw FFT results (complex vector), but actual properly phase vocoded and overlapped signal vectors.

Basic Bidules Connections

Building a layout is easy. Just choose which bidules you want and connect them graphically. one at the time.

To connect two bidules together, you need to select a connector (it will become bigger when you place the mouse pointer over it), press the left mouse button and then move the mouse to another bidule's connector ( it will also become bigger). Once you have selected the correct one, let go of the left mouse button and a cable linking the two bidules will appear.

Advanced Bidules Connections

To connect multiple connectors from one bidule to another, create the first cable while holding the CTRL key - Bidule will try to create as many cables as possible.

You can also have multiple cables coming out of one connector or multiple connectors leading into one of the connectors (the signals will be mixed/duplicated automatically).

You can repatch an existing cable by first selecting it (clicking on it when it's highlighted or by lassoeing), then by clicking on one of the connectors at the end of the cable and holding the left mouse button until you have selected the new connector.

You can of course send outputs signals back to the inputs signals (provided there is at least another module in between) to create a feedback loop.

To process live audio (ASIO devices only), just connect both bidules representing your duplex device to the processing module (in this example - SmartElectronix's SupaPhaserVST) as shown.

If you ever encounter a red bidule when you load a .bidule file, it means that the saved file contains a reference to a module or plugin that cannot be found within your current configuration. This is usually the case if there is a VST plugin you didn't own or if you are trying to open a layout that had an Audio or Midi Device having a bigger index then the number of available devices in your system. The following picture is an example a patch loaded that requires a missing Plogue Rebuilder VST.

Context Menu

To bring up a Bidule context menu, first left click it to highlight (should turn yellow.. not translucent blue), then hit the right mouse button.

Cut

Cuts the selected bidules so you can paste them elsewhere in your layout

Copy

Copies the selected bidules to the clipboard so you can paste them elsewhere in your layout

Paste

Pastes the bidules in the clipboard into the current layout.

Delete

Deletes the selected bidules (and puts them in the undo stack). You can also simply hit the "Del" key, once the bidule is selected.

Rename

Renames the selected bidule. You can also hit F2 to access the rename dialog.

Processing Mode

Sets the way the current bidule is behaving in the patchbay (choices are Process/Mute/Passthrough).

Control from MIDI

Allows selection of the current Bidule internal parameters to be mapped to a MIDI Controller. Only available if a MIDI Device is connected to the current graph. (This will be sorted out in a future version...)

Synchronizing Modules Together

Certain Bidule modules have the possibility to either be slaved or be a master generator of sync information for others.

As a simple example, you might want an AudioFile Looper to be automatically in sync with a certain sequencer, (at least as far as tempo and bar position are concerned).

In most hosts this is no problem, as there is often only one transport control center, which resides in its toolbar. So every plugin "feeds" on info coming from the host's "master timeline".

But in Bidule there is no enforced "master timeline" because you can have many sequencers all free running in parallel. It's up to the user to decide exactly what should be synched to what (as you would do in a real studio). This allows for easy crossfading between different tempoed tracks in a live situation, for instance.

As with many things in Bidule, there are graphical cues to give you a clue of what's happening "under the hood".

If a newly allocated bidule possesses the intrinsic support to be synched, then a small grey "s" (for Slave) letter will appear left of its patchbay representation, meaning it "knows" how to deal with extra sync information.

Similarl, a sync generator bidule (Bidule's Step Sequencer, for instance) has a small green "m" (for Master), followed by a unique identifier, saying it can provide sync information on this sync ID.

If you sync a slave-able bidule to this one, its letter "s" will turn green and the number of the unique master ID will also appear beside it.

  • Grey means "available for sync" (currently free running)
  • Green means active (masters are always active)
  • Most ReWire devices (Reason/Rebirth/Live) can simultaneously be masters and slaves

(*)VST Developers note: a VST plugin should return "1" when asked about canDo "receiveVstTimeInfo" for this option to work.

Alignment

Allows alignment of selected bidules in the patchbay. The six modes of alignment are:

  • Top
  • Center Horizontally
  • Bottom
  • Distribute Horizontally: Spaces selected bidules evenly along the vertical axis
  • Left
  • Center Vertically
  • Right
  • Distribute Vertically: Spaces selected bidules evenly along the vertical axis

Grouping

  • Group Selected Object(s): Selected bidules and cables are grouped together. Internal connections between selected objects are preserved. External connections are lost.
  • Save selected group: Save the selected group in a file. If the file is saved in the "groups" subdirectory of bidule's installation directory it will appear in the "Groups" category in the Palette.
  • Edit group property: Allows editing of the number and type of connectors, the author's name, the group version number, and the name of this group.
  • Parent group: Display the parent of the visible group (if it is not the top level group). The keyboard shortcut for this feature is BACKSPACE.
  • Expand selected group: Make the selected group the visible group. The shortcut for this feature is CTRL - DOUBLE CLICK.

Mouse Usage and Hot Keys

Mouse:

  • Left Mouse Button permits moving bidules, adding connections, etc.
  • Right Mouse Button in black patchbay pops up a bidule selection menu.
  • Right Mouse Button on a bidule, pops up a contextual menu.

Keyboard:

  • Arrow Keys pan through the patchba.
  • CTRL-Up and Down/Mouse Wheel zoom in and out of the patchbay.
  • Home to get back to default pan/zoom settings in the patchbay.
  • Highlighting a bidule or connector + "Del" deletes it.
  • Backspace to go back to the parent group.
  • CTRL-double left click to explore a group.
  • CTRL-C, V, and X for your usual cut and paste needs.

You can select multiple bidules/connectors by pressing CTRL while selecting or by using the left mouse button to lasso.


Toolbar Features

Besides the usual toolbar icons: new, open, save, save as, undo and redo. There's the play/stop icon (CTRL-SpaceBar to toggle play/stop).

Go up a level (up arrow)

Press this icon to go back to the parent group of the group currently displayed in the patchbay

Parameter Linking

Use the chain icon to access the parameter linking window: Simply highlight one source parameter and one destination parameter, then the "Link" button to link them together

MediaPool

Click the box icon to access the MediaPool where all the clips (wavs) used by bidules are managed.

  • Use it to load an audio file so that it becomes accessible to the Audio File Player, for example. Even if you open 15 sample playback devices to play myWav.wav, it will only be read/put in memory once.
  • WARNING: watch the lengths of those audio files!!! (it has to fit in RAM). On the TODO list is an option to stream the files from disk.

To load file(s) press the Add File(s) button and select the audio files you want with the open file dialog. To remove files, select them in the list and press the Remove File(s) button or press the "Del" key.

Palette (Gear icon)

Press this icon to toggle showing and hiding of the palette window

Edit Menu

Besides all the usual options you're used to seeing in the menus, there are 2 important items under Edit.

Preferences

Sample Rate

The sampling rate to use for the audio card driver. Be aware that some cards don't support all possible sampling rate. (You will get an error message if you select a sampling rate not supported by your audio card when you try to use it.)

Buffer Size

This is the size of the buffer used internally in Bidule, not the one for your audio driver. The lower this quantity the lesser the latency, but the higher the CPU requirements!

FFT Window Size

Size of the FFT windows.

FFT Overlap

number of overlaps for FFT frames (also called decimation factor).

VST Plugins Path

This is the path where Bidule will look for VST plugins.

VST By Company

Enabling this will sort the VSTs using the company name (if defined in the plugin) instead of directory names.

VST Internal Names

Enabling this will show the internal VST name instead of the DLL filename.

Shows Tips

Self-explanatory.

Show Processing Modes

View (or not) the processing modes icons alongside the bidules in the patchbay

Show sync masters/slaves

View (or not) the the little letters to differentiate syncable modules/sync source alongside the bidules in the patchbay.

Process at startup

Automatically start processing the audio signal when Bidule is launched.

Scan plugins

Use this option to launch a scan of VST plugins using the directory that is set in preferences.

Reset History

Use this option to reset to 0 the usage of each bidule (in the History list).

Set current patch as default

Use this option to save your usual setup. Once this is done, all new layouts will include all the bidules/devices in the current layout.


Chapter 3. Bidules

Table of Contents

Sample-based Bidules
Audio Buffer
Audio File Granulator
Audio File Looper
Audio File Output
Effects Bidules
Buffer Granulator
Deconcrisseur
Moog VCF
Time Domain Convolver
Instrument Bidules
Boboche Sampler
MIDI Bidules
CC To Params
CC Value Scaler
CC Filter
Channel Filter
Message Filter
Note Filter
MIDI To Sync
MIDI To Value
Note Number To Param
Note Shuffler
Note Transposer
Note Velocity To Params
Particle Arpegiator
CC Remapper
Channel Remapper
Note Remapper
Splitter
Step Sequencer
Velocity Scaler
Misc Bidules
Comment
Parameter Modulator
Mixing Bidules
Crossfader
Gain
Mixer
Pan
Stereo Squeezer
Routing Bidules
Audio Switcher
MIDI Switcher
Spectral Bidules
FFT
Freeze
Frequency Binary Operator
Frequency Breeder
Frequency Buffer
Frequency Gate
Frequency Inversion
Frequency Logic Gate
Frequency Shifter
Frequency Stretcher
Frequency Variable
iFFT
Magnitude Binary Operator
Magnitude Breeder
Magnitude Buffer
Magnitude Gate
Magnitude Logic Gate
Magnitude Scaler
Magnitude Shifter
Magnitude Stretcher
Magnitude Variable
Pitch Scaler
Spectral Freezer
Spectral Cherizer
Spectral Crossfader
Spectral Resynthesizer
Spectral To MIDI
Devices
MIDI Device
Audio Device
Building Blocks
Basic Audio File Player
Delay Line
ADSR Envelope
Basic ADSR Envelope
Envelope Follower
Exponential Envelope
Basic Exponential Envelope
Allpass Filter
Basic Filter
Biquad Filter
Comb Filter
Crossover Filter
FIR
Accum
Binary Operator
Change
Clip
Constant
Counter
Function
Function (Recursive)
Logic Gate
Binary Logic Operator
Unary Operator
Unit Converter
Value List
Variable
MIDI CC Creator
MIDI Note Creator
MIDI Note Extractor
Audio Monitor
MIDI Monitor
Oscillator
Random
Sample And Hold
Sync Extractor
Trigger
Trigger Clock

Sample-based Bidules

Audio Buffer

Fun little device (we think), here's how it works:

  • Passthru: sound passes thru it unaltered
  • Capture: captures audio for a certain length in RAM
  • Playback: plays back what was recorded in loop mode
  • Buffer Size: change the length of the playback buffer
  • Bit Depth/File/Recording: saves current buffer to the specified filename and bit depth, and then loads it in MediaPool, making it available to Audio File Loopers.
  • Playback Amplitude: change the volume of the output

Audio File Granulator

Mad grain/loop audio file playback.

  • Wave file: select a file from the MediaPool
  • Add Files: shortcut to add audio files to the MediaPool
  • Min/Max Static Length: range of available sizes for the grains
  • Zero Percent: adjust the ratio of silence vs. grains
  • Min/Max Pitch: range of available pitches for the grains
  • Change Pitch: ratio of pitch changing
  • Stretch1/2: stretching for the grains
  • Fade: length of the fade window for each grain

Audio File Looper

Loops files loaded into the MediaPool. Syncable to MIDI Step Sequencers.

  • Wave file: select a file from the MediaPool
  • Add Files: shortcut to add audio files to the MediaPool
  • Speed: change the playback speed of the audio file
  • Amplitude: change the volume of the output
  • Interpolation: calculation method for interpolating samples when playing at speeds different than 1x

Audio File Output

Streams audio to disk (in 2 or 6 channels audio file), with the specified file name.

  • Bit Depth/File/Recording: saves the input to the specified filename and bit depth.


Effects Bidules

Buffer Granulator

The same algorithm from Audio File Granulator applied to the incoming audio signal.

  • Min/Max Static Length: range of available sizes for the grains
  • Zero Percent: adjust the ratio of silence vs. grains
  • Min/Max Pitch: range of available pitches for the grains
  • Change Pitch: ratio of pitch changing
  • Stretch1/2: stretching for the grains
  • Fade: length of the fade window for each grain
  • Freeze: freeze the content of the internal buffer

Deconcrisseur

The bidule that F***s Beyond Repair is a pseudo sample rate/bit depth reducer

  • Sample Rate: change the sampling rate of the incoming signal
  • Bit depth: change the bit depth of the incoming signal

Moog VCF

Courtesy of the music-dsp source code archive!

Time Domain Convolver

Don't search for parameters - there aren't any. Just feed two different input signals into each in socket.


Instrument Bidules

Boboche Sampler

Cheapo Sampler, very straight MIDI note to audio clip mapping

  • Wave: select a file for each note from the MediaPool
  • Master Volume: change the volume of the outputs


MIDI Bidules

CC To Params

Same functionality as the CC linking feature from MIDI devices. Can be used to extract CC from a MIDI device without having to connect it to the rest of the graph, or used after a channel splitter to have 16 times more possible CC or at the output of any VST/VSTi/Rewire that could can CC.

CC Value Scaler

Scale the value of incoming CC between the selected range. The 128 possible CC values are used to give more precision in the selected range.

CC Filter

Filters out all unselected MIDI CC.

Channel Filter

Filters out all MIDI events on the unselected channels.

Message Filter

Filters out all unselected MIDI messages by type.

Note Filter

Filters out all unselected MIDI notes.

MIDI To Sync

This bidule is beta. It transforms a MIDI Timing Clock signal to Bidule internal sync info.

MIDI To Value

Convert the selection (incoming MIDI Note or CC) to a smoothed out signal at audio rate.

  • CC#: select the CC to listen to in the incoming signal
  • Use Notes: use MIDI notes as a 0 to 1 interval
  • Channel#: channel to listen to in the incoming signal
  • Smoothing: smoothing time for changes in value
  • Learn: go into learn mode, where the next CC or note will be selected

Note Number To Param

Takes incoming MIDI Note On signals and use the MIDI note number to set the value of its exported parameter that you can link to any parameter using the Parameter Linking window.

Note Shuffler

Randomly alters the incoming MIDI notes.

  • Lowest/Highest Note: select the available range for randomization.

Note Transposer

Alters the incoming MIDI notes by the specified semitones/detune value.

Note Velocity To Params

Takes incoming MIDI Note On signals and use the MIDI note velocity to set the value of the corresponding exported parameter that you can link to any other parameter using the Parameter Linking window.

Particle Arpegiator

Modified version of Nate Robins's particule.c example from the GLUT library. The ParticleArpegiator is meant as an example of what you'll be able to do with the Bidule SDK. In this version, colliding particles trigger MIDI!! Each of the maximum 128 particles represent the 128 possible MIDI notes, so do some tests. You might not hear your synths right away. The ToneGenerator works ok with this, but as you know it is monophonic.

  • Num Particles: the number of particles in the system
  • Flow: the flow of the particles
  • Gravity: the gravity for the system
  • Show Balls: show the ball
  • Spectrum Colors/Blue: use the MIDI to spectrum color code or not
  • Fountain/Waterfall: fountain or waterfall mode
  • Point Size: size of the particles

CC Remapper

Restamps any incoming MIDI CC to the selected CC.

Channel Remapper

Restamps any incoming MIDI event to the selected channel.

Note Remapper

Restamps any incoming MIDI note to the selected note.

Splitter

Splits a MIDI signal into its 16 channels or routes the signal to its 16 outs each time it receives a program change signal in the 1-16 range.

Step Sequencer

With the step sequence editor you can edit a grid of 16 sequences that always loop, or use the playlist to set a desired sequence to play for all 16 output channels. Each sequence step in the playlist can have its own BPM and step size.

  • Load: loads a saved bank of sequences (.bmsd file)
  • Save: saves a bank of sequences (.bmsd file)
  • +: zoom in the grid
  • -: zoom out the grid
  • Play/Stop: start and stop the output of the step sequencer
  • BPM: tempo for the playing sequences. Remember to press ENTER to apply the value!
  • Steps: number of steps for the playing sequences
  • Channel: assign the current sequence to the MIDI channel
  • Sequence: assign the sequence to the current MIDI channel
  • Playlist Mode: use the playlist / loop the current sequences
  • Edit Playlist: show the playlist editor dialog

The playlist editor dialog is where you can assign a sequence number for each channel for a specified number of events. You can also specify the BPM and the number of steps for each event.

  • Playlist Length: number of events in the playlist
  • Playlist Start/End: in/out points for looping
  • BPM/Set BPM: specifies and set the BPM for each event
  • Num Steps/Set Num Steps: specifies and set the number of steps for each event
  • Reset Events: reset all events to the default BPM, number of steps and no playing sequences

Controls for the grid:

  • left mouse button : add and lengthen notes
  • middle mouse button/ctrl-left mouse button : delete notes
  • right mouse button : change a notes velocity (darkens, lightens color of note)

The sequence number playing on each channel is also exported as a parameter that you can link to in the Parameter Linking window. For example, you could have a Note Number To Params per MIDI channel and have each of them link to the corresponding parameter for the currently playing sequence for each channel - giving you hands-on control of the sequence being played on all channels at once!

Velocity Scaler

Like a MIDI dynamics compressor.

  • Lowest/Highest Velocity: range to remap all incoming note velocities
  • Master Attenuation: attenuation for all incoming notes


Misc Bidules

Comment

Just an idea scratchpad for text, no ins or outs.

Parameter Modulator

Reads the first sample of each buffer of the incoming signal and sets its internal parameter to that value so it can be used in the parameter linking. The value, if outside of the defined min and max, will be set to the nearest acceptable value.

  • Min: lower bound to use for the incoming signal
  • Max: upper bound to use for the incoming signal


Mixing Bidules

Crossfader

A simple crossfader.

Gain

A simple 10db gain.

Mixer

8 mono channels mixer with pan/mute/solo and 10db gain for each channel and a master 10db gain.

Pan

A simple pan.

Stereo Squeezer

Squeeze the width of a stereo signal.


Routing Bidules

Audio Switcher

Switch the audio input between the 16 outputs by sending a MIDI program change or choosing the output in the GUI. Each output has a processing mode parameter that you can see in the Parameters dialog and link to another bidule or group of bidules processing mode parameter. When the output is selected the parameter is set at "Processing" and when it is de-selected it is set at "Mute". With this it is possible to have complex layouts and having only the wanted bidules using the processing power.

MIDI Switcher

Same as the audio switcher but for a MIDI signal.


Spectral Bidules

FFT

Time Domain to Spectral Domain Conversion using the Phase Vocoder. Select your own windowing method.

Freeze

Keeps and outputs the current FFT window.

  • Gate Input: the window will be frozen as long as 1 is received. The first time the input goes from 0 to 1, it uses the current window as the frozen window
  • Trigger Input: send a 1 to force a refreeze
  • Freeze Frequencies: check this to freeze the frequencies
  • Freeze Magnitudes: check this to freeze the magnitudes
  • Force Gate: does the same as sending 1 continuously in the gate input

Frequency Binary Operator

Mathematics for Frequency data.

Frequency Breeder

Mix two frequency signals as wanted or at random.

  • Breed Ratio: Amount of the left input to use in the output
  • Crazy Genetics: Enable random amount of mixing for each bin

Frequency Buffer

Works like Audio Buffer but for frequencies (no save option).

Frequency Gate

Select the lower/upper bound of the signal going through.

Frequency Inversion

Finds the highest bin, each bin is changed to the difference between the highest value and the current bin value

Frequency Logic Gate

Simple Logic Gate for the frequency part of the spectral signal

  • Left-Side Argument Input: input for the left-side argument of the logic operator
  • Right-Side Argument Input: input for the right-side argument of the logic operator
  • Value for True Input: input to be redirected to the output when the operator result is true
  • Value for False Input: input to be redirected to the output when the operator result is false

Frequency Shifter

Shifts the frequency signal.

  • Horizontal Shift: shift the order of the bins by the selected value
  • Vertical Shift: add a constant to each bin

Frequency Stretcher

The spectral deconcrisseur: samples a specified number of bins and interpolates values.

Frequency Variable

User-defined variable range with slider and input box. Don't forget to hit ENTER to validate a value you just entered

  • Min and Max: define the range of the slider

iFFT

Spectral Domain to Time Domain Conversion using the Phase Vocoder. Select your own windowing method.

Magnitude Binary Operator

Mathematics for Magnitude data.

Magnitude Breeder

Mix two magnitude signals as wanted or at random.

  • Breed Ratio: Amount of the left input to use in the output
  • Crazy Genetics: Enable random amount of mixing for each bin

Magnitude Buffer

Works like Audio Buffer but for magnitudes (no save option).

Magnitude Gate

Select the lower/upper bound of the signal going through.

Magnitude Logic Gate

Simple Logic Gate for the magnitude part of the spectral signal

  • Left-Side Argument Input: input for the left-side argument of the logic operator
  • Right-Side Argument Input: input for the right-side argument of the logic operator
  • Value for True Input: input to be redirected to the output when the operator result is true
  • Value for False Input: input to be redirected to the output when the operator result is false

Magnitude Scaler

Scales the magnitude signal.

Magnitude Shifter

Shifts the magnitude signal.

  • Horizontal Shift: shift the order of the bins by the selected value
  • Vertical Shift: add a constant to each bin

Magnitude Stretcher

The spectral deconcrisseur: samples a specified number of bins and interpolates values.

Magnitude Variable

User-defined variable range with slider and input box. Don't forget to hit ENTER to validate a value you just entered.

  • Min and Max: define the range of the slider

Pitch Scaler

Simple example to scale frequencies out of a mag/freq pair (this operation can't be decorrelated on phase vocodered signals).

Spectral Freezer

Upon gate "on", this module takes a spectral snapshot and plays it constantly. Triggering takes a new snapshot. When gate is off, the module acts as a passthrough

Spectral Cherizer

The name is a hint. Changes the "loudest" incoming frequency to the nearest one in the well-tempered scale (for now)

Spectral Crossfader

Crossfades 2 Freq/Mag pairs.

Spectral Resynthesizer

AKA Rebuilder's Core. Takes a Frequency and Magnitude Signal and rebuilds the sound using the selected waveform types.

Spectral To MIDI

Take the "loudest" incoming frequency and outputs the nearest MIDI note in the well-tempered scale (for now)


Devices

MIDI Device

For MIDI input and output.

Audio Device

Synchronizing input/outputs only works with duplex devices (ASIO). ASIO is currently the only way to use live input, have multiple outs, and low latency.


Building Blocks

The building blocks bidules are aimed at the more experienced users. Their main feature is that they have inputs for their main parameters instead of a GUI which means that the parameter values are applied at each sample instead of at each block of samples. With these you can design your own effects and synths.

Basic Audio File Player

Really basic file player that let you decide which samples to play.

  • Wave file: select a file from the MediaPool
  • Add Files: shortcut to add audio files to the MediaPool
  • Interpolation: calculation method for interpolating samples when playing at speeds different than 1x
  • Play Trigger Input: send a 1 to start the playback of the file
  • Play Gate Input: once a trigger is received the playing will continue for as long that 1 is received in this input
  • Play Position Input: wanted sample to play at each sample
  • Amplitude Input: wanted amplitude to apply to the output
  • # of samples in audio file Output: use this to know the upper bound to use in the play pos input or to calculate the length of the file with the sample rate output
  • Sample Rate of Audio File Output: sampling rate of the currently selected audio file

Delay Line

Basic delay line

  • Audio Input: input for the audio signal
  • Delay Length: delay length for the current sample (in samples)

ADSR Envelope

ADSR envelope

  • Gate Input: gate input for the duration of the A, D, and S parts of the envelope
  • Retrigger Input: retrigger the ADSR by sending a 1

The second output is an activity gate, it will output 1 for the entire time that the envelope is active.

Basic ADSR Envelope

Basic ADSR envelope, same as the ADSR envelope except that the values used are inputs instead of sliders.

  • Attack Input: Attack time in ms
  • Decay Input: Decay time in ms
  • Sustain Input: Sustain level in %
  • Release Input: Release time in ms
  • Gate Input: gate input for the duration of the A, D, and S parts of the envelope
  • Retrigger Input: retrigger the ADSR by sending a 1

The second output is an activity gate. It will output 1 for the entire time that the envelope is active.

Envelope Follower

Basic envelope follower.

The second output is an activity gate, it will output 1 for the entire time that the envelope is active.

Exponential Envelope

Exponential envelope.

The second output is an activity gate. It will output 1 for the entire time that the envelope is active.

Basic Exponential Envelope

Basic exponential envelope.

Same as the Exponential Envelope except that the decay time is an input instead of a slider.

Allpass Filter

Basic allpass filter.

  • Audio Input: input for the audio signal
  • Delay Time: delay time for the filter (in ms)

Basic Filter

Collection of basic one pole, one zero and one pole/one zero 6db filters that you can cascade to create others.

  • Type : select the type of filter

Biquad Filter

Basic biquad filter.

  • Audio Input: input for the audio signal
  • Frequency Input: frequency to use for the filter for the current sample (in Hz)
  • Q/Bandwidth: Q/Bandwidth for the current sample, depending on the selected filter type

Comb Filter

Basic comb filter.

  • Audio Input: input for the audio signal
  • Delay Time: delay time for the filter in ms

Crossover Filter

Basic crossover filter.

  • Audio Input: input for the audio signal
  • Frequency Input: frequency to use for the filter for the current sample (in Hz)

FIR

Only does Hilbert 90 degree phase shift for now. And coeffs are only valid in 44100 or 48000 sampling rates (for now).

Accum

Accumulate at each sample by a specified amount and output the value at each sample with defined minimum and maximum values.

  • Accumulation type: select the wanted operation to use
  • Loop values between low/high: if this is selected, the accum will wrap around when hitting the lower/upper bound
  • Value to accum Input: at each sample, use this value and the selected operation on the current value to get the new current value
  • Start Value Input: the start value
  • Reset Trigger Input: when a 1 is received, resets the accumulated value to the minimum
  • Value lower bound Input: lower bound of the accum
  • Value higher bound Input: upper bound for the accum

Binary Operator

Math binary operators.

  • +
  • -
  • *
  • /
  • %
  • **
  • MIN
  • MAX
  • LOUDEST
  • QUIETEST

Change

Monitors the incoming signal and outputs 0 when the current sample value is the same as the previous one, 1 when it's greater, and -1 when it's lower.

Clip

Clips the incoming signal between the specified minimum and maximum values. Don't forget to hit ENTER to validate a value you just typed.

Constant

Useful set of available constants; you can also specified your own. This bidule can be synched to a step sequencer to obtain the BPM or the number of samples per beat. Don't forget to hit ENTER to validate a value you just typed.

Counter

Simple counter with specified minimum and maximum values. Don't forget to hit ENTER to validate a value you just typed.

  • Number of samples to increment at Input: used to specify the counting interval. (I.e. increment at each 10000 samples)
  • Reset Trigger Input: send a 1 to reset the counter

Function

Mathematical expression with up to 3 variables (fed into the three inputs) that is evaluated at each sample. Don't forget to hit ENTER to validate the function you just typed. The following functions and constants are available:

  • +,-,*,/,%
  • abs(x)
  • floor(x)
  • ceil(x)
  • exp(x)
  • ln(x)
  • sin(x)
  • sinh(x)
  • cps(x)
  • cosh(x)
  • tan(x)
  • tanh(x)
  • asin(x)
  • acos(x)
  • atan(x)
  • sqrt(x)
  • atan2(x,y)
  • mod(x,y)
  • min(x,y)
  • max(x,y)
  • pi()

Function (Recursive)

Same as the Function bidule except that you have access to the 4 previous values of each variable as well as the 4 previous results using the following functions with 1,2,3 or 4 as the parameter.

  • prevX(n)
  • prevY(n)
  • prevZ(n)
  • prevR(n)

Logic Gate

Simple logic gate.

  • Left-Side Argument Input: input for the left-side argument of the logic operator
  • Right-Side Argument Input: input for the right-side argument of the logic operator
  • Value for True Input: input to be redirected to the output when the operator result is true
  • Value for False Input: input to be redirected to the output when the operator result is false

Binary Logic Operator

Simple logic operator.

  • Left-Side Argument Input: input for the left-side argument of the logic operator
  • Right-Side Argument Input: input for the right-side argument of the logic operator

Unary Operator

Math unary operators.

  • INVERSION
  • RECIPROCAL
  • ABS
  • FLOOR
  • CEIL
  • SQUARE
  • CUBE
  • SQRT
  • EXP
  • LOG
  • LOG10
  • SIN
  • COS
  • TAN
  • ASIN
  • ACOS
  • ATAN
  • SINH
  • COSH
  • TANH
  • LOGICAL NOT
  • ROUND

Unit Converter

Useful sets of common unit conversions.

Value List

A list of values separated by a semi colon (';'). A value will be output until the next trigger is received - by sending a 1 in the trigger input. The second input is used to reset the list to its first member (without requiring to wait until the list loops back to start).

Variable

User-defined variable range with slider and input box. Don't forget to hit ENTER to validate a value you just typed.

  • Min and Max: define the range of the slider

MIDI CC Creator

Creation of MIDI CC messages. It stores the last value for any given CC number and will output a CC message only if the value has changed. The amount of created messages is bound by the MIDI specifications which means about a thousand messages per second.

  • CC Number Input: the number of the CC to create
  • CC Normalized Value Input: the CC value remapped between 0 and 1

MIDI Note Creator

The opposite of the MIDI Note Extractor: use values to generate MIDI notes.

  • Frequency Input: frequency value for the outgoing MIDI note (in Hz)
  • Amplitude Input: velocity value remapped between 0 and 1
  • Gate Input: input for the gate signal, set to 1 on MIDI Note On until a MIDI Note Off is received
  • Trigger input: input for triggers, set to 1 for the sample on which the MIDI note should be created
  • Add Microtonal info (param): if this is selected, the outgoing MIDI notes will carry a detune factor if the frequency input is not an exact MIDI note
Look at the Arpegiator group's internals for an example of how to use the MIDI Note Creator.

MIDI Note Extractor

Useful information extracted from MIDI ON/OFF messages.

  • Frequency Output: frequency value for the incoming MIDI note with pitch bend applied (in Hz)
  • Amplitude Output: velocity value remapped between 0 and 1 (NOTE ON only!)
  • Gate Output: output for gate signal, set to 1 on MIDI Note On until a MIDI Note Off is received
  • Trigger Output: output for triggers, set to 1 for the sample on which the MIDI note is received
  • Stealing Mode: select "Use Lowest" to have portamento
  • Glide Time: used when in portamento mode
  • Wheel Range: range of the pitch bend in cents
  • Always Retrig: select this to send a trigger output even if the note is currently in legato (portamento mode)
Note that once a note is rececived, the frequency and amplitude outputs will continue to output the previous note's information, even if note becomes OFF (gate=0). This is useful to allow for proper envelope release. Please look at the "PhatSynth" group's internals for an example.

Audio Monitor

For the geek in you wanting to see it all passing by.

MIDI Monitor

For the geek in you wanting to see it all passing by.

Oscillator

A simple oscillator with a bandlimited (or not:) signal.

  • Frequency Input: frequency value (in Hz)
  • Amplitude Input: amplitude value between 0 and 1
  • Phase Reset Input: trigger input to reset the phase to 0
  • Phase Offset Input: input for the value to use as the applied phase offset.
    • By using a combination of phase reset/phase offset you can create for example, PWM or Phase Distortion synthesis.

    Random

    Generates random values at the specific rate.

  • Rate Input: rate at which new values are generated
  • Amplitude Input: amplitude value between 0 and 1

    • Sample And Hold

    Basic sample and hold.

    • Audio Input: input for the audio signal
    • Trigger Input: input for the signal with zero crossings

    Sync Extractor

    You can sync this bidule to any master bidule to use some of the sync info for your processing.

    • Playing Output: sends 1 when playing and 0 when not
    • BPM Output: the current BPM
    • Numerator Output: the current time signature numerator
    • Denominator Output: the current time signature denominator
    • Samples per beat Output: # of samples per beat
    • ppq Pos Output : the current ppq position
    • Last Bar started at Output: start ppq of the last bar
    • Trigger at bar Start Output: sends a 1 at each start of bar

    Trigger

    Sends a trigger (a value of 1) in the output signal when the the button is pressed, or at the start of each measure when synched to a syncsource.

    Trigger Clock

    Sends a trigger (a value of 1) in the output signal when the # of samples has been counted.

    • # of samples between triggers Input: # of samples before sending a trigger
    • Reset Clock Input: send a 1 here to restart the clock to the current # of samples input


Chapter 4. VST and VSTi support

Table of Contents

Input/outputs configurations
Plugins availability
VST banks and parameters vs MIDI CCs and program changes
VST errors reported by Bidule
Yet to be implemented VST Features

VST and VSTi Plugins

Bidule's VST implementation is somewhat different than what you might be accustomed to from other hosts. The fact that this host is modular, for instance, allows any possible combination of wiring that you can think of. This leads to new set of possibilities for plugin developers.

The VST 2.0 standard is full of very nice features, that are slowly being used by developers of both plugins and hosts out there. We at Plogue, feel many of these features should be used more often. We tried in Bidule to implement most of the more obscure features. Here's a rundown of Bidule's VST peculiarities.

Input/outputs configurations

We really support all possible combinations of ins and outs for VSTs. Audio Effects receiving/trasnsmitting MIDI, synths with audio input, we even support MIDI only plugins (no audio ins and outs). There are few MIDI only plugins available, though, but they could be easily created. Interested developers may ask us for a template.


Plugins availability

  • Unique IDs

    Unique IDs are a standard feature of the VST format that helps the hosts differentiate the plugins. While many hosts use the file name of the plugin as reference, Bidule and others use their unique IDs (which is the cleanest and most crossplatform way to go). Sadly, most commercial hosts out there don't look at those, so many plugin developers don't enter a unique ID when they code their plugins. As a result, many plugins use the default names that were chosen by Steinberg in the SDK: "Gain","ADlE", "ADly" and "VxSy". We, and other host makers, have decided to deny the right for plugins using these IDs to work in Bidule. This is for reasons of code purity mostly, and to force developers to fix their plugins.

    Same applies to Bidule, if a developer points out a fault in Bidule's hosting, we will gladly cooperate and fix our bugs. (Nobody writes perfect code:)

  • Internal names vs. plugin file names

    One of those features that are used more and more are the plugin's internal names, which can give a better description of the plugin to the user than its filename would. For example "Spectral Inverter Using Pvoc", instead of "si_up.dll". If a plugin doesn't provide a name, Bidule will then revert to its filename.

    Users wanting to use the DLL names only can change this option in the preferences menu.

  • Company name vs Directory names

    As with Internal Names, the VST 2.0 standard also supports the plugins that export their company (vendor) name. Most newer plugins support this feature, but older ones seldom do. These automatically go into the "Unknown Vendor" category.

    Users wanting to categorise plugins by their directory structure instead can do so by changing this option in the preferences.


VST banks and parameters vs MIDI CCs and program changes

A VST plugin's internal programs and the normal 128 patches of a MIDI synth are sometimes 1 to 1, and sometimes completely unrelated. It's a case by case basis. We are still not sure on what would be the best solution for the users.

Some VST plugins can also choose to listen to some CC's _themselves_ and map their internal parameters without Bidule knowing about it!!! (You can imagine the conflict with Bidule's parameter mapping:)

As a host, Bidule can't do much about that sadly, so any VST plugin can decide to map incoming MIDI CCs to their internal parameters without telling the host about it (in fact there is no way for the host to know). However, the Bidule CC learning is there on top of that, in case the plugin doesn't do it.

Two solutions we can think of right now:
  • Use the MIDI Message Filter bidule to filter out all CCs going to a particular VST plugin so that Bidule CC mapping becomes the only one that applies.
  • For the users to use two midiIn devices. ex: PhatBoy plugged in MidiIn1 (and only used as parameter mapper). Keyboard plugged to MidiIn2 and routed to VSTi plugin.


VST errors reported by Bidule

Each plugin can report info/errors of its own. But Bidule can also show supplemental ones on top of those for each plugins:

  • Duplicate VST plugin ID found ("a.dll uses the same ID as b.dll : PLUG")

    This can suggest a couple of things. Either you have two duplicate plugins in your folder (potentially an older version along with a recent one!) or that two developers were unlucky enough to choose the same UniqueID when they created their plugins. In either case, you will have to sacrifice one or the other and rescan. In the meantime, informing the plugin author would be a great help to the community.

  • VST Plugin Error ("a.dll caused an error while unloading so it will not be used.")

    This means the plugin didn't deallocate properly when Bidule was testing it (leaving leaked objects around). While the plugin might work before being unloaded, we found it was wiser to disallow using this plugin at all, since each time you would delete it from the patchbay, it would have left Bidule in an undesirable state. To be on the safe side, you should remove the plugin from your VSTplugins folder, save your layout, and restart Bidule.

  • VST Plugin Error ("plugin a.dll by companyX caused an unknown exception and will be set to passthrough")

    This error will be reported when using the plugin, it means that the central processing function of the VST plugin caused a fatal error. Most other host would have died by now, but instead of killing Bidule, we set the plugin to passthrough automatically. Mind you, as for critical scanning errors, it is always wiser to save your patch and reload it after a fresh restart of Bidule.

  • Too common UniqueID used! ("a.dll uses a common id")

    "Gain","ADlE", "ADly", or "VxSy" Unique ID has been detected. As previously mentioned, Bidule will refuse to use any of these plugins in order to strictly respect the VST 2.0 standard.


Yet to be implemented VST Features

Bidule has yet to support the following VST features

  • setInitialDelay interface (doubtful that we will)
  • pinConnected interface (too many plugs only check this when playing starts. This means that if you connect a in/out while Bidule is processing audio, you might not get any result unless you stop the processing and restart).

If you are a plugin developer and think that Bidule is missing some other interfaces, please contact us.


Chapter 5. ReWire support

Table of Contents

Bidule ReWire support.
Basics
ReWire Sync
Sending MIDI to ReWire Devices

Bidule ReWire support.

Bidule currently supports the ReWire "mixer" interface, meaning that it can load ReWire devices in its patchbay. Using ReWire devices in Bidule is in many ways similar to using VST plugins (with outputs only). In some case (Reason), similar to using a VST instrument. (More on that later.)

Basics

In order to use a ReWire device in Bidule, you must :

  • Close any other ReWire Mixer applications (like Cubase SX)
  • Start Bidule
  • Add a ReWire device to the patchbay
  • Start the device's application (Live/Rebirth, etc, - but Reason will start by itself)
Then to end your ReWire session:
  • Close the device's application (Live/Rebirth, etc, - but Reason will close by itself)
  • Remove the device from Bidule's patchbay (or close the current patch)
The order in which these steps are taken are of utmost importance more info here: ReWire Info .

ReWire Sync

Most ReWire devices also support the Sync Master and Slave interfaces. This means that they can either be slaves or masters of other devices, bidules (like the Audio File Looper), or other VST plugins requiring sync (timing) information. For example, a Bidule layout could contain:

  • Step Sequencer (master)
  • Rebirth (master/slave)
  • Reason (master/slave)
  • Audio File Looper (slave)
  • VST plugin (slave)
By default, all these elements would be free running (i.e., they will not be synchronized). Now, synchronize Rebirth to the Step Sequencer, then the Looper and the VST plugin to Reason, then press play on the Step Sequencer and Reason to see what happens.

Sending MIDI to ReWire Devices

At the time of writing, only Propellerheads Reason is the only ReWire device supporting MIDI inputs (that we know of).

Reason can allocate up to as many as 255 MIDI ports of input to access its different modules through ReWire, and their allocations are made dynamically. Since Bidule currently doesn't support dynamic channel allocation, we've decided that a default 2 input ports would be sufficient for most tasks (some Reason demo tracks do use up to 4 input Busses though). Since this is a preliminary ReWire integration in Bidule, we've made this setting only available in the registry on a "per device" manner. (Please contact us either privately or though our phorums, if you need supplemental information).

Knowing the current mapping

If you double click on the patchbay representation of the ReWire device, you will get an info popup, which gives information on the current channel mapping for each Bus currently though ReWire. By using Bidule's Channel filters/re-mappers, you can then reach the specific unit you require in Reason.

ReWire, Reason, and Rebirth are trademarks of Propellerhead Software, Stockholm, Sweden

Ableton Live is a trademark of Ableton AG, Berlin, Germany.


Chapter 6. Groups

Table of Contents

Creating a new group
Creating a new group from a selection of bidules and links
Group navigation
Exporting group parameters
Editing group properties
Saving Groups
Group Manager
Grouping Submenu

Bidules can be grouped together to form a new bidule that you can reuse. This way, instruments and effects can be built, reused and shared. Anything related to a group in Plogue Bidule is shown in italics (labels in the patchbay, items in the Parameter and Palette windows).

Creating a new group

Selecting "New" from the Grouping submenu will pop up the Group properties dialog box, in which you will be asked to input the configuration of the group you want to create. E.g.: its number of inputs or outputs and of which types, its name... etc.


Creating a new group from a selection of bidules and links

Select a few bidules and links on the patchbay, right click them, and select Grouping:Group selected object(s).


Group navigation

Once a group is created or selected, you can expand it by double-clicking on it while holding the CTRL key. To go back to the parent group, hit the BACKSPACE key. You can also use the menu items found under the "Grouping" menu in the contextual menu (right click on a group to access it).

Once inside a group, you will see a white text line at the bottom of the patchbay. This line identifies which group is currently expanded.


Exporting group parameters

It is possible to select parameters from the children of a group and "export" them as parameters for the group itself. For example, create a group and add a Gain bidule inside it. Select Grouping: Parameters from the contextual menu. Select the amplitude item in the tree to the left and click "Add". Select the "Amplitude" parameter that just appeared in the list at right, click "Rename", and enter a new name for this exported parametes (for example "Final Amplitude"). Click "OK" to close the rename dialog and click "OK" once again to close the "Exported Group Parameters" dialog.

Now, if you double click on the the group in the patchbay you will see a window allowing you to edit the parameter you just exported. Setting its value will automatically set the value of the "Amplitude" parameter of the "Gain" bidule inside the group.

Exported parameters can also be linked in the Parameter window and controlled from MIDI.


Editing group properties

To edit a group's properties, right click the group, and select Grouping:Properties. This will bring up the dialog you saw when you created the group. See the Creating a new group section.


Saving Groups

To save the visible group in the patchbay, right click the patchbay and select Grouping:Save current group. To save a selected group, right click on the group you want to save and select Grouping:Save selected group.

Once a group is saved, it will be accessible in the Palette under the "Groups" tree item. To change its name, rename it using the group properties dialog.


Group Manager

The group manager is accessible using the main window menubar under the "Tools" menu. It allows you to download, upgrade, and delete groups. The upper list shows which groups can be installed or upgraded. To update this list, click the "Get remote catalog" button (this will contact www.plogue.com and download a list of available groups). Once a group is downloaded, it is automatically available in the Palette window (usually under the "Group" category, but it may appear somewhere else).

If you built an interesting group and want to share it with the bidule users community, feel free to send us the related ".bgrp" file found in the "groups" subdirectory of bidule at <groupmanager@plogue.com>.


Grouping Submenu

The Grouping submenu on the patchbay's right mouse menu allows you to:

  • New: Creates a new group and set its properties
  • Save Current Group: Saves the group currently displayed in the patchbay
  • Properties: Pops up a dialog to edit the group properties
  • Parameters: Pops up a dialog to let you choose the parameters of the current group you want to export
  • Parent Group: Goes back to display the parent group


Chapter 7. Building Synthesizer Groups

Table of Contents

Making a voice Group
Polyphonic Adapter
Advanced Polyphonic synth topics
Creating cpu-friendly polyphonic and monophonic synths is now a reality in Bidule. Once you know how to do a group, it's just a matter of following these steps:

Making a voice Group

Let's start by creating the most simplistic synthesizer voice group as a example.

  • Create a new group with 1 MIDI input and 2 audio outputs.
  • Get inside the group
  • Add the 4 modules shown below (you can either create them as shown, or use the already created Monotone group)

Table 7.1. How it works

1) The MIDI Note Extractor does the job of separating the note information encoded into the MIDI stream in a sample accurate manner. More precisely, it decodes the MIDI Note On and MIDI Note Off messages. This is what it outputs:

  • (a) Frequency value for the incoming MIDI note with pitch bend applied (in Hz)
  • (b) Amplitude (velocity) value remapped between 0 and 1 (NOTE ON only!)
  • (c) Gate signal. Set to 1 on MIDI note ON until a MIDI note OFF is received, in which case its 0
  • (d) Trigger. Set to 1 on the sample on which the MIDI note is received, and 0 at any other time
(Please see the bidules section for more details on this bidule.) Once a MIDI note OFF is received, the frequency (a) and amplitude (b) it outputs stay at the same values they had when the note was still ON. This allows for the rest of the group to continue computing the release of the note. (If we don't do this, the note will stop abruptly, creating an unwanted glitch!) Because the Gate output falls from 1 to 0 as soon as the Note is OFF, that's where the ADSR comes in handy...

2)Following down, it's up to the ADSR to generate a normalised (between [0;1]) envelope signal (e) which is independent of the note amplitude (b) given by the extractor. It also generates the VERY important "activity gate" (f) signal that the Polyphonic Adapter will use to detect that the note has completely finished playing (release included) so that it can manage this instance of the voice to another note. In more detail, the activity gate output of the ADSR will be "1" or "on" from the start of the note, until its completion (the release), after which it will output "0" or OFF.

3)Next the "*" (Binary operator), multiplies the original "Note On" amplitude (b) with the current envelope value generated by the ADSR (e). If you recall, the ADSR generated a normalised gate, so in order to get the final amplitude we need to multiply both together.

4)Finally the Oscillator (sine wave by default), will output a nice waveform (h) that will have its frequency given by the Note On Extractor, (a) and a smooth amplitude envelope generated by the results of the original amplitude multiplied by the envelope value at a certain point in time (g). If you look closely, you'll notice that the third input of the oscillator - phase reset - is also filled in by the Note Extractor's trigger output (d) so that each time a new Note is sent to the group, the oscillator's phase is set back to 0.


Polyphonic Adapter

You can now go back one level (pressing the BACKSPACE key or by clicking on the blue arrow pointing up on the toolbar), and connect the MIDI input of your voice group to a source (Sequencer or live MIDI input) and ONLY the FIRST output to your soundcard (you don't want to listen to the activity gate directly!!))

Once you are satisfied with the way the voice sounds and behaves, you can now wrap your voice group with the Polyphonic Adapter!

The Polyphonic Adapter is a special bidule that only appears in the right mouse menu of a voice group. (Basically any group that has at least one midi input, and at least two audio ouputs qualifies as a voice group.) Its purpose is to transparently create cloned copies of your monophonic voice group, and to literally transform it into a polyphonic group. Its job is to listen for all notes that enter it and dynamically dispatch each and every note it receives to one of the clones. It is very customiseable, as you can even specify the maximum polyphony, and both the note stealing and note protection algorithms you need for your specific synth. And that's not all! Some polyphonic synths on the market are plain CPU drains as each and every voice consumes resources all of the time. The Polyphonic Adapter in Bidule takes care of that. If only 1 out of 12 maximum voices are needed at one point, then only 1 out of 12 is effectively taking cpu resources. Here's how you wrap a voice:

  • 1) Select and right click on your voice group
  • 2) Set the wanted settings in the Polyphonic Adapter dialog and press OK
  • 3) Use your newly-made polyphonic synth! Notice the little green number left of it? This is a visual cue telling you its maximum polyphony. Notice also that the second output has disapeared? Well in fact it didn't disappear; in reality, the bidule you now see -is- the Polyphonic Adapter itself.

The Polyphonic Adapter is now well in place and monitors incoming notes given to it and and looks at the activity gates coming from all its hidden clones. It can now manage the polyphony of your synth.

NOTE: If you later want to modify your source voice, you will first need to "UnPolyphonise" the adapter - which will make it disapear - and make your voice group reappear.


Advanced Polyphonic synth topics

Details on the Polyphonic Adapter's voice management algorithms settings. These settings affect the behaviour of the resulting synthesizer once a new note arrives and there are no more free voice group "clones" to play it. The default settings work well (provided you use a good number of voices, like the default 12), so these settings should not be used carelessly.

Note Protection. With this setting, you can specify if you want certain notes to be protected from being stolen (i.e., when there are no notes available and you want a new note to play).

  • None: No note will be protected, any of them can be stolen
  • All: All currently playing notes will be protected (warning, the new note will NOT play)
  • Lowest: Only the lowest note will be protected
  • Highest: Only the highest note will be protected

Stealing Priority, is the complementary option to the Note Protection. It applies to the notes that are playing, but that were not protected by the Note Protection algorithm. Between all the unprotected playing notes, which one will you choose to eliminate first:

  • Arbitrary: Don't care, the adapter will randomly steal one
  • Quietest: The quietest note will go first (this is usually less noticeable when many notes are playing)
  • Closest to New: This will steal the note thats the closest to the new note you want to play
  • Oldest: Will steal the note that's been playing for the longest period of time
  • Newest: Will steal the note that's been playing for the shortest period of time

Retrigger. This option is only available when you want to use the Polyphonic Adapter to create Monophonic Synths in order to benefit from its automatic Note playing/CPU use management. By clicking this option, ALL MIDI Notes will be fed directly to the single mono voice group. (overlapping or not), so you can use the Portamento features of the Note Extractor. If this option is OFF, only one note at time will arrive to the group.

Voice groups are not limited to being created as shown! They can have more audio ins and outs. All its audio ins will be a direct copy of audio data coming to the Adapter from the outside. So, for instance, if you need your synth voices to modulate to an LFO, but you want this LFO to be the same for all voices, then there's no need to duplicate that LFO 12 times - just keep one outside of the Adapter, and wrap both the adapter and the LFO in another standard group.


Chapter 8. Troubleshooting

  • Dropouts in sound

    The Windows menu animations can create discontinuities in sound. To resolve the problem download and install: Microsoft TweakUI . Install, then from the Control Panel, select Tweakui/general/effects, and unselect ALL Windows animations!!!

  • Grey Patchbay (or heavy crash at startup in (graphic driver).dll)

    This usually happens when the driver for your video card doesn't support OpenGL correctly. Please make sure that you have the most recent drivers by visiting your video card manufacturer's website.

    Please note that Bidule requires a properly working OpenGL driver. To test your current configuration for OpenGL, please download and try the two following tests (in order):

    • OpenGL Test1.
    • OpenGL Test2.
    If these two tests are working, there are good chances that Bidule will!

    Bidule works best with any nVidia or ATI Radeon chipsets. Microsoft's default software rendering works fine too.

    ATI128, 3Dfx Voodoo3, S3 Savage have OK OpenGL drivers.

    Many problems were encountered using Matrox cards. Use with caution.

    Also, some people experiencing weird crashes at Bidule startup had to update to DirectX 8.1 to solve them.

    In any case, please report crashes. We are trying to find a solution to this.

    Other: OpenGl info software.

  • "Slow" Patchbay

    It might seems that the display of the patchbay is really slow. This might occur if your display settings (resolution and colour depth) aren't supported by the OpenGL implementation of your video card driver and the display rendering is then done in software instead of using your video card.

If all this fails, please send us the bidule.log file that was created by Bidule at the moment of the crash.


Chapter 9. Acknowledgements

Seb would like to thank his computer for so kindly taking the verbal abuse.

David would like to take a moment of silence for all of those dead PC keyboads and also to thank Martine, parce qu'elle aime ses schemas.

Vincent is somewhere on his bike.

Plogue sends thanks to Bram, Merlijn, Rene, fsm, ers, |gb, Kyle (tester extraordinaire), Steffen, Laurent and everyone on the Plogue mailing list and phorum...

Plogue would also like to thank the following groups/individuals for their support:

  • DSP Consultancy : Smart Electronix
  • The Mutek crew, especially Eric Mattson, who did so much to bring to town all these electronic music talents that gave us ideas.
  • Music-DSP Source Code Archive for all those tips and tricks.
  • libsndfile LGPL library from Erik de Castro Lopo.
  • PortAudio library from Ross Bencina, Phil Burk and many others
  • wxWindows library
  • Xerces library of XML parsers in Java and C++
  • Formulc 2.22 A byte-compiler for mathematical functions LGPL Library (Plogue-modified sources available on demand)
  • Nate Robins For original GLUT Particle C sources.

Bidule uses ASIO and VST technologies which are trademarks of Steinberg Soft- und Hardware GmbH .

Bidule uses ReWire the technology which is a trademarks of Propellerhead Software, Stockholm, Sweden .


Chapter 10. Plogue Bidule Revision History

Revision History:

Version v0.5701 (February 26th, 2003)
---------------------------------------------------
New Modules:
- MIDI CC Creator
- Recursive Function
Bug Fixes:
- Fixed PortAudio bug for ASIO cards using int24 for input (EX: Edirol UA-20)
- Fixed parameter linking
- Support for Waves plugins proxie dll
- Bad contents of Step Sequencer upon pasting.

Version v0.5700 (February 8th, 2003)
---------------------------------------------------
- New Polyphonic Adapter to make polyphonic synths out of mono groups.
- Some audio processing optimizations
- Now using single document interface
(so that OS X and Windows versions look the same)
- OS X Alpha tests started. (please be patient until Beta tests!)
- New faster code to detect the selection of bidules
- Some OpenGL optimizations
- ASIO duplex devices now showing as 2 bidules in the patchbay
- MME and DirectSound duplex devices are now available
- Added a progress bar when loading sound files
- New VST/groups scanning mechanism (should always be up to date
with what's on your HD)
- VST errors now showing in the statusbar
- Can now set the processing mode of a multiple-selected bidules
- New bidules
- Basic ADSR
- Trigger Clock
- MIDI Note Number to Param
- MIDI Note Velocity To Params
- MIDI To Sync (beta)
- Changes
- Stats about the driver and ASIO Control Panel now
available when double-clicking on an Audio Device
- All Envelopes bidules now have an activity gate output
- Step Sequencer now exporting currently playing sequence on
each channel as parameters
- Treating Note On and Note Off as two different message types
in the MIDI Message Filter
- Fixes
- VST
- better refresh
- some VSTs crashing on initialization
- prevent VSTs from sending MIDI events outside of the current buffer
- removed isPinConnected interface implementation since too much
developers haven't implemented it thinking of a modular application.
- linking 2 parameters of the same VST
- P4 denormal with the Biquad Filter
- Possible division by 0 with the Biquad Filter
- Possible division by 0 with the Sync Extractor
- Possible stuck notes when using the MIDI Note Transpose
- Linked parameters not copied when cutandpasting a group
- Unlinking parameters sometimes made other links dissapear
from the list in the Parameter Pool GUI
- Sync link not being loaded correctly sometimes
- List of sync sources in the context menu showing more than it should
- Cut and pasting of bidules from inside a group to the outside sometimes causing
weird connections
- VST plugins directory registry key is an empty value
- Specified Minimun sometimes not loading correctly for Parameter Modulator and Variable
- MIDI Note Creator sometimes not using the correct detune value on Note Off messages
- MIDI Note Extractor using a 1ms glide even when none was wanted

Version v0.5601 (October 26th, 2002)
---------------------------------------------------
- Added "Spectral Freeze" Bidule
- Improved ReWire timing precision (Live's synch seldom flashes anymore)

Version v0.5600 (October 20th, 2002)
---------------------------------------------------
- Added "Random" Bidule
- New group
-Schottstaedt String Tone

-Optimizations in Portaudio library (thanx again Ross!)
-Fixed VSTGUI/ReWire refreshes.
-Fixed Sync Extractor/Arpegiator group

Version v0.5600RC1
---------------------------------------------------
- ReWire Mixer support
- New bidules:
- Building Blocks : Accum
- Building Blocks : Basic Audio File Player
- Building Blocks : Basic Filter
- Building Blocks : Binary Logic Operator
- Building Blocks : Change
- Building Blocks : Clip
- Building Blocks : Counter
- Building Blocks : Function
- Building Blocks : MIDI Note Creator
- Building Blocks : Sync Extractor
- Building Blocks : Trigger
- Building Blocks : Value List
- MIDI : CC Filter
- MIDI : CC Remapper
- MIDI : CC To Params
- MIDI : CC Value Scaler
- MIDI : Message Filter
- MIDI : Note Filter
- MIDI : Note Remapper
- MIDI : Note Transposer
- Misc : Parameter Modulator
- Spectral : Frequency Logic Gate
- Spectral : Frequency Variable
- Spectral : Magnitude Logic Gate
- Spectral : Magnitude Variable

- Modified bidules:
- Audio File : Added saving as 32 bits float to Audio Buffer
- Audio File : Audio File Output now available with 2 or 6 channels
Added saving as 32 bits float
- Audio File : Added interpolation parameter to Audio File Looper.
Added playing start at the same relative position when changing files.
- Building Blocks : Added retrigger input to ADSR Envelope (at any stage)
- Building Blocks : Added e, 12th root of 2, and 1 on 12th root of 2 to Constant
- Building Blocks : MIDI Monitor is now terminal
- Building Blocks : Oscillator : added ramp [0;1] oscillator
Oscillator : changed 4th input from "initial phase" to "phase offset"
- Building Blocks : Added portamento and specifiable wheel range to MIDI Note Extractor
Inversed the order of the Gate and Trigger output to match the other bidules
Plus type of action needed (Always steal, use lowest note)
- Building Blocks : Added Round to Unary Operator
- Building Blocks : Added MIDI note to frequency, frequency to MIDI note, cents to
frequency ratio and frequency ratio to cents to Unit Converter
- MIDI : Added play/stop button to the Step Sequencer
- Spectral : Added Ramp to the possible wave types of Spectral Resynthesizer
- VST Hosting: Implemented effEditKey opcodes
Implemented isPinConnected interface
- New Included groups:
- 16 Step Seq
- 16 Step Seq2
- Analog Drum
- Analog Kit
- Arpegiator
- Complex Limiter
- Formant Filter
- Note to Chord
- PD Osc
- Pitch Sampler
- Pseudo Granulator
- PWM Osc
- Saturate
- Simple Limiter
- Stereo Delay
- Stereo Flanger
- Tone Gen
- Two Band Distortion
- Waveshaper
- Wavetable Synth

- Added mechanism to display sync master/slave status of bidules in the patchbay
- Added transport information when syncing bidules
- Added Alignement Command in the Patchbay context menu
- Added automatic rename in the patchbay to the parameter value for
Binary Operator, Constant, Function, Unary Operator and Unit Converter
- Added display of possible range in the status bar for inputs and outputs of some basic bidules
- Text is now automatically selected in the rename dialog
- Changed the play/stop button in the toolbar for an on/off switch
- Added directory browse dialog when changing the VST plugins path
- Better displaying of audio file types in the MediaPool GUI
- Added option to save MediaPool content when saving a group
- Added mechanism to limit the number of patchbay refresh per second
- Fixes
- Several little VST hosting bugs (many thanx to tobybear's Kondor!)
-fixed CRITICAL bug with host dangling "all notes off" midi events
(made some plugins crash between after a stop/play command)
-fixed preset list drop down to be VST 1.0 compatible
-fixed receiving of MIDI events from certain plugins
-added Bidule-side FPU control word protection
-misc VstTimeInfo members fixed
-audioMasterVersion returns 2200 (as SX)
-audioMasterCanDo's (host) now properly filled
- Rare occurence crash when deleting bidules and audio was playing
- Fixed propper CPU speed detection routine (for tighther timing)
- Bug in our addons to PortAudio that would prevent some audio cards to work
- Crash when trying to use an audiodevice inside a group
- Mixer crashes when using parameter linking with it
- Potential crash with remote catalog
- Bidule appearing in the taskbar and not possible to view its window
- Group dialogs now showing proper value of virtual parameters in the statusbar
- Min and Max inversion in Binary Operator
- Loading problems when using reserved characters for bidules/parameters display name
- GUIs of bidules contained in a group sometimes appearing+disappearing immediatly when
deleting the group
- Fixed first bar syncinfo from Step Sequencer (now starts at ppqPos=0)

Version v0.5000 (July 24th, 2002)
---------------------------------------------------
- Added Pitch Bend to Note Extractor
- VST fxbs load/save added
- VST fixed selected program save/load
- Parameter Pool now is hierachical (by groups)
- Optimized band limited osc.
- Misc Groups manager bugs fixed

Version v0.5000RC1 (July 15th, 2002)
---------------------------------------------------
New features:

- Bidule Grouping ability

- Pre-made example groups:
4-Tap Delay
Comb Tone
PhatSynth
Flanger
Freeverb (based on Jezar's famous reverb - public domain)
LFO
MIDI Gate
MonoTone
Random Computer Tones
SimpleFM

- Group Manager
(up to date live info from plogue.com's Catalog of
of freely downloadable groups)

- Unified Audio Device Types (now one exe for ASIO/DS/MM)

-Bidule Palette

-Patchbay:
CTRL-drag for n to n connections
CUT and Paste of bidules/connections

- Default Patch

----New modules----

Oscillator (new name of "tone generator")
-New choice of bandlimited tones (on/off)
-Freq/amp/trig/phase inputs

-MIDI Note Extractor (extracts freq/amp/gate/trig from MIDI notes)
Can only do monophonic tones right now...
polyphonic and portamento managers in next version

-Sample And Hold
Math:
-Constant (with many usefull defaults, like current SampleRate)
-Logic Gate
-Unit Converter (ms 2 samples, dB to Linear. etc)
Envelopes:
-Exponential
-ADSR
-Envelope Follower
Filters:
-Crossover
-Biquad
-Comb
-Allpass
Monitoring
-Audio Monitor
MIDI
-Midi 2 value (smoothly interpolates CC's into audio)
Mixing
-Stereo Squeezer (Stereo image width reducer)
Routing
-Audio switcher
-MIDI switcher
Spectral
-Magnitude Stretcher
-Magnitude Breeder
-Magnitude Shifter
-Frequency Stretcher
-Frequency Breeder
-Frequency Shifter
-Frequency Inversion

Improved modules

Delay Line
- Fully interpolating output depending on variable delay lenghts

Variable
- now has user definable min/max ranges
- and convenient slider

VST
-reporting errors at the end of scan only
-can be terminal (MIVI now works)
-can generate VstTimeInfo (be master) (lots of things i dont remember)
-manual loading of FXP/FXB started (will be complete in 0.5000 -no RC)

New Parameters
-Better efficiency in linking, CC mapping
- lots more routing flexibility

Bug Fixes
-misc opengl fixes (ATI128 crash),
-misc vst hosting fixes
-and little optimisations here and there

Version v0.4501 (May 12, 2002)
---------------------------------------------------
Bug Fixes
-ASIO devices detection logic in PortAudio.
-OpenGL crashes with some cards (please try with your own!)
-VST GUI ASIO crackles on some plugins
-VST loaded from .bidule causing infinite loop
-VST protection from GUI coordinates fetch.
-VST saving binary "chunk" states.
-VST subdirs "changed" detection for auto scan.
-Loss of sound in iFFT using Frequency Binary ops
-Patchbay panning directions inverted

Version v0.4500 (Apr 23, 2002)
---------------------------------------------------
Bug fixes
-ASIO devices fixes
-PlogueBiduleASIO.exe can now play the tutorial layouts
-New Windows help file and splash
-and more...

Version v0.4500 RC1(Apr 16, 2002)
---------------------------------------------------
New modules:
-Mixer (8 mono ins, stereo out)
-Buffer Granulator (beta)
-Spectral To MIDI (beta)
-Spectral Cherizer (beta)
New features:
-MIDI Splitter has a new program change mode
-Improved parameter linking window.
-Textures in processsing modes (passthru, mute)
-Tone generator now has a toggleable linear envelope.
-New tutorial layouts 7 and 8
Bug fixes/Annoyances
-Layout of default GUI enhanced with value display, tab access.
-Sequencer display buffering enhanced (less flashing)
-Catching errors on VST editor close
-Checking for VST duplicate and Common IDs added to scanning. (and removing them)
-Mediapool bugs
-Bugs in layouts saving
-Error message when current sample rate isnt supported by driver

Version 0.4419 pre-beta (Mar 23, 2002)
---------------------------------------------------
New modules:
-SmartElectronix Granul8 (slightly modified by us:)
-MIDI Channel Remapper
-MIDI Channel Filter
-MIDI Note Shuffler
-MIDI Velocity Scaler
-MIDI Monitor
-SpectralDomain Pitch Shift
New features:
-ALL: Process/Mute/Passtrhough modes added for Bidules (non devices)
-Sequencer: Clear Button and Set BPM/StepSize for all in PlayList
-Correct Phase vocoding with user selectable FFTSize and overlap factors
-SampleRate,BufferSize, FFTSize, FFTOverlap are now in prefferences
Bug fixes/Annoyances
-Adding protection so that only one device is opened at once.
-Fixed VST-selected patch vs. Bidule's selected patch problem.
-Took out warnings after a VST scan.
-Sample Accurate AudioFileLooper, ToneGen, BobocheSampler
-Fixed random GUI appearing when deleting bidules bugs
-Fixed MIDI Learning bug (used last CC received when not in learn mode)
-Fixed crash on manual sequencer bank loader.
-VstTimeInfo fixed for Reaktor3 synchronisation
-Wav file listing discrepancy between wav pool/Bidules

Version 0.4153 pre-beta (Feb 10, 2002)
---------------------------------------------------
-New options to automatically show GUIs when inserting them... or not.
-Fix for paths (they are now remembered)
-Fixed locales (use whatever you want, it doesnt bother Bidule anymore)
-Misc bad VSTi behaviour fixes.
-Added supplemental crash protection in VST scanning phase
(a new popup will warn the user that a plugin acted funny
and that bidule wont use it in the future)
-ASIO driver optimizations, especially for the hacked Live drivers
(a new "output only" driver is now available for it, instead of a fake duplex)
-OpenGL optimizations so that it does less screen refreshes (helps ASIO a lot!)
-Fixed random crashes in AudioFileOutput and AudioBuffer,
that would crash Bidule randomly on start/stop file writing.
-Fixed 24/16 bits file for audio cliping wraparound.

Version 0.4152 pre-beta (Jan 29, 2002)
---------------------------------------------------
-MIDI Outputs work (must have a Audio Device somewhere though)
-Parameters can now "learn" a from a MIDI CC. (see Context menu below)
(got rid of the old MIDIToParam Bidule, now obsolete)
-Playlist Interface for the MIDISequencer ( first version )
-VSTs/VSTis/AudioFileLooper can now be synched to any MIDISequencers
-First third party deal: SmartElectronix Chorus! (more to come!)
-VST Sorting by "directory names", and "DLL names" as option (happy???)
-New "radar" view for the Patchbay
-Speed slider of loopplayer now goes from [-2.0;2.0] Scratchy!
(only available if not synched)
-Modules pins information are now displayed in the status bar.
-Each Bidule now has its own context menu
(bidule must be selected first then right clicked)
-VST fix for some wrongly sized GUIs (FM7, sonic syndicate plus, etc)
-Maybe some other things but we don't remember, it's been a long time ;)
+ and many other bug fixes.

Version 0.4100 pre-beta. (date?)
---------------------------------------------------
- Completely new Patchbay ( see next section )
- Added Spectral Domain Bidules and connectors
This is a preliminary version of all Spectral Bidules, so for now
FFT size HAD to be fixed to 256 so is the Standard Audio BufferSize!!
you can't change it anymore in the registry for this version.
Also the Phase Vocoder overlap factor is also set to 1 (no overlapp)
So everything you do spectral-wise won't exaclty be high quality
all this section is _very_ alpha.(see Bidules section for specific details)
- Enhanced MIDI Sequencer (16 Sequences can run simultaneously, one for each midi channel)
- Added MIDI Splitter
- Added support for VST opcode audioMasterOpenFileSelector and VstPinProperties
- Changed saved files format ( you won't be able to load your previous .bidule files )
- Fixed bug with MIDI Devices allocation/detection
- Added option for selecting your own VSTPlugins directory and manually call the
scanning ( see the Edit Menu )
- Fixed popup dialog when clicking cancel on open file dialog

Version 0.4001 pre-beta. (Oct 22, 2001)
---------------------------------------------------
- Added Ctrl-left mouse button as deleter of connectors/midi notes
- MIDI and Audio Devices appears with their real names in the menu
- Double-clicking on a Bidule in the Patchbay brings up its GUI

Version 0.4000 pre-beta. (Oct 21, 2001)
---------------------------------------------------

Version 0.3003 alpha (Sep 22, 2001)
---------------------------------------------------
New features:
-Layouts Try the 3 new Bidule examples in layouts (but dont use ASIO!!!)
-AudioBuffer Saved wav files now instantly appear in MediaPool!
-Patchbay: Bidules now have a size proportionnal to their max inputs/outputs, yay!
-MediaPool: Can now load many wav,aiff,au,raw files at once!
-ParticleSequencer: Spectrum colored balls.

BugFixes
-Patchbay: Seb added a feature that _we hope_ will solve lots
of crashes that occur when adding/removing connections in playback.
-Patchbay: Middle clicking + hiting del made Bidule crash!
(budz_ reported)
-Menu: First dummy entry on the menu reported "missing main"
(ben@KVR reported)
-VST: Now looking EffectName, then ProductString, then dll name.
(marc3poirier/DFX suggestion)
-ToneGenerator: Noise's wavtable access (noise sounded loopy!)
-Device Names: Now generic (execpt in patchbay) to make sharing of .bidule
files a reality
-MoogVCF: Fixed "speaker destroyer" side-effect.

Version 0.3002 alpha
---------------------------------------------------
-Minor fixes
-Started Implementation of own CPU monitoring with overflow management (50%)

Version 0.3001 alpha
---------------------------------------------------
-Particle Sequencer now outputs MIDI!!!!
-Saves now workspace layouts (thanx seb!)
-Now using VSTPath from registry if previously set, otherwise using/VSTPlugins
-Using SGI GL implemtation. If you have an accelerated card,
your normal Gl ICD will of course be used, otherwise, you have something
faster than MS's implementation .
+ you could test the software mode if you want (see below in GL Config)
-Fixed AudioBuffer filename problem
-Fixed Paths problems
-Fixed Max Midi Devices crashes.. I hope it covers all!
-Minor additions to sequencer. (can now change sequences)!
-Minor AudioDevice Fixes for same input/output name
(thanx Laurent for finding this!)

Version 0.3 alpha (#musicdsp dev friends test)
---------------------------------------------------
Added:
WavePool and AudioFile Player speed changes. (soon to match BPMs)

Version 0.2 alpha
---------------------------------------------------