This is some haphazard documentation for FilterChrist 0.34. This document is being written because the other day I had to struggle to recall what the "pc" filter does, not because I care if people can use this software or not, but I guess that'd be nice, too.

This document assumes you know a little about sound editing and acoustics, not to mention basic safety precautions, i.e. how to NOT blow out your speakers by being stupid and experimenting recklessly.

This document will be formatted to be automatically parsed, eventually.


> How to generate a sound?

* At the main menu, the first thing to do is type a number in, for example '1'. This is the process number.

* The secret is that, once you type 'r' to begin [R]endering the processes, they will always render in numerical order. This is important cuz you don't want to have process 3 reference something in process 30 -- process 30 won't have rendered, and you'll be referencing silence!

* There are a number of functions that generate sound. [sin]e generates a sine wave, that's an obvious example. Many more are documented below.

* Answer the program's questions to set the function's parameters. This raises another interesting point:


> Triple Input kicks ass. There are three ways to answer any question >that has the triple input symbol [##x] at the end:

* Type a single value, for example '440'

This parameter will always equal 440, throughout the entire sound. If you're generating a sine wave, and for the frequency you type '440', the sine wave's frequency will be a constant, irritating 440 hertz. Simple, yes?

* Type two values, separated by a comma. '440,880'

This value will ramp (linearly) from 440 to 880 as the sound progresses. Your sine wave will start at 440 hertz, and climb up to 880, only reaching that final frequency just as the sound ends.

* Type three values, the last is a modulating layer: '440,880,3'

The first two values are parameter numbers, just as if you'd typed two values. BUT! The last value is a reference to >another layer< that has already been rendered. This layer acts like a controller: when the sound in layer 3 is at full negative, the value that's used will be 440. When layer 3 is fully positive, the function will use 880. When layer 3 is somewhere in the middle, the fuction will range between 440 and 880, proportionately.

*** Secret of triple input: If you want a non-linear curve, you can have it. Typing two values '440,880' is secretly the same as typing '440,880,-1' -- negative modulating layers are special numbers that create slopes. Using a negative number other than -1 is equivalent to (LinearCurve ^ abs(NegativeNumberSlope)), so -.3 would change rapidly from 0 to 1, and -7 would be reluctant to change, snapping from a low value up to 1 at the very end of its life.

> Which parameters are triple input -enabled?

* Just about everything: frequency, amplitude, waveshaping amount, gains, clips, distortions, etc etc etc... the amount of power you wield in FilterChrist is staggering.

> What are these other commands?

* Self-explanitory, of course.




> [sin] sinewave

> [saw] sawtooth wave. Note this starts at full negative and climbs >to full positive, so effectively this starts at ninety degrees of >the traditional sawtooth phase.

> [sq] square wave

> [tri] triangle wave

> [pul] variable-width square wave, i.e. it's like a square width but >you can choose to have the positive crests wider than the negative >crests, or vice versa. Pulse width of 0 is full negative, 1 is full >positive. So of course you'll want to keep the pulse value variously >inbetween those, otherwise what's the point.

> [noi] white noise

> [sil] silence

* Amplitude: 0 is silent, 1 is full.


Scours the current working directory, and lists all of the files within. Choose one, and when the process is rendered, it loads the file as sound data and stores it for other processes to mangle.

Note that this will load ANY file, not just sound files, and in fact it is dumb and raw -- it doesn't strip sound file headers off, they're included in all their crackling glory.


Hard clipping with the option for DC offset. The signal is multiplied by the gain value, offset with the DC offset value, and then clipped -- the maximum possible output values in either direction are 1 and -1. This can destroy speakers, so please think twice before you set the DC offset to '-100,100'.


Just like Gainsmasher (previous), but any samples that are out of range (beyond 1 and -1) are wrapped around to the other side. Yes, this filter actually induces the hated digital clipping.

* Type of wrap-around: When set to 2 (full wrap-around) any extreme samples wrap around from full positive to full negative, or vice versa. When set to 1, extreme samples wrap back to 0 and then continue in the same direction they were going.


Similar to both Gainsmasher and Wrapsmasher (above) except that extreme signals beyond the range of 1 and -1 'reflect' off of the maximum sound height, bouncing off the outer limits and reversing their direction.


Maps the incoming signal onto a sine wave graph. This filter lends itself to graphic explanations rather than written ones, but bear with me: With a shaper value of 1, imagine a single sine wave period -- negative crest down, then positive crest up.

When your incoming signal is a sawtooth wave, the resulting signal out will be a sine wave. WHY?! This sine wave you just visualized is a mapping function -- when the sawtooth begins at -1, the output value is determined by looking at the sine wave function, where x=-1. As the sawtooth wave climbs, the shaper map tracks its ascent and steps along the sine wave, outputting it.

Argh I hate teaching. Do a web search if you want to know more about the intimate workings of waveshaping, otherwise just assume it's going to act like a hot warbly distortion filter.


Keeps a running tally of the sound samples, constantly summing them together and spitting out the running tally. Sounds like a thick, dirty lowpass filter. Clips easily, and that may just be a good thing at times.


Measures the rate of change from one sample to the next, and always spits out that value. Sounds like a thick, dirty hipass filter.


Any samples that are close enough to zero become zero, and the rest of the sound data is stretched toward zero accordingly. This can make some pretty fat sounds, which was surprising to me, considering how weak the resulting waveforms look -- sine waves become nice bass instruments.


Simply the function (Input_Sample ^ Power). When the power variable is between 0 and 1, the signal will be _boosted_ (do the math if you want proof) and the filter acts like soft clipping. From 1 upward, the signal is bent towards zero, and becomes an unpleasant, grimy distortion. Power levels below zero aren't recommended and might do fuX0r things.


Adds channels together. Amplitude: 0 is silent, 1 is full. You can certainly use negative numbers for the amplitude, if you're into phase inversion, and that that sort of thing.


Gnuh. Plays the carrier wave back at an unstable pitch, resulting in whole new timbres.

This filter was thrown together haphazardly, so it's difficult to effect this with precision. Right now algorithm 1 ("forward") is hideously unstable, causing the sound to play too fast so that it loops. Algorithm 2 modulates the pitch incorrectly, bending the frequency too far.

As for the modulation index, atleast with algorithm 2 it refers to the number of samples being skimmed forward or backward. 30 is usually good. Be wary of this build of the FM function, it's not so great.

You can have as many modulators as you wish, though, so at least that's something.

If you're trying to construct a basic FM wave, it's easier to first render the modulator wave, then have that control the pitch of a new wave ('440,880,3' for example).


Multiplies layers together.


This doesn't work yet. The idea is that it will evaluate the difference between two waves at any point in time; if they're too close, it pushes them apart, proportionately. The algorithm for this function has been particularly arduous to construct, perhaps I'll try again at some later date.


Note that this function DOES NOT GENERATE PLAYABLE AUDIO. What it does is attempt to track the amplitude of the input wave. It generates a huge, nasty bump of waveform, well below the range of human hearing. This should only be used as controller data.

The output range of this layer is -1 to 1. Silent input will generate -1. Maximal input will generate 1.

[jsi] JIG-SINE

A bizarre wave generator that splices individual crests of sine waves together. Normally this produces a continuous wave, as the amplitudes of higher-frequency crests will be attenuated proportionately. You can change this with the modulation factor -- a value of 1 does not attenuate any crests at all, making the signal much buzzier.

Give it a number of frequencies, and it will randomly choose them and piece together humps of sine waves to generate something whistling and new.


Splices together pieces of cosine waves, one piece being from full positive to full negative. Every other 'piece' will be flipped, producing a continuous output wave.


Constructs a 'sine' wave that changes frequency every time the master frequency goes through a cycle. The master frequency is just a clock controller that determines when a new slave frequency is chosen.


Awesome algorithm that acts like so: Imagine plotting a three dimenional function in space (z = [x y whatever]). Drop a record player needle onto this surface, and spin it around in a circle. The z value (up and down movement of the needle) becomes the output sound.

Hopefully this is self-explanitory... the radius is the distance the 'record needle' spins around the fixed center, and the 'frequency' is the spin frequency. $x and $y are the coordinates of the spin center (you determine this path) and $r is the center's distance from the origin, [ 0, 0 ] .

Bleaurgh choke on a cock


Draws little pieces ('stammers') out of the carrier wave, and splices them back together. The piece size is determined by the 'frequency' value, and the 'stammer position' controls where the pieces are drawn from.

This can act as a pitch shifter, set the frequency to the sample rate, 44100, and put something moderately wild in the position wave.


Divides the input wave into shards -- the beginnings and ends of shards correspond to where the waveform crosses the zero, i.e. whenever it changes from positive to negative, or vice versa.

What the filter does, is to replicate each shard directly after itself. This tends to double the length of the wave, and the program will ask you if you want to expand the duration of the render. There are currently 4 types of wave mirror:

* STAND - Flips the duplicate shard vertically. Original shards will always be positive, duplicates always negative.

* HIT - Rotates the shard 180 degrees. Polarity is as with Stand.

* DOUBLE - Pitch shifts the shard one octave up, then doubles that, so for each single shard in, you get one full shard and two short half-shards out. Polarity alternates with each shard piece, attempting to create a continuous wave, or something.

* NOTHING - The shard data is not replicated, it uses silence instead. The polarity of the audible shards alternates.


Not too amazing -- it splits the waves into shards (see Wave Mirror, above) and flips each shard horizontally.


Splits the wave up according to a master frequency, then normalizes every individual section.

When 'flipping' is turned on, it always aligns the maximal sample to the positive region. Can you say "DC offset in spades".

There is a noise floor of -36 decibels; any section that does not exceed this threshhold remains unaffected.


Splits the wave up according to a master frequency. THEN, draws from each section according to the fractalization amount. It steps through each section at a certain speed, always wrapping around to the beginning if it steps out of bounds. If the fractalization constant is 2.3, it gets a value as if it were stepping through at a speed of 2, another as if 3, and then mixes them together proportionately.

I had BBQ beef for lunch, and it's not agreeing with me.


Checks the zero-crossings to guess what the fundamental frequency of the wave is. If the fundamental frequency repeats itself (within a certain percentage), the previous zero-cross section is repeated in place of the newer data.

It's neat.


Beautiful additive synthesis filter. Specify a carrier frequency, and the overtones to "shimmer" over this frequency. The shimmering layers will pulsate at a rate proportionate to how far they are from the carrier frequency.

* Rate control: This affects the shimmer rate. An overtone three octaves above the carrier shimmers four times as fast as the carrier when it's linear (1 + 3 = 3), and eight times as fast under logarithmic (2 ^ 3 = 8). Logarithmic rate control can produce interesting ring modulations at higher frequencies.

* Amp exponent: How strong the shimmers are. This works like the [pow] function, the amplitude graph for each shimmer is affected a la (NormalRate ^ AmpExponent).

* Base frequency shim rate: This controls how fast the frequencies shimmer. Rate of 1 == 1 full shimmer cycle on overtone 1, across the entire render length.


Guesses the frequency at any given moment according to the zero-crossing values. Then generates a decaying sine wave for each, and adds the sine waves to a composite output.

Nyyuuhhh I hate writing documentation.


Can't remember what this was going to do.