Tutorial #1 - The Basic Patch : AmpEnv

            Overview
            --------

            A synthesizer tone, left to its own devices, would sound
            purely and loudly forever.  Since we have a tendency to like
            music to have discrete duration (like, no greater than CD
            length!) and dynamics (like Mom yelling "KEEP IT QUIET UP
            THERE!"),  the first tutorial will cover amplitude (volume)
            control, with emphasis on the Amplitude Envelope.

            The "Patch Run" section of this tutorial will utilize
            patches from the file TUTOR_01.KRZ (sometimes called
            DDGT0001.KRZ, available at an FTP site, WWW site or
            mailserver near you.


            Technical Discussion
            --------------------

            Some of the simplest programmable synthesizers are the old
            analog mono synths.  They were big enough to have lots of
            knobs, there was a set signal patch (typically silk-screened
            into the front panel) and they had a great sound.  Your
            Kurzweil K2000 has a great sound, but neither programming
            knobs nor a set signal path.  There isn't much we can do
            about the knobs (unless some brave soul wants to design a
            *monster modification*), but we can limit ourselves to a
            specific signal path -- at least for now.

            The typical basic analog synth had the following signal
            path:

            [oscillator] --> [filter] --> [amplifier] --> *output jacks*
                                                ^
                                                |__[envelope generator]

            Following the signal path from left to right, here is what
            each module does:

            Oscillator
            ----------
            The oscillator creates a tone.  This tone is typically
            pitched according to the key that the player hit.   In
            synthesizer lingo, the oscillator is often called a VCO
            (voltage controlled oscillator) or DCO (digitally controlled
            oscillator).  In general, and to avoid confusion, the K2000
            oscillators will be abbreviated as OSC in most diagrams.

            Filter
            ------
            The filter colors the sound.  Imagine a tone control (on
            your stereo, for example).  This filter (or tone) control is
            the primary mechanism used to color the sound of the
            oscillator, and is why old analog filters are considered so
            desirable.  An example of filtering would be the "burbling
            synths" so often heard in techno and pop recordings.  By
            varying the amount and frequency of the filtering, the
            synthesizer tone is drastically changed - often in realtime.
            Synthesists often refer to the filter as a VCF (voltage
            controlled filter).  In these tutorials, the filters may
            be abbreviated as FILT.

            Amplifier
            ---------
            The amplifier is literally a volume control for the
            oscillator (as passed by the filter).  Without this
            amplifier, an oscillator will continue ringing indefinitely
            at the last pitch sounded.  Since we generally want the
            sound to start and stop at specific times, the amplifier
            sections needs to be "turned up" and "turned down" in
            relation to the playing of the synthesist.

            Generically, the amplifier section of a synthesizer is known
            as a VCA, for Voltage Controlled Amplifier.  We will
            abbreviate it as AMP.

            Envelope Generator
            ------------------
            In the case of a straight oscillator-filter-amplifier signal
            path, the sound will start on the first key press and
            continue at full volume until the key is lifted.  This works
            great for an organ, but doesn't give us any flexibility in
            performing swells or blips without constantly riding the
            volume knob.  What is needed is an automated volume knob --
            one that can sense when a key is hit, then swell into a warm
            pad or chop off the note for a staccato feel.  All modern
            synthesizers contain one or more envelope generators, which
            are basically "automated knob turners".  These envelopes
            allow you to express the amounts of change over time.  In
            the case of an envelope modifying the amplifier, you are
            able to define the following:

               How long it will take the sound to get to maximum volume
               (allowing notes to swell).

               How long it will take the sound to stabilize, and at what
               volume (allowing pads with sharp attacks).

               How long a sound will sustain while you hold the key down
               (allowing infinite sustain, or not!)

               How long it will take to fade to silence after you
               release the key (allowing notes to be automatically
               legato).

            These four definitions are called the Attack, Decay, Sustain
            and Release stages, and envelopes are often called ADSR's .
            Each of the stages will have a time and a level definition
            *except for the release stage*, since the note should always
            end at silence.  For argument's sake, imagine the following
            patch:

                 You wish to create a string patch that will slowly
                 swell to a very high volume, then drastically drop in
                 volume to a static level until you let go of the note.
                 You then want the note to slowly fade away.

            If you examine your patch requirements, you can break them
            into the four stages listed above.  The stages would be
            defined:

            Attack Time:
                 Long; you want it to take some time to swell in.

            Attack Level:
                 High; you want it to swell to a peak.

            Decay Time:
                 Short; you want a drastic (fast) drop in volume.

            Decay Level:
                 Mid-low; you want it low, but still audible.

            Sustain Time:
                 Infinite; you want it to sustain as long as you hold a
                 key.

            Sustain Level:
                 Mid-low, you want to maintain a low, but audible,
                 volume.

            Release Time:
                 Long; you want a slow fade out.


            It's important to understand what action triggers each stage
            of an envelope:

               Attack is triggered by hitting a note.
               Decay is triggered by the completion of the Attack
               segment.
               Sustain is triggered by the completion of the Decay
               segment, and continues until the note is released.
               Release is triggered by note release, and continues until
               silence is reached.

            Remember, the envelope is not the amplifier.  Rather, the
            envelope "turns the knobs" on the amplifier -- what synth
            guys call modulation.  Modulation is the key to creating
            dynamic and animated sounds, and is an area where the K2000
            excels.

            On a K2000, there is an envelope generator specifically
            designed for modulation of the amplifier - called the
            AMPENV.  The majority of this tutorial will consider uses
            for the AMPENV envelope, and various modulation options.

            The K2000 has taken the standard ADSR envelope and greatly
            expanded it - breaking the Attack and Release stages into
            three segments.  Also, the sustain portion is never
            displayed - it is assumed with the following rule:

                 If the decay level is greater than zero, the level will
                 be held steady until the note is released.  If the
                 decay level is zero, the sustain and release stages
                 will never be used, since the note is already silent.
                 In the Kurzweil manuals, the envelopes are said to have
                 three sections: attack, decay and release.  However, a
                 good sound designer will always keep the sustain stage
                 in mind when producing a patch.

            Also, the attack and release stages' three sections don't
            all have to be used - or even set up.  If you are going to
            make linear transitions between volume levels, other stage
            segments' times can be left at zero - which causes them to
            be ignored.

            LET'S DO SOME PATCHES!!!



            Patch Run #1 - Bass Tones

            This "Patch Run" will utilize the first four patches, each
            prefixed with "[ddg]01/01".  You should load the patches
            into your K2000 (typically in the 200's bank) in order to
            work along with this tutorial.

            The first patch, labeled "[ddg]01/01 env 1" is a simple,
            Juno-style bass patch, with a smooth chorus effect.  Before
            we dig too deeply into the AMPENV structure, let's examine
            the patch in some detail.  Select it as your current patch
            in the program display.

            To edit the patch, hit the [EDIT] button.  The display will
            now show the "algorithm" -- Kurzweil's method of
            displaying the signal flow.  You will notice that the
            algorithm used is suspiciously similar to the analog model I
            covered earlier.  There is a pitch block - which contains
            the controls for the oscillator.  The center block is listed
            as a "4POLE LOWPASS W/SEP" -- which means that it is a
            lowpass filter (one that will pass low frequencies, and
            effect higher ones), it is a four-pole filter (which means
            that it has a more radical tonal cutoff), and it has a
            separator function (which allows the four-pole filter to be
            split into two 2-pole segments).  For now, the action of the
            filter is not important, as long as you recognize it as a
            "tone control" block.

            The final block of the algorithm is the AMP block, which
            contains our amplifier controls.  In order to view the basic
            AMP controls, hit the [more>] "soft" button once, then hit
            the [F4 AMP] soft button.  The display will list a number of
            parameters, a few of which we should understand:

            Adjust:
                 The Adjust value provides a simple way to control the
                 overall volume of this algorithm.  There are two
                 primary uses for the Adjust parameter.  First, you want
                 to set up a patch to be roughly equivalent in volume to
                 other patches - this prevents you from having to
                 constantly "fiddle" with your mixer on each patch.
                 Secondly, if you are creating a layered patch (one with
                 several oscillators), this will allow you to adjust
                 each layer's volume as required.

            KeyTrk:
                 Key tracking allows you to have this patch's volume
                 increase or decrease based on the note being played.  A
                 positive amount will make the volume higher as you play
                 higher notes, while a negative amount will decrease the
                 volume as you play higher.  Note that, while the name
                 makes it seem like the keyboard is the control source,
                 it is actually repsonding to the MIDI note number
                 value.

            VelTrk:
                 Velocity tracking is similar to key tracking, except
                 that it changes the volume based on the velocity of the
                 key hit, rather than its pitch.  Most patches will
                 apply some amount of VelTrk, allowing basic "feel"
                 changes based on how hard you are playing.

            Pad:
                 This is another way of controlling the patch's volume,
                 but it is generally used when getting *crazy* about
                 internal signal levels.  The Pad drops the volume of
                 the *incoming* signal, preventing possible overload of
                 the amplifier stage.  You only tend to do this if you
                 have done some horrifying oscillator manipulation; but
                 then, you just might enjoy the overload distortion
                 anyway ;-)

            The remaining values are for external modulation of the AMP
            section, and will be covered in later tutorials.

            Since we are concentrating on the AMPENV (amplifier
            envelope) structure, we need to have it displayed.  To get
            to the AMPENV controls, press the [more>] soft button until
            you see AMPENV displayed.  Hit the appropriate soft button.
            The display will change to show a number of parameters, and
            a graphic that looks like a ski hill next to a ski jump.
            This is where we are going to spend our time...

            The parameters across the top of the screen show the various
            parameters available: ATT1-3 are the attack stages, DEC1 is
            the decay stage and REL1-3 are the release stages.  The
            numbers under each parameter represent the time (in seconds)
            and level (in percentage) of that stage.  Additionally,
            there is a LOOP parameter, which we will play with later.

            In order to see the effect of the parameter values on the
            display, move the cursor to the ATT1 stage (using the arrow
            keys), and adjust the time and level parameters.  You should
            see the "ski hill" change accordingly.  If you move the
            cursor to the REL1 stage and adjust the parameters, you will
            see the "ski jump" change.  Return these parameters to
            their original condition (ATT1:0s,100%, REL1:0.20,0%).

            Now, let's adjust some of the parameters, and hear the
            result.  Move the cursor to the ATT1 parameter, and change
            the time from 0s to 0.60.  Press and hold a key, and notice
            that the sound "fades in" rather than hitting at full
            volume.  Some of the most critical parameters of a patch are
            the attack options.  In this case, the sound of the patch is
            totally changed by this one parameter.

            Return the ATT1 time parameter to 0s, and adjust the ATT1
            level parameter from 100% to 0% while hitting a key.  Notice
            how the "punch" of the patch is changed with this
            adjustment.  When creating patches for your sequences, you
            will want to pay close attention to this parameter -- too
            much punch on all sounds can cause a sequence to sound
            overly aggressive, while too little can make a song sound
            limp.

            Return the ATT1 level to 100%, and move the cursor to the
            DEC1 time parameter.  Change the time to 0.80, and notice
            the patch becoming smoother.  The effect of this time
            parameter determine how "spiky" the initial attack is.
            Return the time parameter to 0.20, and move to the level
            parameter.  Change this to 25%.  Notice that the sound now
            settles to a lower level.  The decay stage sets the level
            for the sustained sound, so you should test the patch on
            longer tones.  Return this parameter to 53%.

            The release stage is also very important to the perceived
            sound of a patch.  Move the cursor to the REL1 time
            parameter, and change it to 0s.  Notice that the sound
            immediately stopped when the key was released.  Now, change
            the parameter to 1.00.  Notice the sound slowly fading after
            you release the key.  By extending the release stage of the
            AMPENV, you can create patches that automatically create
            legato lines - especially nice for string and synth pads.
            Return the REL1 time to 0.20.

            The release level is 0%, meaning that the sound will fade to
            silence.  If you adjust this parameter, you will see that
            the "ski jump" is segmented, with the first section gently
            sloped, followed by an abrupt drop to zero.  The K2000
            AMPENV always assumes that the sound will complete at
            silence - otherwise, you could only play 24 notes before
            you'd have to turn off the machine.  Generally, if you are
            only using one release stage, the level of REL1 will be 0%.

            At this point, play with the envelope until you are tired of
            it, then exit program edit mode (by hitting the [EXIT] key).
            Unless you want to save your changes, you should say "NO"
            to the "Save this patch" dialog.

            Now, select the second patch, labeled "[ddg]01/01 env 2".
            Go into edit mode, and select the AMPENV soft button.  If
            you play this patch, you will notice that the note does not
            sustain; i.e., no matter how long you hold the key, it only
            plays a specified amount of time.  On a K2000, this is done
            by setting the DEC1 level parameter to zero.  If you adjust
            any of the REL parameters, you will see that they do not
            have any effect on the sound.  However, adjusting the ATT1
            and DEC1 time parameters still give the swelling/spiking
            sound they did previously.

            One important note on this - the decay stage will only last
            as long as the key is held down.  Move the cursor to the
            DEC1 time parameter, and change it to a value greater than
            1.00.  Now, hit and release a key.  Note that you do not get
            a long decay like you did when we changed the REL1 time.  In
            order to get a note to extend beyond the time that the key
            is held, you need to implement a release stage.

            Exit the edit mode, and select the third patch, labeled
            "[ddg]01/01 env 3".  Play it a little.  In this case,
            there is a slap echo effect.  Now, rather than using the
            effects system (which would put a slap effect on every
            patch), I've implemented a slap echo in the AMPENV section.
            Go into edit mode, and select the AMPENV page.  There is a
            "Twin Peaks" attack section -- using all three attack
            stages.  I've got the envelope jumping up, then down, then
            up again.  If you imagine the envelope "turning the volume
            knob", you will understand exactly what is happening.  In
            order to adjust the time of the delay, the volume of the
            second sound, and the attack of each sound, adjust the
            parameters and listen to the results.

            Exit the third patch, and select the fourth patch --
            "[ddg]01/01 env 4".  Play this patch.  Notice how the
            sound is stable until you release it - then a little
            "reverse delay" kicks in.  Go into edit mode, and look at
            the AMPENV.  You will see that I've used the three release
            stages (REL1-3) to create a "reverse ski hill".  These
            release parameters determine the sound of the reverse delay
            sound.  Play with the parameters to change the delay
            qualities.  And remember to test it by releasing the keys.
            The release stage does not get triggered until you release
            the note!

            That's all for Patch Run #1



            Patch Run #2: Pad Sounds

            Select the patch labeled "[ddg]01/02 env 1".  This is a
            simple vocal pad, with a slower attack, and smooth release.
            Go into edit mode, and look at the AMPENV display.  Note how
            I'm using a longer attack time, and a 2 second release time.
            This gives a controllable amount of legato, and an audible
            attack.  Let's screw it up...

            Change the ATT1 time parameter to 4.00 seconds.  While you
            are adjusting that, notice that the AMPENV graphic display
            will "shift" in order to allow the entire graphic to
            display on the screen.  Now play a chord, and notice the
            "mysterious" swelling sound - great for suspended chords.
            However, releasing the notes causes too short a cutout.  So,
            change the REL1 time to 6.00 seconds to hit that Eno-level
            sustain.  Now, you are ready for a career in New Age music!

            Sometimes, a long pad sound is not animated enough.  The
            K2000, with its multi-segmented attack and release stages,
            can help us with that.  Select patch "[ddg]01/02 env 2".
            Look at the AMPENV display.  I've used all of the envelope
            stages to place subtle accents to the sound.  Hold a chord
            for a few seconds, then release it.  Listen closely, and you
            will hear nice changes that will give a little life to a
            typical pad sound.



            Patch Run #3 : Mechanicals

            Sometimes, nice pads and aggressive basses just aren't
            enough.  We've just gotta have the machinery in the
            background.  In order to simply provide this, the K2000
            comes equipped with envelope looping, a very powerful tool.

            Select patch "[ddg]01/03 env 1", and hold down a single
            note.  Muy mecanico.  Now, I've added a deep reverb and
            modulating filter to this patch to give it some "ambient
            techno" flavor, but the repeating note is totally
            controlled by the AMPENV.  Look at the AMPENV, and you will
            see that the LOOP: parameter is set to "seg1F".  This
            means that the envelope will loop forward (the F part), and
            will loop from the start through the end of the decay, then
            loop back to the first attack segment (the seg1 part).  If
            you have a more complex envelope, you can force the loop
            back to the second or third segments as well.  Also, there
            are loops that end with B - meaning that they are bi-
            directional loops.

            There is also a parameter for the number of loop repeats.
            I've used Inf (for infinite), because I want to loop this
            sound for an entire CD (to making millions of dollars in the
            techno market).  However, you can force just a few repeats,
            allowing the sound to have more animation.  In fact, you
            should try envelope looping on the pads from Patch Run #2 -
            for another animation option.

            Experiment with this sound, adjusting the times and levels,
            adding attack segments, and adjusting the loop values and
            number of repeats.

            That's all for Tutorial #1.  I hope you enjoyed it, and I'd
            request your feedback on anything you found that was good,
            bad, or of no consequence!  You can e-mail me at:

            ddg@wi.rr.com

            Thanks, and see you next week!