### From The MPEG-4 Structured Audio Book by John Lazzaro and John Wawrzynek.

# Part I. A Tutorial Introduction

## Sections

- Introduction.
- The Execution Model. Introduces i-pass, k-pass, and a-pass. Shows how SAOL and SASL work together.
- A Simple Example. Fixed-frequency sine wave oscillator. Introduces instr structure.
- Running the Example. Shows how to use `sfront` to generate audio and MP4-SA files. Computes compression ratio for the first example.
- Playing a Melody. Second example. Plays a melody with the sine-wave oscillator. Shows how to combine i-pass, k-pass, and a-pass computations.
- In Reverberant Stereo. Third example. Shows how to use send and route commands to make effects pipelines. Shows how to change SAOL variables from a SASL score line.

## Introduction

MPEG-4 Structured Audio (MP4-SA) is an ISO/IEC standard (edited by Eric Scheirer) that specifies sound not as audio data, but as a computer program that generates audio when run.

This tutorial introduction shows how to write programs using the MP4-SA programming language SAOL (pronounced sail) and the MP4-SA score language SASL (pronounced sassil) to create audio content. We start with a simple programming example, and add more features to introduce different aspects of SAOL and SASL.

At the end of the tutorial, the reader should have a broad overview of the MP4-SA system. The rest of the book will revisit the issues introduced in this tutorial, and show in detail how MP4-SA works.

As you might have noticed, this tutorial is a bit lengthy; if you just want a quick look at MPEG-SA in action, you might want to look at this simple example instead.

##

## The Execution Model

When we hear a sound, we are sensing fluctuations of air pressure with time. The temporal structure of the pressure waveform has a significant effect on whether or not we find a sound pleasing or interesting.

This structure happens on several different time scales. Notes in a musical composition change on a time scale of hundreds of milliseconds. The timbre of sounds changes on a time scale of tens of milliseconds. The actual sound waveform changes on a time scale of tens of microseconds.

When programmers write software to create audio content in a conventional language like C or Java, much of the effort focuses on managing these three time scales of sound. Since the code is structured around timing issues, it is difficult to group all the code for modeling a specific musical instrument in one place. Instead, the code becomes separated into different sections for different time scales, and the methods of communicating between the time scales become hard to track and modify.

In MP4-SA, time management is a part of the language itself. A SAOL program executes by moving a simulated clock forward in time, performing calculations along the way in a synchronous fashion. For interactive applications (for example, musicians playing MIDI controllers that send data to a SAOL program) this simulated clock is in sync with real time. For off-line applications, like converting a MP4-SA bitstream into an audio file for later playback, the simulated clock is unrelated to real time.

##

The clock is set to 0 at the start of program execution, and moves forward at the audio sample rate (called the a-rate). In addition to the a-rate, there is a slower time scale for timbre changes and note sequencing, called the control rate or k-rate.

The a-rate and k-rate values may not be varied during execution, and the a-rate must be evenly divisible by k-rate. By default, the a-rate is 32 kHz and the k-rate is 100 Hz. We use the terms a-cycle and k-cycle to describe the moments in time that repeat with a-rate and k-rate frequency, respectively.

Sound creation in MP4-SA can be compared to a musician playing notes on an instrument. A SAOL subprogram (called an instr -- SAOL and SASL keywords are in bold face in this text) serves as the instrument. SASL commands (called score lines) act to play notes on SAOL instrs. Just as a musician playing a polyphonic instrument can play several notes concurrently, many instances of a SAOL instr can be active at one time, making sounds corresponding to notes launched by different score lines in a SASL file.

A SAOL instr contains all the instructions for playing a note: code that runs at note launch, code that models timbre evolution at the k-rate, and the code to generate audio samples at the a-rate. Because time management is a part of the SAOL language, computation at these different rates can be written compactly in one place in the file, and communication across these time scales can be expressed easily.

