CMIX is a package of sound-processing, synthesizing, modification and mixing programs that you can use to do virtually anything with any pre-recorded sound, or with which you can synthesize any sound you can imagine. Its workings are very flexible and relatively simple, and, in the right combinations, any musical project can be realized.

Although in our studio we have many friendly "GUI" graphical interfaces for dealing with, modifying, mixing, and playing with sound, which can make these processes very intuitive, sometimes almost gestural; the way in which this user-friendliness and visceral interaction is accomplished can be very task-specific as a result: GUI applications are often very good for writing one kind of music, but very cumbersome or even impossible to use for writing another kind. Sometimes you will have a sonic/musical problem you know exactly how to solve, but whose solution is not served by any of the current graphical interfaces. In that case you can turn to the simple text-based building-blocks of CMIX to pursue your project.

In the old days, CMIX was not a real-time sound processor: you typed in commands, gave it a "score" to play; and then let the computer (take hours to. . . ) crunch the commands, resulting in the sound you were hoping to get (hopefully.) Now, (thanks to Brad Garton's development of RT-CMIX), you can hear, correct, and experiment with your results in a quick, non-discouraging manner. With RT-CMIX (Real Time--) the machine plays the sound as it crunches your "score." This quick turnover allows you to experiment, tweak and perfect your sound in reasonable amounts of time. Thus, you get flexibility that might be lacking with GUI apps, plus speed that almost matches the latter's.

RT-CMIX is much easier to use, but good-old-fashioned "DiskSpace CMIX" (non-real time), though slightly more involved, is not that much more difficult. A fair (though ever-decreasing) number of CMIX instruments still only exist as non-real-time, disk-based. Thus, I shall introduce patient reader to both types, side by side.

You can think of CMIX, at first, as being set up as a kind virtual musician, or virtual "player" to realize your musical ideas. There are a set of available "instruments," which are actually sound-making computer programs. (You can also create your own). You write a companion program, a very simple kind of program, which tells these "instruments" what notes to play, how and when to play them. This program is called, naturally, a "score," or "score file," and it is written in a very simple "language" (I don't want to scare anyone, it's really too simple to be called a "computer language") called MINC, which tells CMIX, the third program, how to use the "score" to create sound.

So, when you run CMIX, basically four things are involved:

                      goes into        which makes  
     Your Score file  ----------->  The  ---------------->   the sound
       in MINC                ^     Cmix                     that gets
                              |     program                  created
                              |     itself
                              |
                              |
                              |
      "Instrument"------------/
       program

At this point, all you need to worry about is the "score" and the output "sound;" that is, your program to make music, and the resulting music (respectively). At first, we will use pre-constructed instrument programs. (Though it is too complex to explore in this introductory document, it is also possible to make one's own "instruments;" thus fully utilizing the flexibility of the CMIX package to tailor all tools to one's own particular musical needs.)

In other words, you write a program, (the .sco (score) file), which gets interpreted by other programs (the CMIX package , the specific instrument program), all of which then work together to create a sound--which is piped directly to speaker output (in the case of RT-CMIX), and/or, which is put into a "soundfile." Thus, to synthesize a sound in Cmix, you have in general to follow these steps:

     
     create/edit    a       ----------->         type  the command:
     score  (.sco)   file                        CMIX < <scorefilename> 
     using  jot   or                             (explained later)
     similar text editor                              |
                                                      |
                                                      |
                                                      V
                                              listen to  your sound

The procedures for running the two different kinds of CMIX are very similar but differ in the following ways:

1) RT-’s output is directly to the speakers (you can also send it to a soundfile with the command rtoutput.) DiskSpace -CMIX’s output goes only to a soundfile on a hard-disk. Disk-space CMIX's output involves some extra procedures that I’ll cover shortly.

2) The command for running RT- is written in CAPS (i.e.--CMIX). The DiskSpace- command is in small letters (cmix).

So to run a wavetable score designed for DiskSpace- CMIX, you type:

To run a score for real-time, one types:

Let's look at a simple score file. Before you write a score file, you must decide what instrument you're going to be using. We'll start with one of the simplest of the instruments: WAVETABLE. In the score for this instrument, you can

1) define the timbre, and envelope

2) define a "note" by describing when, where (in stereo space), how long, and how loud it is, and, of course, the pitch.

You can have as many notes and timbre and envelope changes as you like.

Here's an example, written for RT-CMIX:

Here’s the same score, but written for DiskSpace-CMIX:

Other makegens:

There are other types of makegens available for your use, which graph different kinds of functions in memory slots. To see them all, check out the Makegen WWW page. Makegens in general are used in almost all CMIX instruments.

makegen is a generalized command you’ll find in scores for just about all CMIX instruments. WAVETABLE, however, is a specific CMIX instrument. You can only use the WAVETABLE command when you have loaded the WAVETABLE instrument into your score with the load command mentioned above. (The same will go for any other CMIX instruments.) Let's discuss how WAVETABLE works.

With any CMIX instrument, making a "note" consists of defining the parameters of that particular note. These usually include attack-time, duration, loudness, pitch, stereo position. In fact, with the WAVETABLE instrument those are the only parameters that are necessary. With other, more complex CMIX instruments , other parameters will be added to this basic group. The parameters are usually referred to as p0, p1, p2, etc.

Parameter 0

Parameter 1

Parameter 2

So what does CMIX actually do with all this info?

Well, to write your sounds, it needs some templates, it needs to know what waves look like. The makegens do this. They say, "Here's an example of one cycle of a sine wave. Here {makegen(x, 10, x, x, . . .) } is an example of one cycle of a harmonic sound. Here {makegen(x, 24, x, x, . . .) } is an example of a amplitude envelope. What CMIX actually does is read through the makegen templates in memory, over and over, at just the right speed, according to the frequency you specified in your WAVETABLE command, multiplying or dividing the values of each point in the template according to the amplitude you specified in your WAVETABLE command, and multiplying that by numbers derived from the amplitude envelope specified in makegens. By this process it calculates each and every sample of the 44100 samples that make up each second of each note of your music. That's all it's doing, just copying the makegen waves over and over, modifying them in this way and that; it's that simple. Now, of course, things get complicated when you start modifying waves by waves, and so on, but the basic principle is just this one of copying with modifications.

Again, you will probably be using RT-CMIX most often to make your sound. To actually get sound from your RT-CMIX score, you need merely to save your score on disk somewhere, (probably either in your /snd or in your /Users directory). Then, in your UNIX shell, you cd to that directory, and type

In other words, if I save my score as beeps.sco, in /sndgr/chris, then to run it, I simply type:

OK, but, let's say you've written a DS-CMIX score. How do you go about actually getting sound from it? Follow the following 6-step process: