14-bit Control Change

When we looked at Control Change messages in the Introduction, we noted one limitation: a CC value runs from 0 to 127, and for some parameters 128 steps are simply not enough. Turn a filter cutoff slowly on a good synthesizer and you may hear it move in small jumps rather than a smooth sweep. The effect is called stepping, and it was obvious to the designers of MIDI from the beginning. Their answer was to let two Control Change messages carry one value.

Two bytes, one value

A single data byte has seven bits to spare, which is the 128 values we know. Two data bytes have fourteen, and fourteen bits give 16,384 values. That is 128 times finer, and more than fine enough for the ear.

The two halves get names. The byte that carries the big steps is the most significant byte, MSB for short, and the one that carries the fine steps in between is the least significant byte, the LSB. You met the terms msb and lsb in the Bits & Bytes chapter, where they named the first and last bit of a number. Here the same words name whole bytes, and MIDI documentation uses them in both senses. It is the same idea at two scales: the most significant part is the one that moves the value the most.

Putting the two together is a sum you already know how to do:

value = MSB × 128 + LSB

With an MSB of 64 and an LSB of 32 the value is 64 × 128 + 32 = 8,224. Taking a value apart goes the other way: divide by 128 for the MSB, and the remainder is the LSB. The More Bits & Bytes chapter at the end of this part will show the same operation as it is written in the binary world, but the arithmetic is all there is to it.

Which controller carries which half

Now the elegant part. The MIDI designers did not invent a new message type for the fine half. They paired the controller numbers instead. Controllers 0 to 31 carry the MSB of a value, and controllers 32 to 63 carry the matching LSB: the fine half of controller 1 is controller 33, the fine half of controller 7 is controller 39, and so on, always the coarse number plus 32.

So the modulation wheel, controller 1, at the value 8,224 is sent as two perfectly ordinary Control Change messages on the same channel:

0xB0 0x01 0x40    CC 1  = 64   (MSB)
0xB0 0x21 0x20    CC 33 = 32   (LSB)

One 14-bit value, two ordinary Control Change messages. Controller 1 and controller 33 are the same parameter at two resolutions.

Nothing about these bytes says they belong together. An instrument that knows about 14-bit control combines them; an instrument that does not simply sees controller 1 move to 64 and ignores controller 33, which has no meaning on its own. That is why the standard says to send the MSB first: an old instrument gets the coarse value immediately, and a new one gets the fine value a moment later. Both are happy, and nobody had to change the protocol.

The pairing applies to the standard controllers from the table in the Introduction: Bank Select is 0 and 32, Modulation 1 and 33, Breath 2 and 34, Foot 4 and 36, Portamento Time 5 and 37, Data Entry 6 and 38, Volume 7 and 39, Pan 10 and 42, Expression 11 and 43. Instruments that support high resolution for a parameter use the pair; many only ever look at the MSB, which is why the LSB is so often missing from a manual.

Seeing it on the controller

Let's send a 14-bit value from a control. In the editor, drag a Fader into the layout and give it the name Cutoff. In the control's settings, set the Message Type to CC and the Bits to 14. Leave the parameter at 1 and the channel at 1, and set the fader's Max to 16383 so that the screen shows the full 14-bit value. Then send the preset to the controller.

Open the Console tab and turn the fader's knob. For every movement the console shows two messages, one for controller 1 and one for controller 33. Now type a pair into the console's command line to move the fader from the other side:

cc 1 64 cc 33 32

Both messages go out on one line, and the fader on the controller jumps to 8224. Try a few more pairs. Sending only cc 1 65 moves the fader by a full 128 steps, because you changed the coarse half; sending only cc 33 33 moves it by one.

The order can be swapped

Some instruments send the LSB before the MSB, against the standard. The Electra One has a Byte Order setting on a 14-bit control for exactly this case, and the Lua function midi.sendControlChange14Bit has a matching lsbFirst argument. If a 14-bit control seems to jump wildly on one instrument, check its manual for the order it expects.

Pitch bend was 14-bit from the start

There is one message in MIDI that never had the 7-bit problem. Pitch Bend was given two data bytes in the original design, because the ear is more sensitive to pitch than to anything else:

0xE0 0x00 0x40    centre: LSB 0, MSB 64 = 8192

Two things are worth noticing. The value of 8,192 is the middle of the 14-bit range, which is the wheel at rest; lower values bend down and higher values bend up. And the LSB comes first in this message, the opposite of the 14-bit controller convention. The console's pb keyword follows the message and takes the LSB first too: pb 0 64 is the centre.

What comes next

Two messages for one value solved the resolution problem, but it did nothing for the other limitation of Control Change: there are only 128 controller numbers, and most of them already had a meaning before the synthesizers of the 1990s arrived with hundreds of parameters each. The next chapter is about how MIDI got around that, using the same trick of putting several messages together.