The right panel shows the execution trace of a note played on a SAOL instrument, which is part of a SAOL program that has an audio rate of 40kHz and a control rate of 100 Hz. This note is scheduled to start at a simulated clock time of 0.995 second. However, since notes are launched in SAOL at k-rate granularity, the note launch is delayed to 1.0 seconds.

At 1.0 seconds, instance execution begins with the i-pass, where instr code for note launch executes. Following the i-pass is the first k-pass, where instr code for timbral evolution executes. Following the first k-pass is the first a-pass, where instr code to generate an audio sample runs.

After the first a-pass, simulated time advances by the audio sample period (the inverse of the audio sample rate) and another a-pass is executed. Execution continues in this fashion until `a-rate/k-rate` a-passes have run.

At this point, the first execution cycle of the instance is complete. The subsequent execution cycles consist of a k-pass followed by a set of a-passes. The i-pass code only runs during the first execution cycle.

Note that the analogy of a musician (SAOL) playing notes (SASL) only loosely applies to MP4-SA. In practice, not all SAOL instrs are used for instrument modeling, and instrument models don't always map one-to-one onto instrs in a SAOL program. In addition, there are other ways to trigger notes in MP4-SA besides SASL score lines, including MIDI files and commands run in other SAOL instrs.

## Instance Execution Trace

`

    Audio rate   : 40,000 Hz
    Control rate :    100 Hz
    Start time   :  0.995 s

    Time (s)   Cycle     Pass     X-#

    0.990000   k-cycle
               a-cycle
    0.990025   a-cycle
    0.990050   a-cycle
    0.990075   a-cycle
      ...

    0.999925   a-cycle
    0.999950   a-cycle
    0.999975   a-cycle

    1.000000   k-cycle   i-pass  --
                         k-pass    |
               a-cycle   a-pass    |
    1.000025   a-cycle   a-pass    | 1
    1.000050   a-cycle   a-pass    |
    1.000075   a-cycle   a-pass    |
       ...       ...       ...     |
    1.009975   a-cycle   a-pass  --

    1.010000   k-cycle    k-pass --
               a-cycle    a-pass   |
    1.010025   a-cycle    a-pass   |
    1.010050   a-cycle    a-pass   | 2
    1.010075   a-cycle    a-pass   |
       ...       ...       ...     |
    1.019975   a-cycle    a-pass --

    1.020000   k-cycle    k-pass --
               a-cycle    a-pass   |
    1.020025   a-cycle    a-pass   |
    1.020050   a-cycle    a-pass   | 3
    1.020075   a-cycle    a-pass   |
       ...       ...       ...     |
    1.029975   a-cycle    a-pass --

    1.030000   k-cycle    k-pass --
               a-cycle    a-pass   |
    1.030025   a-cycle    a-pass   |
    1.030050   a-cycle    a-pass   | 4
    1.030075   a-cycle    a-pass   |
       ...       ...       ...     |
    1.039975   a-cycle    a-pass --

    X-# column indicates the passes
    that make up each execution cycle
    of the instance.

`

## A Simple Example

Our first SAOL instr is a simple sine wave oscillator. Our first SASL score triggers this oscillator.

The panel on the right shows this SASL score. It is a list of commands that trigger actions relative to the clock time. These times are expressed as 32-bit floating point numbers, and may use the full resolution of the representation. However, SASL commands are processed at k-rate granularity. At each k-cycle all unexecuted commands whose times are less than or equal to the current clock time are executed.

SASL commands are one line long; the newline marks the end of the command. The first number on the line indicates the trigger time. However, this time is not in units of seconds of time; instead, it is measured in beats of score time. A global tempo value is used to convert beats to seconds.

By default, the global tempo is 60 beats per minute, or 1 beat per second. In the first example in this tutorial, we use this default global tempo, so that all SASL times can be thought of as beats or seconds interchangeably.

We now look at the SASL score on the right panel in detail. The first line of the file is an instr command that triggers the SAOL sine-wave oscillator instrument. The first field (0.25) indicates the start time for the instrument. The second field (`tone`) indicates the name of the SAOL instr to trigger. The final field (4.0) is the duration that tone should play, in units of beats (and in this example, seconds).

The final line in the SASL file is an end command. It signals the simulated clock time to end program execution via its trigger time (4.50 seconds).

`

## sine.sasl [26 bytes]

    0.25 tone 4.0
    4.50 end

`

The right panel shows the SAOL file for the instr tone, a fixed-frequency sine-wave generator. The file begins with several comment lines. SAOL comments begin with the characters // and end with a newline; characters inside comments are ignored by MP4-SA tools.

The keyword instr starts the definition, followed by the name of the instrument (`tone`), and an empty pair of parenthesis. As in C function syntax, curly brackets enclose the body of the definition, which consists of a variable declaration block followed by a code block.

Three variables (`x`, `y` and `init`) are declared as type asig, one of the three signal variable types (asig, ksig, and ivar). Signal variables, the only type of variables that can be used in SAOL expressions, hold 32-bit floating point numbers, and are initialized to 0 at the time a SASL command instantiates an instrument. The asig type indicates that computation involving these variables runs during the a-cycle.

Next, we reach the code block. The syntax of this code seems quite familiar to C programmers: a simple assignment statement, followed by an if statement, followed by two more assignment statements, and finally what appears to be a call to an undefined function output().

What may be surprising, in light of the earlier discussion on SAOL's execution model, is that the statements in the code block aren't marked to indicate the rate of computation (a-rate, k-rate, or i-rate). In SAOL, the time scale of statements is inferred from the time scale of variables used in the statement. As we shall see as we analyze each statement, each statement in this code block runs at a-rate.

`

## sine.saol [286 bytes]

    //
    // instr tone
    // plays a 1kHz sine wave
    //

    instr tone ()

    {

      // variable declaration

      asig a, x, y, init;

      // computing starts here

      a = 0.196307;

      if (init == 0)
        {
          init = 1;
          x = 0.5;
        }

      x = x - a*y;
      y = y + a*x;

      output(y);

    }

`

If we accept that each statement executes at a-rate, we can visualize the combined behavior of the SAOL and SASL code (see the SASL code reproduced in the panel to the right). Starting at the first k-cycle after 0.25s, the code block is executed on every a-pass. In this example, the a-pass happens 32,000 times per second (the default audio rate value). The state of variables `x`, `y` and `init` is maintained between a-passes. Execution stops when the first k-cycle after 4.25s occurs (4.25s is the sum of the start time (0.25s) and the duration 4.0s), at which time this instance of the instr tone is destroyed.

`

## sine.sasl [26 bytes]

    0.25 tone 4.0
    4.50 end

`

We now return to the SAOL file, and analyze each statement in the code block in the instr tone (reproduced in the panel on the right). Recall that this instrument generates a fixed-frequency sine wave.

The first statement is a simple assignment statement, setting a constant value used in the algorithm. Assignment statements execute at the rate of the variable on the left hand side of the statement; in this case, the variable `a` is an a-rate variable, and so the statement runs at a-rate. Note that operator `=` is the only assignment operator in SAOL; C assignment operators such as `+=` and `++` are not a part of the language.

The assignment is followed by an if statement. Like its C equivalent, the code block (enclosed by curly brackets) executes if the value of the guard expression (enclosed by parenthesis) has a non-zero value. In this case, the code block is executed exactly once; the variable `init` is initialized to zero during instrument instantiation, and is set to a non-zero value in the code block of the if statement. The purpose of this if statement is to initialize `x`.

The statements in the code block of the if statement are a-rate, and as a result, the if statement also runs at a-rate.

