Tutorial #3 - The Basic Patch : Lowpass Filter Modulation

            Overview
            --------

            Now that we've spent some time with filtering, we are going
            to take a little side trip to explore modulation.
            Modulation is a method by which you can cause change in any
            signal.  In this tutorial, we will learn how to modulate the
            lowpass filter with both envelopes and physical controllers.

            We've actually worked with modulators before - the AMPENV is
            simply an envelope that modulated (changed) the volume of a
            patch - based on timing and level segments we programmed.
            The same can be done for filter parameters - a common use is
            to create a envelope that changes the filter cutoff over
            time.  This allows the huge "swelling" pads we've all
            heard.  Other modulators you are used to using are the
            physical controllers, especially the mod wheel.  While a
            control envelope remains static (i.e., maintains the same
            structure), a physical controller allows truly expressive
            control over your playing.

            The "Patch Run" section of this tutorial will utilize
            patches from the file TUTOR_03.KRZ (sometimes called
            DDGT0003.KRZ, available at various Internet resources,
            including <bach.nevada.edu>.


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

            First, every synthesist loves knobs to turn.  The K2000
            keyboard provides two general controllers - the modulation
            wheel and the data slider.  We will be working with the mod
            wheel in this tutorial.  The mod wheel is typically a
            control source that provides a 0 - 8196 value set.  However,
            within a K2000 patch, the value is treated like 0% - 100%,
            allowing it to control a value that has any range at all.
            In tutorial #2, we were able to hear changes to the tonality
            while we moved the filter cutoff control.  We will now learn
            how to set up the mod wheel to allow this same kind of
            control while we are playing.

            Secondly, while filters allow a basic level of control over
            the tonal nature of a patch, it is often desirable to have
            the timbre change over time.  In the first tutorial, we
            covered the various elements of the AMPENV envelope - how
            you set up segment rates, levels and looping.  The K2000
            provides two full-featured envelopes (ENV2 and ENV3) that
            are not "pre-hooked" to any part of the synthesizer.
            These envelopes are very similar to the AMPENV, with one
            important exception.  The AMPENV allowed levels from 0%
            through 100%, giving the entire normal range of volumes.
            ENV2 and ENV3 have ranges from -100% to +100%, allowing
            negative, as well as positive control.

            When using a physical control or an envelope as a controller
            (or modulator), you will typically be controlling some
            portion of a patch that has a base value - like filter
            cutoff.  When you are modulating a filter cutoff, it will
            raise or lower the cutoff value by an defined amount, called
            the depth.  The modulator will therefore force a change in
            the filter cutoff of up to +/-100% of the depth amount.

            In order to understand the use of an envelope better, let's
            "think through" an example.  If we have a patch that
            sounds pretty nice, but needs some animation, we may want to
            apply a modulation envelope on the filter cutoff.  Let's say
            that the cutoff value is at C6 (1047 Hz), but we want to
            vary it between C5 and C7.  If we set up the modulation
            depth to 1200 ct (cents), a value change of +/- 100% will
            cover the entire C5 to C7 value range.  Then setting up an
            envelope that "moves" from -100% to +100%, and over time
            will give us the sound we desire.

            Our virtual analog synth will now have the following signal
            path:

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

            While the generic envelopes and physical controls can be
            used to modulate almost anything in the K2000, we will be
            confining ourselves to modulating the filter variables.  It
            is also important to understand the *source* and
            *destination* elements of modulation.  Typically, a source
            is any controlling modulator - like an envelope, the mod
            wheel, or even the keyboard.  The destination is a single
            value which can be controlled by a modulator.  In the above
            diagram, it looks like we are controlling the "filter"
            with an envelope or controller.  However, it is better to
            think of controlling a single filter value (like the filter
            cutoff frequency) - which is the actual destination of the
            modulation.

            One additional thing to note: a single modulator can control
            several parameters.  For example, a mod wheel controller
            could modify both the filter cutoff frequency as well as a
            vibrato - it's all in the programming.  The number of
            available modulation destinations makes some programming
            tasks more difficult, but allows for an incredible amount of
            creativity by the savvy programmer.

            Enough talk - let's make some patches.



            Patch Run #1 - Cutoff Modulation with the Mod Wheel

                 NOTE: If you are not using the K2000 keyboard version,
                 you should set a keyboard controller to be the data
                 slider - which is MIDI controller 6.  This will be used
                 in in future Patch Runs, so have this controller handy!

            This "Patch Run" will utilize the first patch, labeled
            "[ddg]03/01 mod 1".  Select this patch, and play some
            sixteenth notes while moving the mod wheel.  You will find a
            typical "wah-wah" effect on a clav type sound - another
            common synth texture.  Edit this patch, and look at the [F1
            FRQ] page.

            This patch uses a fairly low filter cutoff value - C3 (131
            Hz).  This means that, by default, most of the harmonics of
            the sound will be filtered out.  The right side of the
            display shows modulation controllers, and you should notice
            that the Src1: field is set to MWheel (short for Mod Wheel),
            with the Depth: field set to 7000 ct (cents).  What exactly
            does this mean?

            The Src1: field is a modulation source, which will control
            the cutoff frequency of our filter.  In this patch, I've
            said that I want to modulate the filter cutoff with the Mod
            Wheel.  The Depth: field determines how much my modulator
            will affect the filter cutoff.  In this case, I've set it to
            7200 cents - six octaves.  With this wide modulation range,
            I'm able to open the filter almost completely.

            When a control is being used in a patch, the K2000 processes
            it in the following way:

            1. The modulator (in this case the Mod Wheel) is
            "measured", to determine its value.  A percentage is
            calculated.  If I have the Mod Wheel at the half-way point,
            the K2000 will see it at approx. 4100, and determine the
            percentage to be roughly 50%.

            2. The depth control is checked, and the percentage is
            applied.  In this case, the depth control is set to 7200, so
            the modulation amount would be 7200 @ 50% = 3600.

            3. The filter cutoff is internally changed to C3 (the
            initial value) + three octaves (3600 cents), for a value of
            C6.

            This is constantly done anytime you have a modulator defined
            for a value.  The actual rate of modulation testing is 20Hz,
            or twenty times per second.  This allows for a fairly active
            modulation source with reasonably accurate tracking by the
            modulation destination.

            Experiment with the cutoff frequency and the modulation
            depth control to see what effect variations of these values
            will have.



            Patch Run #2: Modulation with Envelopes

            Select patch "[ddg]03/02 mod 1" and play a few notes of a
            minor chord.  This is a typical "creepy reverse" patch,
            and is a good example of filter envelope effects.

            Move to the [F1 FRQ] page, and examine the modulation
            routing.  The SRC1: field contains the ENV2 controller, and
            the DEPTH: field is set to 8000 cents.  But what does this
            mean?

            If you remember from the AMPENV tutorial, an envelope simply
            acts as an automated "knob turner".  For the AMPENV, the
            envelope turned the volume up and down, based on the
            parameters we entered.  Similarly, generic envelopes (that
            is, ENV2 and ENV3 controls) can be used to turn the knobs of
            a number of variables.  In this case, it is turning the
            cutoff frequency "knob".  I'm now going to dump the knob
            turning analogy, and simply say that the envelope is
            "modulating" the cutoff frequency.

            One of the list members asked to define the difference
            between a physical control (like a mod wheel), and a logical
            control (like an envelope).  There really isn't any.  Both
            types of control can modulate variables, and both can have
            the amount of effect (typically called depth) set within the
            program.  The only difference is in how the control
            interacts with the player - a physical control requires
            player interaction, while a logical control works
            automatically.

            Move to the ENV2 page by hitting the [more>] button, then
            hit the [ENV2] soft button.  This screen should look
            suspiciously familiar - it is very similar to the AMPENV
            page.  There are two main differences.  First, the ENV2
            control (as well as the ENV3) are not connected to anything
            by default.  Secondly, the level values for each segment of
            the envelope allow negative numbers.

            In the case of this patch, I've used a long "ramp"
            envelope to slowly increase the frequency cutoff, then a
            sharp ramp-down to close it off at the end.  This is an
            effect best experimented with, so adjust the ATT1: and REL1:
            time variable to hear the changes in sound.  Once you are
            comfortable with the effects of the envelope, move back to
            the [F1 FRQ] page, and adjust the DEPTH: field.  You will
            notice the only change is in the amount of cutoff frequency
            change.  Nothing on the [F1 FRQ] page can change the time
            factor - this can only be changed by adjusting the envelope
            itself.

            Patch "[ddg]03/02 mod 2" is a "scat singing angel" kind
            of patch.  When playing this patch, notice the little warble
            at the beginning of the sound.  If you listen closely, you
            will find that the pitch never changes - it is only the
            tonality of the sound that shifts.  This is an example of a
            modulating envelope that utilizes a negative level value.
            So why use negative values?

            In most cases, a generic envelope (ENV2 or ENV3) are used to
            modulate a parameter that has a preset value.  In the case
            of this patch, the [F1 FRQ] cutoff frequency is set to
            C4/262Hz, in order to allow the basic high vocal sound to
            come through cleanly.  An envelope that allowed only
            positive values would only be able to increase the cutoff
            frequency.  Having negative values allows us several options
            for sound manipulation with higher frequency tones.

            Move to the ENV2 edit page, and examine the filter envelope.
            This envelope is set to stay pretty "high" for .18
            seconds, then drop to -74% quite rapidly (in .26 seconds).
            The envelope then returns to its initial value over .40
            seconds, where it will stay until the note is completed.
            The parameter settings from the [F1 FRQ] page are cutoff
            frequency = C4/262Hz, SRC1 Depth = 6500 cts.  If our
            envelope is set to cover the range from +100% through -74%,
            we are actually going to be changing the cutoff frequency by
            +6500 cts and -4810 cts (6500 at 74%).  With a starting
            value of C4, we will be varying the cutoff frequency from F9
            down to the lowest frequency possible.  This wide range,
            combined with the quick movement of the envelope, is what
            gives this patch its peculiar sound.  Again, experiment with
            the ENV2 parameters, as well as the [F1 FRQ] parameters,
            until you fully understand the way this patch's filter is
            working.  When you are done, exit the editor.

            Select patch "[ddg]03/02 mod 3", enter the patch editor,
            and look at the [F1 FRQ] page.  I'm using the ENV2 as the
            SRC1 modulator, and have the depth set to 3000 cts.  The
            sound of this patch has a bounce echo - but done solely with
            the filter envelope.  If you examine the [ENV2] page, you
            will see that I've used a triangle wave shaped envelope,
            that slowly decreases over time.  Using this type of
            envelope, I can give an echo-ish effect without changing the
            volume, and without using the effects processor.  Experiment
            with the shape of this envelope and the depth control on the
            [F1 FRQ] page to expand on the envelope techniques we've
            developed.



            Patch Run #3 : A Simple Modulation Matrix.

            "[ddg]03/03 mod 1" is another patch that uses a physical
            controller.  Play this patch while moving the mod wheel.
            Increasing the mod wheel brings in a moving filter sound,
            while decreasing it returns the filter to stasis.
            Additionally, if the mod wheel is "high" when you release
            a note, you get a little "bump" at the tail of the note.
            This patch is full of ideas, and should really get your
            creative juices flowing.

            First, let's look at the cutoff frequency ([F1 FRQ]) page.
            You will notice that SRC1: is not in use; instead, we are
            using the SRC2: field.  The SRC2: field is very similar to
            the SRC1:, except for the handling of the depth parameter.
            When using SRC1:, you set a static depth amount.  With the
            SRC2: control, you are able to set *another* modulation
            source as a controller for the depth value.  This allows you
            to assign one controller to affect another controller - what
            is typically called a modulation matrix.

            But how is this patch using the modulation matrix?  First,
            the ENV2 modulator is set as the source of cutoff
            modulation.  That's fine, but how much will it modulate?
            This is determined by the MinDpt: and MaxDpt: parameters,
            which stand for minimum and maximum depth.  In these fields,
            you set a range, as opposed to a single value.  Which value
            will be used?  The DptCtl: (depth controller) determines
            which controller will set the depth - always calculated as a
            percentage of its own value range.  In our example patch,
            the range is from 0 to 3000 cts, and the depth is controlled
            by the mod wheel.  To experiment with these effects, change
            the depth range, as well as the controller used (try the
            data slider {called Data}, pitch wheel {labeled PWheel, with
            both a positive and negative value!}, or any other
            controller for fun).

            Next, look at the ENV2 envelope.  This is the most
            complicated envelope we've created, and uses most of the
            available envelope functions.  First, notice that the
            envelope is looped, with a setting of seg1F.  This means
            that while the note is being sounded, the envelope will
            constantly loop from the beginning of the attack, to the end
            of the decay segment, then jump back to the beginning of the
            first attack segment.  Try some of the other looping options
            (while keeping the mod wheel high) to hear the variety of
            effects.

            Next, the attack segments have a "bounce", similar to some
            of the previous example patches.  However, the release
            segments also have a bump - something new!  When you play a
            single key, you should notice that you get a scoop after the
            note is released.  This is the effect of this release
            envelope.  Adjust them (you may want to extend the release
            segment of the AMPENV for *real long* release segments) for
            fun and profit...

            Finally, there is a hidden feature - resonance modulation.
            Move back to the [F2 RES] page, and check out its modulation
            routings.  I'm using the ENV2 envelope to modulate the
            resonance (by 28db - just to be radical!), with the depth
            controller defined as the data slider.  This lends an extra
            screech to the modulation, while still under player control.




            This tutorial has been complex, and contains enough
            information to keep an inventive mind going for a long time.
            It is important that you not limit your experimentation to
            my tutorials - you can create better patches for your own
            music than I'll ever be able to imagine.  You need to
            continue the quest...

            <end Castaneda mode>

            Good luck programming.  If you need any assistance, or have
            additional ideas for the tutorial, contact me at:

            ddg@wi.rr.com

            See you later...