Tutorial 7 : AMP and LAYER page information

            Summary
            -------

            So far, we've covered most of the elements found in a basic
            synthesizer model.  In addition to this programming, the
            K2000 provides a number of programming options that allow
            extension of this model.  In this tutorial, we will be
            examining the AMP and LAYER pages, which gives us control of
            amplitude modulation and program-user interaction.

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

            We've already worked with the AMP page -- we used it to
            create an LFO-based tremolo guitar sound in Tutorial 5.  The
            information on the AMP page can be used for the following:

            o    Proper Gain Stage Adjustment
            o    Key-based Volume Changes
            o    Velocity-based Volume Changes
            o    Modulation-matrix Volume Changes

            The fields on the AMP pages are basically controls used for
            an amplifier in the K2000 patch system.  The Adjust: field
            controls the output gain of this amplifier.  As with any
            amplifier stage, caution should be used when adjusting this
            parameter, since distortion can be the result of too much
            gain.  Although, distortion can sometimes be good! (insert
            evil grin here...)  There is also a Pad: field that allows a
            gain reduction prior to this amplifier section - great if
            previous gain stages are overloading this amplifier.  This
            can often happen when using serious filtering, when a
            resonant filter can force a particular sound to peak by over
            20dB.

            The KeyTrk: and VelTrk: fields are used to modify the output
            of this amplifier stage based on key position and key
            velocity, respectively.  The use of velocity tracking is
            obvious, but deserves discussion.  In most cases, we will
            want a hard hit key to be louder than a soft one.  However,
            in some cases (like drum patches), we will want extreme
            changes in volume, while in others (like synth pads), we
            will want a more moderate amount.  Also, in instances of
            exact analog replications, you should not use any velocity
            tracking.  Most analog (and early digital) synthesizers we
            not velocity sensitive, and maintained that same volume
            regardless of the player's style.

            Finally, the AMP page contains the SRC1: and SRC2:
            modulation system that we saw in other K2000 patch pages.
            The modulation matrix increases, but so does the flexibility
            of our programs.  The Patch Runs will examine a few
            additional options for AMP page control modulation.

            The LAYER page, initially, seems to contain too many
            controls.  There is a bit of everything.  Before we look too
            closely, let's touch on what layers represent.  The K2000
            allows you to create programs with multiple layers, up to
            three layers for a regular program, 32 in the case of "drum
            layer" programs.  Each layer is the equivalent of the
            patches we've been creating.  In future tutorials, we will
            be discussing the options available with layering.  However,
            the LAYER page also contains information that we can use
            with our single-layer programs.  Many of the fields on this
            page are used to limit when the layer will sound.  This
            includes the Hi/LoKey and Hi/LoVel: fields, Min/MaxDly and
            DlyCtl: fields, the Enable: and EnablS: fields and the
            Opaque control.  These will be covered in more depth in a
            future tutorial.  The remaining fields, however, are useful
            for single-patch programs.

            The PBMode: field provides interesting pitch bend options,
            including a steel guitar-style bend.  For our single-layer
            patches, the fields on the right column are the most
            important.  The SusPdl:, SosPdl: and FrzPdl: fields
            determine if the patch will respond to the Sustain,
            Sostenuto and Freeze pedal MIDI control messages.  While
            most of us are familiar with the Sustain and Sostenuto
            pedals (since there are jacks for 'em on the back of a K2000
            keyboard), most people don't understand the Freeze message.
            Basically, the Freeze MIDI "on" message (MIDI message 69)
            will stop all envelope decay to stop, and sustain at that
            level until the "off" message is received.

            The final three fields determine how a note will be played
            if it is released before the AMPENV envelope has run through
            the sustain phase.  This allows us to create percussion
            sounds (and other types of sounds) that will sound
            completely until some envelope action is complete.
            Realistically, few people hold drum sounds to their entire
            conclusion, and MIDI drum players don't hold the notes at
            all!  Hence, the K2000 needs to know how long to hold notes
            that are hit for a very short duration.  By default, the
            note will immediately enter the release phase of the AMPENV
            when the note is released.  The IgnRel:, ThrAtt: and TilDec:
            fields will change this program default.

            Let's hear some of these controls in the Patch Run sections.



            Patch Run #1 : AMP Page manipulation.

            These Patch Runs will utilize patches prefaced with
            "[ddg]07/nn", where nn is the number of the patch run.  Load
            the patches, and select patch "[ddg]07/01 amp 1".  This is a
            very basic analog-style synth patch, with a little pitch
            modulation, and no effects.  I've turned off all effects for
            the patch to allow us to hear subtle gain changes.

            Enter the patch editor, and select the AMP page by pressing
            the [more>] button, then hitting the [F4 Gain] soft button.
            This page is formatted similar to the Pitch and Filter
            Cutoff pages, with basic key tracking, velocity scaling and
            modulation options.

            Let's explore the preset tracking options.  By default, the
            KeyTrk field is set to 0 dB, and the VelTrk is set to 20dB.
            This means that a basic patch will not change gain based on
            the MIDI note number, but will be sensitive to velocity
            changes.  As patch explorers, let's make some more drastic
            changes to these options.

            First, change the KeyTrk field to 2.00 dB/key.  BEFORE
            PLAYING, USE CAUTION!  If you are using headphones, or are
            running through a high gain amplifier, turn the volume down!
            Now, play some notes across the keyboard.  You should notice
            that the low notes have become much softer, while the high
            notes are much louder.  This is an extreme example, but
            helps you to better hear the effect of keyboard tracking.
            You will notice that C4 (Middle C for Kurzweil) is at our
            original volume, with gain rising and falling across the
            keys.  While a single layer patch may not use keyboard
            tracking much, we will be using it much of the time when
            working with multi-layer patches.  Return the KeyTrk field
            to 0dB before continuing.

            Next, set the Gain: field to 12 dB.  This makes the entire
            patch quite louder.  Move the cursor to the VelTrk field,
            and set it to 60dB.  Now, play a few notes with widely
            differing velocities.  Velocity track determines the
            variance of modulation (in this case, gain) that velocity
            will apply.  If the VelTrk field is set to 0dB, there will
            be no difference in gain between soft and hard keyboard
            hits.  When we set the VelTrk parameter to 60dB, there is a
            60dB difference between soft key hits and hard ones.  The
            "base" point of this modulation is the Gain: field, which
            represents the maximum gain that will be achieved via
            velocity tracking.

            This is another case of basic modulation technique -- in
            this case, we programmed the "least" effected part of the
            sound using the Gain field, then modulated it positively
            with the VelTrk parameter.  To see the opposite effect, set
            the Gain field at -12, and the VelTrk parameter to -20.

            Notice that the effect is opposite.  In this case, we
            programmed the "most" effected parameter in the Gain field,
            then modulated negatively to "lower" the intensity.  This is
            a principle that we will often be using for patches - either
            setting a "low effects" base, and modulating positively for
            more effect, or setting a "high effects" base, and
            modulating negatively to reduce the effect.  Return the Gain
            to 6dB, and the VelTrk to 20dB before moving on.

            Finally, let's explore some modulation.  Set the SRC2: field
            to LFO1, Depth to MWheel, and the MinDpt and MaxDpt controls
            to 0dB and 5dB respectively.  Play a single note, while
            increasing the Mod Wheel setting.  We've just added a Mod
            Wheel based tremolo effect, with a relatively light effect.
            To intensify the effect, change the MaxDpt control to 20dB.
            However, notice that this makes the overall sound *very*
            hot, and hurts our sensitive ears.  Also, the lowest part of
            the sound never completely disappears - which may be an
            effect we want.  What to do?  Well, try changing the Gain to
            -40, and the MaxDpt to +46.  Now, as the LFO max hits its
            peak, it will apply a +46 gain modulation to a -40 base gain
            setting, resulting in a +6 overall gain.  Conversely, when
            the LFO is at its lowest point, it will apply a 0dB
            modulation to a -40 base gain for (you guessed it) a -40dB
            overall gain.  Pretty quiet, that...  When using modulation
            on the AMP gain stage, experimentation is the key to
            success.



            Patch Run #2 : Layer Page manipulation.

            Select the patch labeled "[ddg]07/02 layr1".  This is an
            electric guitar patch, with a long release time.  We will
            use this sound to experiment with some of the options
            available on the Layer page.

            Enter the Layer page, and move the cursor to the PBMode:
            field.  This has two standard options, and one interesting
            one.  Currently, the field is set to ALL.  Hit a chord, then
            move the Pitch Bend wheel.  The pitch changes, as you might
            suspect.  Change the contents of the field to OFF.  Hit a
            chord, and move the Pitch Bend wheel again.  No change in
            pitch.  This field allows us to override the default Pitch
            Bender -> Pitch modulation routing.  Now, the fun one.
            Change the PBMode: field to KEY.  Hit a chord, then release
            all but one note.  Move the Pitch Bender.  The only note
            that bends is the note you are holding!  This is the secret
            to steel guitar licks, as well as sitar and other "world"
            instrument emulation.  Also works great with ethereal pads
            and ambient backgrounds.

            Next, select the patch "[ddg]07/02 layer 2".  This is a
            patch that has a unique combination of looped samples,
            interesting filtering and deep effects.  Play a note and
            hold it.  Sounds interesting, unless you release the key
            before the "movement" has completed.  This is an example
            where we would like to ignore the release of the key, and
            just let the sound ring to its natural conclusion.

            In the patch editor, move to the Layer page, and move the
            cursor to the IgnRel: (Ignore Release) field.  Set this to
            ON.  Now, when you hit a key, the entire "movement" will be
            performed.  This setting should only be used on notes that
            will "die off" on their own - the K2000 basically ignores
            MIDI Note-On messages, and will ring the note "forever"
            unless the AMPENV (or some other modulator) shuts the sound
            down without requiring a release stage.  Patch "[ddg]07/02
            badrel" is an example of a patch that just won't let go!
            (To make a note stop sounding, your only option is to hit
            the [PANIC] soft key on the Program Select display)

            First, turn IgnRel: to OFF.  This will allow the sound to
            move through the release stage.  However, now we are
            required to hold the key throughout the entire effect.
            Instead, we can use the ThrAtt and TilDec fields on the
            Layer page.  The ThrAtt and TilDec fields are similar.
            ThrAtt (Hold Through Attack) will force a sustain through
            the initial (first) attack stage before jumping to the
            release stage, while the TilDec (Hold until Decay) field
            will force the patch to move through the all three attack
            stages.  Modify "[ddg]07/02 badrel" by changing these
            fields.  Hit short notes, and hear the effect of each.
            ThrAtt will cut quickly (in this case, only reinforcing the
            long attack), while TilDec will hold the note much longer,
            allowing the entire AMPENV attack structure to be run.

            Note that, in both of these cases, the release phase of the
            envelope is run at the end of the patch sounding.  This is
            never the case with IgnRel, which never sees a Note-Off
            message, and hence never hits the Release stage of the
            AMPENV.  When doing various patches, keep this difference in
            mind.  Typically, I'll use IgnRel for percussion sounds,
            which I set up with decay envelope stages that will end at
            the 0 level.  IgnRel limits that amount of control a
            keyboard player will have on the sound, since the duration
            of the note must be programmed into the sound itself.  I
            will use the ThrAtt and TilDec fields to reinforce certain
            envelope effect that I may have programmed, without totally
            eliminating the release phase of the AMPENV.  This is great
            for slowly building pads or filter effect, which require the
            entire movement of an envelope, but which I also need to be
            able to control duration (sustains) from the keyboard.



            This has been a pretty short tutorial, but a very important
            one.  Use these ideas to modify your own patches, or to
            change patches from previous tutorials.

            Darwin Grosse
            ddg@wi.rr.com





            *******************************************************
            BONUS! BONUS! BONUS! BONUS! BONUS! BONUS! BONUS! BONUS!
            *******************************************************

            As you may have noticed from past tutorials, I'm a big fan
            of modulation.  I'm nutty about any synth that gives me
            unique mod options (that's why my collection includes the
            K2000, an Xpander, a Jupiter-6, a Pro-One, a Waldorf
            Microwave among others), and I take every advantage of
            modulator usage that I can.

            The K2000 has the unique ability to use any number of MIDI
            controllers simultaneously - rare even among current
            synthesizers.  Yash created the following mini-tutorial, and
            I'm adding it here, with the hope of spreading the
            "modulator message".  Enjoy!

            [ddg]

            [From:nursingh@clyde.ens.insa-rennes.fr]

            On the K2k the number of physical controllers sometimes
            seems limited.  With a patch which uses say the MODWHEEL for
            vibrato, DATA SLIDER for opening a filter cutoff frequency,
            and aftertouch for resonance, nearly all realtime
            controllers are taken up.What if you want to be able to
            modulate yet another parameter of that patch in a multi-
            timbral sequence ?

            Some sequencers, like CakeWalk offer the possibility of
            drawing modulation information and this is then applied to
            the parameter in question.  The ideal way to do this would
            be to be the proud owner of a multi-slider controller like
            JLCooper's FaderMaster or Peavey's PC1600. These have a
            special learn mode that practically "learn" the SysEx
            messages and do the  slide-to-parameter routing
            automatically.

            Here's a way to achieve *nearly* the same power with just
            the K2k and a sequencer.

            The situation is as follows : ModWhl, DataSlider, Pitch Whl
            and MPressure are all taken up. Still, you need to have
            control over a certain parameter, at least for the lifespan
            of the sequence.

            What you need is to use one of those midiXX or CTRLX
            controllers as SRC for the parameter you need control over.

            Next, go to the Layer Page and switch ModWhl(or something)
            so as it does not send modulation wheel info but the midiXX
            or CTRLX you chose earlier. Don't worry, this is only
            temporary.





            Then when recording your sequence, use the ModWheel to
            control the parameter in realtime. The sequencer will store
            the modulation as midiXX or CTRLXX.

            You can then switch back to the usual Physical MWheel ->
            modulation routing on the Layer page, so that any Mwheel
            modulation made earlier in the sequence are retained.

            Yash