The next two assignment statements do the real work of the instrument; these statements implement a classic iterative algorithm for sine and cosine generation, that is guaranteed to be stable. The value of the variable `a` sets the frequency of the waveforms (in this example, the value of `a` maps to a frequency of 1000 Hz). The initial value of `x` sets the amplitude of the waveform. Since `x` and `y` are both a-rate, both statements execute at the a-rate.

The final statement is an output statement, part of a class of SAOL statements that use the syntax of C functions. The output statement is defined as a-rate, and serves as the mechanism to communicate audio samples outside of an instr. Audio in SAOL is read and written to special 32-bit floating-point variables called buses, which are initialized to zero at the start of each a-pass.

SAOL has a special bus, output_bus, that represents the final audio output of an MP4-SA system. In this example, the output statement adds data onto the output_bus (the default behavior in SAOL). In this case, it adds a sample of the sine wave, which will vary in value from -0.5 to +0.5 (since `x` is set to 0.5 in the if statement during the first a-pass).

After an a-pass is complete, the output_bus is clipped to the range -1.0 to +1.0, and sent to the audio output device (usually a file or a sound card). If no instrs are running during an a-pass, the initial zero value of the output_bus is sent to the audio output device, resulting in silence. In this example, a silent sections happen before the instr tone is triggered and after the instr tone is destroyed.

`

## sine.saol [286 bytes]

    //
    // instr tone
    // plays a 1kHz sine wave
    //

    instr tone ()

    {

      // variable declaration

      asig a, x, y, init;

      // computing starts here

      a = 0.196307;

      if (init == 0)
        {
          init = 1;
          x = 0.5;
        }

      x = x - a*y;
      y = y + a*x;

      output(y);

    }

`

## Running the Example

In this section we show how to use the SAOL to C translation program sfront to run the example above. We assume a UNIX command-line shell environment.

The process begins by running sfront, using the syntax shown on the right panel. The -orc option is used to specify the SAOL file, and the -sco option is used to specify the SASL file.

By default, sfront creates a file `sa.c`, a C program that, if compiled and executed, produces the audio output specified by the SAOL and SASL code. We direct the output to the audio file `output.wav` by using the -aout option.

Finally, since MP4-SA is a compression format, we would also like to create a compact version of the ASCII SAOL and SASL files, for efficient transmission and storage of the example. We create the MP4-SA binary file `sine.mp4` using the -bitout option.

We show the files created by sfront on the right panel. The `sine.mp4` doesn't have a link, since as a binary file it may crash certain Web browsers if displayed as an ASCII file. Note that `sine.mp4` is 143 bytes in length, but encodes both `sine.saol` (286 bytes) and `sine.sasl` (26 bytes) within it.

Next, we compile the generated `sa.c` file, and run the executable `sa`. This produces the audio file `output.wav`. If you are connected to the Internet, and if your Web browser is set up to handle audio files, you can click on the link to listen to it.

Finally, by dividing the size of the `output.wav` file (288044 bytes) by the size of the `sine.mp4` file (143 bytes), we compute effectiveness of MP4-SA as a lossless compression format. This calculation yields a compression ratio of 2014 -- about 100 times better than a perceptual encoder like MPEG 2 Level 3 (MP3) would do on this example!

## Running sfront:

    sfront -orc sine.saol -sco sine.sasl\
    -bitout sine.mp4 -aout output.wav

## Creates the files:

##

##

    sa.c [30636 bytes]

    sine.mp4 [143 bytes]

    Compiling and executing sa.c:

    gcc -O2 sa.c -lm -o sa ; ./sa

    Creates the file:

    output.wav [288044 bytes, a Web link]

## Playing a Melody

In this section, we rewrite the SAOL and SASL programs to play a melody with the sine-wave oscillator. We also upgrade the audio output to DAT quality, and eliminate the annoying click at the start of each note. To implement these improvements, we take full advantage of SAOL's ability to express computation that runs at different time scales.

##

The right panel shows the new SAOL program. The file begins with a global block, an optional part of a SAOL program that controls the execution environment of all SAOL instruments.

