Having provided a bit of a taster for the different types of MIDI sequencing tools available under iOS in the previous part of this occasional MIDI 101 series, in this instalment, I thought I might take a closer look at the sorts of things MIDI sequencing allows you to do. This will include some of the basics of general MIDI note editing – and the pros and cons of that under iOS – but also some of the other editing tools (corrective and creative) that a good MIDI sequencer can provide.
While I hope this might be useful for the MIDI newbie – particularly the iOS musician who is a bit of a MIDI newbie – what I suspect it will also do is highlight both the good and the bad of MIDI sequencing under iOS. Don’t get me wrong because I think what a sequencer such as Cubasis or Gadget can do on a (fairly) humble iPad is actually pretty remarkable. But, where appropriate, I’ll also highlight those areas where, at present at least, what we are currently able to do on our mobile devices falls some way short of what’s possible of some of the better (and also more complex/expensive) desktop MIDI sequencing environments.
For most of the examples I’m going to present here, I’ll use Steinberg’s Cubasis. This is simply because (a) it’s the environment with which I’m most familiar, (b) it’s a popular app that lots of people will have some experience of and (c) it is one of the slicker MIDI editing environments available for iOS musicians but is (by design) also fairly streamlined in terms of features. It will, therefore, by comparison with a more sophisticated desktop MIDI editing environment, enable me to identify some additional features that it would, at some stage, be nice to see.
And finally, before I set started, this is a bit of a mega-post. If you like your information in bite-sized chunks, then maybe this one’s not for you. You have been warned J
What’s it for?
Having grown up with MIDI from very early on in my own music technology journey, I’ve often been surprised by just how many musicians are simply not familiar with MIDI and its applications. If that’s you, however, don’t feel you are alone; I get regular emails from readers of the blog who, while comfortable with the principles of multitrack audio recording – and are happy to record synth parts or drum machine tracks as audio – are much less comfortable with MIDI-based recording.
I’ve sort of covered this issue in the first couple of parts of this series but, for those to whom this might apply, let’s (very) briefly remind ourselves of the key advantages of recording our virtual instrument parts as MIDI rather than audio, whether those parts be from software synths or virtual drum machines.
In days of old, when computers had less processing power and storage space than that found on the original iPod, one advantage of MIDI was that it was a compact data format. Instead of recording the audio output from the synth or drum machine, instead, you just recorded a series of note on/note off messages. This was a tiny amount of data by comparison so those lower-powered computers (a) could cope with the processing demands and (b) didn’t require as much storage to hold the data.
In terms of desktop computers, it’s probably 10+ years since that reason for using MIDI was really an issue. And, while it could still be an argument that you might apply to something like an iPad or an iPhone, providing you don’t fill the device to capacity with the apps (that is, you actually save some space into which you can store your musical projects), the processor grunt and storage capacity, while not matching that found on a modern desktop computer, is, in principle, more than adequate for multi-track audio recording. In essence, you don’t ‘need’ MIDI recording as a means of saving CPU resources or storage space.
There is another qualifier to be added here in terms of MIDI’s ability to save you CPU cycles. In days of old, this is an argument that certainly applied as the majority of the synths or drum machines that the MIDI data was driving were hardware units. Today however – and this applies under iOS as well – they are much more likely to be virtual instruments and quite probably running on the same CPU as the MIDI sequencer. Any saving in terms of reduced load from fewer audio streams to be handled is, therefore, offset (almost certainly more than offset) by the additional CPU load required to run the virtual instrument.
So, if this resource argument is no longer really a reason for using MIDI, what is the main reason for its use? Probably the main one is flexibility and MIDI provides this in a couple of simple ways. While you hear the sound of your synth or drum machine as you play MIDI notes into it, what gets recorded is those MIDI notes. In terms of advantages, therefore, first, it means that having recorded those notes, if you wish to change the actual sound (for example, by using an electric piano instead of an acoustic piano) you can do so without having to re-record the performance (not something you can do if you recorded the part as audio).
Second, as well as changing the sound, you can also – via the wonders of the MIDI editing tools built into your DAW/sequencer – edit the performance without having to re-record the whole performance. This might be as simple as correcting one duff note but, equally, it might be changing a whole melody line or adjusting the chords. You might also adjust the timing of the performance… and all this can be done by simply editing the positions of the MIDI notes that you have recorded. This is very easy to do and, again, not something that is easily achieved if the original performance had been recorded as audio (although not impossible if you happen to own one of the top-end versions of something like Celemony’s Melodyne on your desktop computer).
Oh, and don’t forget ‘editing’ your performance might include changing the tempo. With a MIDI part, this is easily handled by your sequencer and the timing of the note on and note off messages are easily re-calculated. However, for an audio recording, such a change means some time-stretching of your audio. In today’s DAW software, that is usually handled pretty well but, even so, it doesn’t take much of a tempo shift for audio artefacts to become obvious to the ear.
So, for both these reasons, MIDI offers you some extra flexibility in that you can easily change the sound and details of the performance without having to re-record. The disadvantage – although it is one that generally has a very simple workaround – is that in order to hear your MIDI part while you continue to work on the project (for example, while recording further audio or MIDI tracks), the virtual instrument (or instruments) has to be running all the time alongside your DAW/sequencer. This places an additional CPU load on your device. On most modern desktop system this is not such as issue… on an iPad (and, in particular, an older iPad), it can be more of an issue, and the more MIDI parts your project contains, the more of an issue it might be.
Get it in
However, before we can capitalise on the advantages suggested above, we have to record the MIDI data in the first place and, as described in the previous part of this series, that requires a MIDI sequencer of some sort…. and the ability to get MIDI data into that sequencer.
I looked at some of the hardware/technical issues involved in part 2 of the series so I’ll not repeat that information here. Instead, let’s think more specifically about the methods for playing the MIDI performance – generating those MIDI notes – that our MIDI sequencer software will then record.
With a DAW/sequencer app such as Cubasis – which offers a very similar approach to most desktop DAW/sequencers, albeit with a somewhat more streamlined feature set – you actually have a number of options. However, before we can record any MIDI data, we need a MIDI track to record that data on and a sound source (virtual instrument) to play that data back with. In Cubasis, at the bottom of the track list within the Project window there are dedicated buttons for adding new audio or MIDI tracks so, as you might expect, we simply tap the ‘+ MIDI’ button….
By default, this adds a new MIDI track at the bottom of our track list and automatically allocates it a basic acoustic piano sound using Cubasis’ own Micro Sonic virtual instrument. You can, of course, change this sound before you get started on playing depending upon the type of instrument/sound required. The sound can be drawn from those that Cubasis itself can provide via Micro Sonic (sample-based sounds) or Micrologue (the Cubasis synth instrument) or, alternatively, you could be using a 3rd party sound source via IAA or Audiobus. For now, let’s stick with the default acoustic piano that Cubasis dishes up automatically….
We are now ready to create our MIDI data that this piano sound will play back. There are a number of options for doing this. First, we can simply tap on the Keys button (located top-left of the Cubasis Project window) to open the Cubasis virtual piano keyboard. Most iOS sequencer apps will offer this kind of virtual keyboard or, if you are using a 3rd party synth or keyboard sound source in another app, you can also use the virtual keyboard within that app.
Virtual keyboards are fine if you are making music on the move and have limited other options but not even competent keyboard players probably feel they make for the most expressive or comfortable of playing experiences. And, if like me, your keyboards skills are perhaps best described as ‘limited’, then some of the alternatives are worth considering.
These do, of course, include a ‘real’ keyboard in the form of an external MIDI keyboard connected (as described in part 2) to your iPad and most players – even those with limited playing skills – will generally find this a better experience.
Visit my pad
A third possibility offered by Cubasis is the Chord Pads. Located above the virtual keyboard are ten numbered buttons/pads and, if you tap the ‘e’ button beside them, you can then play in a set of notes (‘proper’ chords or otherwise) and associated them with one of the pads. Fill up as many of the pads as your song has chords and then you can switch off the ‘edit’ option and use these buttons to play your chords. You can even combine using the Chord Pads (for chords) and the virtual keyboard (for a melody) if you are dextrous enough.
While these Chord Pads are useful, the rather anonymous numbers mean you have to remember which chord is associated with which pad. However, a further option – a sort of ‘Chord Pads plus’ – is available if you tap the Pads button (located top-left on the virtual keyboard window). These pads are actually dual purpose; when you have a melodic instrument selected then you get a set of 16 chord pads. However, if you have a drum instrument selected (and Micro Sonic has a number of sample-based drum instruments you can selected from) then these pads are used as drum pads to trigger the different drum sounds in your drum kit.
The big advantage of these pads is that each shows the chord name associated with it so it is much easier to play without losing your way. Tap the Edit button and you can also easily configure which chord is associated with each pad including the octave in which it plays. Equally, the pads provide some sense of velocity sensitivity; tap near the centre and the playing is louder while towards the edge you get a softer response.
The downside of these pads is that, unlike the numbered pads – where you can control exactly how the chord is voiced (which notes, how many notes, and where on the keyboard), with the larger pads, you just get to pick the chord type/root note; Cubasis then supplies a fairly standard chord voicing based upon a piano-style left-hand (that is, all the notes are close together as might be played by a single hand on a piano).
While I’ve focused on the options provided by Cubasis here, lots of iOS music apps – other DAW/sequencers included – offer their own types of ‘MIDI performance’ options that, by exploiting the flexibility offered by the touchscreen interface, allows developers to design all sorts of tailored ways of ‘playing’ a virtual instrument.
There’s an app for that…
And if your particular DAW/sequencer doesn’t offer a lot of help in this regard, or you simply want something different, then a further option is you use one of the excellent 3rd party MIDI performance apps. Providing your DAW/sequencer will take MIDI data in from another app (and most will), then you could try any of the popular MIDI performance apps that I discussed in a recent (ish) round-up article.
There are actually a number of really good options here depending upon just how you view the ‘simple vs deep’ take on these things…. If you want something simple then you might start with an app like Chordion but, if you want something a little deeper then ChordPolyPad is worth a look. There are, however, plenty of apps to explore in this regard.
The beauty of these kinds of apps is that they allow you to ‘play’ your virtual instruments (that is, send them MIDI note data) but without you needing to have traditional keyboard skills. Instead, via the wonders of the touchscreen – and a dose of clever UI design – you can trigger chords with a single finger and a melody or bass line where the only notes available to you are ‘in key’; duff notes are, therefore, a thing of the past.
Going (MIDI) loopy
A further option is just to find some pre-recorded MIDI loops or phrases. On the desktop this is fairly easy to do as MIDI loop/phrase libraries can be purchased commercially and many virtual instruments ship with a collection of such MIDI phrases that you can simply load into your DAW/sequencer and assemble (and perhaps edit) as required to suit your needs. Such MIDI files could, of course, be imported into your iOS DAW/sequencer of choice from your desktop system. Cubasis, for example, allows you to do this.
There are some iOS music apps that ship with what are essentially MIDI loop libraries. For example, if you delve into the MIDI section of the Cubasis Media window, you can find a whole bunch of MIDI drum loops and, while this won’t be much help in terms of melodic content/inspiration, as a way of getting a drum track organised in super-quick time, it is a great way forward.
Perhaps one of the best iOS examples of an app that includes a collection of usable MIDI phrases is IK Multimedia’s SampleTank. While this app is primarily of interest as a multi-timbral (up to four different sounds at the same time) sample-based virtual instrument (at which it is actually very good indeed), the app also includes a fairly impressive collection of MIDI phrases that can either be triggered from within the app or from an external sequencer (such as Cubasis). I’ve reviewed SampleTank on the blog in the past so check that out for further details but the MIDI phrases include a diverse range of instruments including drums, bass sounds, leads, and various stops between.
Alt controller music
One final option to consider (OK, a final option aside from some of the alternative MIDI controllers such as MIDI guitar systems; I’m not going to get into those here) if the more laborious route of simply using the MIDI editing tools provided by your sequencer to enter the notes manually one at a time. If you just need to create some short phrases or chord parts (which you can then copy and loop) then this is a perfectly practical way forward, especially if your keyboard skills are somewhat basic.
It is, perhaps, the method of last resort though and, for anything more complex, while your personality might differ from mine, this is the kind of thing that could easily rank alongside cutting grass with nail scissors…. dull and duller…. and whatever musical inspiration you might have had to start with is likely to have cleared off down the pub before you get past bar 12….
Editing MIDI data you have created (hopefully quickly) using one of the approaches outlined above is both useful and often necessary (depending upon your level of musical skill) and, while still a bit of a chore, it well worth spending some time on. Let’s look at that next….
Make it right
If you look at the specification of the MIDI editing functions within a top-flight desktop DAW/sequencer such as Cubase or Logic Pro it can make for pretty impressive reading. Whether it is done via a ‘piano roll’ editor, a drum grid editor or even editing within a virtual stave environment (yep, all those ‘proper’ musical dots), the degree of control available can be staggering.
Under iOS – at present at least – we don’t have that same level of sophistication. It’s more than likely going to come (and Auria Pro, when it does eventually arrive, looks like it will be a significant step along that road) but, as yet, the more popular iOS sequencing apps (or those that are DAW/sequencers) tend to come with a more limited features set.
Given the compact format (that is, modest screen size and modest storage space) and relatively youthful nature of the platform for music creation, this is perhaps both to be expected and also, in the main, a deliberate design decision. I’ve been lucky enough to use the full version of Cubase for a number of years (and, before that, Logic) and, while I can appreciate the power it offers for editing and manipulating MIDI data, most days, the vast majority of that power goes unused. For my own music production, while I might do lots of the more routine MIDI editing tasks, perhaps 5% of the feature set gets used for 95% of the time (actually, that sounds like lots of desktop software, including the popular word-processor I’m using to type this article).
In that sense then, the more limited MIDI editing features found under iOS are perhaps less of a limitation to workflow/creativity than the feature lists might imply. Providing the designers have included the right core features, most of the time, the absence of those more esoteric features may not really be an issue. Indeed, you might argue that not having the software bloat or the cluttered menus full of options you only need once in a blue moon, makes for a more efficient workflow; less is perhaps more?
Whether that’s the case depends upon (a) your particular idea of what the ‘right core features’ are for working with MIDI editing and (b) whether the developer of your iOS DAW/sequencer has the same idea for their app. So, again using Cubasis as an example, let’s have a quick scoot through the MIDI editing options and see just how far Steinberg have got down my own personal ‘key MIDI editing wishlist’ in the current version of the app.
Clips vs notes
There are perhaps two ‘levels’ at which you can consider MIDI editing. First, within the Project window, you can take a MIDI ‘clip’ (perhaps a performance of a set of chords you have played in using one of the methods outlined above and covering just a few bars) and you can perform various actions on that. For example, you might copy and paste the event (clip) to a later point on the timeline (for example, where the same chord performance is required for a second verse or chorus section of the project).
Cubasis includes various tools for this clip-level of MIDI editing. You can, for example, simply tap on an event to select it and then drag it to move it along the timeline. However, arranged above the timeline, and below the top-most strip of menu items in the Project screen, are a strip of controls for use with this clip-level editing. While these can be used with audio clips, they also form part of the app’s suite of MIDI editing tools.
The set of tools are all petty obvious and basic but, as I mentioned earlier, it’s these ‘obvious and basic’ tools that you need to get 95% of your typical editing work done. So, for example, the Select button, once tapped, lights up blue and then allows you to tap and drag within the events area to select multiple events or simply to tap on multiple events to select them. Again, you might use this to select all the audio and MIDI clips that make up a song section that you wish to copy and paste to a later point along the timeline.
Most of the options within this strip are obvious – Copy and Paste, for example – but others are perhaps a little less so and it is also worth noting that some of then only become available for use once you have selected a suitable clip (they are greyed out until then).
Split allows you to divide the selected clip (or clips) at the current position of the timeline cursor, and will work with either audio or MIDI clips. The opposite tool – the Glue button – allows you to join two separate clips together on a track but, unlike the Split tool, this is a ‘MIDI-only’ function; it is not available for use with audio clips.
The same ‘MIDI-only’ label applies to the Draw option. You can use this to create an empty MIDI clip and, into which, you could then manually add some MIDI notes…. And that gets us to the second ‘level’ at which MIDI editing – and the level at which we get down to individual notes – gets done. This is perhaps the level most of us associate with ‘proper’ MIDI editing gets done.
The other obvious option at the clip level is provided by the Transpose button. This allows you to apply an clip-level (that is, all notes within the selected clip or clips) transposition, either by a number of semitones or by a number of octaves. If you start your music project based upon a few MIDI instruments, transposing up/down in this way to find a key that’s most comfortable for your singer can be very useful before you start recording any audio tracks.
Having created a MIDI clip upon one of your MIDI tracks, if you want to actually start editing the individual notes within that event, double-tapping the clip will open it for editing within the Cubasis’ MIDI editor. This takes the most popular form of sequencer MIDI editors; a piano-roll editor. This is, in essence, a grid where pitch runs top-to-bottom (high to low) and notes are placed along the timeline that runs left to right.
By default, when opened, the MIDI editor fills the bottom half of the display. However, if you tap top-left of this area (where the clip’s name is displayed) and drag upwards, you can expand this view to fill as much of the screen as you might like. Given that manual editing of MIDI notes can be a bit of a fiddly process, being able to see this editor pretty much ‘full screen’ can be a good thing.
Using the term ‘grid’ above to describe the editor format is perhaps a term that needs a little clarification. First, in terms of pitch, this is a ‘fixed grid’ where the placement of notes is ‘quantised’ to a specific pitch on our standard 12-note chromatic scale. That’s not to say you can’t have pitches that are in between the notes of the chromatic scale but the only way to do this is by applying pitchbend data to control how far a note is shifted from a chromatic scale note.
In the time domain, things are somewhat more flexible. Used at its most simple (that is, without any quantising of the notes timing), notes will be positioned at the exact (within the timing accuracy of your overall music production system) time at which each was played (for example, when you pressed the notes on your MIDI keyboard). They can, therefore, sit exactly on a beat or some other exact musical time division. However, they can just as equally sit slightly ‘off’ the beat.
In terms of giving your music a ‘feel’, this is a good thing; musicians often play ahead or behind the beat (often instinctively) to create a particular rhythmic feel. In terms of tidying up the sloppy timing often induced by less than ideal virtual piano keyboards (or, as in my case, less than stellar keyboard skills), it is perhaps less useful. And that’s where timing quantisation (tools that will automatically adjust the timing of individual notes and, if required, drag them closer to the closest bar/beat division) can come in very handy.
In fact, Cubasis has a range of basic editing tools for adjusting individual notes (or sets of notes selected within an event; as when selecting multiple events, once in the MIDI editor, the Select button will allow you to select multiple MIDI notes for editing if you wish). These editing tool include the obvious options for moving a note vertically (changing the pitch) or horizontally (changing its start position along the timeline) or changing its length.
If you have used these kinds of tools with a mouse in a desktop DAW/sequencer (even within Cubase) then the tools in this touchscreen environment are slightly different in operation. This might require a little adjustment on behalf of the user but it is something that you soon get to grips with. There are a couple of issues here. First, you do have to get used to tapping and holding editing options within the strip of buttons located down the left-edge of the MIDI editor display. These constrain exactly what you can edit so, for example, the ‘Move left/right’ button, when held, will only allow you to move notes either left or right along the timeline and not change their length or pitch. These buttons are very useful given that screen real-estate is at a bit of a premium even on a full-size iPad and stumpy fingers can often block your view, making some of this editing a bit tricky.
The other element to get familiar with is the quantise options themselves. You can disable these while manually editing if you wish (set the Quantize resolution to ‘off’ so it shows the horseshoe magnet icon). However, it you know the timing has been a bit sloppy, having notes ‘snap’ to a nearby grid position as you move them, or applying the current quantize settings to a selected set of notes, can be very useful.
So, basic editing tools are covered and so are basic quantize functions. The only other notable element of the MIDI editing features is the ability to add a bit of ‘swing’ (usually notes on the off-beats have their timing adjusted to achieve this) to the timing quantization. If your playing is solid then this may well be something that you just do instinctively as you perform. However, if you want to add a bit of swing after the fact (or just experiment with it to see what it does to the feel of the music), then you can add as much or as little as you might like.
In terms of other MIDI-related editing, Cubasis also allows you to change MIDI controller data, whether that’s something as simple and obvious as note velocity data or, once you get into the (rather nicely) implemented automation system, editing MIDI CC data for other parameters.
This might be parameters linked to synths (internal or external) or it might be data concerned with mixer functions (volume, pan, effects, etc.). Either way, whether you are conscious of it or not, this is MIDI editing work that you are undertaking and Cubasis provides you with basic graphical editing tools via the touchscreen to get the job done.
Fingers and thumbs
While Cubasis does allow you to ‘grow’ the size of the MIDI/automation editing panel so that it fill more than the lower-half of the screen (this is the default when the panels are first opened in a project; tap and drag top-left of the panel’s window and you can swipe up/down to change the panel size), even when you get the panel to pretty much full-screen, if you are trying to do edits on a busy bit of MIDI data, one thing can get in the way; your own fingers.
It is easy to deride the humble (and now fairly ancient) desktop computer mouse, but when it comes to precision editing as required with MIDI data, it actually has a lot going for it, not least that it doesn’t actually get in the way of seeing what’s on the screen itself…. which is exactly what your fingers do as you try to make a delicate adjustment to a MIDI note on your iPad’s touchscreen.
This is not a Cubasis-only issue; in truth, all DAW/sequencing environments under iOS (or other touchscreen mobile platforms) suffer the same problem. And, if you have larger hands/fingers, the problem is worse.
If you are lucky enough at some stage to be using an iPad Pro – with it’s larger screen size – then this will make life a little easier. However, iPad Pro or not, the other option is not to use your fingers at all but to invest in a suitable touchscreen stylus. While Apple have been a little slow off the mark with the introduction of the Pencil (for understandable reasons, some of them based upon matters of principle rather than practical concerns), other manufacturers have been making touchscreen styluses for quite some time.
For example, I’ve used an inexpensive Griffin touchscreen stylus for routine MIDI editing tasks for some time. While it doesn’t totally overcome the problem (it is still chunky enough to get in the way), it is somewhat smaller than my fingers and therefore easier to see what I’m actually pointing it at.
Incidentally, if you have ever used a larger-format touchscreen (for example, a full-sized touchscreen monitor for a desktop computer), it is pretty obvious that size does matter here. On a larger screen, where the objects you are try to touch and manipulate are proportional larger themselves, it is a much easier proposition.
I want one of those
So how does this range of MIDI editing feature in Cubasis (as our example iOS DAW/sequencer) compare with what can be found in the desktop version of Cubase? Well, if you go right up to the ‘Pro’ version then, frankly (and unsurprisingly), Cubase contains a considerably more extensive MIDI editing feature set than Cubasis.
For example, Cubase includes a collection of ‘MIDI plugins’. These are essentially filters that you can add to a MIDI track and that will apply all sorts of ‘live’ adjustments to the MIDI data on playback (the original data remains unchanged). For example, these include an arpreggiator, a step-based drum beat editor, a ‘transformer’, various MIDI ‘modifiers’ (to tweak velocity or other properties), a MIDI velocity compressor amongst a number of others.
In addition, Cubase include the rather scary (but very powerful) Logical Editor that, as part of its brief, can be used to configure all sorts of complex manipulations of MIDI data. This is high-powered stuff and perhaps not for the MIDI newbie… but those doing lots of MIDI-based music creation would find it a brilliant tool.
Cubase also offers a number of different ways to visualise your MIDI data including a MIDI Monitor plugin and the List Editor (see your MIDI data in a Matrix-style text format!) plus numerous options for dissolving and bouncing MIDI parts, looping them and, if dots and staves are your thing, doing all your MIDI editing in a Score Editor environment. There is a lot more besides….
However, if I had to highlight two MIDI editing tools that would be on my personal wish list for porting over to Cubasis from the desktop version of Cubase, it would be groove quantise functions and the Drum Editor.
As its name suggests, the first of these is an extension of the more standard quantise functions that Cubasis already features and that you would find in most DAW/sequencers (iOS or otherwise). However, it is perhaps more on the ‘creative’ side of MIDI editing (rather like adding some swing quantise is) than the corrective use more basic quantise tools are used for to overcome sloppy timing or somewhat limited performance skills with a MIDI keyboard.
One of the beauties of music played by humans – particularly those who have plenty of performance miles under their belt – is that (often instinctively) they will play a particular song with a ‘groove’. The notes don’t always ‘hit’ the exact beat/bar divisions (no robot music here)… instead, the musicians ‘play’ with the timing and might push and pull some of the notes within the bar relative to the exact grid. This becomes an integral part of what gives the performance its ‘feel’… it is part of the ‘groove’.
Groove quantise is quite an interesting bit of technology therefore and most major desktop DAW/sequencers now offer something along these lines. In essence, the software can ‘detect’ the groove in a MIDI performance (and, in some software, in an audio performance), extract that groove, save it as a ‘groove preset’ and then apply that groove preset to another MIDI performance (and, again, in some cases, even to another audio performance) so that it then has the same ‘groove’ as the original. This is obviously quite powerful – and quite musical – stuff and the ability to apply a similar sense of groove to your key MIDI parts can really add a sense ‘human’ to the performance.
On the grid
The second wish list item – a MIDI Drum Editor – is perhaps a more obvious and straightforward suggestion. Cubase (and many other DAW/sequencers on the desktop) provides a dedicated ‘drum-friendly’ MIDI editing environment that looks similar to the sort of step-based pattern editors found in many iOS drum machine apps. Instead of a piano-roll view, where each horizontal lane is a note on the piano keyboard, in a drum editor, each lane is a different drum sound (although, obviously, also associated with a MIDI note). It might sound like a simple difference but this does making programming MIDI drum parts that much easier.
Of my one two personal wishlist items, I could imagine Steinberg adding a drum editor to Cubasis without too much difficulty. Implementing a full groove quantise system would, however, be a much more significant undertaking. However, a sort of halfway house – where the app simply includes a number of useful ‘groove quantise presets’ that you can apply to your MIDI performances –is perhaps a less ambitious ask.
I’ve no idea what, if any, plans Steinberg might have to expand the MIDI capabilities of Cubasis… but healthy competition amongst all the iOS DAW/sequencer app developers is likely to see some progress made in terms of app feature sets over time for all of the main contenders. The specification for the upcoming Auria Pro (at the time to writing, the app is still in beta testing) suggests it will have a pretty impressive MIDI track feature set so things are bound to move forwards in other apps as a response. Here’s hoping….
The wider iOS world
The example I’ve used here to illustrate what’s typical of the current state-of-play for MIDI sequencing under iOS – Steinberg’s Cubasis – is, of course, just one of many iOS MIDI sequencer options. While some of these are, like Cubasis, ports or streamlined versions, of software that is also available on the desktop, others are products that started life under iOS. And, like, iOS itself, the bottom line here is that the platform is still finding its feet as a music-making environment.
This ‘still maturing’ context, plus the fact that iOS (like all mobile platforms) really has a design ethos of keeping its software streamlined and focussed (one app for each specific job), means that we are unlikely to see an iOS DAW/sequencer that really matches the top-end of what’s available currently on the desktop for some time.
I’ve no problem with that and, given the argument I presented earlier about 95% of what you do involving perhaps just 5% of the features in most desktop DAW/sequencers, providing the iOS app you use has been specified to provide those key 5% of features, the more streamlined spec of a typical iOS DAW/sequencer is not going to be too restrictive (nor an excuse not to get the job done). Yes, let’s hope that the feature lists do evolve and expand but, equally, let’s also hope that the worst excesses of software bloat can be avoided.
However, there is a further point to make here. While iOS might be some way behind the desktop when it comes to an ‘all-in-one’ conventional MIDI sequencing sequencing, in some other – albeit niche – ways, iOS offers creative options that are not always found on the desktop.
I’ve recently reviewed a couple of iOS music apps – Fugue Machine and midiSTEPs – that illustrate this point very clearly. I’ll not repeat that material here (go check out the original reviews) but both of these apps bring something just a little different to the concept of what MIDI sequencing is about. No, neither app is going to be the only MIDI sequencer you might need, and neither app really covers the ‘conventional’ feature set that the majority of musicians would see as desirable in the workhorse DAW/sequencer environment, but both are hugely creative. The indie development environment that iOS offers has allowed all sort of new and interesting MIDI sequencing tools to appear and that’s got to be a good thing.
There is one other issue that I think is worth discussing here and, while it is not specifically related to MIDI editing, it is relevant to how ambitious you might get with the MIDI-based elements of your iOS music productions; track freezing.
If you are creating your music using a lot of virtual instrument sounds – synths, drums, sample-based sounds, etc. – all of these parts will be built upon MIDI data of some sort and stored either within the various apps or, more likely, within your DAW/sequencer. The MIDI data itself is not an issue; as mentioned elsewhere in this series, one of the reasons MIDI was first created was as a compact data format for the recording and reproduction of music.
However, just as with desktop computers a few years ago, while the latest iOS hardware has plenty of raw CPU grunt, with more than a few virtual instruments running alongside your DAW/sequencer (and perhaps a few audio tracks and effects going alongside), it will not be too much of a surprise to realise that your hardware might, eventually, begin to sweat a little.
Most of the leading DAW/sequencers offer ways of lightening the load that all these virtual instruments can place on a system and, while there are variations out there, the majority offer something that is based around track freezing. All this process consists of is that, behind the scene, the software turns your MIDI-based track (within its CPU intensive virtual instrument) into an audio track (which doesn’t consume as much CPU during playback, although make sure to quit the virtual instrument app of it will still be running in the background and making use of some resources). The MIDI data, the software instrument, and all the other settings for the track are ‘frozen’ into the created audio track.
This is not a permanent process though; you can ‘un-freeze’ a track again if you need to make further edits. However, under iOS there are a few differences with how track freezing might work on the desktop. First, as you can only (at present anyway), have one instance of an iOS app running at any one time, track freezing is actually a good way of getting multiple tracks out of a single iOS synth or other virtual instrument. You can create the first track, freeze it, and this then frees up the same synth to be used in a second track.
The second thing to note is that track freezing only really works if you are using a virtual instrument that is somehow ‘inside’ your DAW/sequencer app. So, taking Cubasis as an example again, if you are using a virtual instrument via IAA inserted on a Cubasis track, then you can apply a freeze, unload the app, and save some resources. However, if an app is having MIDI data sent to it from a Cubasis MIDI track but is actually running standalone or via Audiobus, then the Cubasis track freeze system can’t capture the audio and freeze the CPU load in the same fashion.
That might, of course, all be about to change if the new AU format built into iOS9 gains some traction with potential DAW/sequencer hosts and with virtual instrument/effects app developers. MultitrackStudio for iPad is first past the post to offer this feature but others will undoubtedly follow.
Let’s hope that happens because then, not only will multiple instance of your favourite synths or effects be possible within your DAW/sequencer host but, because those instances will be running as plugins within the host, they will be easy for the host’s track freezing system to manage. There are other advantages also (for example, in terms of project management and loading/saving projects) but this AU technology has the potential to move iOS music making/recording a significant step closer to the desktop in terms of workflow efficiency.
Phew… did you make it to the end? Well done….
I’ve covered a lot of ground here (sorry!) but, hopefully, it has provided a bit of context for the MIDI newbies. So, from the initial drivers behind the creation of MIDI (computers were not powerful enough to allow audio recording), to the flexibility MIDI recording offers (the ability to edit both sounds and performance after they have been recorded), mix automation (all done via MIDI data in a modern DAW/sequencer), the creative options provided by MIDI editing such as easy transpose, tempo adjustment and groove quantise, through to the less conventional, but highly creative, MIDI sequencing options offered by iOS, MIDI is a powerful musical tool with a long history.
iOS is gradually becoming part of that MIDI story. No, not everything in the garden is perfectly rosy but we are getting there and, in some of the rather creative, niche MIDI sequencing tools we have, there are some real highlights. And perhaps, as the leading ‘conventional’ iOS DAW/sequencers try to out-compete each other for top-dog status, the MIDI recording and editing feature sets will gradually start to move towards those found on the desktop (although, hopefully, without the software bloat).
OK, so when we have all had a bit of a breather, what might be in the next part of the series? Well, one of the things that those new to MIDI can often find a bit bewildering is MIDI data flow.
In days of old, when all your MIDI equipment was connected with real physical cables, this perhaps wasn’t such a complex task (well, except for the cable spaghetti that could develop). However, today, much of that MIDI connectivity is virtual and connects virtual MIDI devices (instruments and effects). This can be a bit of a mystery even on the well-established desktop platform but, under iOS, where MIDI implementation can be somewhat scratchy in some apps, there is the added complication that things might not work even when you know you are doing everything ‘correctly’.
Again, this is an issue that is (slowly) improving… but, in the next piece, we will take a look at MIDI in, MIDI thru and MIDI out under iOS and see just where the current state-of-play has got us. Until next time…. enjoy your MIDI-based iOS music making….