DJ Tech Tools MIDI Fighter Twister - Showing Bank Titles and Labels via Max For Live in Ableton Live

In the run-up to Black Friday, lots of companies now do previews of prices, and so I recently visited my usual 'go to' source of coloured cables and knobs: DJ Tech Tools, to see what they had. I ended up buying some neon orange 'Chroma Caps' replacement knob caps, plus a MIDI Fighter Twister to join my MIDI Fighter 3D that I bought at a previous preview. (Dangerous things, previews!).

Now if I didn't already have a 'button masher' MIDI Fighter 3D (and wanted to have a 'matching pair'!), then my fallback solution for 'lots of rotary MIDI controllers in a box' would have been the Faderfox EC4. The EC4 is more expensive, but has little OLED displays for each control, so that you can label them. Which set me thinking...

After a bit of programming, I produced a new Max For Live plug-in, with the snappy title of 'MIDImftLABELSfloat' that provides a floating window in Ableton Live which gives you named banks and named labels for each rotary control, plus a way to set the colour of the little colour-bars in the window. (- and ONLY the window. I didn't manage to decode the colour mapping that the MIDI Fighter Twister uses, and so sending the commands to set the colours in the MIDI Fighter Twister will have to be a future enhancement, if I ever find the time...). 

To set the colours LOCALLY in the plug-in, you use the little grey number next to the coloured rounded box under each almost-square box (with the user-editable text inside!). Select it and use the cursor keys to change the colour, or drag it up and down with the mouse (as you can do with all Ableton values...). What I do is set them to more or less the same colours as on the Twister itself, and this also serves as a useful indicator of which rotary controls are active. The mapping of colours to numbers is not obvious, and although I'm sure there is a simple algorithm that drives it, I haven't been able to find out what it is, so this version gives you the default mapping... Sorry.

As a not-very-well-hidden additional control, the little grey number on the left hand side, nestled at the end of, and in-between the second and third rows of boxes, is a 'global colour' control. Select it and use the cursor keys, or drag it up and down with the mouse, and all of the 16 colour boxes will change. Now, if I was Pioneer DJ (okay, now kind of Toraiz as well), then I would take a cue from the SP-16 and make these boxes really big and bright...

In the course of developing this plug-in, I discovered something that I didn't know about how Ableton Live handles MIDI messages, and had to solve some interesting problems in Max For Live. 

MIDI Routing...

I tend to be an experimentalist rather than a documentation reader, probably as a result of many years of discovering that hardware data sheets often have errors. So the first thing I did was decode the MIDI messages that the MFT (henceforth abbreviated to MIDI Fighter Twister in this post) sends when you move between banks using the little middle buttons on the sides of the MFT. The documentation says that the MFT sends a MIDI Controller 0 off message, followed by a MIDI Controller 1 On message when you switch from Bank 1 to Bank 2, etc. So I initially unpacked the MIDI Controller Output of a 'MIDIparse' object, and then tried to figure out how to detect pairs of numbers like the 0 0, 1 127 sequence that I mentioned previously. Eventually I realised that automatically unpacking the pairs of numbers wasn't the best approach, and I removed the 'unpack' object and used my new favourite object, the 'zl compare' string comparison object. one thing that I don't like about the 'zl compare' object is the need to send a bang to message boxes to get an output from the zl, and so I over-use 'button' indicator objects as usual. 

The final patch is shown above, although it is encapsulated in the real thing. Showing everything in one place makes it easier to see what is happening. The 'sel 1' object converts the 'zl compare' output into a bang which forces a '1' out of the message object and this goes into another message box that is usdto display the Bank number. The middle part (around the 'zl compare') is repeated four times to detect 0 127, or 1 127, or 2 127 or 3 127 for the four bank switches. I know that I should have detected the full Off and On sequence of messages, but this worked okay. Actually it doesn't work perfectly because Ableton Live rechannelises all incoming MIDI to Channel 1, and so if you do too much rotary controls twisting in Bank 1, then you can confuse the plug-in. I tired in vain to figure out how to detect the full 0 0, 1 127 sequence, but didn't have any success. I may drop Cycling '74 a support question about how to do this, because I couldn't get it to work...

I also decoded the 16 rotary control MIDI Controller messages so that I could indicate which rotary control was being twisted... I used '% 16' modulo arithmetic to decode all four banks, but then I ran into my standard 'display' problem. I've talked about this before with the dual step sequencer, but in this case I needed a variation: something that would highlight a 'panel' object border when that rotary control was being twisted, and that would un-highlight it when any other rotary control was twisted. The standard technique to achieve this is to have two different message objects that send the highlight and un-highlight commands to the 'panel' object. So here's the essential parts of the encapsulation that I produced:

As before, I'm only showing two of the 16 sections. As I've rediscovered many times, there's a 'trap' in the 'sel' object - the left hand output sends a bang when the input matches the number following the 'sel', but the right hand output is the number that doesn't match, not a bang! I know with absolute certainty that I will forget this again, because I keep doing it! So that's why I use a 'button' indicator object to convert the number into a bang so that it triggers the message output. As it turns out, for many applications, having the number as the 'doesn't match' right output is very useful, and actually that's what some of the 'zl' comparison objects do... 

With the bank selection and control decoding done, I then mapped a few of the rotary controls to some parameters, and the decoding of the controls stopped working - just for the mapped controls. Now I have never looked at the Ableton M4L documentation in great detail, so I did some confirmation, and realised that when a MIDI Controller is not mapped to a parameter, then it appears in Max For Live, but when it IS mapped, then it does't appear in Max For Live. I bet this is in the documentation! Anyway, here's some diagrams that explain it in pictures (I like pictures!):

 Above is what I was doing when I first tested the decode patch. The MIDI Controller messages go into Ableton Live, and then into Max For Live...

 Above is what seems to happen when a parameter is mapped to the MIDI Controller - it no longer gets sent to Max For Live (or at least, it doesn't for me!). 

Doesn't Do Anything!

Yep, that's more or less correct. Apart from the Bank select tracking, the colour indicators, and the rotary control decoding, the MIDImftLABELSfloat plug-in doesn't do anything other than show a floating window with some user-editable text in it. In terms of MIDI or audio functionality, it is probably the least functional M4L plug-in that I have made, but I find it useful, because I'm always forgetting what I have mapped to what with all of my MIDI Controllers when I come back to a project some time later. I may make more versions of it for my other MIDI Controllers... 

Plus, whenever my mind spends time with something, it tends to come up with something different, and that's exactly what has happened here. So expect something eventually... I'm struggling with an M4L project at the moment - it is much harder than I thought, and I've been trying to find ways to do stuff in M4L that I haven't done before... But that's another story and another blog post, and there's part 4 of the 'Single Cycle Waveforms' series to finish as well...

Getting MIDImftLABELSfloat

You can get MIDImftLABELSfloat here:

     https://maxforlive.com/library/device/6726/midimftlabelsfloat

Here are the instructions for what to do with the .amxd file that you download from MaxforLive.com:

     https://synthesizerwriter.blogspot.co.uk/2017/12/where-do-i-put-downloaded-amxd.html

(In Live 10, you can also just double-click on the .amxd file, but this puts the device in the same folder as all of the factory devices...)

Oh, yes, and sometimes last-minute fixes do get added, which is why sometimes a blog post is behind the version number of MaxForLive.com...

Modular Equivalents

In terms of basic modular equivalents, then implementing MIDImftLABELSfloat is quite tricky - there's very little applicable functionality to translate across. You could use a MIDI processor to detect the Bank Select or rotary control messages, but I'm not aware of any obvious ways to store general text messages. So I'm going to declare this as an ME of zero. Pencil and paper storage is probably the way to go for modular, (and definitely 'analog' as well!) or maybe a mobile phone photo as 'instant documentation'.  

---

If you find my writing helpful, informative or entertaining, then please consider visiting this link:

Buy me a coffee

Synthesizerwriter's Store (New 'Modular thinking' designs now available!)

    

     

  

Decoding a 'ParamName Value' control string in MaxForLive...

Over time, Max and its 'Ableton Live' cousin, MaxForLive, have iteratively added functionality to do music, MIDI and audio-related tasks. 

Me, I'm not so good with new functions. I tend to use the same Max objects over and over again, because I know them, I'm familiar with how they work, and so I use them. 

The problem is, sometimes this means that I struggle to solve problems when there's a perfect solution just waiting, not hidden but overlooked, already in Max. This happened recently when I wanted to decode a 'ParamName Value' control string, and string processing is not one of Max's greatest strengths. I have used quite a few of the 'zl.' list processing functions, but there are a lot that I've never used as well. Searching through the 'zl.' help pages, I found 'zl.sub', where the example shown isn't very exciting:

Okay, so for the first number, '1', then it will output the number '1' indicating the first position in the list. And 2 for the second item, and so on. But then I realised that the numbers were distracting me, this is a list processor, and so it could be any 'symbol': numbers or text. It suddenly dawned on me (Duh!) that the 'sub' in the name meant 'Sub-set', and it all became clear. All of those convoluted 'If' objects that I had struggled with previously to process text strings were instantly rendered obsolete. 

Yep, a face-palm moment.

So here's an example that should make it much clearer what you can do with zl.sub in a more musical  'MaxForLive' type of context:

At the start is a control string: a parameter name, followed by the value of that parameter. The sort of string that is human-friendly... The 'fromsymbol' object turns it into a list containing a string symbol ('Cutoff') and an integer ('100'). This is then split into two separate fragments by the 'unpack' object. The symbol goes into zl.sub, which reports back that 'Cutoff' is the 5th item in the list, and the integer is the value of that parameter. 

Human-readable input becomes programming-friendly name and value pair. It's not a click-bait headline, but it makes quite a few of my abandoned projects much more possible now. 

So that's a face-palm turned into a light-bulb moment. Not bad for a Max command I'd always overlooked. My Day: Made. Happy face.

(Yep, one of the shortest blog posts so far, I think...)

---

If you find my writing helpful, informative or entertaining, then please consider visiting this link:

Buy me a coffee

Synthesizerwriter's Store (New 'Modular thinking' designs now available!)

  

Triple Flexible Routing Probabilistic Transposing Delay in Max For Live for Ableton Live

Sometimes, a MaxForLive device is right on the edge of not working, and normally I put it to one side for 'further investigation'. But every so often, an 'almost working' device is so cool that it goes along a different route: an experimental device with warnings. MIDIdelA3 is just such a device...

For a while now, I have been exploring the edge of the musical map that has 'Probability' on it, off to one side of a region called 'Generative'. But it wasn't until I combined probability with a much older topic, echoes, that things started to get really interesting. One of my very early echo effects was called 'Missing Echo', because it didn't put an echo on every note, and updating the concept with probability, as well as moving the delay into the MIDI domain, started to produce some useful results.

People have been playing around with echo and delay effects for a long, long time. One of the current 'leading lights' is Olafur Arnalds, an Icelandic multi-instrumentalist who has been using custom 'smart delay' software in live performance, and who recently collaborated with Spitfire Audio to release 'Stratus', a toolkit of software and a linked sample library that uses complex delays to augment live performance.

MIDIdelA3

MIDIdelA3 isn't complex, and it isn't anywhere near the functionality of Stratus, but it hovers at the edge of what my 2008 Macbook Pro can reliably accomplish in MaxForLive. It might be generously described as being 'far from perfect', and isn't really suitable for 'mission critical' use, but it is a fascinating glimpse into what is possible with MaxForLive. It has three identical processing sections, each with a delay, a transposer, a probability control, a velocity scaler and a loop switch. You can connect the three sections together in three different ways: in series, in parallel, and in a mix of serial and parallel. There are 20 memories, and a large rotary control that lets you select from those memories, so once you have set up the memories, then it can be used as a 'single control' device if you wish.

Setting up the memories sounds easy, but there's more to it than meets the eye. Having three different topological connections between the three sections is quite hard to get your head around, and the probability control has more effect that you might think, because when a note has an 80% chance of passing through a section, then that drops when it goes through a second section with 80% probability, and if it goes through a third section, then another 80% probability means that you aren't going to hear that triply-delayed note very often. Then there's the velocity scaling, which reduces the velocity of notes, and which is particularly important when you loop a section, because it keeps things stable, or almost does. Yep, this is one of those delays that can run away with itself...

Inside

I haven't used the MIDI Delay that Ableton include as one of the MaxForLive demos because it is too much like 'a maze of twisty little passages, all different'... Instead I have coded it myself using a different approach, and this probably explains why it 'almost' works - my programming is not very advanced, I'm afraid. But it does get close enough to being usable to be worth revealing, because I'm sure that there are better programmers out there who can improve on the concept...and like all of my software on MaxForLive.com, it is free and unencumbered by rights licensing restrictions.

The way that you are supposed to do operations on time-critical events is to time-stamp them as they arrive, and then work your way through a time-based list, so that they are dealt with in strict time order. If you look inside the Ableton MIDI Delay example MaxForLive code then that is exactly what you will find - and there's quite a lot of code in there...

I chose to do it using the much simpler 'cheat's' way. I used two 'pipe' objects, one for the MIDI Note Number values, and the other for the MIDI Velocity values. Normally, when time-stamping a pair of values like Note Number and Velocity, you would group them together as a single event, and give that pair of values a time-stamp. When using two separate pipe objects, then the Note Number becomes one event in a time-delay, whilst the Velocity becomes a different event in a different time-delay. You can probably see why this isn't a perfect solution! But, for 'quick and dirty', it kind of works, and it requires very little coding!

So for the three processing sections (Time Delay, Transpose, Probability, Velocity Scaling, and Looping) there are six pipe objects, arranged in pairs (Note Number, Velocity). These three sections are connected together using a set of 24 switches that do all of the routing for the three different ways that the three sections can be connected (serial, parallel, and a mix). The three connection diagrams look a little bit like the FM 'Algorithm' diagrams that the Yamaha DX7 had on its top panel, and they kind of show the same sort of routing, but nothing more than that.

Using it

Depending on the way that the three processing sections are connected, the basic explanation goes like this:

Connection 1 - the serial (top diagram) connection sends the MIDI messages through section 1 (and outputs delayed notes), then section 2 (and outputs delayed notes), then section 3 (and outputs delayed notes).

Connection 2 - the mix of serial and parallel connections (middle diagram) sends the MIDI messages through section1 and outputs delayed notes), and then through section 2 and 3 at the same time (in parallel) (and outputs delayed notes from both sections).

Connection 3 - the parallel (lower diagram) connection sends the MIDI messages through sections 1, 2 and 3 at the same time (and outputs delayed notes from all 3 sections.)

Each section has a separate Loop button, and the Velocity Scaling rotary control acts like the 'Feedback' control in an ordinary audio delay or echo effect. If the Velocity Scaling is set too high, then the processor will quickly become overwhelmed with too much data, and will stop working. This may cause strange noises, which may be loud! Please use the Loop buttons with care. If the device does become overwhelmed, then the 'All' button can be used to turn off any of the Loop buttons.

The Loop buttons can be turned on whilst the device is operating. So you can set up the controls, and then turn on looping for just one of the sections - this is very effective for creating rhythmic 'motifs' and other repeating sounds. The recommendation is that you normally have all of the Loop buttons set to Off, and turn one (or more) on to get a repeated motif for a short time, and then to turn the Loop button off again. This will keep the device stable.

If you have a transpose control set to anything other than the middle 'zero' setting, then using the Loop buttons will quickly cause very low or high MIDI notes to be produced - because the transposition accumulates for each repeat. If you set it for an octave, then after only a few repeats the notes will be at the limit of the MIDI range. Please use the Loop buttons with care when using the Transpose rotary controls.

The Time, Probability and Velocity Scaling rotary controls are not linear - half way round is not half the effect. This is deliberate, and is intended to provide the most control where it is needed. For example, the Velocity Scaling you will use most will be at around 70 or 80%. 100% may cause the effect to be overwhelmed, and is not recommended. Less than 60% will tend to produce only a small number of repeats (echoes).

Note that the Probability rotary control prevents notes from passing through a section. This applies to repeated echoes, so the Probability rotary control and Velocity Scaling rotary control will both reduce the number of repeats (echoes), and will help to prevent the device from being overwhelmed.

To store settings that you like in a preset 'memory', shift-click on the relevant grey square in the lower left hand corner. To recall a 'memory' preset, just click on the relevant square (it will change to white), or use the 'Preset' rotary control. If you use the 'Save' icon on the upper right of the device, then you can save your settings in a file inside Ableton Live, ready for use next time.

MIDIdelA3 is a sophisticated MIDI delay unit. It is capable of some interesting effects, including some that are not normally found in echo or delays that process audio signals (digital or analog). Please be aware that too many notes played at once, or high settings of Probability or Velocity Scaling may cause the processor to become overwhelmed, so take care. The red '!' round button is a placeholder for a future method of stopping the processing from becoming overwhelmed.

MIDIdelA3 sometimes behaves strangely with some instruments, and you may experience 'held' or 'stuck' notes. I am still trying to find out why this happens... For your first testing, please use a percussive sound that decays to nothing relatively quickly, rather than a sound that sustains.

Remember that this is an experimental MaxForLive device, and it is not perfect. Some of the links below may provide more robust, similar and more advanced versions of the effects that MIDIdelA3 produces, and should be researched if you want to explore this type of MIDI delay further.

Update

Since version 0.03 was published, I have spent a lot of time trying to find out why sustained notes caused so much trouble to this plug-in. Here's what I found...

The development of this MaxForLive plug-in started out as an experiment to see what it was like to have delay, transpose, and probability in a single device. Somewhere in there, the idea of putting feedback around it came up, and so I added the velocity scaling in an attempt to ensure that it would be stable. Adding feedback revealed some interesting things that I hadn't noticed up until that point: first, my bright idea to scale the velocity each time a note went round the delay loop, so that it would stop the device from running away, worked, but it didn't do quite what I thought it would. (My assumption (never assume anything!) had been that when the velocity value got scaled down to 1, then eventually a subsequent repeat would have the value zero, which is a note off, and that this would then stop the audio neatly. What actually happened was that it got down to a velocity value of 1, and then sat there, repeating over and over again.

This sort of situation often happens in programming, and there's a great temptation to just fix that aspect. Yep, that's what I did. I added extra code so that when the Note On MIDI message happened, the next note would have a velocity value of zero,  (which is the same as a Note Off MIDI message (, and hoped that everything would be fine. the problem with is is that the Note Off message is still in the pipe objects somewhere, and so you get two Note Off messages. And we know that Note Off messages are ignored...

There's a trap here. This is no longer a delay. It has become a Note Off message generator - and those Note Off messages just go round and round and round the feedback loop. And here's where I made the big mistake. I added more code to fix the problem that I had just created. I detected when a velocity value of 1 or less occurred, and then killed that whole message, so that Note On message never got turned into a Note Off message.

What I didn't test was what happened when a note was played that was shorter than the delay time. When I did test this in detail, I discovered that I got hanging notes because the Note Off messages were missing! And why were they missing? Because I was killing Note Off messages! The difficulty here is that Note On and Note Off messages should always be in pairs, and if you start to remove Note Off messages, then you have too many Note On messages and you get hanging notes. Worse still, I was turning Note Ons into Note Offs, so I had no way of keeping track of pairs of On and Off messages. There's no difference between a Note Off message and a Note Off message that used to be a Note On, except that one of these should be followed by a Note Off, and the other should not be!

If I removed all of the Max code that messed around with turning On messages into Off messages, then everything was fine when the Loop was turned off, but as soon as I turned the Loop on, then I got messages going round and round the feedback loop, eventually getting the velocity scaled down to zero, and then the Ons became Offs... For one moment, I did consider putting in a switch connected to the Loop button, so that when Looping was off, I didn't mess about with the Note Ons, but when looping was on, I did mess about. Then I realised that this would probably create a device that created hanging notes only when Loop was on...

At this point, I realised that I was trapped inside the loop of 'You have created unwanted behaviour by fixing unwanted behaviour...'.

A little bit of SWOT analysis told me that the expected behaviour of an echo with feedback was that it would go wrong if there was too much feedback. Unexpected behaviour was that an echo would cause hanging notes. Unexpected behaviour is bad, and so I ditched it. I took out all of the additional Max code that tried to remove the 'runaway' effect when you turned up the feedback too far. And this is version 0.04.

Oh, and I also fixed a few bugs in the horrendously complicated switching - you know those three diagrams that show the three ways of connecting the three processing sections together? Well, surprise surprise, there were bugs in there! For a single, relatively simple device, it is quite impressive that I could get so many things so wrong... 

I think version 0.04 should have less hanging notes...   

Other MIDI processing devices may exist...  

One thing that I have now noticed in other MIDI processing devices is that some of them only operate on the MIDI Note On messages, and so you have to pre-define the length of the notes that are produced. This way of doing MIDI processing had never occurred to me! It avoids any requirement for the processing of Note Off messages, and this should simplify the coding task, I think. If I ever get the time, then MIDIdelA3F may one day get released!                       

Links

Stratus, from Spitifre Audio, is probably the leading edge of current 'smart delay' technology, and combines it with a sophisticated sample library.
Midihub, from blokas.io, is a very nice MIDI event processor, patchbay and interface. (Yes, I know it should be MIDIhub, but they never asked me.)
BomeBox, from Bome Software, is a sophisticated MIDI processing, mapping and patching interface that can link a computer and MIDI devices over 5-pin DIN, USB, Ethernet and Wifi, and is also a MIDI host.

Getting MIDIdelA3

You can get MIDIdelA3 here:

     https://maxforlive.com/library/device/6400/mididela3mr

Here are the instructions for what to do with the .amxd file that you download from MaxforLive.com:

     https://synthesizerwriter.blogspot.co.uk/2017/12/where-do-i-put-downloaded-amxd.html

(In Live 10, you can also just double-click on the .amxd file, but this puts the device in the same folder as all of the factory devices...)

Oh, yes, and sometimes last-minute fixes do get added, which is why sometimes a blog post is behind the version number of MaxForLive.com... and pictures may not always be the current version... but Schrodinger's cat's status is permanently uncertain...

Modular Equivalents

In terms of basic modular equivalents, then implementing MIDIdelA3 can be approached from two different directions. A purist will use MIDI processing utilities to delay, transpose, probability-ise, and velocity scale the MIDI information, then connect it to a modular sound generation chain. A pragmatist will use three delays plus some additional processing and work in the analogue domain. Purists will require 3 or maybe 6 MIDI processing utility modules and may need to write some code for some solutions, giving an ME of 3 or 6. Pragmatists will require about three sets of 4 modules (voltage processor for transpose and velocity scaling, delays for the delay, utility for the probability, and a switch for the loop button), giving an ME of 12.

---

If you find my writing helpful, informative or entertaining, then please consider visiting these links:

Buy me a coffee

Synthesizerwriter's Store









 

Minimalistic octave remapper plug-in in Max For Live for Ableton Live

Gregory Taylor's article for Cycling'74, where he talks about 'One Big Knob' effects plug-ins, made me think...You might have noticed that I'm not exactly a 'minimalistic' user interface person - some might say that I provide too many controls. So I'm trying an experiment...

Recently, I released MIDIchromatixN, a 128x128 MIDI note number remapper that has quite a few controls... Well, I have just released the exact opposite, a remapper with one big rotary control, and one small rotary control! It does something different with remapping, but the core code for doing the remapping is identical - the differences are all in the fine detail of the controls and what they do. Because I really wanted to boil it down to a single 'big knob', but failed, I have called it MIDIchromatixONE, in an attempt to distract you from the two controls.

MIDIchromatixONE

MIDIchromatixONE creates inversions of notes or chords in sequence clips - musical transformations of some of the notes, and not the 'invert' function where low notes become high and vice-versa. There are two controls (but you already knew that!); a big 'Map' rotary control that selects from the initial  20 presets, and a smaller 'Pitch' rotary control that 'tunes' the internal mapping to suit different input notes. Preset number 1 on the Map rotary control is a 'Thru' setting, where notes pass through unchanged, so it is more accurate to say there are 19 presets (at the moment) that do stuff other than nothing. The presets are arranged in 5 groups, based around modifying in groups of twelve notes, six notes, four notes, three notes or two notes. In each of the groups, the mapping starts out sparse and open, and gets more complex and thicker for higher numbered presets. So 'Preset 5 : Six Notes 1' is simple, whilst 'Preset 8 : Six Notes 4' is complex. The best thing to do is to put some notes from a clip through it, and listen to the presets.

The Pitch control shifts the internal mapping by up to +/- 24 semitones. This doesn't mean that it pitch shifts the output, it means that the way that the remapping is done can be shifted by 2 octaves up or down. I did wonder if I should call it 'Tune' instead of 'Pitch', but the word 'Tune' sounded too vague - this is one of the 'not fully nailed down yet' bits of the design, so it may still change in the future. Again, the best way to see what it does is to put some notes through it and to listen. Kind of what you might do with a plug-in with just 'One Big Knob', really.

Note really a control, the '!' button is a 'Panic' button that attempts to clear up any hanging notes, and also sends an 'All Notes Of' MIDI Controller message. I did think about restricting the Map button to changes only when the Ableton Live transport was stopped, but discovered that using an LFO to change the presets was rather cool, so I didn't put any limits on it - which means that if you change the Map button whilst a chord is held, then you may get held notes... Take care!

Inside

Inside MIDIchromatixONE, there are lots of lookup tables, kind of 'hand crafted' by myself, using assistance from a variety of tools that I wrote in Max For Live. (Which may or may not be a good thing - there's certainly quite a lot of 'tool artefact' in most of the presets... This might end up in a blog post one day - how do you avoid your tools affecting what you do?) I used source note clips from monophonic 'synth' sequences and polyphonic orchestral arrangements, and deliberately went for a range of effects, rather than just choosing the most complex ones - kind of how you would create presets for a real device...

The screenshot above shows part of the development environment for MIDIchromatixONE, where I'm using my 'Huge Noter' tool devices to show the input and output notes. Eagle-eyed viewers will also spot that I'm still in my 'Muted Impure' phase...

And above you can see just one or two of the simple tools that I use to assist me... Normally, you never get to see what happens behind the scenes... One programmer that I know told me that his tool-to-release ratio was about 100:1, so he wrote one hundred times as much code for the tools that he wrote to enable him to write the one final device that he then released.

Sometimes tools and utilities DO get released - examples from me on MaxForLive.com include the following:

- Aud Colours (inspired by Adam Neely @adamneelybass)
- Huge Noter (big display of notes, as used in this blog post!)
- DLS Helper N (Explore MIDI DLS...)
- MIDI cc tool (MIDI Continuous Controller message analysis...)
- MIDI cc  (simulation of a MIDI Continuous Controller...)
- Wavetable Creator ('512 sample' wavetables are increasingly becoming 'retro', these days...)

Regular readers may have spotted that one of these is closely related to my 'should be famous' M4L device which still has zero downloads!

Demo

There's a demo on SoundCloud here. It starts off with 16 bars of plain source material, then fades out and is followed after a pause of one second, by the same material processed by MIDIchromatixONE with a slow LFO running gradually through all of the presets - even the 'Thru'. There's also a bit of probability-based note pruning and some added random velocity from my MIDIprobNV plug-in. they sound gratifyingly different, at least to my ears. The material is not quite in 'Lamb of God' territory... and it isn't done using the Spitfire Audio BBC Symphony Orchestra Discover! Instead it uses an edited version of one of my 'mrOrchestra' Instrument Racks, and so exploits some of the articulation capabilities very nicely. (which is based on 'Quick_Arranger', which is still available...) I really should do another blog post about the 'Quick_Arranger' Instrument Racks...

In Use

MIDIchromatixONE doesn't do anything other than a few note transpositions, which sounds easy and trivial until you look at all of those lookup tables. My advice would be to start with Preset 1: Thru to create your clip, and then to audition the presets and find one that you like the sound of. There's a tiny bit of influence from the MiniMoog front panel design for waveshape selection, because the presets tend to get more complex and thicker as you go to the higher values. This doesn't mean that Preset number 20 is the best, of course! Don't forget to explore fine-tuning things with the 'Pitch' control, and remember that the effect it has depends on the source material, so don't expect huge changes!

One important thing to remember is that MIDIchromatixONE is not your standard effect plug-in. It is perfectly possible that many of the presets will have little or no effect on most of the MIDI Notes that you pass through it. Conversely, it can change notes in ways that would take quite a lot of manual editing time. Finally, the presets are my first pass through creating ways of using the underlying transposition engine - I intend to make more presets (probably less than 107 more!) for a future update when I have time, and these might use the tools less and be be done with more manual editing of the tables - I did worry that the tools were doing too much of the driving...

A final thought: the presets so far are very tame: chromatic and very constrained inversions. If you look at MIDIchromatixN, then there's lots more power lurking in the underlying engine... In the 107 available preset slots that are left (can you figure out why?) then there is space for more 'challenging' presets, but would people like something that would produce discordant outputs? For a while I have been considering releasing some of the 'broken' abandoned devices that don't, and in many instances, can't work properly, or whose output is imperfect in some way. Maybe MIDIchromatixOOPS will get released one day...

Getting MIDIchromatixONE_mr

You can get MIDIchromatixONE_mr here:

     https://maxforlive.com/library/device/6273/midichromatixone

Here are the instructions for what to do with the .amxd file that you download from MaxforLive.com:

     https://synthesizerwriter.blogspot.co.uk/2017/12/where-do-i-put-downloaded-amxd.html

(In Live 10, you can also just double-click on the .amxd file, but this puts the device in the same folder as all of the factory devices...)

Oh, yes, and sometimes last-minute fixes do get added, which is why sometimes a blog post is behind the version number of MaxForLive.com... and pictures may not always be the current version... but Schrodinger's cat's status is permanently uncertain...

Modular Equivalents

In terms of basic modular equivalents, then implementing MIDIchromatixONE_mr is just about as awkward as MIDIchromatixN, even though the transpositions are much simpler. The 'mapping' of the 128 MIDI notes is the problem, unfortunately, and I still haven't found a neat solution. The Make Noise 'Maths' module starts to get somewhere close, but not entirely. The Expert Sleepers 'Disting mk4' also gets close, and maybe the Quantizer can be tweaked suitably, or possibly the Waveform Animator, maybe. But I couldn't find a direct equivalent. This means, of course, that I will get a comment pointing me to a classic module that I have overlooked, or never heard of, or forgotten, or didn't know about - there are lots of modules out there. Anyway, until then, I don't have an ME for this device...

The obvious solution goes outside of a purist interpretation of 'Modular' and 'DAWless' synthesis, and takes us into 'Hybrid' territory: use a dual DC-coupled 'audio' interface to connect Ableton Live into your modular system so that you can use MIDIchromatixONE (or N).

---

If you find my writing helpful, informative or entertaining, then please consider visiting this link:

Buy me a coffee

Full-range Chromatic Note Remapper in Max For Live for Ableton Live

I have experimented with remapping previously with my MIDI ChromatixT, which takes incoming MIDI notes and changes their numbers to new ones, but each octave is treated the same, and when you generate a new mapping grid, then it is often a huge change and not the slight variation that I really wanted. So I've been playing around wth a few ideas...

MIDIchromatixN

MIDIchromatixN is the result. It combines two of the methods that I explored into one device: a random remapper and a modulo-arithmetic remapper. Both use almost exactly the same controls, and the outputs are very different - the random remapper is, well, random and wild, and the modulo remapper is more mathematical and constrained. In both cases, you need to follow them by a scale-setting device: the stock/factory Ableton Live Scale device is fine, or you could use my MIDINoteScalery device for extra control, proper invert and 'n'-octave folds as well.

MIDIchromatixN is basically just a look-up table. If you want to, you can set it so that the notes coming out have exactly the same note numbers as the ones going in (velocity is unchanged in this note remapper), but that isn't very useful. You can set it so that it inverts the whole MIDI note range as well, so that low MIDI notes become high ones, and vice-versa, but MIDINoteScalery makes that easy with a single button instead of setting about 8 rotary controls... However, if you want to gradually make changes to a constrained random (or mathematical pattern) mapping every so many bars, and have detailed control over the mapping, then you need MIDIchromatixN. In many ways, it is conceptually a bit like the stock/factory Saturator plug-in, but for note numbers rather than audio - and the mathematical functions it uses are different...

The flow diagram above also shows what you need to do to allow MIDIchromatixN to work. You need to have put some notes into a clip on the same track, and you need to add Scale or MIDI Note Scalery after MIDIchromatrixN. Finally, you need something to make a sound - any of the stock/factory Ableton Live Instruments is fine, or you could use a VST plug-in instrument.

So what does a remapper do?

A note remapper goes between the notes produced by a Clip and the sounds produced by an Instrument. MIDIchromatixN isn't sophisticated enough to do things 'in key', and so you need to add a scale controlling device after it. A remapper uses mathematical formulas to change the note numbers as they pass through. So As an example, with the Modulo mode selected, I tried 10 different variations when I input a C Major chord (C E G) and set the scale device to only let C Major notes through. The outputs were: C D A, C D A, F G D. A C G, D D F, A C G, D F C, G A F, C C D, and A F F, where a repeated letter indicates a note one octave higher. These output notes are consistent in Modulo mode - if you select a Variation number and input C E G then you will get exactly the same notes out again. Change the settings, and the output notes would be different, of course. In Random mode, things are slightly different, because the randomness gets shuffled each time you move some controls, and so, as the name suggests, you get more unpredictable 'random' notes out - and they won't be the same if you set the controls to the same settings. 

So what do you use it for?

A remapper can be used to change a melody (or chords). Whatever you put into the Clip, the output from the remapper is probably going to be different - unless you find one of the 'input=output' settings - and you would be able to see that on the display. So you can use it to create new melody ideas, or for generative music, or just for fun!

User Interface

As normal, I will go across the user interface from left to right...

There are two indicator lights with 'Yes/no' buttons underneath them, with rotary controls called 'AutoVar' or 'AutoRand'. These enable changes in the remapping to happen every 'n' bars. The 'Var' section controls the Variation rotary control, which makes small changes to the mapping. You can move the Variation rotary control manually to audition the effect that it has on the remapping of notes. The 'Var' section works in either of the two modes of operation (more about them in a moment). To enable the automatic variation, you just select the repetition rate (every 'n' bars) and click on the 'Yes/No' button so that it says 'Yes'. When Ableton Live's transport is running, then the indicator light will flash after that number of bars have happened, and the Variation rotary control will increase by one. After 127, it resets to 1 again.

Well, that WAS how it worked, right up until when I was writing this, where I realised that having the Variations button always cycle through all 128 possible values was a bit boring... As a result, I added 'Start' and 'Range' numbers, plus 'nudge' controls to adjust them, and now you can set the start Variation number, plus how many increments it will make before it returns to the start value. You can see the new controls on the far left hand side in the diagram above.

So if you set the Start to 1, and the Range to 4, then it will increment through Variations 1, 2, 3, and 4 (and then back to 1) every 'n' bars - where 'n' is set by the 'AutoVar' rotary control. If you set the Start to 8 and the Range to 16, then it will increment through Variations 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, and 23 (and then back to 1).

The 'AutoRand' section only works in the 'Random' mode, and causes a new random remapping to be generated every 'n' bars - if the 'Yes/No' button is set to 'Yes'. Note that the two auto bar settings can be different values. To the right of the AutoRand section is the 'Transport' section: the red/green indicator light shows when Live is stopped (red) or running (green).  The small indicator light will flash once every beat, and the bar count on the right will increment every bar. You need to make sure that you stop Live in order for the bar counting to work properly - just pressing the spacebar for pause doesn't work properly, but I'm working on it...

The main control just above the transport indicators is the 'Random/Modulo' button. In 'Random' mode the remappings are rough and 'random', plus the background colours are slightly more purple, whilst in 'Modulo' mode the remappings are more repetitive and mathematical in appearance. Apart from the AutoRand only happening in 'Random' mode, all of the other controls work in both modes.

Above the mode button are the main set of controls for the remapping. There are two identical mathematical generators inside, connected in series (the notes from the clip go through generator 1 first, then generator 2, then go to the Scale device) and each generator has a Range rotary control and a Step rotary control. Range sets the range of output notes, and Step sets the increment of the output notes within that range - which roughly equates to the slope of the diagonals (within limits, as we will see). If you set the controls like this:

...then you get what you might expect - the Ranges mean that the remapping uses the whole of the output range, whilst the step size of 1 means that every output note is used, and so you get a 1:1 mapping of input notes to output notes. So every incoming note will cause the exact same output note to be output, although the Scale device may then change that note, of course. You might wonder why you have a device that does nothing! But set the controls like this (turn Step2 to 64, and Pitch2 to 32):

...and things are now very different. The output range is only half what is was before, and there are now two different input notes that produce the same output note. Let's look at that 'sawtooth' shape in more detail...

The central user interface feature is what looks like a strange audio waveform on a dark background, or maybe a broken LFO waveshape. Above this are 128 numbers which define the mapping of input MIDI note numbers to output MIDI note numbers - and they are very small because for most purposes they are very boring and you may not need to use them very often! So when we had the first setting, then there was a straight line across the rectangle, from lower left to upper right. When we set the Range2 rotary control to 64, then there were two diagonal lines and we needed to alter the Pitch2 control to get the output notes playing the correct notes. So what would happen if we set the Step1 value to -1 instead of 1?

The screenshot above shows the effect of a Step1 of -1 - with Pitch2 increased to 95 to compensate for the pitch dropping. The diagonal lines are now sloping the opposite way. Let's reiterate how to think about the controls, and add a caveat: the Range controls set the output range of notes, but these may need adjusting with the Pitch controls so that they are not limited by the top and bottom (0 and 127) of the note numbers. 

Let's see what happens if we rewind a couple of steps and change Range1 down to 96:

This gives us one diagonal controlled by Range2, and another controlled by Range1. Okay, which means that the Range controls are separate. Got it.

Earlier I said that the Step controls changed the slope of the diagonals. If we change Step1 to -2, then this happens - but it shows that the Range 1 control might not have been doing what it seemed to be. Here's what it now looks like:

Yep, we have squashed two repeats into the space of one horizontally, and what looked like two little diagonals is now revealed to be just one. Unfortunately, just as you think you have got the hang of this, then there's a problem because when the diagonals get to a certain slope, then they 'alias', just like digital audio. Here's what this looks like:

There have been several changes to the Range and Step values, but what you see instead of the nice, neat diagonals, are more complex mappings between the input and the output. But the same principles apply: Range sets the output note range, Pitch puts the notes back into a usable range, and Step alters the diagonals - except that now we have individual aliased dots instead of diagonal lines. Here's another example of the sort of mapping that you can produce:

In the course of playing with the values, the two Pitch controls on the far right hand side have also been introduced, and they complete the user interface. Don't forget that the Scale device that follows allows you to constrain the output of the remapper so that it plays only the notes that you want, and remember that you could use the MIDI NoteScalery device instead of scale, so that you can have more scales, better folding, correct inverting, etc.:

One final thing to note: if you try to set the Step value to zero, then the rotary control background will turn red to remind you that you shouldn't use this value.

Theory 

The rectangle with all the sawtooth and dots in it is really just a squashed lookup table:

The diagonal line that we started with should really be like this: 128 values on the lower edge for the input note numbers from 0 to 127, and 128 values on the right hand edge for the output note numbers from 0 to 127. Because the diagonal sets how an input maps to an output, then in this case, any input number maps to the same output number. 42 in maps to 42 out, as shown on the diagram above.

Do you remember when Step2 was set to 64, and the Pitch2 was adjusted so that the two sawtooth shapes were in the middle of the display? Let's look at what this does to the mapping:

The two sawtooths set the mapping of input note numbers to output note numebrs, so when there are two shapes like this, there are two inputs for every output. So an input of 43 produces an output of 78, but so does an input of 98. The smaller the output range, the more there will be several notes on the input that produce the same output note number. If you tweak the settings, then you will probably find some that produce a horizontal line, and this is a special case: there is only one output note number, and every input note number maps to that number. This isn't very useful...

If you look up MIDIchromatixT, then you will see that it only has 12 inputs and outputs, and that it repeats that octave for the full 0-127 range. MIDIchromatixN has no repeats! All 128 note input numbers are mapped individually to the 128 output note numbers.

When the Range and Step values give us mappings that aren't anything like a nice simple diagonal line, then the mapping can be lots more complex. Here's a Random mode mapping:

This mapping has none of the obvious repeated patterns of previous examples, but you should now be able to confidently adjust the output range of notes by changing the Range values, and then using the Pitch values to get the pitches at the right place, and know that changing the Step values will alter where the dots are horizontally.

Inside

This time I'm not going to go very deep into how MIDIchromatixN works in Max For Live, and instead I'm going to show how one very useful bit of the UI is done, and show you where to find more related stuff.

The little red/green indicator light that shows when Live is stopped or running is the target. The code looks like this:

For when Live's transport is not running/playing. However, if you try to open the Help page for this, then you get the help page for a patcher object, which isn't quite a useful. instead, what you need to do is go to the 'Extras' menu in Max:

...and there is the M4L.api.ListOfAbstractions, which opens a window full of interesting objects:

,,,including the one that I used to find out if Live was running or stopped - there in the lower right hand box. Clicking on the text for Global.ObserveTransport opens the tiny little box on the far right hand side, which shows how to use it. Here's that same code, but this time with Live's transport running:

Each of those six boxes covers a topic, and there are all sorts of other interesting objects in there, ready for you to use!

Getting MIDIchromatixN_mr

You can get MIDIchromatixN_mr here:

     https://maxforlive.com/library/device/6263/midichromatixn

Here are the instructions for what to do with the .amxd file that you download from MaxforLive.com:

     https://synthesizerwriter.blogspot.co.uk/2017/12/where-do-i-put-downloaded-amxd.html

(In Live 10, you can also just double-click on the .amxd file, but this puts the device in the same folder as all of the factory devices...)

Oh, yes, and sometimes last-minute fixes do get added, which is why sometimes a blog post is behind the version number of MaxForLive.com...

Getting MIDI Note Scalery 

MIDI Note Scalery can be downloaded from here, with documentation here.

    https://maxforlive.com/library/device/5260/midinotescalery

Modular Equivalents

In terms of basic modular equivalents, then implementing MIDIchromatixN_mr is quite awkward. The Make Noise 'Maths' module starts to get somewhere close, but not entirely. The Expert Sleepers 'Disting mk4' also gets close, and maybe the Quantizer can be tweaked suitably, or possibly the Waveform Animator, maybe. But I couldn't find a direct equivalent. This means, of course, that I will get a comment pointing me to a classic module that I have overlooked, or never heard of, or forgotten, or didn't know about - there are lots of modules out there. Anyway, until then, I don't have an ME for this device... (This is a first, I think!)

---

If you find my writing helpful, informative or entertaining, then please consider visiting this link:

Buy me a coffee

Different Two - dual channel 'old school' step sequencer for parameter control sinking and sourcing

Sometimes you just don't see the wood for the trees. It happened to me when there was a question on the Facebook Max For Live Users group about a step sequencer. from Johan Wallen The OP wanted to control the slider values in a step sequencer with an external MIDI Controller. As it happens, one of the side effects of having a ready-made maxforlive object that does just about everything you might ever want in a step sequencer means that MaxForLive.com has many, many 'live.step'-based step sequencers available on it. But 'live.step' has limits (everything does!), and the question made me think - could you even do what was being asked for with live.step?

Bait taken. I was quickly in Max and testing out live.step, and it was true - you couldn't Apple/Cntrl-M map a MIDI controller to the sliders that control the pitch, velocity, etc. in live.step. Note that the intended usage for live.step is that you use the mouse to set the sliders, and then map the output to a parameter in another device. This was different - controlling the sliders themselves in live.step with a MIDI Controller. Challenge accepted.

Not using live.step was going to be interesting. Back to first principles...

The result is MIDIdifferentTWO, which is, of course, different to MIDI differentONE! TWO is deliberately 'old-school' in design, with rotary controls and big lights for each step, and is built without using live.step. So there's a classic 'counter' object to generate the steps, the rotary controls are scanned using an 8-way 'gate' object, and the lights are the standard 'blink' / 'bang' buttons. driven by a 'switch 8'object.  To complicate matters, the 'gate' object allows values to pass through it, but you have to send the value, and a rotary control only outputs a value when you change it (or bang it). My attempt at a solution was to use a 'message' object as a buffer between the rotary control and the 'gate' object, and this seems to work quite well, at the cost of quite a bit of wiring up of bangs...

I was wondering if I should use the buffer contents to replace the parameter value of the rotary controls, but decided in the end that this wasn't required. I also rejected the idea of using the buffer as the map target for the Ableton 'remote control' system 'control voltages', so that I could have the rotary controls set as 'hidden', but I'm leaving this as an option depending on feedback. The Ableton M4L Guidelines for hiding objects so that they don't overwhelm the Undo history seems to be incompatible with making controls map targets, so this design has some flexibility in terms of possible mitigations.

The Max For Live code above is simplified, and there's a missing connection! The step clock output from the counter should be connected to the left-hand input of the 'gate 8' object - but you can always look at the real code if you download the amxd from MaxForLive.com.

The initial design was just a rapid response to a Facebook 'Max For Live Users' group query, and so was me trying to see if I could make do without live.step. The result then went through several drafts to the latest release (so far) of 0.06, adding direction to the steps (the counter object makes this easy, shuffling of the order of the steps (via a look-up table), skipping of steps (using the pack object to remove/restore numbers in the look-up table, and adding a second channel synchronised to Live's transport. Having two channels, where one can be free-running (or driven by MIDI events in a clip, which probably counts as user-controlled-sync!) and the other is locked to the DAW transport gives two very different, contrasting sources of 'control voltages', plus it also looks good. For a single channel 8 step, un-synced step sequencer, then I might have been tempted to put the rotary controls in two rows to reduce the width of the device (M4L Guidelines again!), and I might even have thrown away the 'old school' look and used sliders, but two channels means that the width is going to be wide anyway, and stacking two sliders vertically doesn't work for me. 

Implementing the 'Skipping' of steps required additional map targets for each step, and I was thinking of a Novation Launch Control (or XL) when I was doing this, but there are lots of other MIDI Controllers available. The solution was to just use a toggle text object as the map target...  One complication in the Max For Live coding was how to deal with the number of steps when you could skip or un-skip steps, but once again, the 'counter' object makes changing the count maximum easy, and so I just used the look-up table length as the counter maximum, and it was sorted! I'm always intrigued by how some problems loom ahead as being major, maybe insurmountable  challenges, but when you actually start to code them, they kind of shrink and aren't as impossible as you anticipated. There again sometimes apparently simple things can take ages to figure out, so there's no certainties!

The blinking lights proved to be one of the most challenging things to get right... The 'button' object has a parameter called 'blinktime', which controls how long the light stays on once it gets a 'bang' signal. Unfortunately, when the rate at which you scan across the steps changes, then blinktime needs to change as well - ideally so that there is no overlap with other steps so two lights are both lit at once, and without any gaps where no light is lit at all. This turns out to be difficult! Now if the 'button' object would just light up for the whole of the time that a step was active, like an LED or even a bulb, then it would be easy. But initially I didn't want to mess about making a custom graphic object like that, although eventually I decided that I had to, and here's what I did...

I wrote a special object just to decode the step number to drive scrolling lights! As often happens with these things, (and as noted above!) when you sit down to do it, then it isn't as difficult as you expected. It turned out to be nothing more than a set of compares, but instead of using the 'button' object as the indicator, I used the live.toggle object, which shows one colour when you send it a one, and another colour when you send it a zero. So now the steps are shown by an indicator that lights up for the whole of that step, and is off the rest of the time. Neat and much better than my previous default indicator: the 'button' object. Sometimes being forced into a change is good for you...

Notice that this time the missing connection is missing no longer! So what do the comparisons look like inside the scroll_mr package?

As I said, all a bit obvious really. But it works very nicely!

Using MIDIdifferentTWO

For something that started out as about half an hour's coding in response to a Facebook query, the final result (so far) has quite a lot going on! So, as usual, here's a side-to-side detailed descriptoon of all of the controls and what they do:

First, notice that there are two separate step sequencers. The top one can be either free-running (with its own clock running at the 'Rate' speed when the 'Mode' selector is set to '=Not Synced=' (I'm never sure if there should be an 'h' in synced/synched...), or else triggered by one of five different MIDI Events from the clip in Ableton Live: Any MIDI Note, Any change of MIDI Note Number (so repeated notes trigger the step advance the first time, but not after that), Note number 0 (very low frequency!), Note Zero with a MIDI Velocity of zero (the lowest, quietest note in MIDI 1.0!), or any note with a MIDI Velocity of 1 (the quietest note in MIDI 1.0). Because these MIDI Events are in the clip on the track in Ableton Live, then they are synced to Live's transport, but there's nothing to stop you having all sorts of weird timing of those notes, and don't forget the 'ignore repeated note' mode. The lower step sequencer is always synced to Live's transport, but you can choose anything from the step advancing every 8 bars to every quarter beat, which is quite a big range.

Both sequencers have the same controls after the speed/sync section. After the step number and a little count-up indicator, downwards there is the Direction control, which allows selection of left-right (ascending through the numbered steps), right-to-left (descending), and back & forth (palindrome mode, as some say). Underneath are two tiny toggle buttons. '1-8' and 'Skips' forces the full 8 steps when it is showing '1-8', whilst in 'Skips' mode the step numbers can be clicked so that they turn into 'X's, and then that step will not happen (and the length of the sequence will be shorter). Sequences that are one step long are okay, but they aren't very interesting! As you click on the step numbers to change them to the 'X's, then you will see that a row of tiny numbers will change to show the missing number. The 'Shuffle' button changes the order that the sequencer plays the steps - and again the row of tiny numbers will change to reflect the new order. Each time you get the 'Shuffle' button then the order will change. The lowest controls are nudge '+/-' buttons for the sequence length, shown as a small blue number on the left side. The step length automatically changes when you set up skips.

The central section is 'old-school': rotary controls for setting the step values, and big indicators to show which step is playing. The modern twist here is that the step numbers (in the grey squares) can be used to skip steps, but there's another hidden twist - you can control the rotary controls and the skip buttons with Ableton Live's 'remote control' 'control voltage' system. To do this, you either use the Map button in an LFO or other device, and then click on the rotary control of the grey step number square in MIDIdifferentTWO, or you put Ableton Live into MIDI Learn mode (Apple/Control-M to get into the 'blue' mode), then click on a rotary control or a grey step number square and move a slider or press a button on an external MIDI Controller. If you did this is the right order then the rotary control or step number will show an indication of the note number of MIDI controller that you have mapped to that control in a small grey box, and a line will appear in the 'Mapping' table at the upper left of Ableton's screen.

For testing, I used a Novation Launch Control to control the skips:

In the photo above you can see that the four lit buttons on the Novation Launch Control have turned steps 5,6,7, and 8 on the upper sequence into 'X's, and so those steps will be skipped. Also note that the sequence length has changed to 4 steps (the little number on the left). When I took the phot I was just about to map the rotary controls on the Launch Control to the rotary controls for the step values in MIDIdifferentTwo, so that I could control the sequence from the external MIDI Controller. You could, of course, use just about any MIDI Controller to control the sequencers inside MIDIdifferentTWO... Using an external MIDI Controller like this crosses the line from DAWless to 'DAWed', of course, but using a MIDI Controller definitely looks 'DAWless'!

After the eight sets of step  controls, the section on the right hand side deals with the output values of the step sequencers. The large blue numbers are the current output value - there's a label that says so! Underneath this is a 'Normal/Invert' toggle button, which inverts the value (so 127 becomes zero, and zero becomes 127). Next on the right are three rotary controls. 'Offset' adds to the value of each step, and can be used as a way to shift all of the values at once. If you are controlling a filter with the step sequencer, then this would behave just like the cut-off frequency control in the filter, for example. The 'Depth' rotary control scales the step values. At zero it scales the values down to nothing, so you won't hear any effect. At 100% the output is the values shown on the rotary controls. At 200%, the output is scaled to twice the values shown on the rotary controls - which means that the output value may well 'max out' at 127! The final rotary control is the 'Smooth' control, which is like the 'Slew' control on modular synths, and it turns abrupt jumps of value into more gentle slower 'slides' - it 'smoothes' the output!

Finally, there are two 'Map' buttons and their inverses, 'Unmap' buttons. You use these to map the output values of the two step sequences to other instruments, effects, or utilities inside Ableton Live. Controls that are being controlled generally go grey to indicate that they are being controlled from somewhere else (LFO, MIDI Controller, etc.), and their value moves on its own! To unmap and select another control, you use the 'Unmap' button.

Sinking and sourcing?

These are electronics terms for outputs and inputs respectively. In lots of electronic interfaces, an output is a source of current flow (it 'sources' current is the colloquial phrase), and an input is a sink of current flow (it 'sinks' it is the colloquial phrase). So for the MIDIdifferentTWO device, the step rotary controls and the grey step number squares are sinks, and an LFO or MIDI Controller that is controlling it via Ableton's 'remote control' control voltage' system would be a source. At the output of MIDIdifferentTWO, the two big 'Map' buttons are sources, and whatever they control would be sinks. Jargon, that's all.

In use

One thing to try is to change the cut-off frequency of a filter (a well-worn cliche that you can also do with the stock/factory 'Auto Filter' effect), or change the time delay of Delay (there isn't a stock/factory effect that does this!), or change the Depth in the Saturator effect to give an interesting rhythmic 'bite' variation. Basically, whatever your favourite 'control to tweak' is, you can now apply a shimmering, rhythmic version of it automatically, and free up that hand for something else, like pitch bend, or a mod wheel, or mousing, or adjusting knobs on outboard gear, or anything else. Now I know that I already have a device called '3rd Hand' (look it up on MaxForLive.com), but this is a bit like having a third hand!

Getting MIDIdifferentTWO_mr

You can get MIDIdifferentTWO_mr here:

     https://maxforlive.com/library/device/6160/mididifferenttwo

Here are the instructions for what to do with the .amxd file that you download from MaxforLive.com:

     https://synthesizerwriter.blogspot.co.uk/2017/12/where-do-i-put-downloaded-amxd.html

(In Live 10, you can also just double-click on the .amxd file, but this puts the device in the same folder as all of the factory devices...)

Oh, yes, and sometimes last-minute fixes do get added, which is why sometimes a blog post is behind the version number of MaxForLive.com...

Modular Equivalents

In terms of basic modular equivalents, then implementing MIDIdifferentTWO_mr is just two step sequencers, giving an ME of 2. The ability to control step values and skips may vary with the specific sequencer, but if implemented, then it is just more patch cables. Perhaps MEs should also include some sort of measure for the number of patch cables that are required?

---

If you find my writing helpful, informative or entertaining, then please consider visiting this link:

Buy me a coffee