In this global block, we initialize two SAOL system parameters, srate (the audio sampling rate, or a-rate) and krate (the control rate, or k-rate). Note that parameter initializations do not include an = operator.

The remainder of the file holds the instr `vtone`, an enhanced version of the sine-wave oscillator instr `tone` from the previous example.

The first change is evident in the instr preamble: `vtone` has the parameter `num`. An instr parameter is an i-rate variable. When an instr instance is created by a SASL instr command, its parameters are set to initial values provided on the SASL score line.

In this example, the parameter `num` sets the pitch of the note, using MIDI note numbering (integers from 0 to 127 that map to notes on the piano keyboard, with 57 mapping to A below middle C).

The main body of `vtone` begins with declarations for 6 ivar variables (for i-pass computations), 1 ksig variable (for k-pass computations), and 3 asig variables (for a-pass computations).

In this example, comment banners partition the code block for `vtone` into separate sections for i-pass, k-pass, and a-pass code. This convention greatly improves the maintainability of SAOL programs. We now look at each section in turn, to introduce the interaction between time scales in SAOL programs.

The i-pass section of an instr executes as soon as a new instrument instance is created. During `vtone`'s i-pass, assignment statements set the values of the 6 ivar variables. In the rest of the code block (k-pass and a-pass sections) these ivars will appear on the right-hand side of k-rate and a-rate assignment statements. In this way, an i-pass serves to pre-compute values once that may be used millions of times.

We now look at the i-rate assignment statements in detail. The first statement computes the value of the oscillator frequency control variable `a`. This statement introduces SAOL opcodes which are similar to C functions. The simple opcodes used here (the trigonometric function sin and the conversion routine cpsmidi) are part of the SAOL core opcode library. The opcode cpsmidi converts a MIDI note number into a frequency (in Hz).

This statement also introduces SAOL standard names. Standard names are read-only variables that convey status information. The s_rate standard name used in this example holds the value of the a-rate (defined in the global block as 48 kHz).

The remaining assignment statements in the i-pass block specify characteristics of the amplitude envelope that shapes the sine wave. The first two statements set default attack and release times for the envelope. The remaining code handles the case where the duration of the note is too short for these defaults; it uses the dur standard name, that holds the duration of the note (in seconds, not beats).

The k-pass section of this example generates the envelope waveform. Since the envelope changes slowly in time relative to the audio sampling rate, we compute an envelope value during the k-pass, and apply it to samples generated in the following set of a-passes. To avoid the "zipper noise" that may happen if amplitude changes abruptly, we use a fast k-rate of 417 microseconds (set in the global block).

To compute the envelope samples, we use core opcode kline, which is specialized for piece-wise linear waveshapes. The parameters of the kline opcode alternate between the end-point values of the linear envelope (0 and 1 in this example) and the durations of the linear segments (computed during the i-pass).

Finally, the a-pass section computes the audio samples of the sine wave. Apart from scaling the final output by the envelope, this code is unchanged from the `tone` instr in the first example.

`

## vsine.saol

    global {
      srate 48000;   // DAT-quality
      krate  2400;   // 417 us
    }

    //
    // instr vtone
    // shaped sinewave
    //

    instr vtone (num) {

      // declarations

      // envelope settings
      ivar atime;   // attack
      ivar rtime;   // release

      // internal env state
      ivar attack;
      ivar release;
      ivar sustain;

      ivar a;       // sets osc f

      ksig env;     // env output

      asig x, y;    // osc state
      asig init;

      // **********************
      // computed during i-pass
      // **********************

      // turns MIDI number into
      // oscillator constant

      a = 2*sin(3.1415927*
    	    cpsmidi(num)/s_rate);

      // envelope computation

      atime = 0.3; // attack time (s)
      rtime = 0.2; // decay time (s)

      // computes envelope state

      if (dur > atime + rtime)
        {
          attack = atime;
          release = rtime;
          sustain = dur - atime
    	- rtime;
        }
      else
        {
          attack = dur/2;
          release = dur/2;
          sustain = 0;
        }

      // **********************
      // computed during k-pass
      // **********************

      env = kline(0, attack, 1, sustain,
    	      1, release, 0);

      // **********************
      // computed during a-pass
      // **********************

      if (init == 0)
        {
          x = 0.25;
          init = 1;
        }

      x = x - a*y;
      y = y + a*x;

      output(y*env);

    }

`

