MidiDesigner "Stream Byter" plugin

stream byter - binary logic math - midi messages - midi designer pro - dk70

The Stream Byter plugin for Midi Designer can be used to reroute and alter MIDI messages before the MIDI stream hits the app, or before the MIDI is sent out. Stream Byter was licensed from Audeonic's MidiFire app. If you run on an older iOS device, like an iPad Mini 2 with iOS 12.5, you cannot upgrade to the latest version of Midi Designer Pro 2, and you have to work with an earlier version of the StreamByter plugin. Some newer StreamByter commands result in an ERROR in the MidiDesigner version.

The lack of the newer "Rules" (read "Commands") in MidiDesigner's implementation of the StreamByter plugin will not get in the way of your programming needs at all. The only difference is, that they would have made life easier. Still it's a lot of fun to use. This page intents to show the limitations for the Streambyter plugin in the Midi Designer Pro 2 app, for versions earlier than v2.200. You can check your version of Midi Designer Pro 2 by pressing the "More" button, press "Config", press the "About" tab. If you see version v2.200 or higher, you can use the newer Streambyter commands. Else this page will be handy.

Manual
For pre-v2.200 versions you can stop studying the Audeonic University Stream Byter manual roughly at "Defines, Subroutines and Includes". These functions are not yet implemented in the Streambyter plugin. For a primer, start with this MIDI Bridge Stream Byter manual (MIDI Bridge is an older product from Audeonic).

From Audeonic: StreamByter is a plugin for creating custom MIDI effects on iOS & MacOS. StreamByter is ported from our MidiFire (=routing app) MIDI processing environment. An iOS 11 device and a suitable AU host app such as AUM, apeMatrix, Cubasis or Sequencism is required to use the AU variant on an iDevice.

From Midi Designer Pro 2: The Stream Byter version in the pre-v2.200 Midi Designer Pro app, is the "Stream Byter II" version that exists in Audeonic’s MidiFire app (iOS/macOS). Stream Byter input and output rules are saved and shared with your layout. Any MIDI Designer Pro 2 user may open a layout with rules someone else has authored free of charge. There's an in-app purchase to author or edit Stream Byter rules.

MidiDesigner StreamByter version
Download the UltraEdit Wordfile for Streambyter code (for MDpro2 pre-v2.200). Copy/Paste the code to the WORDFILE.TXT, maybe change L10 to another number.
Here are the limitations for pre-2.200 versions of Midi Designer. The table contains a list of "rules" from the Audeonic manual, and the implementation in earlier MidiDesignerPro 2 versions.

It also means, that if you develop with the limitations for earlier versions in mind, your code will work in all Streambyter versions of MidiDesigner.

Streambyter rules:

* not implemented, though All MIDI communication is automatically printed to the MidiDesigner LOG screen.

To continue with the limitations for earlier versions

SET not implemented (see Nil Velocity Rewrite), so use '9X XX 00 = 8X' for Note Off rewrite,
because the Note On check 'if MT == 90' could be Note off, when Velocity == 00.

Decimal values not implemented. MIDI Array index "MC" can be accessed, because the reserved variable MC does not exist.

To summarize:
- Use only HEX and Note values, decimal values are not implemented
- The reserved MIDI Variables "MC" and "MT" are not implemented

SYNTAX

FLAGS

Rules are evaluated top to bottom and the results of each rule are fed into the next (unless the clone flag is set).

SYNTAX (verbose)
vertical table

IF (LEFT SIDE matches string) {
  SND RIGHT SIDE composed string
}

SYNTAX (verbose)
same, but horizontal table

Range example '8, A, C' is not implemented for any Streambyter versions.

PERMITTED VARIABLE NAMES (ALPHABETICAL)

ARRAY VARIABLES
indices start from 0.
0 is hex and $0 is decimal

T: Each time you refer to a timer variable, the value returned will be the number of milliseconds elapsed since that timer variable was last referenced. The first time you refer to a timer variable after a scene load, it will return 0 milliseconds. The values of variables are not reset when you press the 'Install Rules' button, but they are reset during a scene load.

R/O variables that contains a copy of the current midi message

other variables

indirect array addressing

VALUES
Values come in different flavours

Values can be:
- a literal hex value: 0A (hex)
- a literal decimal value: $10 (dec) DOES NOT WORK IN STREAM BYTER
- a literal negative decimal value: $-10 (dec) DOES NOT WORK IN STREAM BYTER
- a note literal: ^C-2 (from C-2 to G8), ex. ^C3 ^G#6 ^Bb0 ^Bb-1 ^D-2 ^G2
- the contents of another variable

ASSIGN
As in: the LET command in BASIC

ASS L0 = 5
ASS L1 = 70 23 2 A7 $51 L02 4 3 ^C1 # Fill L01-09 with hex hex hex hex dec var hex hex note

MATH
Mathematical functions. like ASS but with operators.

MAT I0 = I0 + 1 # Add
MAT I0 = I0 - 1 # Subtract
MAT I0 = I0 * 3 # Multiply
MAT I0 = I0 / 2 # Divide
MAT I0 = I0 % 2 # Mod

And Bit operators

MAT I0 = I0 & 0F # And
MAT I0 = I0 | 0F # Or
MAT I0 = I0 ^ FF # Xor

See bit operations on the page Binary Logic Math.

SEND
Send a MIDI stream of max. 16 bytes.
Split SysEx messages into separate Send-commands

SND B0 01 L01 # Send CC $2 to Channel 2, get the value from L01
SND 90 C2 7F # Send Note C2 On to Channel 1, Velocity 127

PROGRAMMING STUFF

CONDITIONAL BLOCK
can be nested

IF M0 == C0
  # do something
  # ELSE is not implemented, use a variable or XOR
END

OPERATORS

==, !=, <, <=, >, >=
note that = means assign (ASS), and == means compare (IF, WHILE)

IF-CLAUSE STRUCTURE

<value> <OPERATOR> <value> [<value> [<value>] [<value>]] [+L[OOP]]

If more than one value is specified after the operator (max 4), then the left hand value should be an Array and each right hand variable corresponds to an incremental index of the Array.

IF M12 == 64 32 G01
  # do something
END

# Same as:
# IF (M12==64) AND (M13==32) AND (M14==G01) THEN

Another fun example: get the index for K from variable I

ASS K0 = 1 2 3 4 5 6 7 # indices K0-K6 are filled
ASS I0 = 3

IF KI0 == 4 5 6
  # this will be true
END

# the conditional above works out to be the same as
IF K3 == 4
  IF K4 == 5
    IF K5 == 6
    END
  END
END

ASS I0 = 0
IF I0 < 10 +L
  MAT I0 = I0 + 1
END

HEADER OF CODE
LOAD command, is executed before any MIDI has arrived, so the M variable is still empty.
Commands in RED do not function for earlier Midi Designer Pro 2 versions.

Behaviors that apply to any Output and Input Rules
Don Sabourin also observed the following behaviors while testing v2.200.

The BLOCK can be inserted anywhere in the Code (beginning, middle, or end). The location of the BLOCK affects the ability to use parameters of the Output Rules (triggering) message being blocked (such as M1, M2, etc.). Parameters can be used prior to the BLOCK, but do not exist after BLOCK even though the code still runs.

The outgoing message, if not blocked, will be sent immediately. Any messages sent within the code will follow the outgoing message with minimal delay.

Delays occur after the outgoing message is received. If the outgoing message is not blocked, it will be sent immediately followed by any delay messages after their delay.

For multiple SNDs with delays, timing of the sends are independent strictly based on their delay value. A delay with D1000 will be sent before a delay of 2000, no matter their location in the code (e.g., if D2000 is entered in the code prior to D1000, D1000 will occur one second before D2000).

copyright: tinyloops.com - contact