Scala 1.01

Please Note: I've gone back through the examples, and modified them by enclosing them in PGD Code for online display. They should all work now as described below in the Copy/Paste explanation. Anyone still having difficulties with this, please let me know.
For the background procedure using Rapture and Dimension Pro 1.2, check out the Microtuning in Rapture (and DimPro 1.1?) thread. We'll call that one Scala 1.00. For those wishing to follow along step-by-step, or the envelope-pushers in the group, I'd strongly urge snagging the free application Scala 2.22.


Or, you can copy the text files presented here directly. Paste it in any text editor [Notepad], and save it as a Scala file (save as *.scl) for your own use. Just copy the sections between the ">>><<<", and don't include the arrows themselves. You might want to make a new subfolder under (Dimension Pro 1.2 or Rapture)/Tunings for easy access.

No theorizing or additional background information. We're just going to dive into it. The standard Western hemisphere scale that you're going to hear most commonly is a 12 note per-octave equal tempered scale. One way to look at it is this:

! C:\Cakewalk\Rapture\Tunings\B Rock Equal Tempered.scl
 !
 Basic equal tempered scale [one octave displayed. 100 cents per step]
  12
 !
  100.000 cents
  200.000 cents
  300.000 cents
  400.000 cents
  500.000 cents
  600.000 cents
  700.000 cents
  800.000 cents
  900.000 cents
  1000.000 cents
  1100.000 cents
   2/1

Several ways to do this in the Scala application. In fact, there's multiple routes to take with anything in Scala. This one's easy:
File/New/Equal Temper. Apply the changes.



Here's something different in subtle ways. We take the same perfect prime (a 1/1 ratio), and expand that into a justified tuning.

! C:\Cakewalk\Rapture\Tunings\000 B Rock Scala\B Rock Just Intonation.scl
 !
 Basic just intonation scale [One octave displayed. Variable cents per step]
  12
 !
  105.88235
  211.76471
  317.64706
  388.23529
  494.11765
  600.00000
  705.88235
  811.76471
  882.35294
  988.23529
  1094.11765
  2/1

Use File/Scale/Modes for several variations on that one. Now here's something different: We're going to take the usual ascending order of a an equal tempered scale, and shift it around. In effect, you're re-mapping the notes that output from your keyboard into a 'tone row' consisted of 12 steps. Very useful for serial composition (duo-decaphonic). You can input the 12 tones in your tone row in any order that you choose, and they will be played back by an ascending (descending for retrograde) chromatic scale played by a .mid/.ptn file, or KB input. Here's just one single possible example:

! C:\Cakewalk\Rapture\Tunings\00 B Rock Tone Row 21.scl
 !
 Keyboard re-mapped to a tone row.  Ascending input results in C C# G# F# F B Eb G A D Bb E C.1 (octave)
  12
 !
  100.00000
  800.00000
  600.00000
  500.00000
  1100.00000
  300.00000
  700.00000
  900.00000
  200.00000
  1000.00000
  400.00000
  2/1

File/New/Scale (or Input on the GUI). Manually enter the values in cents. Or hand-edit an equal tempered scale with Edit/Edit Scale ... (Edit on the GUI). There's no mystery here about the use of the term 'cents'. Think 'hundredths of a semitone' (totaling one step on the keyboard per 100). A semitone is equal to 100 cents, so an octave (12 semitones) is equal to 1200 cents. This is an important concept to grasp in pitch divisions, as well as synthesis in general. Filters, pitch deviations, detuning, and other components of synthesizers are often labeled in this manner; defined as cents.



OK: I can't resist throwing in a crazy one, and this is going to lead us into another important concept in Scala 1.02: Keytracking . We'll call this one an extra-credit assignment. There's a bonus question at the end of this tutorial, because I have to determine who's really following through on this stuff. <g> This little number takes the equally tempered scale at the beginning of this tutorial, and mangles it within the Scala application. The result? Octaves occur on the tritones (augmented fourth and diminshed fifth), and stretches a two-octave keyboard controller to span four octaves in the results. Of course, you're going to lose a few intervals along the way. <g>

! C:\Cakewalk\Rapture\Tunings\000 B Rock Scala\00 B Rock 2 Octave Crush.scl
 !
 Two octaves of keyboard input yield a four-octave span in the output.
  6
 !
  200.00000
  400.00000
  600.00000
  800.00000
  1000.00000
  2/1

In the Scala application, you would start with an equal temper scale (as in example one above), but would input 6 steps per octave unit in Division, instead of 12. OK, now for the bonus question:

you want me to take a punt?

No. The bonus questions get more difficult as the Scala series progresses. You get to answer those. (I might not have ther answer myself.)

You're a nutter.

Flattery will get you ... everywhere.

Is it key tracking Sir, is it, is it?