The right panel shows the SASL file that drives the SAOL file above. This example introduces the SASL tempo command, which changes the mapping between score beats and simulated clock time. A tempo score line starts with trigger time, followed by the keyword tempo, and the new tempo value (in units of beats per second).

Next is a set of SASL instr commands that play a simple melody. On each score line, the start time, SAOL instr name, and duration fields are followed by the initial value for the `vtone` parameter `num`.

Note that the trigger time of the first instr command precedes the trigger time of the last tempo command. SASL score lines do not need to be ordered with respect to trigger times.

If you are connected to the Internet, you can listen to the audio output produced by this example by playing the file output.wav.

`

## vsine.sasl

    0 tempo 110
    2 tempo 112.1
    4 tempo 114
    6 tempo 116
    8 tempo 118

    1 vtone   1.5 52
    3 vtone   1.5 64
    5 vtone   1   63
    6 vtone   0.5 59
    6.5 vtone 0.5 61
    7 vtone   1   63
    8 vtone   1   64

    10 end

## output.wav

[505,524 bytes, on the Web]

`

## In Reverberant Stereo

In this section we enhance the previous example by adding reverberation and dynamic stereo panning to the melody line. We also add legato phrasing to the melody. In implementing these improvements, we show how to use two instrs together in a SAOL program. We introduce SAOL arrays, global variables, and user-defined buses, as well as SASL control statements.

`

`

#### The Global Block

The right panel shows the SAOL program. In the global block, we declare the global signal variable `bal`, that is used for dynamic stereo panning. Global variables in SAOL can be read and written by instr instances, and updated by SASL control commands. Global variables may be declared ivar or ksig but not asig.

This example uses two instrs. A new version of the sine-wave generator instrument (`vctone`) produces notes, and an effects instrument (`mixer`) places them in the stereo field and adds room reverberation.

In SAOL, effects instrs are not launched by SASL commands. Instead, instances of effects instrs are created at the start of program execution, along with the buses that route audio into and out of the instances.

Two statements in the global block instantiate the effects instr `mixer` and set up its audio buses. A route statement specifies that audio from all `vctone` instances sum onto the audio bus `tonebus`. A send statement creates an instance of the instr `mixer`, and sets `mixer`'s two parameters to 2 and 0.25. The send statement also creates the bus `tonebus`, that serves as the audio input to the instr `mixer`.

Since no route statement exists using `mixer`, the audio output for `mixer` adds to the default output_bus. This output_bus is a stereo bus, because we initialize the SAOL system parameter outchannels to 2 in the final statement of the globals block.

The route and send statements introduce several concepts. The first concept is that buses may be arrays (in fact, in SAOL signal variables may also be declared as arrays). However, note that the send statement that defines the bus `tonebus` does not include an array width specifier. It is possible to declare the width of a bus in a send statement, but it is not required. If the bus width is unspecified, SAOL infers it from the code in instrs that write to the bus, as we see later in this example.

A second concept introduced by the route and send statements is that instruments instantiated by a send statement have audio input as well as audio output. The standard name input, a read-only array variable, is made available in effects instruments, and holds the current value of audio sent to the instrument.

A final concept concerns the execution order of the instrs `vctone` and `mixer`. Note that if `mixer` instances execute before the `vctone` instance during the a-pass, the bus `tonebus` is read before it is written.

