User Guides v3.0

Bindings

Bindings let you control nearly all settings in Cantabile (and any loaded plugins) from an external MIDI device like a keyboard, control surface or drum pad. Cantabile supports many different MIDI controller events and many different controllable elements within Cantabile.

Cantabile Performer can supports "reverse bindings" where a setting inside Cantabile can be reflected to an external MIDI device so that whenever the setting changes an appropriate MIDI message is sent.

Note: "Bindings" is the new name for what was called "MIDI Assignments" in earlier versions of Cantabile

Bindings Editor

Bindings are edited using the Bindings tab in Cantabile's main window:

Bindings

You can switch to this tab either with the mouse, or by pressing Ctrl+D or by using Ctrl+Tab/Ctrl+Shift+Tab.

Learning Binding Source

The easiest way to create a new binding is to let Cantabile "learn" it. Click the "New Binding" button and choose the "(learn)" option.

Learn Binding

A window will appear that shows all incoming MIDI events. Move or press the controller that you want to bind and it should appear in the list. Double click the event you want to bind and a new binding with that source controller will be created.

You can then use the drop downs in the other columns to configure what it's bound to. The bindings editor supports undo/redo, copy/paste, and move up/down commands

Learning Binding Targets

The other way to create a binding is by right clicking on the target setting you want to bind to. For example to create a binding to the master gain setting, right click on it an choose Create Binding:

Create Binding

You'll then be prompted to move the control you want to bind to with the appropriate target binding point selected:

Learning Plugin Parameter Binding Targets

Create Binding Step 2

To create a learn a binding to plugin parameter, open the plugin's editor and choose Create Parameter Binding:

Create Parameter Binding

While the Learn Binding window is open you can move any setting in the plugin editor and the associated parameter will be selected in the Bind To drop down. Here the Amplifier Attack knob was turned resulting in the "A_Attack" parameter being selected:

Create Parameter Binding Step 2

Binding Settings

Depending on the kind of binding (MIDI -> Setting, Setting -> MIDI, MIDI -> MIDI etc...) different columns in the bindings editor may or may not be applicable.

Here is a random selection of bindings that demonstrate some of the different ways bindings might appear.

Binding Examples

The following describes each column:

State
The LED indicator lights up when the binding is active - ie: when its responding to changes from the source.
The check mark can be used to enable/disable the binding
The "play" button can be used to invoke simple command based bindings (not available on all bindings)
Source
The source of binding event. This could be an external MIDI device or an internal object such as the "Master Levels"
Source Channel/Property
The second part of the source column is used to select MIDI Channel number for MIDI sources, or the source property or trigger event for object sources.
Event Kind
The MIDI event kind to monitor (see below for more)
Event Controller
Depending on the event kind, there might be an additional controller number setting. (eg: for MIDI CC events, this would be the CC number). Some trigger events support a delay setting here. eg: the song "On Load" trigger supports a delay before invoking the target of the binding.
Target
The object to be controlled by the binding
Target Channel/Property
The second part of the target column is used to select the MIDI Channel for MIDI targets, or the target property for object targets.
Action
For MIDI targets, the MIDI event to send (CC, Pitch Change, Note etc...)
Value
Depending on the type of source and target objects this might be a value to value mapping, or other options that control how the binding works.

Jump Prevention and Rotary Encoder (Relative CC) Support

See Binding Jump Prevention and Relative (Rotary) Encoder Support

Routing Modes

Bindings have a routing mode that determines how processing proceeds after the binding has been matched to an incoming event:

Continue
The original event continues to be routed as if the binding didn't exist.
Suppress
The original event is suppressed. Subsequent bindings and other MIDI targets won't receive the event. This mode is useful when binding specific notes to action (eg: binding the lowest key on your keyboard to move to the next song)
Block Until Complete
The target of the event is invoked, and all incoming MIDI on the same MIDI port is queued for processing until target action has completed. This mode is useful when binding to slow actions where you want to make sure the action has completed before sending subsequent events. (eg: loading a song and then sending configuration events).

To set the routing mode of a binding right click on the binding and choose the routing mode from the menu.

Binding Routing Modes

Note: some binding targets support immediate and delayed versions of the same action. eg: "Set List -> Load Next Song (Delayed)" and "Set List -> Load Next Song (Instant)". The blocked routing mode doesn't work on the delayed versions of these actions as incoming MIDI will only be blocked and queued until the delayed load has been initiated, not completed.

