MIOConsole3d
v. 6.2.01 Release Notes

This is a bugfix update to v.6.2. It contains the following changes:

  1. Bootstates saved by the firmware included with the 6.2.01 console corrupt USB when restored; this caused USB connectivity to fail for units with old boot states. This firmware update changes the compatibility version of the boot states, disabling old states that will cause a problem.
  2. Under certain circumstances, the mapping config could cause a crash. This build removes those conditions.
  3. Attempting to set mappings for the Monitor Controller after mappings were created and restored after relaunch, when the Monitor Controller configuration was loaded from global prefs rather than the cnsl3d file would lead to corrupted UI and eventually a crash. This build fixes that.
  4. Make the targets for Talkback and Listenback be parameter targets rather than command targets, so that Set/Toggle/Momentary can be used

Detailed changes since release/6.2.00: (11 commits)


MIOConsole3d
v. 6.2 Release Notes

This release provides numerous new features and bug fixes, and is a recommended update for all users. This version has been tested on macOS Sonoma (macOS 14.x), as well as previous macOS releases.

Table of Contents

MIOConsole Changes

MIDI Learn & External Controller Mapping Support

The big news in this release is a suite of features added to provide flexible support for user-defined mapping of external MIDI controllers to virtually every aspect of the system.

We have added extensive instrumentation throughout to support binding of external controllers to specific controllable elements of the system. This release of MIOConsole3d adds support for mapping external MIDI controllers. The architecture of the mapping system was designed to enable support of multiple external controller types (such as OSC and Front Panel User Mode in addition to MIDI) and we plan on adding support for things like OSC in the future.

Definition

Mapping: A software connection between the messages sent by a physical control on an external device or any virtual device that can generate MIDI messages (e.g. via Network MIDI or CoreMIDI IPC MIDI channels) and changes to a specific virtual control in the system.

Mappings are represented in MIOConsole as a set of filters that restrict the response to messages of the specific type emitted by the external controls.

Mappings can be made between external controls and the parameters, commands and various UI elements in the software.

This mapping system differs from MIOConsole3d’s existing support for EuCon and Mackie Control Protocol based control surfaces (also known as Control Surface Support). Both the new mapping system and the existing Control Surface Support run in parallel with each other, and any or all of the external control systems can be enabled and active at the same time.

The Control Surface support dynamically assigns physical controls from surfaces with well known layouts to the various supported virtual controls in the system (with support for paging and nudging, and context sensitive control modes).

The mapping system aims to provide a different capability.

Rather than having a dynamic mapping based on the control surface layout and Metric Halo’s mapping choices, the the new mapping system provides the user with the capability of making fixed mappings between arbitrary external controllers and specific parameters and/or commands in MIOConsole3d on the fly. Mapping Flow

While you use the GUI to easily select what parameter or command you want to map to, the bindings you create are not dependent on the UI, so they remain active even when the UI is not on screen.

For global elements of the system (eg. Monitor Controller, Cue Controllers, Transport, Key Commands), this fixed mapping is quite natural. For more dynamic elements of the system (eg. strips, busses, plugins) the fixed mapping may feel limiting or surprising.

Think of it like a mapping for performing with a specific setup (performing in the generic sense, as this could just as easily apply to mastering as it does to performing on stage). You associate a fixed control on your external surface with a fixed element in the system.

It allows you to build a dedicated fixed-knob-per-function control surface for the processing in your setup.

Utilizing the Used Future

Since the system utilizes virtually any MIDI message for control, you can take advantage of the wide variety of MIDI controllers most users collect over the years.

No Controllers, no problem

If you don’t have any MIDI controllers available in your personal inventory of gear, there are a huge number of different MIDI controllers readily available from different vendors and many of them are very inexpensive with direct USB connections. So pretty much whatever generic MIDI controller(s) you choose, it is plug and play.

Mapping in Practice

Mappings can be established in one of two ways:

  1. Per-control assignment
  2. Auto-assignment mode

Per-control assignment: This is initiated by typing ⌘1 (Command 1) while hovering the mouse over the control that you want to map to.

The control you are hovering over can be any on the list below, or the name of a command in the command-keys window.

When you press ⌘1, an assignment window will popup pointing at the control. Screenshot

If the control doesn't have a mapping, the assignment window will automatically be in Learn mode (e.g. the Learn button will be illuminated). While in Learn mode, you can trigger a MIDI message by touching a button, key knob, expression controller or the like on the external MIDI controller, and, the assign window will capture the message and set up the mapping for you. You can finalize the mapping by clicking on the Set button (or press the return/enter key), or you can further edit the mapping parameters using the controls in the assignent window before finalizing the mapping.

If you want to cancel the mapping rather than finalizing it, you can click the Remove button. This can also be used to delete an existing mapping.