To prevent this problem, the SAOL language has a set of rules for execution ordering. One ordering rule states that instruments adding signals to a bus execute before instruments reading the bus, ensuring the correct execution order for simple pipeline structures. For more complex structures, the global statement sequence may be used to override this rule to achieve the desired results.

Note that since all buses are set to zero at the beginning of each a-pass, buses cannot hold audio state between a-passes.

#### Instrument `vctone`

The sound-generating instr in this example, `vctone`, is similar to the sine-wave oscillator instr `vtone` in the last example. The major enhancement is the support of legato voicing, through the variable `bend`.

The variable `bend` is declared as an imports variable. A imports variable may be assigned a new value during a k-cycle in the following ways:

1. If a global variable is declared with the same name as the imports variable, the imports variable is assigned the value of the global variable at the start of each k-pass for the instrument instance.
2. If no global variable has the same name as the imports variable, a SASL labelled control statement may modify the variable at the start of each k-cycle.

In this example, the second rule applies, as we use `bend` to signal legato voicing changes from the SASL score.

The code that implements legato voicing is found in the k-pass section of the code block. The if statement in the k-pass section checks to see `bend` has been set to a non-zero value by a SASL line, and if so recalculates the oscillator frequency control variable `a` to reflect the modified pitch value. This if statement also initializes `a` to the proper value during the first k-pass.

Finally, note that the output statement in the a-rate section has a single scalar parameter (the expression `env*y`). As a result, we infer that the width of the bus `tonebus` that this statement writes has a scalar width. If the statement had been

    output(env*y, env*y);

the bus `tonebus` would be a stereo bus.

#### Instrument `mixer`

The instr `mixer` processes the monaural `tonebus` audio bus, panning the signal in the stereo field and adding reverberation. It accesses `tonebus` through the standard name input. It places `tonebus` in the stereo field under direction of the global variable `bal`, whose value is changed in the SASL file using control score lines.

The instr `mixer` accesses the global variable `bal` through the instr signal variable `bal`, declared with type imports ksig. At the start of the k-pass for the `mixer` instance, the current value of the global variable `bal` is copied into the instr `bal`, and code in `mixer` accesses this local copy.

The variable declaration block also defines the signal variable arrays `pos` and `out`, introducing SAOL array declaration syntax.

The k-pass section of the code block shows how individual elements of SAOL arrays are addressed using C square-bracket notation. This k-pass code updates the left- and right- channel values for the panning weight array `pos`.

The a-pass section shows how unindexed arrays may be used in SAOL arithmetic expressions. In this example, the expression on the right-hand side of the assignment statement combines an array of width 2 (`pos`), an array of width 1 (the standard name input), a scalar (`wet`), and a core opcode with a scalar return value (reverb), to compute a stereo audio signal.

In this computation, all monaural signals are promoted to stereo arrays before the calculation begins. The stereo result is stored in the array `out`, and added to the stereo output_bus using an output() statement.

