Tutorial #6 - Basic Synth: Keymap Control
            ---------------------------------------------

            Overview
            --------

            In the first five tutorials, the provided programs utilized
            internal K2000 samples and keyboard mappings.  However, many
            unique effects can be produced by placing these samples on
            the keyboard differently.  Also, if you are doing your own
            sampling,  you will be required to create your own key
            mapping.  Finally, keymaps allow us to define the keyboard
            layout for percussion sets.  All of these options will be
            explored in this tutorial.


            TECHNICAL DISCUSSION
            --------------------

            In tutorial #3, we touched on the patch editor's KEYMAP
            page.  It allowed us to use a preset keymap in "scary" ways,
            by altering the transposition, key tracking and velocity
            tracking of an entire keymap.  There are a few more options
            available on the KEYMAP page that require discussion.

            First, the KEYMAP page allows us to select a keymap.  There
            is a list of 168 internal keymaps, followed by any custom
            keymaps (from loaded patches or ROM blocks).  A keymap is a
            separately created "object", and can be saved with a patch
            when it is stored to disk.

            In addition to the transposition and tracking options that
            were discussed earlier, there are four other fields
            available for keymap modification.  First is the STEREO:
            setting.  If you are using a stereo sample (which you would
            have loaded externally, since none of the K2000 ROM samples
            are stereo), this field will allow you to use it
            appropriately.

                 NOTE: The K2000 doesn't actually contain stereo samples
                 - samples that sound like stereo are actually mone
                 samples in layers, or use the effects processor.  User-
                 defined stereo samples are treated as two separate mono
                 samples.

            When this is set to ON, additional parameters are available
            in the KEYMAP editor, and an extra panning option is
            available to the patch.  Why wouldn't you want to have
            STEREO set to on?  Because a stereo sample uses two voices
            of polyphony,  halving the number of simultaneous sounding
            notes to 12!

            The remaining three fields are used to adjust the sound of
            the keymap as it is played back.  TimbreShift adjusts the
            sample playback rate to change the harmonic content.
            AltAttackCtl allows you to set a controller to change the
            start point of samples.  Finally, PlayBackMode allows you to
            play the sample normally, reversed, bidirectionally, or to
            replace the keymap samples with a white noise generator.  We
            will further explore these fields
            in the Patch Runs.

            In addition to altering the KEYMAP pages, we must also look
            at the keymap editor.  This allows us to place any sample at
            any place on the keyboard, tune or transpose it, and adjust
            its relative volume (to other samples in the keymap).  The
            keymap editor limits you to one sample per key, and assumes
            that you will have every key assigned to a sample.
            Additionally, the keymap editor allows you to set up
            velocity crossovers -- areas where different samples will
            play based on the velocity of the key hits.  This is
            especially useful for emulating percussive sounds which
            change timbre as they are hit harder.

            One important note about using the VelCrossover option:
            there is no way to tell the K2000 to make a keymap velocity
            sensitive!  In order to use this feature, you need to alter
            an existing velocity sensitive keymap.  For our editing
            purposes, the "most often used" keymap starting points are:

            No VelCrossover     : #168 Silence
            2 Position Velocity : #002 Dual Elec. Piano
            3 Position Velocity : #164 ExtDynPrtls1

            By using these keymaps as your "starting point", you will be
            able to get the velocity sensitivity you need.

            When I am programming a new patch, I almost always start
            with keymap editing.  Once your ear is sufficiently
            developed, you will be able to hear the necessary qualities
            in each keymap, or be able to create a new keymap, that will
            help you create virtually any sound you can imagine.  The
            Patch Runs will examine each of the above concepts in
            detail, and help you to become a registered "Keymap Doctor".



            Patch Run #1 : KEYMAP Page Editing.

            The patches used in this tutorial will be prefixed with
            "[ddg]06/nn", where nn is the patch run for which it
            applies.  Load the patches, and select the patch named
            "[ddg]06/01 kmap1".  Play a keyboard lead line - it sounds
            like a stock acoustic guitar sound, with a retrigger on
            every note.  Let's now use the KEYMAP page of the patch
            editor to alter the sound of this program.

            Move to the KEYMAP page, and change the KeyMap parameter
            value.  You can scan through all of the internal keymaps,
            the new keymaps from my patches, any other loaded keymaps,
            and the ROM BLOCK keymaps (if you have the ROM Block(s)
            installed).  The selection of a keymap is the basis of the
            sound your patch will produce.  After you are done
            experimenting, return the KeyMap: field to #200 ([ddg]06/01
            kmap1).

            As in tutorial #4, I suggest that you play with the XPose:,
            KeyTrk: and VelTrk: fields -- they allow you to alter the
            relationship between your keyboard and the sample pitch.
            For now, leave them set to 0ST, 100ct/key and 0ct
            respectively.  Move the cursor to the TimbreShift: field,
            and change it to -24ST.  Listen to the sample, and notice
            how the harmonic content (the "feel") of the tone has
            changed.  Changing this parameter is the equivalent of
            dropping the XPose: field by 24 semitones, then raising the
            pitch by 24 semitones in the PITCH page.  Whenever you are
            using a keymap that sounds too "clean" or too "light",
            turning this parameter down can add the heaviness or grit
            you might be looking for.  Now, change it to +12ST.  Again,
            notice the change in the basic timbre of the sound.  Moving
            this parameter higher gives the sound a "lighter" and more
            metallic quality.  Use of this field is very valuable when
            creating "image" sounds, or greatly altering samples for
            "industrial hardness".  Return the value to 0ST, and move
            the cursor to the AltAttackCtl field.

            The Alternate Attack parameter allows us to set a controller
            to change the start point of samples.  For now, just
            consider that samples can have two starting positions;  the
            first is the normal start point, the second is the alternate
            start point.  I've modified the internal samples to use more
            drastic alternate starts, and they are included in keymap
            #200.  Change the value of AltAttackCtl: to "ON", and play a
            legato line.  Notice how the sound no longer seems to attack
            at each key hit?  This is because I'm chopping off the
            beginning of each note based on the Alternate Sample Start.
            Most of the internal samples have some type of alternate
            start point for legato play.  You can set this field to be
            modified by any controller (like the ModWheel, and LFO or
            and envelope).  Other AltAttackCtl uses would be to add
            punch using a controller (by reversing the start point, so
            the normal start point does not include the punch, but
            altered notes do), changing percussion samples (removing
            some of the drum "snap" based on the velocity of the hit) or
            just some oddball ideas (using an LFO to determine which of
            two start points will be used).

            Now, select patch "[ddg]06/01 kmap2".  Play the note, and
            notice the goofy loop point - just doesn't sound right.
            I've placed a *horrible* loop point on this sound, to help
            illustrate the looping of a sample, and to help you hear the
            direction of sample playback.  Go into the patch editor, and
            get to the KEYMAP page.  Change the contents of the
            PlayBackMode: field to Rvrs, and now listen to it.
            Different, radical, but not necessarily good.  Next, change
            it to Bi-Dir.  Now, you can hear the sound ramp into itself,
            then ramp back down.  You can have a lot of fun with bi-
            directional looping - there is an implied rhythm that is
            created by this type of loop.  Finally, change it to Noise -
            instant CRASH!  This is our old pal White Noise, a useful
            tool for the intrepid synth programmer.

            Choose patch "[ddg]06/01 kmap3", and play the patch through
            a stereo headphone or stereo speaker arrangement.  What's
            this???  We have a piano coming out the left side, a synth
            out the right, but both are being affected by a filter
            sweep!  This is an evil use of stereo keymaps.  Again, the
            K2000 treats any stereo sample as two separate samples.  If
            you had a stereo sample, you would create a keymap for each,
            and enter the appropriate keymaps into the KEYMAP page in
            the patch editor.  In this case, however, I'm simply using
            two separate keymaps for the patch - something Kurzweil
            would _never_ suggest you do.  And you can see why -- there
            is no way to tune one keymap without detuning the other.
            But, seriously, since we are here to experiment, we had to
            do it!

            NOTE: Why does the synth not follow the correct key
            tracking?  I really don't know, but I suspect it has
            something to do with differing sample lengths.  I will be
            talking to Kurzweil to get an answer.



            Patch Run #2 - Keyboard Splits

            Select patch "[ddg]06/02 split", and play both sides of your
            keyboard.  The lower half of the keyboard plays an electric
            bass patch, while the upper half is a acoustic piano.  This
            is the classic example of a split patch, and is an example
            of a keymap containing two separate sample sets.  NOTE: The
            transitions of the samples in the keymaps are purposely
            audible so you can hear the changes in the keymap sections
            used.  I'm not trying to pull a fast one ... really!!!

            In the patch editor, move to the KEYMAP page.  We are using
            a custom keymap.  To edit a keymap, you hit the [EDIT] key
            while on the KEYMAP page.  This will display the first
            sample in the current keymap.

            Let's examine each field in depth.  The MasterXpose: allows
            you to transpose *all keyranges* within a keymap.  This
            would usually be done to adjust the location of keyboard
            splits.  Next, the KeyRange: fields, determine the highest
            and lowest notes that will be handled by this sample.  The
            CoarseTune: and FineTune: fields are for tuning the current
            sample, in case it was either out of tune, or needs
            transposition.  The VolumeAdjust: field allows you to adjust
            the relative volume between all samples in a keymap.  This
            is very important!  Often, beginning sampler users will grab
            samples, place them on the keyboard, and be dissatisfied
            with the sound of chords or percussion kits.  Inevitably,
            the relative volumes are inappropriate, giving a lop-sided
            sound.  When you set up a multi-sample set, make sure that
            the relative volume between samples is set up appropriately.

            Finally, the VelCrossover: field is found in multiple
            velocity keymaps.  Otherwise, the patch (like this one)
            simply displays the velocity range as "ppp-fff".  How do
            we add velocity levels?  Can't do it!  The Keymap Editor has
            no method for adding this information.  Rather, you need to
            start with the type of keymap you are trying to create, and
            modify it to suit your needs.  For grins, exit the keymap
            editor (returning you to the patch editor), and select
            Keymap #002.  Reenter the keymap editor (by hitting the
            [EDIT] key), and check out the VelCrossover section.  It now
            contains the VelCrossover: field, which tells the K2000 at
            which velocity level to change.  There is a third keymap
            type, contained in keymap #164, which allows for three
            velocity levels.  This provides you with three completely
            different samples based on the velocity of the key hit.  You
            can change the velocity range just like you can change the
            key range.

            Exit the keymap editor, reselect keymap #203 "[ddg]06/02
            split", and reenter the keymap editor.  Place the cursor on
            the KeyRange: field, and turn the data knob.  You can switch
            between the various key ranges.  In this case, there are
            several different samples in use.  This is done to provide
            the best sounding samples in each range of the keyboard.
            You will also notice that a major shift takes place at C4.
            This is where we switch from electric bass samples into
            piano samples.  In order to change the split point, move the
            cursor to the Lo: field of the first piano field, and move
            it up to F#4.  Move the cursor back to the KeyRange: field,
            and hit the "-" key.  The sample below the piano has shifted
            its "Hi:" field to fill in the area between C4 and F#4.
            This is an example of one major rule of key mapping: EACH
            KEYMAP PROVIDES A SAMPLE FOR EVERY KEY.  IF YOU DO NOT
            DEFINE A SAMPLE FOR A KEY, A SAMPLE (AND PROBABLY NOT A
            GREAT ONE) WILL BE PROVIDED FOR YOU!

            Now, let's modify the keymap to have a third instrument from
            F#3 to F#4.  Since the last bass sample covers this area, we
            can simply change the sample in use, and we will have a new
            split point.  Change the sample to #15 Tenor Saxophone.
            This gives us a saxophone in the middle of the keyboard --
            not necessarily so useful, but it proves the point.  Adjust
            the tuning and volume to suit, then play around on the
            keyboard.  Exit the keymap editor, saving the keymap if you
            wish.  You can replace the existing map, place it in a
            different keymap "slot number", or even rename it.



            Patch Run #3 - Percussion key mapping

            Patch "[ddg]06/03 perc1" is a simple keyboard percussion
            set.  However, it is using the General MIDI kit - and I want
            something a little more aggressive. So, we are going to make
            a new keymap from scratch.

            From within the patch editor, move to the KEYMAP page.
            Select keymap #168 (Silence), then move into the keymap
            editor.  You will have one sample across the entire
            keyboard.  In order to place samples where we want them, we
            will need a number of new ranges.  First, let's make one the
            hard way!

            Move the cursor to the Lo: field, and change the value to
            C3.  Set the Hi: field to C3 as well.  Change the sample to
            #49 24in Amb Kick.  This sets the single key C3 to sample
            #49.  Play that key, and hear a drum.  Sounds too low!
            Using the CoarseTune: and FineTune: fields, adjust the drum
            sound to taste.  This method of range creation works, but is
            kind of tedious.

            To create the next range, hit the [NewRng] soft key.  The
            K2000 will request a low and high key, then move back to the
            keymap editor with the new range selected.  You simply have
            to define a sample, and tune it appropriately. For this
            example, hit the C#3 key for both Hi and Low keys, then
            select sample #60 Sidestick.  Tune it appropriately (by
            playing, then changing the Tune: fields).  You can continue
            adding ranges, or check out my "aggressive" keymap.  Exit
            the keymap and patch editors, and select patch "[ddg]06/03
            perc2".  This is a style of drum kit that I like...

            For experimentation, you should create a keymap that
            controls your entire keyboard.  Save it, and use one of the
            above patches as a base patch to use it.  You can then play
            with tuning, filtering and enveloping your percussion sounds
            - yet another lifetime of fun!



            Patch Run #4 - Velocity Sensitive keymaps

            Grab patch "[ddg]06/04 mvel".  Play a single note a varying
            velocities.  Now, try *this* with yer ol' analog synth!!!
            In this case, I've set up three totally different synth
            sounds in a keymap that is sensitive to velocity.

            Take a look at the keymap for this guy.  It is a single key
            range, with three velocity settings.  For reference, I
            started by using keymap #164 as a starting point, then
            changed the samples to three very different sounds.  You can
            extend this idea by adding key ranges, using more similar
            sounds (a good example - three slightly different snare
            samples, with each "speaking" differently, will give more
            realistic drum sounds), or different tunings.  Use this
            patch as an idea builder.



            That completes tutorial #6.  I hope you enjoyed.  The .KRZ
            file, as well as all previous tutorial information, can be
            found at:

               bach.nevada.edu:\pub\K2000\primer

            or via WWW page at:

               http://www.execpc.com/~ddg/index.html

            Thanks to Jason Cathcart, Keith Cowgill and others for the
            effort spent setting up and maintaining K2000 sites.