If the control already has a mapping, the Learn button will be light grey and the message parameters will be listed at the bottom of the assignment window like this: Screenshot

If there is a mapping present, you can either edit it via the controls in the assignment window, or you can click the Learn button to enter Learn mode (as described above).

If the UI item you are hovering over when you press ⌘1 has multiple parameter targets associated with it (for example a surround panner, or an aux send control), then all the available parameters will be in the “Target:” popup menu. You can click on that popup to switch between the available targets: Screenshot If you select a new target, the current controller filter will be saved for the target you are switching from (as if you had clicked the Set button); this allows you to press ⌘1, touch an external control to assign the first target of the UI control, then use the popup menu to switch to the next target and repeat the process, clicking the Set button once you have set the controllers for all the targets you wish to assign.

Screenshot

The following MIDI messages are supported:

By default, the learned mappings filter MIDI events to the specific message from the specific port that the learned message was received from. So if you, for example, learn CC#0, on channel 2 of Port "Sampson Graphite M25", even if you send a CC#0 from a different port, or even the same port on a different channel the filter will treat it as a different controller.

However, you can if you choose set the various filters to "Any", and if a given filter is set to "Any", then the mapping will trigger as long as the rest of the filters match. So you could set the port to "Any", and then any CC#0 on channel 2 would trigger this mapping.

For each message, the following processing modes are available (although some messages and/or targets only support a subset of the processing modes):

The system will attempt to select the correct processing mode automatically, but you can set it via the "Mode" popup menu in the Assignment window.

Each mapping also includes a user-configurable range for mapping the external controller value to the underlying parameter's value when the Mode is "Set".