Binding Delays

Some bindings (notably trigger bindings such as Song - On Load) have an option to specify a delay before the binding is invoked and a second delay after the binding has been invoked.

Binding Delay Settings

The "before delay" is self explanatory and introduces a delay between the time of the triggering event and the time the target side of the binding is invoked.

The "after delay" is a second delay that will be introduced between the time this binding is invoked and the next delayable binding is invoked. If there are no other delayable bindings after this one then this setting has no effect.

The "Block Other Operations Until Complete" option specifies what happens if certain major operations occur (such as song or state switch, engine shutdown etc...) while the binding is in the pre-delay period:

  • When enabled, the operation will block until the binding has fired.
  • When disabled, the binding will be canceled and wont fire.

For example suppose you have a binding configured to fire 10 seconds after a song loads. Then suppose you load the song and then immediately switch to another song (before the 10 second time out). If the binding is configured as blocking then Cantabile will block the song switch until the 10 second time expires, the binding will then be invoked and then the new song will be invoked. If the binding is configured as non-blocking the delayed action will be canceled and the song switch will happen immediately.

By default bindings are marked as blocking. If it's not important that the binding be reliably invoked then marking the binding as "non-blocking" will allow for faster song and state switching because the engine doesn't need to wait for the bindings to fire.

Sys-Ex Bindings

(Cantabile Performer Only)

A binding can generate sys-ex data if the target is a MIDI port and the event kind is set to "SyeEx". For details on setting up sys-ex bindings, see the Sys-ex Expression reference.

Global Bindings

Often you will want to configure bindings that work across all songs.

eg: it doesn't make much sense to create a binding in a song to load the next song in a set list since you'd need to create an identical binding in all songs for it work correctly.

For this reason, Cantabile has a "Background Rack" - a special rack that is always running in the background and whose primary purpose is for global bindings.

To create global bindings:

  1. From the View menu, choose "Background Rack"
  2. Switch to its Binding tab
  3. Create bindings as per any other rack

Note that not all binding targets are available from the background rack. eg: you can bind to a specific plugin in a song because that song might not be loaded when the binding is invoked.

Song, Rack and Background Rack Bindings

Each song and rack has it's own set of bindings and bindings are processed in the following order:

  1. Song bindings
  2. Bindings in racks loaded into the active song, in the order the racks are in the song
  3. All other rack’s bindings (except the background rack) but in an undefined order
  4. The Background rack’s bindings

The most important part of all this is that the Song bindings take precedence over the Background rack bindings.

Let’s say you have a button on an external controller that for all your songs you want it to perform some function. You could create a binding for that action in the background rack.

Now let’s say for that for one particular song you want to change that button to perform some other action. If you create that binding in the song and set its routing mode to suppress — the song’s binding will take precedence over the background rack bindings and effectively override it.

Special Event Kinds

Most event kinds are self explanatory as they simply reflect the associated MIDI event. For MIDI Continuous Controller events (CC's) however there are a couple of different ways they can be used - depending mostly on the type of physical control they're originating from:

Binding Event Kinds

To explain some of these:

Controller
This is a normal MIDI CC event that can be assigned to a variable value (eg: a gain level)
Controller (Fine)
These bindings combine MIDI CC 0-31 with 32-63 to create a more precise 14 bit controller.
Controller (Button)
A momentary MIDI button that sends a value > 64 when pressed and < 64 when released. This kind of binding is edge-triggered in that it invokes the target when the value crosses from less that 64 to greater than 64.
Controller (No Edge Button)
Use this for MIDI buttons that send a non-zero value when pressed and no event or a CC value of 0 when released. ie: it triggers on any non-zero value.
Controller (Switch)
This is for non-momentary on/off MIDI buttons and switches that send a value >=64 when on and <64 when off.

Bindings to Routes

Unlike most other objects, routes do not automatically appear as assignable objects in the Bindings editor. This is because by default routes don't have a name and therefore can't be referenced.

To create an binding to an audio or MIDI route:

  1. Select the route in Cantabile's main window
  2. From the Edit menu choose "Rename", or press F2
  3. Type a unique name for the route and press OK
  4. Though the name won't show in the main window, the new name will appear in the Bindings
  5. From the bindings editor you'll now be able to create bindings for the route

All routes support binding to the enabled/disabled setting. Audio routes also support bindings to the route's audio gain level.