`

## vcsine.saol

    global {

      srate 48000;   // DAT-quality
      krate  2400;   // 417 us

      ksig bal;  // position

    // routes vctone to mixer
    //
    // ----------     ---------
    // |        |     |       |--> stereo
    // | vctone |-->--| mixer |    audio
    // |        |     |       |--> out
    // ----------     ---------

      route (tonebus, vctone);
      send(mixer; 2, 0.25; tonebus);
      outchannels 2; // stereo

    }

    //
    // instr vctone
    // shaped sinewave
    //

    instr vctone (num) {

      ivar atime;   // attack time
      ivar rtime;   // release time
      ivar attack;
      ivar release;
      ivar sustain;

      ksig env;     // envelope multiplier

      imports ksig bend; // pitch bend
      ksig numacc;  // pitch bend state
      ksig a;       // oscil constant
      ksig kinit;   // first k pass flag

      asig ainit;   // first a pass flag
      asig x, y;    // state vector

      // **********************
      // computed during i-pass
      // **********************

      // envelope computation

      atime = 0.3; // attack (sec)
      rtime = 0.2; // decay (sec)

      // envelope state

      if (dur > atime + rtime)
        {
          attack = atime;
          release = rtime;
          sustain = dur - atime - rtime;
        }
      else
        {
          attack = dur/2;
          release = dur/2;
          sustain = 0;
        }

      // **********************
      // computed during k-pass
      // **********************

      // computes envelope

      env = kline(0, attack, 1, sustain,
    	      1, release, 0);

      // computes sine const
      // does pitch bend

      if ( !kinit || bend)
        {
          if (!kinit)
    	{
    	  numacc = num;
    	  kinit = 1;
    	}
          if (bend)
    	{
    	  numacc = numacc + bend;
    	  bend = 0;
    	}
          a = 2*sin(3.1415927*
    	cpsmidi(numacc)/s_rate);
        }

      // **********************
      // computed during a-pass
      // **********************

      if (ainit == 0)
        {
          x = 0.5;
          ainit = 1;
        }

      x = x - a*y;
      y = y + a*x;

      output(env*y);

    }

    // instr mixer
    // adds reverb, panning

    instr mixer (rt60, wetdry) {

      ivar wet,dry;
      imports ksig bal;
      ksig pos[2];
      asig out[2];

      // **********************
      // computed during i-pass
      // **********************

      wet = wetdry;
      dry = 1 - wetdry;

      // **********************
      // computed during k-pass
      // **********************

      pos[0] = dry*(1 - bal);
      pos[1] = dry*(bal);

      // **********************
      // computed during a-pass
      // **********************

      out = pos*input +
    	 wet*reverb(input[0], rt60);

      output(out);

    }

`

The right panel shows the SASL file that drives the SAOL file above. The file begins with a set of SASL instr lines that play a melody on the instr `vctone`. Two lines are labelled for later reference. This example introduce the label syntax for SASL: a label name, followed by ":", at the start of the instr command.

Next are two labelled control commands. Labelled control statements start with a trigger time, followed by a label defined earlier in the file and the keyword control. The label is used to direct the control change to a particular instrument instance.

The final two fields of the labelled control commands are the name of variable to change, and the new value of the variable. This variable must be defined, with type modifier imports, in the instr launched by the SASL score line associated with the label.

In this example, the labelled control commands modify the `bend` variable of `vctone` instances. K-rate code in `vctone` senses the change and shifts the frequency of the sine-wave oscillator, implementing a legato transition to a new note number.

This example also introduces SASL unlabelled control statements. A set of 5 control statements alter the k-rate global variable `bal`, changing the spatial position of the melody in the stereo field. In this encoding 0 is hard left, 0.5 is center, and 1 is hard right. We use unlabelled control statements because the instr `mixdown` that performs the panning is instantiated with a SAOL send statement, not a SASL instr command, and so there is no instantiation score line to label.

If you are connected to the Internet, you can listen to the output of this SAOL and SASL program pair by playing the file output.wav.

`

## vcsine.sasl

           1   vctone  1.5 52
           3   vctone  1.5 64
           5   vctone  1   63
    ver  : 6   vctone  1   59
    rain : 7   vctone  2   63

    6.5 ver control bend 2
    8   rain control bend 1

    0 tempo 120

    1   control bal 0
    3   control bal 0.2
    5   control bal 0.5
    6   control bal 0.8
    7   control bal 1

    10 end

## output.wav

[960,124 bytes, on the Web]

`

## Conclusions

These three examples have introduced, in simple form, most of the basic techniques of SAOL and SASL programs. Notably absent are commands relating to SAOL tables, which are variables specialized for audio samples, and information on user-defined opcodes. Also missing are the syntax and semantic rules for SAOL, especially in regard to variable rates and widths and bus widths. The rest of the book revisits SAOL and SASL in systematic detail, showing all the options and usage rules.

Next: Part II: The SAOL Language

`

`

Copyright 1999 John Lazzaro and John Wawrzynek.