The Min setting will be the value used when the external controller is set to its minumum value. The Max setting will be the value used when the external controller is set to its maximum value, and in-between values for the external controller will interpolate between the user specified min and max (using the parameter's built-in taper) for the underlying parameter.

Note: You can set the min to be larger than the max, and this will have the effect of inverting the sense of the parameter.

This user-defined range mapping can be used to good effect to do things like:

We have added a new window (External Control Mapping List) that shows all of the defined mappings in the system; when there are no mappings defined, it looks like this: Screenshot

After you define a mapping (e.g. via ⌘1 or the Auto-assignment mode below), the mappings will be added to the list: Screenshot

You can sort the columns by clicking on them, (Ena, Parameter Path, Source). You can edit a mapping directly from the list by clicking the associated mapping button, or you can relearn the mapping directly via the Learn button. The Enable checkbox allows you to disable (or re-enable) the mapping without removing it. The Min and Max columns in the table are editable directly from the table without having to invoke the mapping editor.

Finally, you can delete a mapping in one of the following three ways:

  1. ⌘1 or click the Edit button, and click the Remove button
  2. Right-click the dot in the left most column and select Delete Row
  3. Click and then command or shift click the dots in the leftmost column to select multiple rows, and then click the – button in the bottom left hand corner of the window

Auto-assignment mode: This is initiated by typing ^2 (Control 2). The External Controller mapping list window will be shown if it was not already visible and the Auto Learn: button in that window will turn yellow. Screenshot

As you touch controls or fire commands in the MIOConsole3d, the text next to the button will be updated to reflect the current command/parameter that will be mapped on the next MIDI message. Screenshot

When the next MIDI message is received, it will be mapped to the current parameter (as if you used the per-control assignment mode, and immediately press the Set button after the MIDI message is received). Screenshot

You can then touch another control, and send a MIDI message to map it, and repeat as desired. When you are done mapping controllers, you can click the Auto Learn: button or press ^2 again to toggle off the auto-learn mode.

Note: When an external controller’s message matches the filter assigned to a target the associated “Source” field in the External Control Mapping List will flash green to let you see that the messages are being received and matched.

The green Global Enable button in the lower right corner of the External Control Mapping List window is connected (and synchronized) with the Global Enable External Mapped MIDI Controllers menu command. When the button is green, the mappings are active and will respond to messages. When the button is light grey, the mappings are globally disabled. You can use this to turn off all the mappings without having to delete them or disable them individually.

Multiple Mapping

Each parameter or command can only have one external controller mapped to it, but any external controller can be mapped to multiple parameters, so you can control more than one parameter with one external controller.

In addition, each mapping can have an independent processing mode, and can also have a different mapping range. One useful thing you can do is set on/off controls to have opposite mappings with one external source. This allows for arranging multiple bypasses or enables to be operated in opposition to each other with one CC or note controller.

New Menu Commands

There are four new menu commands in the Edit menu that relate to external controllers:

The elements that can be controlled are:

The elements that can not yet be controlled are:

New Plugins

The Quad Modulation LFO plugin provides an analog-synth style multi-waveform LFO generator: Quad Mod LFO UI

This signal generator creates a low-frequency waveform (0 - 20 Hz). The two outputs of the plugin are in quadrature (e.g. one is 90° phase shifted from the other).

The signal generator can create the following waveforms (selectable from the popup menu). These waveforms are not bandlimited when the filter is not engaged.

The frequency of the generated signal is controlled by the Rate parameter.

The signal generator also includes a Low Pass Filter. The filter can be used to shape the waveform and smooth the sharp transitions.

The Filt Ena parameter controls whether the filter is on or off. The Filt Cutoff parameter sets the cutoff frequency of the filter in Hz. If you set the Filt Cutoff parameter to 0 Hz, the plugin will automatically make the filter cutoff frequency track the LFO frequency.

Finally the Depth % parameter controls the magnitude of the waveform.

Plugin updates

The plugins included in the 3d system have received significant updates. Most of of these updates apply to all the plugins in the system (Undo/Redo/Snapshots/Blend/Controller Support), but the Sontec MES-432D9D has received many plugin-specific updates.

Sontec MES-432D9D

Quad Mod LFO UI

This release of the Sontec MES-432D9D adds an Options panel, which provides access to some of the most requested features in a friendly and easy to use layout. The new features include:

These new features allow you to fine tune the equalizer to your particular workflow.

When in mid-side mode L/R input gain becomes M/S input gain, but the output gain remains left and right.

The knob controls in the UI have many gestures available to support alterate modes of operation. Many gestures were already supported in the previous release, but there are new gestures that have been added. The comprehensive list of gestures supported by this release are:

The Transfer Function panel allows you to see the transfer function of EQ based on the settings you have made. Since the MES-432D9D supports unlinked operation, the transfer function displays the curve for both channels when it is unlinked:

The SpectraFoo logo (the tuning fork+magnifier) in the top-right corner of the transfer function controls the display of the analyzer. You can -click the SpectraFoo Logo to popup the Analyzer Options menu:

Input/Output Meters
The meters are displayed to the right of the transfer function in the transfer function panel. The meters include Peak Hold (held red bar), PPM (floating bar), VU (floating grey bar) and RMS (solid bar). Click to reset peak holds and clip indicators.

Inputs are smaller meters to the outside, outputs are larger meters in the middle. This adjacent layout allows you to adjust output gain to level match Output to Input.

Plugin Undo/Redo

Undo/Redo UI

All the plugins now provide support for undo/redo from the plugin header bar.

The left and right curved arrows represent Undo (Left) and Redo (Right). These arrows are grey when there is nothing to Undo or Redo.

The arrows are white when it is possible to Undo (Left) or Redo (Right). Clicking the left arrow when it is white will undo the last action you made in the plugin. When you undo something that change is placed on the redo stack, and the Redo button will turn white.

Clicking the Redo button (when it is white) will restore the state that the last Undo changed.

If the Redo button is white, and you make a change in the plugin, the Redo button will go grey as the redo stack will be cleared.

Plugin snapshot registers: A/B

A/B/Blend UI

The A and B buttons control the A and B state registers. For each of the A and B buttons the visual display tells you the state of the register:

You can perform the following actions:

Snapshot blend

The Blend button’s visual display tells you the state of the register:

The Blend button allows you to interpolate between the settings in the A and B registers. It becomes active when both A and B have a setting stored. Undo/Redo UI

Click on the Blend button to popup the blend control. Slide all the way to the left to apply the settings in the A register. Slide all the way to the right to apply the settings in the B register. Intermediate settings for blend will give you intermediate settings for any parameter that is different in register A and B. The blend control does not change the state of Bypass.

Note that the Blend is not a parallel processing mode where two instances of the processor are running with A and B settings and the output is a parallel blend of the two settings. Rather Blend applies the interpolated settings to one instance of the processor.

Blend is a mappable parameter so it can be controlled with an external controller.

The A/B and Blend settings are stored and recalled as part of the plugin state (but not presets in the preset bar).

While you can use the blend with arbitrary A and B settings we find it works best when you craft the settings in the two registers in such a way as they are related to each other.

Specifically, if an indexed parameter is different between the two settings, the interpolated value will snap to one of the indexes between the two settings, which can be jarring (e.g. Q, MS, Band Enable).

It is best if the parameters that you blend are smooth parameters (e.g. gains, frequencies) and make sure the indexed parameters (enables, modes, band types) are set the same for both registers.

The easiest way to do this is to load the same setting into both registers and then tweak the settings one of the registers.

This works especially well if you make one of the registers be the basic settings with all the gains or thresholds flattened out so that you can smoothly interpolate between a setting and effectively bypassed - we have found that this allows you to zero in a perfect configuration between too much and too little.

Miscellaneous Changes

Most of the changes in this section are small usability enhancements.

Bug Reporter Changes

As macOS has evolved, the places that data is logged by the system has changed, and relevant data that might bear on problems that you may encounter is now in different system logs. We have updated the log collection mechanisms in MIOConsole3d so that the logs that are attached to bug reports you file will be more helpful in isolating the source of the problem.

Sometimes the logs that have been generated are quite large and, in the past, oversized logs have prevented bug reports from being processed correctly due to upload file size limits on the back end server. With this release, MIOConsole3d automatically detects when a log file is likely to be too big, and automatically compresses it before uploading to avoid issues in processing the bug report.

Cue Controller Hardware Sync

In previous versions of MIOConsole3d, even when a Cue controller was connected to an output path that supported direct hardware control over Gain, Mute, and Dim (e.g. the headphone output on any box for mute & dim, and a LIO-8 or ULN-8 for headphone gain), there was no syncing between changes made in the Cue Controller and the underlying hardware controls.

Each control UI was independent, and if you made a change via the HW controls, the GUI would not update to reflect those changes. If you then touched the GUI controls, the state of the HW would jump to reflect the current GUI settings.

This release of MIOConsole3d, along with the included firmware update resolves this disconnect, and now the Cue Controller will automatically follow changes you make to the Gain, Mute, and Dim via the HW controls, thus ensuring that everything remains in sync.

Note: This functionality does rely on changes to the firmware, and as result, will require you to update your MIO firmware in order for the Cue control sync to work properly.

Graph sub-graph nodes

We have added support to the +DSP graph to allow creating or inserting graphs as nodes within the graph. This works any place you can insert a graph (including insert slots, monitor and cue output graphs, and within subgraphs).

To insert a graph inside a graph, just select “Graph” or “Macro” from the insert popup selector. If you insert an empty graph, you’ll get a stereo->stereo graph node. If you insert a Graph preset or Macro, you’ll get a node that has the I/O config of the preset. Screenshot

To edit the contents of a Graph node, you double-click it, just like a plugin node. That will open a graph window representing the subgraph. As we mentioned above, you can also insert graphs within subgraphs - this can be done recursively.

You can also create a subgraph in-place from a group of selected Nodes within a graph. To do this, select the nodes you would like to push down into the new subgraph node, and then press the “n” key. Screenshot

This will move the selected nodes as well as all the connections that are internal to the selected group of node into the new subgraph; it will create an input port for any connection that enters the group from outside the selected set, and it will create an output port for any connection that exits the selected set. The connections entering and exiting the selected set will be connected to the created ports, and the created ports will connect to existing connection points within the containing graph. Screenshot

The net effect is that the signal graph will run exactly the same way as before you extracted the subgraph, but the selected nodes will now be within the newly created subgraph.

This allows you to simplify graphs that have become too complicated, and also allows you to build up complicated graphs from a library of simpler subgraphs.

Session improvements

We have added support for a dedicated “Virtual Sound Check” mode to Session to simplify routing.

We have fixed an issue with the display of very long (> 10 hours) sessions.

We have fixed an issue with the display the timeline ruler in long sessions.

Domain management improvements

We have added a command to delete all offline domains at once.

Bug fixes

Please look through the Detailed Change Log for a list of the bug fixes in this release.

New Firmware

We added the support required for the HW to properly notify MIOConsole3d when hardware Gain/Mute/Dim was changed for the headphone output path; this allows MIOConsole3d to keep the Cue controllers that are assigned to headphone outputs properly synchronized with the the state of the hardware.

The firmware had a bug that prevented defining link groups on analog outputs from the front panel on LIO-8/ULN-8. This was a regression from how the 2d firmware worked, and this issue has been fixed.

The meters in the system are generated as a side effect of the signal routing process in the MHLinkRouter in each unit. Under normal circumstances this always works correctly, but under heavy load conditions the last few channels routed did not have the meters calculated. This issue has been fixed.

The Sonic 303 is a unit based on 2d that doesn't have an analog board. This version of the firmware adds support for upgrading the 303 to 3d.

Driver Updates

We fixed a rare race condition that could cause a crash in the MHLinkServer process that provides the services to communicate with units over MHLink.

We fixed a rare corner-case condition that could cause either the MHLinkServer or MIOConsole3d to crash under certain network conditions.

We fixed an issue that could cause audio to stutter when streaming began. This issue was only triggered by a subset of hosts, based on how they used the CoreAudio API.

We increased the amount of safety offset you can set using the MHLink CoreAudio Driver Control Window. This is not required (or even desirable) for most users, but for people recording very large channel counts at very high sample rates, especially on older computers, the scheduling jitter in the OS can be high enough to swamp the previous maximum safety offset of 10ms. For people doing large live recordings, RT latency is not an issue (as the computer is not used for monitoring for talent) whereas absolute safety is. So for this use case, you can now increase the safety offset up to 100ms.


Detailed changes since 6.1.02

Changes since release/6.1.02 (1067 commits)