I reckon sir could do something pretty radical using <curve> if he wanted. But I'm just a touch too tired (DJ Spooky) this morn to de Bono that all the way through to a yes/no answer…

Could you possibly post and example?

My brain is still too dry and devoid of proper sleep to whip anything up now. However, I get what your getting at (after 3 reads) and think it possible. I'll look into it soon… I believe there's a couple ways of going about it (crossfading could be an option too if you're dealing with layered wavetables).

From what I undertand, the neat thing about the <curve> control is that you don't have to specifiy all 127 points in the CC controller range. AFAIK, you just plug in the key points (i.e. v000=0 v127=1) and sfz will linear interpolate the values in between. That's just off the top of my head though… Don't blame me if your curves sag, wobble or otherwise…

Where's René's on-topic post from a couple months ago gone? Oh, it's here, right where Tom left it.

could do something pretty radical using <curve> if he wanted.

Trust me: I've been surrounded by more <curves> this past week than should be legal in a modern civilized culture. Luckily, I don't live in one; I live in Miami.
Focus, people: Scala 1.01. My quadrupedal friend was correct above, if a bit incomplete in his reply.

The bonus answer was indeed the Keytrack setting, at a setting of 200 cents per key. So what's the advantage of using a .scl file, when you can just use a GUI setting instead? As Rene pointed out in the Microtuning thread, the Keytrack parameter modifies a loaded Scala file itself (further 'downstream'). As I see it, Transpose & Tune modify incoming MIDI information 'upstream' of the Scala file. It's important to note here that none of the actual MIDI Note values are changed (from the point of view of your host application). The incoming MIDI info is siphoned off by Rapture, and used as as a source to modify en route to its own audio output.

A Scala file that crams two octaves into one will pass through as such with a Keytrack setting of 100 cents (default). A KT settting of 200 (in effect) adds another 100 cents per half-step (degree) to the .scl file. That results in one octave of keyboard input yielding 3 octaves of output. Bringing Keytrack down to 0 cents neutralizes the the 2 Octave Crush, and returns Rapture to a 'normal' equal tempered scale.

Then, there's the negative values. A -100 setting in KT is now required to bring Rapture to the 'all-MIDI-Notes-output-one-note' stage. That becomes the new pivot point, where output begins to run 'backwards'. -200 gives you an equal tempered scale running in reverse. And with Transpose & Tune adjustments, we can shift these results around in 'pitch' by static amounts. One loaded Scala file sets some given parameters, and Rapture's GUI features change those into something else entirely.

Morph might be a better term, because Transpose, Tune, and Keytrack can all be controlled by automation curves. And, if you core down into the exposed automation parameters, you can use your host's MIDI Remote Control feature to bind these to a controller message from your MIDI keyboard. Remember, everything in Rapture can be modified in real-time by MIDI, in more than one manner. If you don't see what you need, you simply have to hunt it down.

So, with the Scala file, you can determine not only the number of degrees of change per-octave, but you can also set an arbitrary octave size. You don't have to have 12 equal half-steps in an octave, and an octave doesn't have to be twice the 'pitch' of your starting point. In Rapture & Dimension Pro 1.2, a MIDI note doesn't have to be 100 cents from the next one, and it doesn't have to be at the expected output 'pitch'. And one side modifies the other.

You can combine the static, yet nearly unlimited variables of Scala with the ever-changing MIDI-controlled, yet limited ranges in the synth 's GUI for use as deployable performance techniques. And this, my friends, is where you can begin to shift scales from 'safe territory' into the 'unexplored wilderness'.

Even more astounding: all of this happens on a per-Element basis.

Edit: Work in progress.

you're talking about that ‘weird’ stuff aren't you? I'm thinking that you're thinking ‘art’ rather than ‘pop’.

I must admit: I am hinting at the esoteric potential, but my focus is on the journey from basic scale manipulation to less-than-mainstream applications. In the process, I'm aiming to gear this towards the performing musician, who could develop custom practical methods of their own. Toward that end, I want to include the maximum external control over those methods, with the least amount of effort. That's where MIDI Control will play a huge role.

Rene gave us the tools to to form an unholy alliance between scale manipulation, and remote control at your fingertips. But there's meat-and-potatoes meals to be enjoyed here as well. Consider 'compressing' or 'filtering' your incoming keyboard notes. If, for example, you wanted to confine your entire keyboard to an augmented scale, how would you get there? No matter what you hit, it'll be within the given scale structure. You might approach that like this:

! C:\Cakewalk\Rapture\Tunings\000 B Rock Scala\B Rock Augmented (Scale BandPass Filter).scl
 !
 One Octave Input Constrained by Augmented Scale
  12
 !
  100.00000
  100.00000  Dropped 100 cents
  400.00000  Raised 100 cents
  400.00000
  400.00000  Dropped 100 cents
  700.00000  Raised 100 cents
  700.00000
  800.00000
  800.00000  Dropped 100 cents
  1100.00000  Raised 100 cents
  1100.00000
  2/1

In the Scala app: File/New/Equal Temper. Then, Edit/Edit Scale ... and manually adjust the intervals. Speaking of which, Scala allows for input in cents (anything with a period), or intervals (ratios). And scales and related data can be viewed in a variety of units, including conventional (or adjusted for micro/macrotonal) notation, absolute Hertz, cents, and more. The last one mentioned is what Rapture, Dimension Pro, and the other synths understand, so that's why cents is my 'unit of choice' here.

Let's say that someone is better at descending keyboard technique than ascending scales. Whittle yourself a crutch, until your technique starts to match your creative ideas. Take the augmented Scala file, and turn it around with the Keytrack control. In your host app, burrow down in DXi Automation until you find Pitch Keytrack 01 (assuming Element 1 only). Assign a CC# message to a keyboard slider, and (if you can) limit the Low value to ~95, and the High value to ~31. [There'll be some slight variations from controller to controller, and interpolation errors.]

