Tutorial #11 - Layering : Stacked Programs

            Overview
            --------

            To this point, all of the programs we have created have used
            a single Oscillator-Filter-Output order.  We've found plenty
            of interesting things to do with a basic sound to create a
            'whacked out' program.  However, often a single Oscillator-
            to-Output stream will not give us enough variety to create
            the sound we (or a pushy producer) might require.  In these
            instances, we will want to use 'layering', a technique that
            allows us to use a number of independent patch 'pipes', in
            various combinations, to create a more complex patch than is
            possible with a single patch layer.

            Let's examine the concept of synthesis 'pipes' _ an apt
            paradigm for the K2000's layering system.  In a plumbing
            system, the contents of a pipe's output is a combination of
            a number of water sources.  A single pipe can be fed from
            pumps and other 'feeder' pipes.  There are a few basic
            plumbing truths _ the output of a pipe is never 'less' than
            its inputs, and the composition of the output is a
            proportionally related to contents of the inputs.

            Well, this paradigm does break down a little.  First, unless
            too much amplitute is applied, a K2000's synthesis output
            seldom 'leaks'.  And your neighbors will probably not spoil
            your program's output by flushing the toilet.  However,
            there are some interesting parallels.  First, like a
            plumbing system, the output of a synthesizer is continuous
            unless stopped (or gated).  Secondly, addition of a number
            of synthesis elements will result in a harmoically 'greater'
            output.  Finally, the harmonic output of the synthesis
            'pipe' will be in direct proportion to the amplitude of the
            input that you use.

            That was a nice little parable, but it does give us
            visualization tools to use when working with layering.  So,
            throughout the next several tutorials on layering
            techniques, I'll be drinking from the plumbing paradigm
            (sorry for the pun!) to help explain various layer options
            we use.  However, if you prefer, you can just replace my
            goofy visualization with one of your own;  rivers,
            electrical wiring, or Donkey Kong balls_





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

            Layering techniques really involve little synth programming,
            per se.  However, they do require a good ear, and an
            understanding of how multiple audio signals interact.  We
            will experiment with some audio interaction in the patch
            runs, but we do need to understand some of the basics of
            patch layering on the K2000.

            A layer is simply a single Oscillator->Output stream.  All
            of the programs we've created in previous tutorials have
            been single-layer programs.  For the next few tutorials, we
            will be creating multiple-layer programs.  The K2000
            supports two types of multi-layer programs _ 'standard'
            programs (with a maximum of 3 layers), and 'drum' programs
            (with a maximum of 32 layers).  In this tutorial, we will be
            dealing only with 'standard', 3-layer-max programs.

            When dealing with multi-layer programs, you will need to
            manipulate its content by adding, modifying and deleting
            layers.  Again, remember that each of these layers is like
            one of the patches that we've created in earlier tutorials.
            Within the program editor, you have the following options:

            NewLyr (New Layer)
            This allows you to create a new, 'defaulted' layer.  Per the
            manual, this new layer contains the parameters of Program
            199 (called 'Default Program').  Since this default layer is
            a good starting point for a basic layer (since it doesn't
            have radical modulations or DSP functions), it is
            appropriate for creating a layer that is significantly
            different from existing layers.

            DupLyr (Duplicate Layer)
            This option also creates a new layer, but loads it with the
            contents of the current layer (the layer you are 'looking
            at' in the program editor).  This is most useful when you
            wish to create a layer that is similar to an existing layer
            like when you are creating octave stacks, or flange/comb
            filter programs.  We will take a look at both of these types
            of programs in the patch runs.

            ImpLyr (Import Layer)
            Importing a layer simply allows you to 'grab' a layer from
            another program, and place it into the current program.  As
            you develop a library of programs that you often use, you
            will find a number of layers that are critical to your
            sound.  Instead of constantly recreating them, you can use
            the import function to quickly apply a layer to a patch you
            are editing.

            DelLyr (Delete Layer)
            Obviously, this simply removes the current layer from a
            program.  You are prompted to verify the action, to make





            sure you don't delete a critical layer.  However, layer
            deletion is a critical function, since you will often find
            yourself modifying an existing program by removing layers
            that are not applicable to the sound you want.

            Finally, when you are in the program editor, you can use the
            CHAN/BANK (also labeled the Layer/Zone) buttons to move
            between layers.

            SO, LET'S DO SOME PATCHES!!!






            [NOTE: As in previous tutorials, these patch runs depend on
            having a continuous controller assigned to MIDI CC#6 - the
            DATA controller.  K2000 keyboard owners will generally have
            the DATA slider assigned to this controller.  K2000r owners
            should have one of the controllers on their master keyboard
            assigned to this function.]

            Patch Run #1 - An Octave Stack

            This patch run will use the first patch, labeled '[ddg]11/01
            ocstk'.  If you play a bass line on it, you will find that
            it is a simple pulse wave sound.  It is a 'stock' sound, and
            one that you will often used for dance and pop sequencing.
            However, one of the most useful additions to a pulse bass
            sound is a sub-oscillator _ a similar tone sounding an
            octave below the original.

            In the keyboard world, these types of sounds are generally
            called 'stacks', because they were originally created by
            having a stack of expensive keyboards.  Anyone who (like me)
            grew up watching Toto videos will know exactly the type of
            stack originally implied.  Now, with the current multi-
            timbral sound modules available, we can create stacks in
            'software'.  The addition of a sub-oscillator is a very
            simple stack sound _ more advanced stacks will be examined
            later.

            OK, how do we create the sub-oscillator?  Enter the program
            editor, and select the [MORE>] button until you see the
            DupLyr label on the bottom of the K2000's screen.  Hit the
            button underneath the label, and the current layer is
            duplicated.  At the top-right of the display is a label
            showing the current layer.  In this instance, the label
            should now read 'Layer:2/2', meaning that you are looking at
            the second of two layers.  Now, move to the Keymap page, and
            change the Xpose parameter to  -12ST.  This will drop the
            sound of this layer by an octave, without changing the pitch
            of the original layer.  If you play the patch, you will
            notice that the sound has an increased depth, due to the
            new, lower sound that was added.  Adjust the relative
            volumes of the layer to create the right blend of original
            vs. sub-octave sound.  You can change the volume in a
            variety of ways _ we will use the [F4 AMP] page.  Move to
            the Amp page, and change the Adjust: field.  If you are
            still on the second layer (that is, if the label on the top-
            right shows 'Layer:2/2'), you will hear the sub-oscillator
            get louder or softer with the adjustment.  If you find a
            sound that you like, you may want to save it - otherwise,
            just exit the patch editor.






            Patch Run #2: Two Big Stacks

            Select the patch labeled '[ddg]11/02 bgstk'.  This is a
            relatively 'large' sounding patch, but it is also somewhat
            lacking in high harmonic content.  We are going to remedy
            this by adding a new, non-similar layer.

            Enter the program editor, hit the 'Layer/Zone' key to move
            to the second layer,  then add a new layer by pressing the
            [NewLyr] soft button.  This will create a third layer
            (labeled Layer:3/3).  This layer is initialized to a simple,
            non-filtered piano patch.  Not quite what we really need,
            but that's easily changed.  Move to the KEYMAP edit page,
            change the KeyMap field to #158 (Buzz Wave), and change the
            Xpose: parameter to 12ST.  This will apply a harmonically
            rich sound, and it will be raised an octave to create even
            more high-end content.  However, this high sound is now a
            bit overwhelming to the overall patch, so we need to make a
            few more adjustments.

            Move to the ALG (Algorithm) page, and change the center DSP
            option to our old favorite _ the 4-Pole Low Pass filter.
            Move to the [F1 FRQ] page, and change the Coarse: (Frequency
            Cutoff) parameter to an appropriate value - I used 2794 Hz.
            Finally, move to the AMP page, and adjust the amplitude to
            taste.  Note that none of these changes affect any other of
            the sound components _ only the Buzz Wave layer.  This is
            what allows us to completely control each component of a
            complex sound, while maintaining the integrity of program
            components that we are pleased with.

            Patch '[ddg]11/02 xfstk' is a neat, spooky patch.  If you
            play a note, and move the DATA slider while holding the
            note, you will hear the sound change from a low sine wave to
            a higher sine tone.  This was done by creating two separate
            layers, and having a single controller (the DATA slider)
            change the volume of each in opposite 'directions'.  Enter
            the program editor, and move to the OUTPUT page.  You will
            notice that the first layer (which is the lower sound) has
            the XFadeSense: parameter set to NORMAL, while the second
            layer has this parameter set to REVERSE.  This, combined
            with setting the CrossFade: parameter to the DATA
            controller, allows each layer to faded into the other.  In
            order to visualize how this is working, remember the
            plumbing paradigm;  this situation is like a pipe with two
            source pipes and a flapper valve.  If the sources were both
            shut off, you would not get any flow.  However, if the
            flapper valve is swung from one side to another, a steady
            flow is maintained by opening one source while closing the
            other_






            Patch Run #3: Coordinated, Time-Variant Layers

            Nice name, eh?

            Well, let's decode what that title means.  First, the
            'Coordinated' part obviously means that the various layers
            we will use are designed to work tightly together.  However,
            it also means that continuous controllers that are used will
            have an effect across all layers, and will create
            complimentary changes to each layer to integrate the whole.
            The 'Time-Variant' adjective means that the layers will be
            coordinated over time.  Let's look at a patch to better
            understand what is happening.

            Select patch '[ddg]11/03 time1', and hold down the middle C
            key.  We get a Martian-rhythm-section kind of wave-sequence
            sound, which is actually three layers sounding in a rhythmic
            order.  This is done through the use of LFO's and looped
            envelopes.  Now, while holding down the key, move the DATA
            slider.  You will notice that the tempo of the rhythm
            changes, but the pitch and rhythmic orientation remains the
            same.  This is much different than sampling a wave-sequence
            and pitch shifting it _ because that will cause both pitch
            and tempo to change in unison.

            Enter the patch editor, and look at the parameters used in
            the AMPENV, ENV2 and the LFO screens of all layers.  You
            will notice that they all share similar speed and length
            parameter values.  In addition, they all are using the DATA
            controller to adjust the envelope segments and LFO speeds in
            a similar fashion.  This allows the single change in the
            DATA controller to simultaneously adjust the timing factor
            for all layers.

            Let's create one of these Time-Variant programs from
            scratch.  We will be using the default layers created by the
            NewLyr function to create a piano-based 'riff' (I've
            included it as program [ddg]11/03 time2).  First, select
            program 199 (Default Program).  It is a simple, somewhat
            stale sounding piano.  Enter the patch editor, and move to
            the AMPENV page.  Change the Mode: parameter from Natural to
            User, and make the following adjustments:

                 ATT1:     0s @ 100%
                 ATT2:     0.98s @ 100%
                 ATT3:     0.02s @ 100%
                 DEC1:     1.00s @ 0%
                 REL1:     0s @ 100%
                 Loop:     seg1F

            If you hold down a key, you will now hear a piano note for
            one second out of every two.  Next, we need to provide a
            tempo change via the DATA slider.  Move to the ENVCTL page,





            and change the ATT: and DEC: fields to have a SOURCE:
            parameter of DATA, and a DEPTH: parameter of 2.000x.  This
            will allow the DATA slider to 'double' the tempo at its
            highest setting.  Hold down a key while adjusting the DATA
            slider, and note the change in the tempo of the resultant
            piano note.

            Now, use the DupLyr function to create a new layer that is
            an exact duplicate of our current layer.  This will be layer
            2/2.  If you hold down a key, you don't hear much change _
            it is simply playing two piano notes on each AMPENV loop.
            Move to the AMPENV page, and make the following changes:

                 ATT1:     1.00s @ 0%
                 ATT2:     0.02s @ 100%
                 ATT3:     0.98s @ 100%
                 DEC1:     0s @ 100%

            Now, if you hold a key down, you will hear a second fading
            note sound after the first.  Move to the PITCH page, and
            change the COURSE: value to 7ST.  This will transpose the
            second note to one fifth higher than the first.  The riff
            begins to form_

            Finally, let's create a third layer that will 'hover' over
            the first two, providing a bit of padding for the piano
            whacks.  We'll do this in steps:

            1. Use the NewLyr function to create a new layer.  This will
            be layer 3/3.  Move to the AMPENV page and change the Mode:
            to User.

            2. Move to the KEYMAP page, and select Keymap #141 (Partials
            5,7,9,11).  This will give use a weird harmonic base to use.

            3. Move to the ALG page, change the algorithm to #1, and
            change the middle DSP block to our friend, the 4-pole
            lowpass filter.

            4. Move to the [F1 FRQ] page, and change the Coarse:
            parameter to A6.  This will alter some of the higher
            harmonics until we want a change.  To create that change,
            set the Src1: parameter to LFO1, and the depth to 2600ct.
            Move to the AMPENV page, and change the following settings:

                 ATT1:     .5s @ 0%
                 ATT2:     1s @ 100%
                 ATT3:     0s @ 100%
                 DEC1:     2.48s @ 0%
                 Loop:     seg1F

            5. Next, move to the LFO page, and change LFO1 to have a
            MnRate: parameter of 0.50H, and a Shape: parameter of +Sine.
            This will modulate the filter cutoff with a sine wave, but





            only in a positive direction.  Since the LFO is not synced
            to the tempo of the AMPENV, it will change in a non-periodic
            way in relation to the AMPENV _ a useful trick in ambient
            music styles.

            6. Finally, move to the Effects page, and select a nice
            reverb or delay effects patch.  Turn the Wet/Dry Mix:
            parameter to a pretty high level.  This should fill out the
            sound, and make you an instant star on the Windham Hill
            record label.  If that doesn't work, give the FAX record
            label a call_

            You can greatly enhance the above patch if you like, or just
            throw it away.  However, the use of time-variant layers is a
            great effect, and will often 'jump start' the creative
            process when you are in a bit of a slump.  If you want more
            information about wave-sequencing options, you can check out
            the tutorial written by Yash, which is available on a Web
            site near you.

            Oh, and sorry to any owners, employees or relatives of the
            Windham Hill and FAX record labels.  Really, guys, your
            lawyers won't find anything worth taking_






            That's all for Tutorial #11.  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