What you're looking to have is a slider action that hovers at 100 cents unused (default), and a full-throw readout of -100 cents (in the Multisample Keytrack value). At 'rest', there's an augmented scale overlay on your playing. With your slider (mod wheel, or anything else) at maximum, you've reversed your entire keyboard range (pivoting on middle C, which remains the same)

Edit: Did I neglect to mention the huge variety of scales with values between those two extremes? Near midway presents a Rimsky-Korsakov theme and beautiful trills, and all held notes are treated to pitchbending/portamento effects using that same single control in motion.

Your scale still stays augmented, but now you've re-mapped the keyboard in the opposite direction with the flick of a finger. In another scenario, you might only want to raise the perfect fourth or fifth in your scale a quarter tone, to capture the elusive 'blue note'. The sky's the limit. If you can conceive an idea involving scales, you can make it a reality in Scala. Then, you can vary that template with MIDI RC in a Scala-friendly application.

Performance techniques. As soon as I can squeeze out the time: as applied to audio examples.

Thanks, Mr. Meier. Coming from someone with your knowledge, this is indeed complimentary. I'm thinking of leaving Scala 1.01 right here, barring any new questions or developments. But we'll part with one more tip for our hapless keyboardist (we'll call him Mr. B ) with a serious dexterity problem.

Now let's assume that our keyboard player has tightened up his upward scale chops, yet still has a stronger right-hand technique than the left. He must be a guitarist; you'd think that it would be the opposite, but for some reason it isn't. So, we give him an equal tempered scale, but we remap the octaves to travel progressively downward:

! C:\Cakewalk\Rapture\Tunings\000 B Rock Scala\B Rock One Octave & Drop.scl
 !
 Normal ET Scale with Octaves Reversed
  12
 !
  100.00000
  200.00000
  300.00000
  400.00000
  500.00000
  600.00000
  700.00000
  800.00000
  900.00000
  1000.00000
  1100.00000
 -1200.00000

In the Scala application: New/Scale/Equal Temper. Then Edit/Edit Scale .... Drop the octave ratio [2/1], and substitute -1200.000 cents in its place. Now, a scale will ascend 12 notes as with a 'normal' setup, but reaching the next C takes you to the octave below, rather than above. Remember, this is just because the scales are based on middle C and locked to A=440. Your reference pitch can be anything. You can change that in the Scala app as well. [Edit/Edit Mapping ... (as one example).]

Now, it's starting to dawn on Mr. B that any incoming MIDI is modified by the Scala file that's loaded. And each of the Elements can have a different scale loaded. So, placing an arpeggiator before Rapture presents a certain octave range and pattern shape. But that octave range and shape is transformed by the Scala file, and each Element can change it in a different manner. So, what goes up, may come down, but it can also go up, down, sideways, or in any other defined direction. And the interaction between Elements (note-wise at the output) produces a huge amount of combined potential directions.

So, Scala becomes a re-shaping tool for an arpeggiator as well. One arp goes in, and (up to) six arps come out. I don't need to explain this any further.
Try it once, and you'll be hooked.

What does all this mean for someone who has Rapture with no musical training whatsoever?

It means that you're going to have a tough run ahead of you, Adam. But if you're really willing to put in the work, I'm willing to help you through it.
Deal ... or no deal?

First of all, you can just explore the Scala 'presets' do see exactly what they do. Some of the changes to scales are subtle; others are more extreme. There's 3,304 Scala files included with Rapture. Check out the new Rapture Support page [here], or my own Microtuning thread [here] to get you started on the basic procedure. Just start clicking on some of the included .scl files, play a normal C major scale (or similar), and see what comes out.

As a background, Scala (and many other synth parameters as well) divide a half-step on your keyboard (E to F, or C to C#, as examples) into 100 parts. It's labeled as cents, and just like the monetary unit, it breaks up the whole into 100 increments. It's just another way to describe a note, and that allows a scale to be represented in finer increments.

So, an equal tempered scale (most everything that you commonly hear) has 12 notes in an octave; C to B. Then, you begin another octave, and the process repeats. Using a description in cents, each of those 12 notes has a value of 100 cents. So, there's 12 notes, at 100 cents each, for a total of 1200 cents per octave.

An octave has twice the frequency (in Hertz) that the one below it does, and half the frequency of the octave above it. Same 'basic note', but higher in pitch. Scala represents that as a ratio: 2/1, or in cents (1200 cents). 4/1 would be two octaves higher than your starting pitch. That beginning pitch is called a perfect prime (1/1) in Scala, but just consider that as your scale's 'reference' pitch for now.

What Scala does for you is to allow you to use other increments than what you're accustomed to hearing. Each note [C to C#; C# to D; & on up] doesn't have to be 100 cents apart. Think of it like bending a guitar string. From one fret to the next, you have a one half-step increase in pitch. But if you bend the string slightly, you have a pitch that's somewhere in-between. With Scala, you can bend that string to 100 different distinct spots (more, really).

That will get you some exotic tunings with the right numbers, and you can emulate instruments from history, bell-like tunings, instruments from around the world, and a whole lot more. It adds an air of authenticity to the instruments that you're trying to reproduce. But you can also use Scala as a tool to create all sorts of tunings that don't exist in the natural world, or that have never been heard before. This is one powerful tool.

In some of the examples above, I've used Scala to remap your keyboard. So, you might finger an Eb on the keyboard itself, but C comes out instead. This might not seem useful yet, but as you progress further, you'll see that this has applications toward extending your playing techniques, and expanding on creative composition. You can reverse what comes out, confine every note (even 'wrong' notes) to a single scale, or configure exactly what pattern shapes result from an arpeggiator. And that's just for starters.

Let's just say that you can do a lot with Scala. I'm getting beyond the basics here, but let me know if this helped any, Adam. If you want some further clarifications, or I didn't explain this well enough, feel free to respond back with your questions.

#1: Sure you can. The whole point of Scala, Adam, is that you can re-define just one of the keys, all of them, or anything in-between. And that can be by a very small amount (a few cents), or a large amount (for example 500 cents, or shifted up/down a perfect fourth). One more thing: you can define all of the black and white keys to play only the equivalent of the white keys. So, anything that you hit will be played back (as one example) in a C major scale. The twelve notes in an octave will only output seven choices. Of course, you can configure anything else as well.

#2: That's the beauty of this system. You treat a scale within the parameters of an octave, and that gets transposed up & down the keyboard. So, if you "mess" with a few notes in the defined octave, those same notes get "messed up" throughout the range of the entire keyboard. And the others remain "in tune".

Without getting ahead of ourselves, let me just mention that you can re-define what an octave stands for, too. So you can stretch or compress what you would normally see as an octave. In one example above, I cram two octaves of "sound" into one octave of keyboard space.

The entire system is open-ended, so you can make changes in the slightest manner, or as radical as you can imagine. Keep the questions coming, Adam.

I do wonder if this would hurt me more than help - long term.

Yes. I'm just using those examples as an introduction to Scala. There's no substitute for learning proper instrument technique. But if that eases someone into the concepts, I'll use it to describe a temporary crutch.

As for your other questions, a complete explanation is going to require much more time than I have right now. The 100 cents per-key is relative to the octave ratios. Actual frequencies in Hertz is whole 'nother ball game. We'll get back to this, Adam, but in the meantime. I suggest that you go [here] to the Scala home page, and get a little background first.

You don't have to absorb everything at once; there's a lot there. But speculating what might or might not be will do more harm than good. Better to have a basic idea of the concepts before you dive in head first.

Edit: Do me a favor, Adam. Try the Copy/Paste method that I detailed in the opening post, and check out the examples in this thread. I don't want to go any further with posting examples unless they work under all conditions. As a bonus, you'll begin to uncover how switching the numbers around affect the results in Rapture. You can edit the numbers directly in your Scala file (using Notepad), and make your own files from them. Just make sure to save them with a .scl extension; not the default .txt one.

I have it bookmarked . Thank you kindly!

Are all my questions in the forums making me look dumb here?

I'm actually planning on taking some classes at the local community college beginning in the Fall. I just have a desire to learn all of this... I have been technical and/or in the engineering field for about 15 years now. My right brain is screaming for more of this mysterious stuff some call music.

Adam