New Tool (3.0): CDP lua tool

Nice, will update the bunch that I already did for the distort process.

heh yeah Soundloom is one of a kind, I apparently deleted Soundshaper from my system, can’t find it anymore but think through trial and error, going through the docs we can find out most stuff. Could also consult the CDP dev’s through email.

Some things I came across;

I noticed that for certain processes, besides min and max values, you’ll see something like “Cyclecnt may vary over time” or “freq may vary over time”, *insert parameter " * may vary over time". I think these arguments can take break-point files, sets of numbers that describe an envelope over time. Like for instance in the process ‘Distort Delete’. Something to look into for the future, would be nice to have for the time-stretching processes, start of speeding up a sound, gradually slowing it down et cetera.

Also in the docs, certain parameters have a range of for example 2 to 16 and than it says integer only. Look at 'Distort Divide’ for the divider argument. What if an argument only takes integers, is there a way to set a min and max for this, or maybe it doesn’t matter?

In ‘Distort Shuffle’ you can shuffle wavecycles through defining a domain (for example abcd) and describing a so called image (for example aacccbdd, or dcbba, or dac). Using commandline you have to connect these using a dash like abcd-aacccbdd. Is there a way, for processes that accept them, you could also implement some kind of imput field for characters, letters?

edit;

could you also implement a ‘tip’ option for the cmds line, something to paste the musical application and/or additional info, for example;

cmds = { exe = "distort", mode = "average", tip = "DISTORT AVERAGE performs a mathematical averaging of the data in cyclecnt pseudo-wavecycles. The effect is more akin to a loss of resolution than the blurring which might be expected. Values below 10 retain some semblance of the original, while values of, for example, 100 seem to create a kind of 'sample hold' effect. For modest distortion, values 5 or less are recommended." },  

Cheers :slight_smile:

Here’s a bunch I already did (including tips), am sure I messed up some ranges, but I’m getting results so am happy :slight_smile:

[details=“Click to view contents”] ```
dsp[“Distort Average - average the waveshape over N wavecycles”] = {
cmds = { exe = “distort”, mode = “average” },
arg1 = { name = “cyclecnt”, min = 1, max = 6000, tip = “number of cycles over which to average (Range: > 1)” },
arg2 = { name = “maxwavelen”, switch = “-m”, min = 0, max = 1, tip = “maximum permissible wavelength in seconds (Default: 0.50)” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 1000, tip = “(integer) number of wavecycles to skip at start of file” },
}

dsp[“Distort Divide - Distortion by dividing wavecycle frequency”] = {
cmds = { exe = “distort”, mode = “divide” },
arg1 = { name = “N”, min = 2, max = 16, tip = “divider (Range: integer only, 2 to 16)” },
arg2 = { name = “-i”, switch = “-i”, tip = “use waveform interpolation: slower but cleaner” },
}

dsp[“Distort Fractal - Superimpose miniature copies of source wavecycles onto themselves”] = {
cmds = { exe = “distort”, mode = “fractal” },
arg1 = { name = “scaling”, min = 2, max = srate()/2, tip = “(integer) division of scale of source wave (Range: 2 to sample_rate/2)” },
arg2 = { name = “loudness”, min = 0, max = 10, tip = “loudness of scaled component relative to source (Loudness of source is reckoned to be 1.0)” },
arg3 = { name = “pre_attenuation”, switch = “-p”, tip = “apply attenuation to infile before processing” },
}

dsp["Distort Interpolate - Time-stretch file by repeating wavecycles and interpolating between them "] = {
cmds = { exe = “distort”, mode = “interpolate” },
arg1 = { name = “multiplier”, min = 0, max = 50, tip = “(integer) number of times each ‘wavecycle’ repeats” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 20, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Multiply - Distortion by multiplying wavecycle frequency”] = {
cmds = { exe = “distort”, mode = “multiply” },
arg1 = { name = “N”, min = 2, max = 16, tip = “multiplier (Range: 2 to 16, integer only)” },
arg2 = { name = “-s”, switch = “-s”, tip = “smoothing (try this if glitches appear)” },
}

dsp[“Distort Omit – Omit A out of every B wavecycles, replacing them with silence”] = {
cmds = { exe = “distort”, mode = “omit” },
arg1 = { name = “A”, min = 0, max = 5000, tip = “number of wavecycles to omit” },
arg2 = { name = “B”, min = 0, max = 5000, tip = “size of group of ‘wavecycles’ out of which to omit A wavecycles” },
}

dsp[“Distort Overload – Clip the signal with noise or a (possibly timevarying) waveform”] = {
cmds = { exe = “distort”, mode = “overload 1” },
arg1 = { name = “clip-level”, min = 0, max = 1, tip = “level at which the signal is to be clipped (Range: 0 to 1) The signal level is renormalised after clipping.” },
arg2 = { name = “depth”, min = 0, max = 1, tip = “depth of the pattern of distortion imposed on clipped stretches of the signal. (Range: 0 to 1)” },
}

dsp[“Distort Overload – Clip the signal with noise or a (possibly timevarying) waveform”] = {
cmds = { exe = “distort”, mode = “overload 2” },
arg1 = { name = “clip-level”, min = 0, max = 1, tip = “level at which the signal is to be clipped (Range: 0 to 1) The signal level is renormalised after clipping.” },
arg2 = { name = “depth”, min = 0, max = 1, tip = “depth of the pattern of distortion imposed on clipped stretches of the signal. (Range: 0 to 1)” },
arg3 = { name = “freq”, min = 0, max = 22500, tip = “frequency of the waveform imposed on clipped stretches of the signal” },
}

dsp[“Distort Pitch - Pitchwarp wavecycles of sound”] = {
cmds = { exe = “distort”, mode = “pitch” },
arg1 = { name = “octvary”, min = 0,0, max = 8,0, tip = “maximum possible transposition up or down in (fractions of) octaves (Range > 0.0 to 8.0)” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “mamimum number of ‘wavecycles’ between the generation of transposition values (Range: > 1, Default: 64)” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Pulsed - Impose impulse-train on a sound”] = {
cmds = { exe = “distort”, mode = “pulsed 1” },
arg1 = { name = “stime”, min = 0.001, max = 10, tip = “time in the source sound where the impulses begin” },
arg2 = { name = “dur”, min = 0.001, max = 10, tip = “length of time that the impulses continue” },
arg3 = { name = “frq”, min = 0, max = 1000, tip = “number of impulses per second” },
arg4 = { name = “frand”, min = 0, max = 12, tip = “number of semitones by which to randomise the frequency of the impulses” },
arg5 = { name = “trand”, min = 0, max = 10, tip = “amount of time in seconds by which to randomise the relative time positions of amplitude peaks and troughs from impulse to impulse” },
arg6 = { name = “arand”, min = 0, max = 1, tip = “randomisation of the amplitude shape created by the peaks and troughs from impulse to impulse” },
arg7 = { name = “transp”, min = 0, max = 1, tip = “transposition contour of sound inside each impulse” },
arg8 = { name = “tranrand”, min = 0, max = 1, tip = “randomisation of transposition contour from impulse to impulse” },
arg9 = { name = “-s”, switch = “-s”, tip = “keep start of source sound, before impulses begin (if any)” },
arg10 = { name = “-e”, switch = “-e”, tip = “keep end of source sound, after impulses end (if any)” },
}

dsp["Distort Pulsed - Imposed regular pulsations on a sound "] = {
cmds = { exe = “distort”, mode = “pulsed 2” },
arg1 = { name = “stime”, min = 0.001, max = 10, tip = “time in the source sound where the impulses begin” },
arg2 = { name = “dur”, min = 0.001, max = 10, tip = “length of time that the impulses continue” },
arg3 = { name = “frq”, min = 0, max = 1000, tip = “number of impulses per second” },
arg4 = { name = “frand”, min = 0, max = 12, tip = “number of semitones by which to randomise the frequency of the impulses” },
arg5 = { name = “trand”, min = 0, max = 10, tip = “amount of time in seconds by which to randomise the relative time positions of amplitude peaks and troughs from impulse to impulse” },
arg6 = { name = “arand”, min = 0, max = 1, tip = “randomisation of the amplitude shape created by the peaks and troughs from impulse to impulse” },
arg7 = { name = “cycletime”, min = 0, max = 10, tip = “duration in seconds of wavecycles to grab as sound substance inside the impulses” },
arg8 = { name = “transp”, min = 0, max = 1, tip = “transposition contour of sound inside each impulse” },
arg9 = { name = “tranrand”, min = 0, max = 1, tip = “randomisation of transposition contour from impulse to impulse” },
arg10 = { name = “-s”, switch = “-s”, tip = “keep start of source sound, before impulses begin (if any)” },
arg11 = { name = “-e”, switch = “-e”, tip = “keep end of source sound, after impulses end (if any)” },
}

dsp[“Distort Reform - Convert to fixed level square wave”] = {
cmds = { exe = “distort”, mode = “reform 1” },
}

dsp[“Distort Reform - Convert to square wave”] = {
cmds = { exe = “distort”, mode = “reform 2” },
}

dsp[“Distort Reform - Convert to fixed level triangular wave”] = {
cmds = { exe = “distort”, mode = “reform 3” },
}

dsp[“Distort Reform - Convert to triangular wave”] = {
cmds = { exe = “distort”, mode = “reform 4” },
}

dsp[“Distort Reform - Convert to inverted half-cycles”] = {
cmds = { exe = “distort”, mode = “reform 5” },
}

dsp[“Distort Reform - Convert to click streams”] = {
cmds = { exe = “distort”, mode = “reform 6” },
}

dsp[“Distort Reform - Convert to sinusoid”] = {
cmds = { exe = “distort”, mode = “reform 7” },
}

dsp[“Distort Reform - Exaggerate waveform contour”] = {
cmds = { exe = “distort”, mode = “reform 8” },
arg1 = { name = “exaggeration”, min = 0,000002, max = 40, tip = “exaggeration factor (Range: 0.000002 to 40.0)” },
}

dsp[“Distort Repeat - Timestretch soundfile by repeating wavecycles”] = {
cmds = { exe = “distort”, mode = “repeat” },
arg1 = { name = “multiplier”, min = 0,0, max = 50, tip = “number of times (integer) each ‘wavecycle’ (group) repeats” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “number of ‘wavecycles’ (integer) in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = "number of ‘wavecyles’ (integer) to skip at start of file " },
}

dsp[“Distort Repeat 2 - Repeat wavecycles without time-stretching”] = {
cmds = { exe = “distort”, mode = “repeat2” },
arg1 = { name = “multiplier”, min = 0,0, max = 50, tip = “number of times (integer) each ‘wavecycle’ (group) repeats” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “number of ‘wavecycles’ (integer) in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = "number of ‘wavecyles’ (integer) to skip at start of file " },
}

dsp[“Distort Replace – The strongest wavecycle in a cyclecnt group replaces the others”] = {
cmds = { exe = “distort”, mode = “replace” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 5000, tip = “(integer) size of group of ‘wavecycles’” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “number of ‘wavecyles’ (integer) to skip at start of file” },
}

dsp["Distort Replim – Timestretch by repeating wavecycles (below a specified frequency) “] = {
cmds = { exe = “distort”, mode = “replim” },
arg1 = { name = “multiplier”, min = 0.001, max = 100, tip = “the number of times each wavecycle (group) repeats (Integer)” },
arg2 = { name = “cyclecnt”, switch = “-c”, min = 0, max = 5000, tip = “the number of wavecycles in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = " the number of wavecycles to skip at the beginning of the soundfile” },
arg4 = { name = “hilim”, switch = “-f”, min = 0, max = 22500, tip = “the frequency below which cycles are counted” },
}

dsp[“Distort Reverse - Cycle-reversal distortion in which the wavecycles are reversed in groups”] = {
cmds = { exe = “distort”, mode = “reverse” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 10000, tip = “number of ‘wavecycles’ in a reversed group (Range: > 0)” },
}

dsp[“Distort Telescope - Time-contract sound by telescoping N wavecycles into 1”] = {
cmds = { exe = “distort”, mode = “telescope” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 1000, tip = “the number of ‘wavecycles’ in a group” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “number of ‘wavecyles’ (integer) to skip at start of file” },
arg3 = { name = “-a”, switch = “-a”, tip = “telescope to an average ‘wavecycle’ length (Default: telescope to the longest ‘wavecycle’ length)” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles below freq”] = {
cmds = { exe = “distort”, mode = “filter 1” },
arg1 = { name = “freq”, min = 10,0, max = 22050.0, tip = “frequency in Hz (Range: 10.0 to 22050.0)” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles above freq”] = {
cmds = { exe = “distort”, mode = “filter 2” },
arg1 = { name = “freq”, min = 10,0, max = 22050.0, tip = “frequency in Hz (Range: 10.0 to 22050.0)” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles below & above freq”] = {
cmds = { exe = “distort”, mode = “filter 3” },
arg1 = { name = “freq1”, min = 0,0, max = 22050.0, tip = “frequency in Hz to delete below” },
arg2 = { name = “freq2”, min = 0,0, max = 22050,0, tip = “frequency in Hz to delete above” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}


dsp[“Modify Brassage - Pitchshift -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 1” },
arg1 = { name = “pitchshift”, min = -0,33, max = 0,33, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
}

dsp[“Modify Brassage - Timestretch -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 2” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
}

dsp[“Modify Brassage - Reverb -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 3” },
arg1 = { name = “density”, min = 0,0, max = 1000, tip = “amount of grain overlap (Range: > 0)” },
arg2 = { name = “pitch”, min = -0,33, max = 0,33, tip = “transposition factor (Range: -0.33 to 0.33)” },
arg3 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg4 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
}

dsp[“Modify Brassage - Scramble -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 4” },
arg1 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg2 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
}

dsp[“Modify Brassage - Granulate -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 5” },
arg1 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg2 = { name = “-d”, switch = “-d” },
}

dsp[“Modify Brassage - Brassage -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 6” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
arg2 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg3 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg4 = { name = “pitchshift”, min = -0,33, max = 0,33, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
arg5 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg6 = { name = “space”, min = 0, max = 1, tip = “spatial position – set stereo position” },
arg7 = { name = “bsplice”, min = 0, max = 1000, tip = “length of start-splices on grains in ms (Default: 5)” },
arg8 = { name = “esplice”, min = 0, max = 1000, tip = “length of end-splices on grains in ms (Default: 5)” },
arg9 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
arg10 = { name = “jitter”, switch = “-j”, min = 0, max = 1, tip = “randomisation of grain position” },
arg11 = { name = “outlength”, switch = “-l”, min = 0, max = 10, tip = “maximum outfile length (if end of data is not reached)” },
arg12 = { name = “channel”, switch = “-c”, min = 0, max = 2, tip = " extract and work on just one channel of a stereo input (Range: 1 or 2) Set channel to 0 (the Default) for this parameter to be ignored." },
arg13 = { name = “-d”, switch = “-d” },
arg14 = { name = “-x”, switch = “-x”, tip = “do exponential splices (Default: linear)” },
arg15 = { name = “-n”, switch = “-n”, tip = “no interpolation for pitch values (quick but dirty)” },
}

dsp[“Modify Brassage - Full Monty -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 7” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
arg2 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg3 = { name = “hvelocity”, min = 0,0, max = 5000,0 },
arg4 = { name = “hdensity”, min = 0,0, max = 5000,0 },
arg5 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg6 = { name = “pitchshift”, min = -0,33, max = 0,33, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
arg7 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg8 = { name = “space”, min = 0, max = 1, tip = “spatial position – set stereo position” },
arg9 = { name = “bsplice”, min = 0, max = 1000, tip = “length of start-splices on grains in ms (Default: 5)” },
arg10 = { name = “esplice”, min = 0, max = 1000, tip = “length of end-splices on grains in ms (Default: 5)” },
arg11 = { name = “hgrainsize”, min = 0, max = 5000 },
arg12 = { name = “hpitchshift”, min = -0,33, max = 0,33 },
arg13 = { name = “hamp”, min = 0, max = 1 },
arg14 = { name = “hspace”, min = 0, max = 2 },
arg15 = { name = “hbsplice”, min = 0, max = 1000 },
arg16 = { name = “hesplice”, min = 0, max = 1000 },
arg17 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
arg18 = { name = “jitter”, switch = “-j”, min = 0, max = 1, tip = “randomisation of grain position” },
arg19 = { name = “outlength”, switch = “-l”, min = 0, max = 10, tip = “maximum outfile length (if end of data is not reached)” },
arg20 = { name = “channel”, switch = “-c”, min = 0, max = 2, tip = " extract and work on just one channel of a stereo input (Range: 1 or 2) Set channel to 0 (the Default) for this parameter to be ignored." },
arg21 = { name = “-d”, switch = “-d” },
arg22 = { name = “-x”, switch = “-x”, tip = “do exponential splices (Default: linear)” },
arg23 = { name = “-n”, switch = “-n”, tip = “no interpolation for pitch values (quick but dirty)” },
}

dsp[“Modify Loudness - Alter gain of sound”] = {
cmds = { exe = “modify”, mode = “loudness 1” },
arg1 = { name = “gain”, min = 0,0, max = 100,0, tip = “adjust level by factor gain” },
}

dsp[“Modify Loudness - Alter dB-gain of sound”] = {
cmds = { exe = “modify”, mode = “loudness 2” },
arg1 = { name = “gain”, min = -96, max = 96, tip = “level expressed in dB (Range: -96dB to 96dB). NB: every drop of -6dB halves the previous level.” },
}

dsp[“Modify Loudness - Normalise”] = {
cmds = { exe = “modify”, mode = “loudness 3” },
arg1 = { name = “level”, switch = “-l”, min = 0, max = 1, tip = “force level (if necessary) to the maximum possible, or to the level given (Range: 0 to 1).” },
}

dsp[“Modify Loudness - Force level”] = {
cmds = { exe = “modify”, mode = “loudness 4” },
arg1 = { name = “level”, switch = “-l”, min = 0, max = 1, tip = “force level to maximum possible, or to the level given (Range: 0 to 1)” },
}

dsp[“Modify Loudness - Invert Phase”] = {
cmds = { exe = “modify”, mode = “loudness 6” },
}

dsp[“Phase - Invert phase”] = {
cmds = { exe = “pahse”, mode = “phase 1” },
}

dsp[“Phase - Stereo Enhance stereo file”] = {
cmds = { exe = “pahse”, mode = “phase 2” },
arg1 = { name = “transfer”, switch = “-t”, min = 0, max = 1, tip = “amount of signal to be used in phase-cancellation.” },
}

dsp[“Modify Radical - Reverse”] = {
cmds = { exe = “modify”, mode = “radical 1” },
}

dsp[“Modify Radical - Shred”] = {
cmds = { exe = “modify”, mode = “radical 2” },
arg1 = { name = “repeats”, min = 0, max = 1000, tip = “number of repeats of shredding process” },
arg2 = { name = “chunklen”, min = 0, max = 500, tip = “average length of chunks to cut and permutate” },
arg3 = { name = “scatter”, switch = “-s”, min = 0, max = 10, tip = “randomisation of cuts (Range: 0 to K, where K = duration of infile/chunklen Default = 1)” },
arg4 = { name = “-n”, switch = “-n”, tip = “use this flag for a smoother output” },
}

dsp[“Modify Radical - Scrub back and forth”] = {
cmds = { exe = “modify”, mode = “radical 3” },
arg1 = { name = “dur”, min = 0, max = 10, tip = “minimum length of outfile required” },
arg2 = { name = “down”, switch = “-l”, min = 0, max = 12, tip = “lowest downward tranposition in semitones” },
arg3 = { name = “up”, switch = “-h”, min = 0, max = 12, tip = " highest upward transposition in semitones" },
arg4 = { name = “start”, switch = “-s”, tip = "scrubs start before time start seconds " },
arg5 = { name = “end”, switch = “-e”, tip = “scrubs end after time end” },
}

dsp[“Modify Radical - Lose resolution”] = {
cmds = { exe = “modify”, mode = “radical 4” },
arg1 = { name = “bit_resolution”, min = 0, max = 22050 },
arg2 = { name = “srate_division”, min = 1, max = 256, tip = “Range: 1 to 256 Default 1 (normal)” },
}

dsp[“Modify Radical - Ring Modulate”] = {
cmds = { exe = “modify”, mode = “radical 5” },
arg1 = { name = “modulating-frq”, min = 0, max = 44100, tip = “number of cycles per second” },
}

dsp[“Modify Revecho - Standard delay”] = {
cmds = { exe = “modify”, mode = “revecho 1” },
arg1 = { name = “delay”, min = 0, max = 5000, tip = “delay time, in milliseconds” },
arg2 = { name = “mix”, min = 0, max = 1, tip = " amount of delayed signal in final mix: 0 gives ‘dry’ result (Range: 0 to 1)" },
arg4 = { name = “feedback”, min = -1,0, max = 1,0, tip = “produces resonances related to delay time (with short times) (Range: -1.0 to 1.0)” },
arg5 = { name = “tail”, min = -1,0, max = 1,0, tip = “time to allow decayed signal to decay to zero (Range: -1.0 to 1.0)” },
arg6 = { name = “prescale”, switch = “-p”, tip = “prescales input level, to avoid overload” },
arg7 = { name = “-i”, switch = “-i”, tip = “inverts the dry signal (for phasing effects)” },
}

dsp[“Modify Revecho - Varying delay”] = {
cmds = { exe = “modify”, mode = “revecho 2” },
arg1 = { name = “delay”, min = 0, max = 5000, tip = “delay time, in milliseconds” },
arg2 = { name = “mix”, min = 0, max = 1, tip = " amount of delayed signal in final mix: 0 gives ‘dry’ result (Range: 0 to 1)" },
arg4 = { name = “feedback”, min = -1,0, max = 1,0, tip = “produces resonances related to delay time (with short times) (Range: -1.0 to 1.0)” },
arg5 = { name = “lfomod”, min = 0, max = 1, tip = “depth of the delay-variation sweep (Range: 0 to 1)” },
arg6 = { name = “lfofreq”, min = -50, max = 50, tip = “frequency of the delay-variation sweep (negative values give random oscillations)” },
arg7 = { name = “lfophase”, min = 0, max = 1, tip = “start-phase of the delay-variation sweep (Range: 0 to 1)” },
arg8 = { name = “lfodelay”, min = 0, max = 10, tip = “time in seconds before the delay-variation sweep begins” },
arg9 = { name = “tail”, min = -1,0, max = 1,0, tip = “time to allow decayed signal to decay to zero (Range: -1.0 to 1.0)” },
arg10 = { name = “prescale”, switch = “-p”, tip = “prescales input level, to avoid overload” },
arg11 = { name = “seed”, switch = “-s”, min = 0, max = 100, tip = "non-zero value gives reproducible output (with the same seed) where random oscillations are used " },
}

dsp[“Modify Revecho - Stadium Echo”] = {
cmds = { exe = “modify”, mode = “revecho 3” },
arg1 = { name = “gain”, switch = “-g”, min = 0, max = 1, tip = “to apply to input signal (Default: 0.645654)” },
arg2 = { name = “roll_off”, switch = “-r”, min = 0, max = 10, def = 1, tip = “rate of loss of level across stadium (Default: 1))” },
arg4 = { name = “size”, switch = “-s”, min = 0, max = 10, tip = “multiplies average time between echoes (the Default time between echoes of 0.1 sec)” },
arg5 = { name = “count”, switch = “-e”, min = 0, max = 23, tip = “number of stadium echoes (Default and max: 23)” },
}

dsp[“Modify Space - pan”] = {
cmds = { exe = “modify”, mode = “space 1” },
arg1 = { name = “pan”, min = -1,0, max = 1,0, tip = “floating point value to specify location between the pair of stereo speakers, or breakpoint file of time pan pairs. Range: -1.0 to 1.0; 0.0 is centre.” },
arg2 = { name = “prescale”, switch = “-p”, min = 0, max = 1, tip = “gain factor multiplier with which to adjust the input level (Default: 0.7)” },
}

dsp["Modify Space - Mirrow: two channels swap sides "] = {
cmds = { exe = “modify”, mode = “space 2” },
}

dsp[“Modify Space - Narrow: Narrow the stereo image of a sound”] = {
cmds = { exe = “modify”, mode = “space 4” },
arg1 = { name = “narrowing”, min = -1,0, max = 1,0, tip = “make the stereo image less wide” },
}

dsp[“Modify Speed - Vary speed & pitch of a sound”] = {
cmds = { exe = “modify”, mode = “speed 1” },
arg1 = { name = “speed”, min = 0, max = 4, tip = “transposition value (ratio) expressed as a floating point multiplier” },
}

dsp[“Modify Speed - Vary speed & pitch by (fractional) number of semitones”] = {
cmds = { exe = “modify”, mode = “speed 2” },
arg1 = { name = “semitone-transpos”, min = -12, max = 12, tip = " transposition value in positive or negative number of semitones; e.g., 12 raises the sound by an octave, and -12 lowers it by an octave. NB: use 0 (semitones) for no transposition." },
}

dsp[“Modify Speed - Accelerate or decelerate a sound”] = {
cmds = { exe = “modify”, mode = “speed 5” },
arg1 = { name = “accel”, min = 0, max = 100, tip = “multiplication of speed to be reached by goaltime – i.e., a transposition ratio” },
arg2 = { name = “goaltime”, min = 0, max = 30, tip = “time in outfile at which the accelerated speed is to be reached.” },
arg3 = { name = “starttime”, switch = “-s”, min = 0, max = 10, tip = “time in infile / outfile at which the acceleration begins” },
}

dsp[“Modify Speed -Add vibrato to a sound”] = {
cmds = { exe = “modify”, mode = “speed 6” },
arg1 = { name = “vibrate”, min = 0,0, max = 120,0, tip = “the rate of vibrato shaking in cyles-per-second (Range: 0.0 to 120.0)” },
arg2 = { name = “vibdepth”, min = 0,0, max = 96,0, tip = “vibrato depth (pitch shift from centre) in [possibly fractional] semitones (Range: 0.0 to 96.0)” },
}

dsp[“Modify Stack -Create a mix that stacks transposed versions of source on top of one another “] = {
cmds = { exe = “modify”, mode = “stack” },
arg1 = { name = “transpos”, min = 0, max = 12, tip = “transpos is the transposition in semitones between successive copies” },
arg2 = { name = “count”, min = 0, max = 100, tip = " the number of copies in the stack” },
arg4 = { name = “lean”, min = 0, max = 10, tip = “the loudness of the highest component, relative to the lowest (may be > 1)” },
arg5 = { name = “attack-offset”, min = 0, max = 50, tip = “adjusts the time at which the attack of each sound occurs” },
arg6 = { name = “gain”, min = 0,1, max = 10, tip = “an overall amplifying gain factor on the output sound; some reduction (less than 1) may be needed. (It may also be > 1.) Range: 0.1 to 10” },
arg7 = { name = “dur”, min = 0, max = 1, tip = “how much of the output to make (a proportion, from 0 to 1)” },
arg7 = { name = “-s”, switch = “-s”, tip = " see the relative levels of the layers in the stack” },
}

  
Only thing I can't get any sound of is the '[b]distort pulsed[/b]' process, not sure what I'm doing wrong in the definition.  
  
After adding the tips and trying to run the script I got;  
  
[quote]  
'C:\Users\plugexpert\AppData\Roaming\Renoise\V3.0.0\Scripts\Tools\com.afta8.CdpInterface.xrnx\' failed to execute in one of its menu entry functions.  
  
Please contact the author (afta8 | fathand@gmail.com ) for assistance...  
  
main.lua:109: loop or previous error loading module 'definitions'  
stack traceback:  
 [C]: in function 'require'  
 main.lua:109: in function <main.lua:96>  
[/quote]  
  
[quote]  
'C:\Users\plugexpert\AppData\Roaming\Renoise\V3.0.0\Scripts\Tools\com.afta8.CdpInterface.xrnx\' failed to execute in one of its menu entry functions.  
  
Please contact the author (afta8 | fathand@gmail.com ) for assistance...  
  
main.lua:167: attempt to index local 'arg' (a nil value)  
stack traceback:  
 main.lua:167: in function 'build_arg_params_row'  
 main.lua:232: in function 'build_args_column'  
 main.lua:326: in function <main.lua:96>  
[/quote]  
  
I guess because the tips portion in each argument isn't expected, or maybe I made a mistake?  
  
  
edit;  
  
I've noticed the added processes don't get alphabetically ordered in the drop down menu of the tool gui, is this possible for better overview?  
  
edit 2; updated the code list with more stuff, unfortunately can't check for syntax errors.  
  
edit 3; updated list, fixed typo's

Amazing!

Thanks! I have added these to the latest version which is attached to this post.
WARNING: Make sure you back up your definitions file, before you install the update as it will overwrite your old files. I have added everything up to [modify stack] so any you have done after that will be lost unless you back them up.

I have also marked of where your presets are in the definitions file also and I won’t mess with them for now as you might want to change them given some of the new things I have added.

Keep them coming!

Good idea, I have added this to this version. As you have suggested any text added to the ‘tips’ in cmds will be displayed above the sliders. I have done this for a few as an example.

I did wonder what that meant! I’ll look into this some more, maybe we can use Renoise envelopes for this.

Will look at this, if it doesn’t throw an error when it receives a fractional number then we could leave this, otherwise there will need to be a tag in the arg that indicates an integer is required.

Interesting, not sure I get how this works but I will look into it, adding an input field should be fairly simple.

Will look at this.

I fixed a few in this update so lets see how we go from here.

Fixed in this update.

Also added to this update is a cycle() function that returns number of cycles in a sample, use this in the same way srate() is being used but where you need the cycle numbers… cyclecnt I think. And I added key pass through so you can play sounds when the dialog is focussed.

Phew! Thanks for all your input

Thanks for the heads up!

Btw, after installing the latest version, and initializing the script on an empty instrument it still throws up an error notice;

If I do load a sample, than open up the tool it says;

Cool!

Nice dude, thnx :drummer:

edit;

installed the script again, and now the gui opens without error, maybe because I hadn’t closed down Renoise?

Possibly to do with the way it loads definitions, it shouldn’t come up with that no sample error as it checks for that before it does anything else. Not sure why it came up again, but lets see how it goes.

I get the error whenever I just loaded Renoise, start op the tool without any sample present. Once I’ve had the error notice, loading up a sample doesn’t fix it. The tool still doesn’t start up, I get the other notice, see a few posts above.

When I start up Renoise, load a sample, than boot up your tool, everything works as expected. Maybe it is a windows thing?

Btw updated most of the presets with the docs descriptions and fixed a few mistakes, but there are bound to be more errors because of wrong range setting. Hopefully will iron these out soon, also with the cycle() function;

[details=“Click to view contents”] ```
–[[
Instructions for definitions

You do not need to specify the infile or outfile these are handled by the tool.

Name the preset within the square brackets and in quotation marks after dsp[] e.g. dsp[“Preset name”]
The name can be anything but try and keep it the same or similar to the CDP reference documentation.

cmds

exe - The name of the CDP executable (exclude the .exe extension)
mode - The first part of the command argument that comes after the exe and before infile, outfile

arg1 to arg…n

name - The name displayed in the GUI (STRING)
switch - The switch flag, use only if it is a command switch e.g “-s” (STRING)
min - The minimum value of the range (NUMBER)
max - The maximum value of the range (NUMBER)
def - The default value the preset loads with (OPTIONAL NUMBER)
tip - The tool tip for the GUI control (OPTIONAL STRING)

Additional functions are available that give info about the sample

srate() - Gives the sample rate
cycles() - Gives the number of wavecycles (same as number of zero crossings/2)

–]]

dsp = {} – Do not edit this


– PRESET DEFINITIONS - afta8 –

dsp[“Filter Bank 1 - Harmonic”] = {
cmds = { exe = “filter”, mode = “bank 1”, tip = “The harmonic series is formed by multiplying a given frequency by an ascending series of integers: 1, 2, 3, 4, etc. The harmonic relationships produced are sonorous, but depart from the structure of triadic chords higher in the series. This Mode builds this type of harmonic relationship onto lofrq, which may be the actual pitch of a pitched tone or any arbitrary pitch. Because this is being done with a filter process, other sonic material is cleaned away, so a cleaner (and possibly quieter) sound may result, with more complex noise elements removed. Quite a bit of gain may be required – values of 40 or 50+ in this situation will not be unusual. Set hifrq as high as possible less too few harmonics are produced. This clean sound may provide a good input for spectral time-stretching, for example, to achieve a well-tuned sound with a minimum of artefacts.” },
arg1 = { name = “Q”, min = 0.001, max = 10000, tip = “Sets the Q of the effect” },
arg2 = { name = “Gain”, min = 0.001, max = 10000, def = 25 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Scatter”, switch = “-s”, min = 0, max = 1, tip = “Random scatter of frequencies” },
arg6 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 2 - Alt Harmonic”] = {
cmds = { exe = “filter”, mode = “bank 2”, tip = “This will be like Mode 1 but with every other harmonic omitted: the odd numbered partials are retained. The resulting sound will probably sound more ‘hollow’.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg6 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 3 - Sub Harmonic”] = {
cmds = { exe = “filter”, mode = “bank 3”, tip = “The ‘subharmonic series’ is the intervallic inverse of the harmonic series. Thus the departure from triadic-type intervals increases as the series descends. The resulting sound has a deeper tone and is somewhat hollow and somewhat inharmonic.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg6 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 4 - Harmonic Linear”] = {
cmds = { exe = “filter”, mode = “bank 4”, tip = “The offset in Hz is added to each harmonic. This will displace them so that they will no longer be exact multiples of the fundamental. This means that the cycles of the waveforms no longer line up at nodes, which introduces an ‘inharmonic’ dimension into the sound, heard as an increase in timbral components.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Offset (Hz)”, min = 10, max = srate()/3 },
arg6 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg7 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 5 - Filter Intervals”] = {
cmds = { exe = “filter”, mode = “bank 5”, tip = “Here we depart from the harmonic series and simply divide up the specified frequency range into an equal number filters: how many is specified by the user with param. The first effect this equal spacing will have is to create inharmonic (rather than integer multiple) relationships between the partials. A low number of filters will produce an ‘open’ sound, and a high number of filters will produce a denser, richer sound. These might be very interesting sounds to timestretch.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “No. Filters”, min = 1, max = 100 },
arg6 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg7 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 6 - Semitone Intervals”] = {
cmds = { exe = “filter”, mode = “bank 6”, tip = “By specifying the interval (in semitones), we in effect repeat these intervals within the frequency space between lofrq and hifrq, thus producing complex chords composed of the same interval ‘piled up’. This is a quick way to ‘harmonise’ a sound, with the resulting density dependent on the size of the interval. It is well worth re-running this function, entering intervals from 1 to 7, for example, to hear what kind of transformations will be produced. Some unexpected resonances may result; they could be filtered out later.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Semitones”, min = 1, max = 12 },
arg6 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg7 = { name = “Double”, switch = “-d” }
}


dsp[“Filter Phasing 1 - Allpass Filter”] = {
cmds = { exe = “filter”, mode = “phasing 1” },
arg1 = { name = “Gain”, min = -1, max = 1 },
arg2 = { name = “Delay”, min = 0.045, max = 1644.35 },
arg3 = { name = “PreScale”, switch = “-s”, min = 0, max = 1 },
arg4 = { name = “Linear”, switch = “-l” }
}

dsp[“Filter Phasing 2 - Phasing Effect”] = {
cmds = { exe = “filter”, mode = “phasing 1”, tip = “The ‘phasing effect’ is a kind of sweeping band passing through the sound, such as is sometimes heard when aeroplanes fly overhead, and is much used in popular music.Increasing the gain factor has some effect on the reverberant quality of the sound. So does increasing the delay time. The sound will still sound quite dry with delay < 20 (ms). Between about 20 and 45 ms there is a touch of resonance in the sound. Around 50 ms there is significant echoey reverberation (though somewhat granulated), and after 100 ms we start to hear larger portions of the sound repeating.Overall, the degree of reverberant effect is controlled by increasing both the gain and delay parameters in tandem” },
arg1 = { name = “Gain”, min = -1, max = 1 },
arg2 = { name = “Delay”, min = 0.045, max = 1644.35 },
arg3 = { name = “PreScale”, switch = “-s”, min = 0, max = 1 },
arg4 = { name = “Linear”, switch = “-l” }
}

dsp[“Filter Phasing 2 - Phasing Effect”] = {
cmds = { exe = “filter”, mode = “phasing 1”, tip = “The ‘phasing effect’ is a kind of sweeping band passing through the sound, such as is sometimes heard when aeroplanes fly overhead, and is much used in popular music.Increasing the gain factor has some effect on the reverberant quality of the sound. So does increasing the delay time. The sound will still sound quite dry with delay < 20 (ms). Between about 20 and 45 ms there is a touch of resonance in the sound. Around 50 ms there is significant echoey reverberation (though somewhat granulated), and after 100 ms we start to hear larger portions of the sound repeating.Overall, the degree of reverberant effect is controlled by increasing both the gain and delay parameters in tandem” },
arg1 = { name = “Gain”, min = -1, max = 1 },
arg2 = { name = “Delay”, min = 0.045, max = 1644.35 },
arg3 = { name = “PreScale”, switch = “-s”, min = 0, max = 1 },
arg4 = { name = “Linear”, switch = “-l” }
}


dsp[“Filter Sweeping 1 - High Pass”] = {
cmds = { exe = “filter”, mode = “sweeping 1”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.”
},
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}

dsp[“Filter Sweeping 2 - Low Pass”] = {
cmds = { exe = “filter”, mode = “sweeping 2”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.” },
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}

dsp[“Filter Sweeping 3 - Band Pass”] = {
cmds = { exe = “filter”, mode = “sweeping 3”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.” },
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}

dsp[“Filter Sweeping 4 - Notch”] = {
cmds = { exe = “filter”, mode = “sweeping 4”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.” },
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}


– Djeroek –

dsp[“Distort Average - average the waveshape over N wavecycles”] = {
cmds = { exe = “distort”, mode = “average”, tip = “DISTORT AVERAGE performs a mathematical averaging of the data in cyclecnt pseudo-wavecycles. The effect is more akin to a loss of resolution than the blurring which might be expected. Values below 10 retain some semblance of the original, while values of, for example, 100 seem to create a kind of ‘sample hold’ effect. For modest distortion, values 5 or less are recommended.” },
arg1 = { name = “cyclecnt”, min = 1, max = 6000, tip = “number of cycles over which to average (Range: > 1)” },
arg2 = { name = “maxwavelen”, switch = “-m”, min = 0, max = 1, tip = “maximum permissible wavelength in seconds (Default: 0.50)” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 1000, tip = “(integer) number of wavecycles to skip at start of file” },
}

dsp[“Distort Divide - Distortion by dividing wavecycle frequency”] = {
cmds = { exe = “distort”, mode = “divide”, tip = “Without altering duration, this process effectively lowers the sound while adding a rough texture.This is a useful form of distortion because it roughens the sound without being too violent about it” },
arg1 = { name = “N”, min = 2, max = 16, tip = “divider (Range: integer only, 2 to 16)” },
arg2 = { name = “-i”, switch = “-i”, tip = “use waveform interpolation: slower but cleaner” },
}

dsp[“Distort Fractal - Superimpose miniature copies of source wavecycles onto themselves”] = {
cmds = { exe = “distort”, mode = “fractal”, tip = “Note the very wide range of scaling. Because it is a divisor, the larger the value of scale the shorter will be the miniature copies to be superimposed. These superimposed copies can be made to increase (be careful!) or decrease in amplitude with the loudness parameter. Using a value of 1.0 maintains the original amplitude of the infile, which will be heard as pretty much as the original, but with the superimpositions on top of it. Loudness is therefore a means of balancing the input and the processed sound components.This is a powerful and somewhat wild tool for producing distortion effects. The higher the value of scaling, the more the superimposed copies appear as a sheen of distortion above the original sound.” },
arg1 = { name = “scaling”, min = 2, max = srate()/2, tip = “(integer) division of scale of source wave (Range: 2 to sample_rate/2)” },
arg2 = { name = “loudness”, min = 0, max = 10, tip = “loudness of scaled component relative to source (Loudness of source is reckoned to be 1.0)” },
arg3 = { name = “pre_attenuation”, switch = “-p”, tip = “apply attenuation to infile before processing” },
}

dsp["Distort Interpolate - Time-stretch file by repeating wavecycles and interpolating between them "] = {
cmds = { exe = “distort”, mode = “interpolate”, tip = “With this process, the shape of a ‘wavecycle’ is transformed into that of the next over multiplier repetitions. Note that this is waveshape-based interpolation, not a spectral interpolation, and that the length of the ‘wavecycle’ is also transformed by the process. The effect of the transformation is drastic, leading to a strongly granular outfile. The length of the outfile increases in step with the value of multiplier, as does the apparent pitchiness.The interpolation process adds a modulatory quality to the output, so that the successive wavecycles gliss and bend as they flow into one another. Even so, as multiplier increases, the perception of separate ‘grains’, i.e., ‘wavecycles’ increases. A value of 32, for example, changes the sound to a strange stream of modulating tones.” },
arg1 = { name = “multiplier”, min = 0, max = 50, tip = “(integer) number of times each ‘wavecycle’ repeats” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 20, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Multiply - Distortion by multiplying wavecycle frequency”] = {
cmds = { exe = “distort”, mode = “multiply”, tip = “The duration of the sound is not changed, only the frequency of the ‘wavecycles’, with the result that the pitch rises.The distortion is relatively mild, in that the original sound remains recognisable. However, the surface is textured and the pitch rises with each increase in the value of N. DISTORT MULTIPLY can be used, for example, to create high, modulating, grainy vocal sounds.” },
arg1 = { name = “N”, min = 2, max = 16, tip = “multiplier (Range: 2 to 16, integer only)” },
arg2 = { name = “-s”, switch = “-s”, tip = “smoothing (try this if glitches appear)” },
}

dsp[“Distort Omit – Omit A out of every B wavecycles, replacing them with silence”] = {
cmds = { exe = “distort”, mode = “omit”, tip = “Because the omitted ‘wavecyles’ are replaced by silence, the overall duration of the sound does not change. The larger the proportion of ‘wavecycles’ omitted from B, of course, the more distorted the the sound becomes. This distortion is like a rough texturing, rather than the highly modulatory results of some of the other processes.This process can be used, therefore, to achieve a rough texturing with no loss of duration.” },
arg1 = { name = “A”, min = 0, max = 5000, tip = “number of wavecycles to omit” },
arg2 = { name = “B”, min = 0, max = 5000, tip = “size of group of ‘wavecycles’ out of which to omit A wavecycles” },
}

dsp[“Distort Overload – Clip the signal with noise or a (possibly timevarying) waveform”] = {
cmds = { exe = “distort”, mode = “overload 1”, tip = “The clip-level parameter is rather like a ‘gate’ level. If the signal level is already high, anything over, for example, 0.1 is likely to push it into distortion, and values considerably higher than this will make it heavily distorted. However, if it only distorts, Trevor advises me, when it reaches a level of, for example, 0.99, it is not going to be distorted very often. The sound doesn’t actually have amplitude overload, because it is distorted by ‘slicing off’ the top (clipping) where it would have overloaded. The sound becomes loud and ‘strained’, like a voice which is shouting too loudly.Given the trials made so far, this can be a fairly subtle effect, but the words ‘straining’, ‘loud’, ‘uncompromising’ seem appropriate as the amplitude gets pushed towards the top of the range.” },
arg1 = { name = “clip-level”, min = 0, max = 1, tip = “level at which the signal is to be clipped (Range: 0 to 1) The signal level is renormalised after clipping.” },
arg2 = { name = “depth”, min = 0, max = 1, tip = “depth of the pattern of distortion imposed on clipped stretches of the signal. (Range: 0 to 1)” },
}

dsp[“Distort Overload – Clip the signal with noise or a (possibly timevarying) waveform”] = {
cmds = { exe = “distort”, mode = “overload 2”, tip = “The clip-level parameter is rather like a ‘gate’ level. If the signal level is already high, anything over, for example, 0.1 is likely to push it into distortion, and values considerably higher than this will make it heavily distorted. However, if it only distorts, Trevor advises me, when it reaches a level of, for example, 0.99, it is not going to be distorted very often. The sound doesn’t actually have amplitude overload, because it is distorted by ‘slicing off’ the top (clipping) where it would have overloaded. The sound becomes loud and ‘strained’, like a voice which is shouting too loudly. Mode 2 can add an extra ringing sound as the value for freq gets higher, e.g., 2000Hz and beyond. Given the trials made so far, this can be a fairly subtle effect, but the words ‘straining’, ‘loud’, ‘uncompromising’ seem appropriate as the amplitude gets pushed towards the top of the range.” },
arg1 = { name = “clip-level”, min = 0, max = 1, tip = “level at which the signal is to be clipped (Range: 0 to 1) The signal level is renormalised after clipping.” },
arg2 = { name = “depth”, min = 0, max = 1, tip = “depth of the pattern of distortion imposed on clipped stretches of the signal. (Range: 0 to 1)” },
arg3 = { name = “freq”, min = 0, max = 22500, tip = “frequency of the waveform imposed on clipped stretches of the signal” },
}

dsp[“Distort Pitch - Pitchwarp wavecycles of sound”] = {
cmds = { exe = “distort”, mode = “pitch”, tip = “The random up/down movement of the ‘wavecycles’ within the total octvary range produces a great deal of bending of the sound, especially if the original alters its pitch a good deal. It is better, therefore, to start with relatively small values for octvary – e.g., less than 1 – so that you start to use this function with some degree of control over the results.The full power of DISTORT PITCH doesn’t really come into its own until time-varying parameters are used, especially for cyclecnt. Large values for the latter will serve to slow down the rate of change. DISTORT PITCH is useful for creating ‘flexitones’ (to coin a term) – with distortion, of course.” },
arg1 = { name = “octvary”, min = 0,0, max = 8,0, tip = “maximum possible transposition up or down in (fractions of) octaves (Range > 0.0 to 8.0)” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “mamimum number of ‘wavecycles’ between the generation of transposition values (Range: > 1, Default: 64)” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Pulsed - Impose impulse-train on a sound”] = {
cmds = { exe = “distort”, mode = “pulsed 1”, tip = “Distort a sound by imposing a series of impulses on the source, or on a specific waveset segment of the source. An impulse is like a brief event created by a sharp envelope on the sound. The sound inside the impulse might glissando slightly, as if whatever is causing the impulsion has warped the sound by its impact.” },
arg1 = { name = “stime”, min = 0.001, max = 10, tip = “time in the source sound where the impulses begin” },
arg2 = { name = “dur”, min = 0.001, max = 10, tip = “length of time that the impulses continue” },
arg3 = { name = “frq”, min = 0, max = 1000, tip = “number of impulses per second” },
arg4 = { name = “frand”, min = 0, max = 12, tip = “number of semitones by which to randomise the frequency of the impulses” },
arg5 = { name = “trand”, min = 0, max = 10, tip = “amount of time in seconds by which to randomise the relative time positions of amplitude peaks and troughs from impulse to impulse” },
arg6 = { name = “arand”, min = 0, max = 1, tip = “randomisation of the amplitude shape created by the peaks and troughs from impulse to impulse” },
arg7 = { name = “transp”, min = 0, max = 1, tip = “transposition contour of sound inside each impulse” },
arg8 = { name = “tranrand”, min = 0, max = 1, tip = “randomisation of transposition contour from impulse to impulse” },
arg9 = { name = “-s”, switch = “-s”, tip = “keep start of source sound, before impulses begin (if any)” },
arg10 = { name = “-e”, switch = “-e”, tip = “keep end of source sound, after impulses end (if any)” },
}

dsp["Distort Pulsed - Imposed regular pulsations on a sound "] = {
cmds = { exe = “distort”, mode = “pulsed 2”, tip = “Distort a sound by imposing a series of impulses on the source, or on a specific waveset segment of the source. An impulse is like a brief event created by a sharp envelope on the sound. The sound inside the impulse might glissando slightly, as if whatever is causing the impulsion has warped the sound by its impact.” },
arg1 = { name = “stime”, min = 0.001, max = 10, tip = “time in the source sound where the impulses begin” },
arg2 = { name = “dur”, min = 0.001, max = 10, tip = “length of time that the impulses continue” },
arg3 = { name = “frq”, min = 0, max = 1000, tip = “number of impulses per second” },
arg4 = { name = “frand”, min = 0, max = 12, tip = “number of semitones by which to randomise the frequency of the impulses” },
arg5 = { name = “trand”, min = 0, max = 10, tip = “amount of time in seconds by which to randomise the relative time positions of amplitude peaks and troughs from impulse to impulse” },
arg6 = { name = “arand”, min = 0, max = 1, tip = “randomisation of the amplitude shape created by the peaks and troughs from impulse to impulse” },
arg7 = { name = “cycletime”, min = 0, max = 10, tip = “duration in seconds of wavecycles to grab as sound substance inside the impulses” },
arg8 = { name = “transp”, min = 0, max = 1, tip = “transposition contour of sound inside each impulse” },
arg9 = { name = “tranrand”, min = 0, max = 1, tip = “randomisation of transposition contour from impulse to impulse” },
arg10 = { name = “-s”, switch = “-s”, tip = “keep start of source sound, before impulses begin (if any)” },
arg11 = { name = “-e”, switch = “-e”, tip = “keep end of source sound, after impulses end (if any)” },
}

dsp[“Distort Reform - Convert to fixed level square wave”] = {
cmds = { exe = “distort”, mode = “reform 1”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to square wave”] = {
cmds = { exe = “distort”, mode = “reform 2”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to fixed level triangular wave”] = {
cmds = { exe = “distort”, mode = “reform 3”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to triangular wave”] = {
cmds = { exe = “distort”, mode = “reform 4”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to inverted half-cycles”] = {
cmds = { exe = “distort”, mode = “reform 5”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to click streams”] = {
cmds = { exe = “distort”, mode = “reform 6”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to sinusoid”] = {
cmds = { exe = “distort”, mode = “reform 7”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Exaggerate waveform contour”] = {
cmds = { exe = “distort”, mode = “reform 8”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
arg1 = { name = “exaggeration”, min = 0,000002, max = 40, tip = “exaggeration factor (Range: 0.000002 to 40.0)” },
}

dsp[“Distort Repeat - Timestretch soundfile by repeating wavecycles”] = {
cmds = { exe = “distort”, mode = “repeat”, tip = “The repetition of the ‘wavecycles’ stretches out the sound, making it both longer and more granular in texture. This granularity is increased if (increasingly larger) groups of cyclecnt ‘wavecycles’ are used: then the whole group repeats multiplier times. DISTORT REPEAT produces long, grainy (distorted) sounds. The sense of stretching out the original is very apparent.A significant application of DISTORT REPEAT is that, by increasing the cyclecnt factor, one crosses the pitch-perception boundary: that is, starting with a noisy sound in which all the wavecycles are randomly different, one ends up with, for example, 7 repetitions of the same wavecycle, followed by 7 of another and so on – and each of these comprise sufficient repetitions for us to hear pitch. Thus the noise source becomes a string of pitch beads, each of arbitrary timbre. With a cyclecnt of, for example, 128, one can even get a slowish random melody.” },
arg1 = { name = “multiplier”, min = 0,0, max = 50, tip = “number of times (integer) each ‘wavecycle’ (group) repeats” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “number of ‘wavecycles’ (integer) in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = "number of ‘wavecyles’ (integer) to skip at start of file " },
}

dsp[“Distort Repeat 2 - Repeat wavecycles without time-stretching”] = {
cmds = { exe = “distort”, mode = “repeat2”, tip = “Repeating the ‘wavecycles’ without time-stretching (as in DISTORT REPEAT) enables you to increase the strength of the distortion with the multiplier parameter without making the output file any longer than the original. Larger values for cyclecnt increases the length of infile that is affected. Higher values for multiplier increase the distortion, while higher values for cyclecnt increase the length of infile that is processed as one unit. Thus we could have: a low value for multiplier coupled with a high value for cyclecnt – this will produce a bit of distortion while the source remains recognisable, a high value for multiplier coupled with a low value for cyclecnt – this will produces a great deal of distortion, but the effect is limited because only a few cycles are affected as a unit. High values for both parameters – this appears to create the most distortion” },
arg1 = { name = “multiplier”, min = 0,0, max = 50, tip = “number of times (integer) each ‘wavecycle’ (group) repeats” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “number of ‘wavecycles’ (integer) in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = "number of ‘wavecyles’ (integer) to skip at start of file " },
}

dsp[“Distort Replace – The strongest wavecycle in a cyclecnt group replaces the others”] = {
cmds = { exe = “distort”, mode = “replace”, tip = “The replacing action serves to simplify the sound. Note that the single strong ‘wavecycle’ in the group will take the place of several others, which will be deleted. This simplification becomes extreme when the cyclecnt is high, leading to a ‘sample-hold’ kind of stepped effect. Time-varying cyclecnt makes it possible to introduce gradual change. With DISTORT REPLACE we can achieve a simplification of the sound, up to very clear ‘sample-hold’ type stepped tones” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 5000, tip = “(integer) size of group of ‘wavecycles’” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “number of ‘wavecyles’ (integer) to skip at start of file” },
}

dsp["Distort Replim – Timestretch by repeating wavecycles (below a specified frequency) “] = {
cmds = { exe = “distort”, mode = “replim”, tip = “This function is like DISTORT REPEAT, but with a slight change. Here the length of wavecycle to be affected can be set. Thus, if you set a mid-range frequency, only those below that frequency will repeat, and the others (above the frequency) will be discarded (filtered out). Hence the name ‘REP-LIM’, meaning ‘repeat (with a) limit’. DISTORT REPLIM is therefore like a filtering program that also repeats wavecycles. In the DISTORT set, the wavecycles are wavelengths that occur between zero crossings, so distortion also occurs. It is helpful to remember that wavelength is inversely proportional to frequency. Wavelength is the actual physical length of the oscillation, and frequency is the number of cycles that occur in one second (i.e., Hertz). These two aspects of sound are inversely proportional to one another: P = 1/f. For example, a sound oscillating at 100 Hz will have a period, i.e., a wavelength of 1/100 meters = 0.01 meters (0.39 inch). A sound oscillating at 1000Hz will have a wavelength of 1/1000 meters = 0.001 meters (0.039 inch). Short wavecycles are therefore higher in pitch and long ones are lower in pitch. When the frequency setting for DISTORT REPLIM is high, the filter point is set higher and more of the sound will be retained. Here we are dealing with ‘pseudo-wavecycles’ (portions of soundfile between zero crossings), which is what introduces distortion into the equation.The net result of the function is to create repetition distortion while filtering out a user-definable amount of the higher frequencies. Remember that the relative amounts of high and low frequencies in the infile will affect the results.” },
arg1 = { name = “multiplier”, min = 0.001, max = 100, tip = “the number of times each wavecycle (group) repeats (Integer)” },
arg2 = { name = “cyclecnt”, switch = “-c”, min = 0, max = 5000, tip = “the number of wavecycles in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = " the number of wavecycles to skip at the beginning of the soundfile” },
arg4 = { name = “hilim”, switch = “-f”, min = 0, max = 22500, tip = “the frequency below which cycles are counted” },
}

dsp[“Distort Reverse - Cycle-reversal distortion in which the wavecycles are reversed in groups”] = {
cmds = { exe = “distort”, mode = “reverse”, tip = “Here the original soundfile is grouped into a series of ‘wavecycles’ with cyclecnt ‘wavecycles’ in each group. Then each of these groups of ‘wavecycles’ is reversed. The term ‘distortion’ here is something of a misnomer, because no distortion process is applied to the ‘wvecycles’ themselves. Instead, cyclecnt sets the number of ‘wavecycles’ which are to be copied in reverse as a group to the outfile. For example, if cyclecnt = 3, 15 ‘wavecycles’ reversed in groups of 3 will assume the order: 3-2-1, 6-5-4, 9-8-7, 12-11-10, 15-14-13. Thus, not only is the sound material backwards, but the reversed 1st ‘wavecycle’ is now adjacent to the reversed 6th ‘wavecycle’. This mimics the classical tape studio technique of cutting up a length of tape into segments (of varying lengths), reversing the segments, and joining up the reversed pieces. The result will be similar to a random brassage because of the differing lengths of the ‘wavecycles’. The process moves steadily through the infile from beginning to end, so the normal order of the (reversed) events is preserved. It is surprising how normal the output can be. With mid-range values for cyclecnt (say, 30 to 100), one hears the original breaking up, but only with very large values for cyclecnt does one hear the sound sweeping backwards in large swathes. Again, it is a question of ‘resolution’: the size of the units being manipulated. A small value for cyclecnt will produce a grainy result, mid-values a ‘broken up’ result, and large values swathes of reversed sound. If the value for cyclecnt exceeds the number of ‘wavecycles’ in the infile, you will be told that the ‘sound source is too short…’. DISTORT CYCLECNT returns the number of ‘wavecycles’ in a sound, should you want to provide a value for cyclecnt which is right up to the limit. Reversing the output of DISTORT REVERSE turns the cyclecnt groups back the other way while reading the whole soundfile from back to front, producing an interesting mixture of forwards and backwards! Using the time-varying option for cyclecnt provides an opportunity for dramatic or gradual changes in the output.” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 10000, tip = “number of ‘wavecycles’ in a reversed group (Range: > 0)” },
}

dsp[“Distort Telescope - Time-contract sound by telescoping N wavecycles into 1”] = {
cmds = { exe = “distort”, mode = “telescope”, tip = “Although at first rather like DISTORT OMIT, here the ‘wavecycles’ are not deleted as such. Instead, they are superimposed (i.e., mixed) onto each other, with shorter ‘wavecycles’ being stretched to fit the longest one in each group of cyclecnt ‘wavecycles’. The outfile will usually be much shorter than the infile and can be reduced to a mere blip with this process. The -a flag tells the program to telescope to the average ‘wavecycle’ length, rather than to the longest. Since the longest ‘wavecycle’ in each group is compressed by this method, the outfile will be even shorter. Interesting results can be achieved with small values for cyclecnt, the output tending to have a ‘mushy’ quality. It responds well to pitched material, producing a singing, if mushy, tone.” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 1000, tip = “the number of ‘wavecycles’ in a group” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “number of ‘wavecyles’ (integer) to skip at start of file” },
arg3 = { name = “-a”, switch = “-a”, tip = “telescope to an average ‘wavecycle’ length (Default: telescope to the longest ‘wavecycle’ length)” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles below freq”] = {
cmds = { exe = “distort”, mode = “filter 1”, tip = “Period and frequency are inverse functions. Therefore it is possible to relate the length of a ‘wavecycle’ to the frequency it would have were it to recur regularly. This program therefore filters by removing ‘wavecycles’ shorter or longer than those relating to a specific, user-defined, frequency. The duration of the outfile is affected by this process: because ‘wavecycles’ are being removed, the outfile will be shorter, by varying degrees. The aural effect of the DISTORT FILTER process is actually like gating. In gating, you can imagine a horizontal line drawn through the time/amplitude display of a soundfile. If the peaks above the line are retained (by filtering out lower frequencies), you just hear them (joined up). Similarly, if you filter out above the line, the peaks are gone, leaving the lower sound material (joined up). The difference here is that the process is operating on ‘pseudo-wavecycles’ according to their length, so here the results are more unpredictable and also distort the sound to some degree, depending on where the horizontal line – the frequency variable(s) – is drawn. Technically, the process is akin to low-, high- and band-pass filters, but aurally it is more like gating. You can therefore use this procedure to cut out some and distort other material in a sound.” },
arg1 = { name = “freq”, min = 10,0, max = 22050.0, tip = “frequency in Hz (Range: 10.0 to 22050.0)” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles above freq”] = {
cmds = { exe = “distort”, mode = “filter 2”, tip = “Period and frequency are inverse functions. Therefore it is possible to relate the length of a ‘wavecycle’ to the frequency it would have were it to recur regularly. This program therefore filters by removing ‘wavecycles’ shorter or longer than those relating to a specific, user-defined, frequency. The duration of the outfile is affected by this process: because ‘wavecycles’ are being removed, the outfile will be shorter, by varying degrees. The aural effect of the DISTORT FILTER process is actually like gating. In gating, you can imagine a horizontal line drawn through the time/amplitude display of a soundfile. If the peaks above the line are retained (by filtering out lower frequencies), you just hear them (joined up). Similarly, if you filter out above the line, the peaks are gone, leaving the lower sound material (joined up). The difference here is that the process is operating on ‘pseudo-wavecycles’ according to their length, so here the results are more unpredictable and also distort the sound to some degree, depending on where the horizontal line – the frequency variable(s) – is drawn. Technically, the process is akin to low-, high- and band-pass filters, but aurally it is more like gating. You can therefore use this procedure to cut out some and distort other material in a sound.” },
arg1 = { name = “freq”, min = 10,0, max = 22050.0, tip = “frequency in Hz (Range: 10.0 to 22050.0)” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles below & above freq”] = {
cmds = { exe = “distort”, mode = “filter 3”, tip = “Period and frequency are inverse functions. Therefore it is possible to relate the length of a ‘wavecycle’ to the frequency it would have were it to recur regularly. This program therefore filters by removing ‘wavecycles’ shorter or longer than those relating to a specific, user-defined, frequency. The duration of the outfile is affected by this process: because ‘wavecycles’ are being removed, the outfile will be shorter, by varying degrees. The aural effect of the DISTORT FILTER process is actually like gating. In gating, you can imagine a horizontal line drawn through the time/amplitude display of a soundfile. If the peaks above the line are retained (by filtering out lower frequencies), you just hear them (joined up). Similarly, if you filter out above the line, the peaks are gone, leaving the lower sound material (joined up). The difference here is that the process is operating on ‘pseudo-wavecycles’ according to their length, so here the results are more unpredictable and also distort the sound to some degree, depending on where the horizontal line – the frequency variable(s) – is drawn. Technically, the process is akin to low-, high- and band-pass filters, but aurally it is more like gating. You can therefore use this procedure to cut out some and distort other material in a sound.” },
arg1 = { name = “freq1”, min = 0,0, max = 22050.0, tip = “frequency in Hz to delete below” },
arg2 = { name = “freq2”, min = 0,0, max = 22050,0, tip = “frequency in Hz to delete above” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}


dsp[“Modify Brassage - Pitchshift - Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 1” },
arg1 = { name = “pitchshift”, min = -0,12, max = 12, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
}

dsp[“Modify Brassage - Timestretch -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 2” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
}

dsp[“Modify Brassage - Reverb -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 3” },
arg1 = { name = “density”, min = 0,0, max = 1000, tip = “amount of grain overlap (Range: > 0)” },
arg2 = { name = “pitch”, min = -0,33, max = 0,33, tip = “transposition factor (Range: -0.33 to 0.33)” },
arg3 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg4 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
}

dsp[“Modify Brassage - Scramble -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 4” },
arg1 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg2 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
}

dsp[“Modify Brassage - Granulate -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 5” },
arg1 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg2 = { name = “-d”, switch = “-d” },
}

dsp[“Modify Brassage - Brassage -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 6” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
arg2 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg3 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg4 = { name = “pitchshift”, min = -0,33, max = 0,33, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
arg5 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg6 = { name = “space”, min = 0, max = 1, tip = “spatial position – set stereo position” },
arg7 = { name = “bsplice”, min = 0, max = 1000, tip = “length of start-splices on grains in ms (Default: 5)” },
arg8 = { name = “esplice”, min = 0, max = 1000, tip = “length of end-splices on grains in ms (Default: 5)” },
arg9 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
arg10 = { name = “jitter”, switch = “-j”, min = 0, max = 1, tip = “randomisation of grain position” },
arg11 = { name = “outlength”, switch = “-l”, min = 0, max = 10, tip = “maximum outfile length (if end of data is not reached)” },
arg12 = { name = “channel”, switch = “-c”, min = 0, max = 2, tip = " extract and work on just one channel of a stereo input (Range: 1 or 2) Set channel to 0 (the Default) for this parameter to be ignored." },
arg13 = { name = “-d”, switch = “-d” },
arg14 = { name = “-x”, switch = “-x”, tip = “do exponential splices (Default: linear)” },
arg15 = { name = “-n”, switch = “-n”, tip = “no interpolation for pitch values (quick but dirty)” },
}

dsp[“Modify Brassage - Full Monty -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 7” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
arg2 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg3 = { name = “hvelocity”, min = 0,0, max = 5000,0 },
arg4 = { name = “hdensity”, min = 0,0, max = 5000,0 },
arg5 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg6 = { name = “pitchshift”, min = -0,33, max = 0,33, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
arg7 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg8 = { name = “space”, min = 0, max = 1, tip = “spatial position – set stereo position” },
arg9 = { name = “bsplice”, min = 0, max = 1000, tip = “length of start-splices on grains in ms (Default: 5)” },
arg10 = { name = “esplice”, min = 0, max = 1000, tip = “length of end-splices on grains in ms (Default: 5)” },
arg11 = { name = “hgrainsize”, min = 0, max = 5000 },
arg12 = { name = “hpitchshift”, min = -0,33, max = 0,33 },
arg13 = { name = “hamp”, min = 0, max = 1 },
arg14 = { name = “hspace”, min = 0, max = 2 },
arg15 = { name = “hbsplice”, min = 0, max = 1000 },
arg16 = { name = “hesplice”, min = 0, max = 1000 },
arg17 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
arg18 = { name = “jitter”, switch = “-j”, min = 0, max = 1, tip = “randomisation of grain position” },
arg19 = { name = “outlength”, switch = “-l”, min = 0, max = 10, tip = “maximum outfile length (if end of data is not reached)” },
arg20 = { name = “channel”, switch = “-c”, min = 0, max = 2, tip = " extract and work on just one channel of a stereo input (Range: 1 or 2) Set channel to 0 (the Default) for this parameter to be ignored." },
arg21 = { name = “-d”, switch = “-d” },
arg22 = { name = “-x”, switch = “-x”, tip = “do exponential splices (Default: linear)” },
arg23 = { name = “-n”, switch = “-n”, tip = “no interpolation for pitch values (quick but dirty)” },
}

dsp[“Modify Loudness - Alter gain of sound”] = {
cmds = { exe = “modify”, mode = “loudness 1” },
arg1 = { name = “gain”, min = 0,0, max = 100,0, tip = “adjust level by factor gain” },
}

dsp[“Modify Loudness - Alter dB-gain of sound”] = {
cmds = { exe = “modify”, mode = “loudness 2” },
arg1 = { name = “gain”, min = -96, max = 96, tip = “level expressed in dB (Range: -96dB to 96dB). NB: every drop of -6dB halves the previous level.” },
}

dsp[“Modify Loudness - Normalise”] = {
cmds = { exe = “modify”, mode = “loudness 3” },
arg1 = { name = “level”, switch = “-l”, min = 0, max = 1, tip = “force level (if necessary) to the maximum possible, or to the level given (Range: 0 to 1).” },
}

dsp[“Modify Loudness - Force level”] = {
cmds = { exe = “modify”, mode = “loudness 4” },
arg1 = { name = “level”, switch = “-l”, min = 0, max = 1, tip = “force level to maximum possible, or to the level given (Range: 0 to 1)” },
}

dsp[“Modify Loudness - Invert Phase”] = {
cmds = { exe = “modify”, mode = “loudness 6” },
}

dsp[“Phase - Invert phase”] = {
cmds = { exe = “phase”, mode = “phase 1”, tip = “Playback of the output inverted soundfile shows that there is no audible difference from the input soundfile. However, if you mix the original sound with the phase inverted sound, you will generate a silent output: positive and negative amplitude values cancel out. However, if you mix the input and output with an offset, you get signal and hear an overlap of the two soundfiles (the cancelling out does not fully happen). You can try this with SUBMIX MERGE.” },
}

dsp[“Phase - Stereo Enhance stereo file”] = {
cmds = { exe = “phase”, mode = “phase 2”, tip = “This mode is supposed to be a means of creating an enhanced stereo image by suppressing any aspects of the Left image which have bled to the Right, by adding (part of) the phase inverted Left signal on the Right, and vice versa. I (T Wishart) learned of this idea from a mixing engineer I met in France, but I’m still not convinced that this achieves anything except in very special circumstances (with particular types of material). The output may sound the same as the input, except perhaps on the largest PA systems.” },
arg1 = { name = “transfer”, switch = “-t”, min = 0, max = 1, tip = “amount of signal to be used in phase-cancellation.” },
}

dsp[“Modify Radical - Reverse”] = {
cmds = { exe = “modify”, mode = “radical 1”, tip = “Sound plays backwards, the soundfile is re-written back to front: starting at the end and ending at the beginning.” },
}

dsp[“Modify Radical - Shred”] = {
cmds = { exe = “modify”, mode = “radical 2”, tip = “The soundfile is (randomly) segmented, and these segments reordered by means of a permutation process. As the number of repeats increases, it gets more and more jumbled, literally ‘reducing it to shreds’. The -n adds splicing that results in a smoother output.” },
arg1 = { name = “repeats”, min = 0, max = 1000, tip = “number of repeats of shredding process” },
arg2 = { name = “chunklen”, min = 0, max = 500, tip = “average length of chunks to cut and permutate” },
arg3 = { name = “scatter”, switch = “-s”, min = 0, max = 10, tip = “randomisation of cuts (Range: 0 to K, where K = duration of infile/chunklen Default = 1)” },
arg4 = { name = “-n”, switch = “-n”, tip = “use this flag for a smoother output” },
}

dsp[“Modify Radical - Scrub back and forth”] = {
cmds = { exe = “modify”, mode = “radical 3”, tip = “This is an acceleration/deceleration process which models an editing procedure used in the ‘classical’ tape studio: the desired edit point was found by turning the tape spools by hand so that the tape moved (very slowly!) across the tape head. You could hear locate exactly where silence began or ended, where clicks came etc., although the sound was very low because of the slow speed.The SCRUB function could also be used creatively, to create extreme speed modifications of the source sound on the tape, e.g. an abrupt acceleration-deceleration as the tape went from not-moving, to fast-moving, to stopped as the hands jerked the tape across the heads.” },
arg1 = { name = “dur”, min = 0, max = 10, tip = “minimum length of outfile required” },
arg2 = { name = “down”, switch = “-l”, min = 0, max = 12, tip = “lowest downward tranposition in semitones” },
arg3 = { name = “up”, switch = “-h”, min = 0, max = 12, tip = " highest upward transposition in semitones" },
arg4 = { name = “start”, switch = “-s”, tip = "scrubs start before time start seconds " },
arg5 = { name = “end”, switch = “-e”, tip = “scrubs end after time end” },
}

dsp[“Modify Radical - Lose resolution”] = {
cmds = { exe = “modify”, mode = “radical 4”, tip = “LOSE RES: Reducing the sample rate reduces the level of the Nyquist frequency (sample_rate/2), thereby lowering the frequency level which can be safely handling during processing. Lowering bit-resolution reduces the precision of the numerical expression of the data, making the digital ‘quantisation’ of the sonic material coarser. This means that time-varying information is lost.” },
arg1 = { name = “bit_resolution”, min = 0, max = 16 },
arg2 = { name = “srate_division”, min = 1, max = 256, tip = “Range: 1 to 256 Default 1 (normal)” },
}

dsp[“Modify Radical - Ring Modulate”] = {
cmds = { exe = “modify”, mode = “radical 5”, tip = “RING MODULATION: multiplies two (bipolar) signals. In this case, one signal is a soundfile and the other is a modulating_frq. This creates two ‘sidebands’ which are the sum and the difference of the two signals, while the carrier signal disappears. The result is a timbrally ‘hollow’ sound. (See Curtis Roads, The Computer Music Tutorial, pp. 215-220).” },
arg1 = { name = “modulating-frq”, min = 0, max = 44100, tip = “number of cycles per second” },
}

dsp[“Modify Revecho - Standard delay”] = {
cmds = { exe = “modify”, mode = “revecho 1”, tip = " Mode 1 provides a standard delay. If a smooth echoey effect is wanted, be careful to keep mix on the low side. Remember that delay is given in milliseconds; after 60ms or so, one begins to hear a strong reverberation; after 100 ms the reverberation begins to ‘bounce’, and by 200 ms one begins to hear distinct echoes. Delay times greater than 1000 will cause repetitions of (all or much of) the sound. Don’t forget to lengthen the tail to match the delay time.The mix parameter, in adding in the delayed signal, increases the reverberant effect. With a short delay time, this can sound like the reverberation which occurs in an enclosed space. Feedback has a similar effect, becoming very pronounced towards a value of 1.0 – rather like the ‘feedback’ which occurs when a microphone is placed facing a loudspeaker. The operation of a standard delay line in Mode 1 ranges from modest reverberation to echo effects. The reverberations, however, tend easily towards rough edges, so for smoother reverbs, look to the programs listed below." },
arg1 = { name = “delay”, min = 0, max = 5000, tip = “delay time, in milliseconds” },
arg2 = { name = “mix”, min = 0, max = 1, tip = " amount of delayed signal in final mix: 0 gives ‘dry’ result (Range: 0 to 1)" },
arg4 = { name = “feedback”, min = -1,0, max = 1,0, tip = “produces resonances related to delay time (with short times) (Range: -1.0 to 1.0)” },
arg5 = { name = “tail”, min = -1,0, max = 1,0, tip = “time to allow decayed signal to decay to zero (Range: -1.0 to 1.0)” },
arg6 = { name = “prescale”, switch = “-p”, tip = “prescales input level, to avoid overload” },
arg7 = { name = “-i”, switch = “-i”, tip = “inverts the dry signal (for phasing effects)” },
}

dsp[“Modify Revecho - Varying delay”] = {
cmds = { exe = “modify”, mode = “revecho 2” },
arg1 = { name = “delay”, min = 0, max = 5000, tip = “delay time, in milliseconds” },
arg2 = { name = “mix”, min = 0, max = 1, tip = " amount of delayed signal in final mix: 0 gives ‘dry’ result (Range: 0 to 1)" },
arg4 = { name = “feedback”, min = -1,0, max = 1,0, tip = “produces resonances related to delay time (with short times) (Range: -1.0 to 1.0)” },
arg5 = { name = “lfomod”, min = 0, max = 1, tip = “depth of the delay-variation sweep (Range: 0 to 1)” },
arg6 = { name = “lfofreq”, min = -50, max = 50, tip = “frequency of the delay-variation sweep (negative values give random oscillations)” },
arg7 = { name = “lfophase”, min = 0, max = 1, tip = “start-phase of the delay-variation sweep (Range: 0 to 1)” },
arg8 = { name = “lfodelay”, min = 0, max = 10, tip = “time in seconds before the delay-variation sweep begins” },
arg9 = { name = “tail”, min = -1,0, max = 1,0, tip = “time to allow decayed signal to decay to zero (Range: -1.0 to 1.0)” },
arg10 = { name = “prescale”, switch = “-p”, tip = “prescales input level, to avoid overload” },
arg11 = { name = “seed”, switch = “-s”, min = 0, max = 100, tip = "non-zero value gives reproducible output (with the same seed) where random oscillations are used " },
}

dsp[“Modify Revecho - Stadium Echo”] = {
cmds = { exe = “modify”, mode = “revecho 3”, tip = “This creates a stereo outfile, bouncing the signal between speakers with a very prominent delay factor. The idea is that you hear the signal bouncing around the ‘stadium’. The defaults work quite nicely, but you can intensify the effect by multiplying the delay time with the size parameter. Note that this is a multiple, so values less than 0 (multiplied with the default time of 0.1 sec) will decrease the delay time. Beyond size = 2, you are likely to run into insufficient buffer space, so if you really want longer delay times, you will have to increase the buffer size with ‘set CDP_MEMORY_BBSIZE=…’ (bear in mind the RAM capacity of your machine). (The default buffer size is 1 Mbyte and the units are in ‘k’: e.g., a BBSIZE of 3000 units is 3 Mbyte)” },
arg1 = { name = “gain”, switch = “-g”, min = 0, max = 1, tip = “to apply to input signal (Default: 0.645654)” },
arg2 = { name = “roll_off”, switch = “-r”, min = 0, max = 10, def = 1, tip = “rate of loss of level across stadium (Default: 1))” },
arg4 = { name = “size”, switch = “-s”, min = 0, max = 10, tip = “multiplies average time between echoes (the Default time between echoes of 0.1 sec)” },
arg5 = { name = “count”, switch = “-e”, min = 0, max = 23, tip = “number of stadium echoes (Default and max: 23)” },
}

dsp[“Modify Space - pan”] = {
cmds = { exe = “modify”, mode = “space 1”, tip = “Adjusts the amplitude levels of the two channels so as to create spatial illusions. A time pan breakpoint file is used to create movement. Mode1 PAN: control of sound in 3-D space has been a basic procedure when composing with ‘sound’ material, especially when these are drawn from nature/the environment. The assumption here is that you are thinking about the placement and movement of sound as an integral part of your compositional process. In this case, we are dealing with building these procedures into the sound itself. There is a further aspect external to the sound itself, achieved by ‘mixing’ (superimposing sounds and writing a new soundfile) and ‘diffusion’ (sound placement during playback achieved by manipulating the pan controls on a mixer).” },
arg1 = { name = “pan”, min = -1,0, max = 1,0, tip = “floating point value to specify location between the pair of stereo speakers, or breakpoint file of time pan pairs. Range: -1.0 to 1.0; 0.0 is centre.” },
arg2 = { name = “prescale”, switch = “-p”, min = 0, max = 1, tip = “gain factor multiplier with which to adjust the input level (Default: 0.7)” },
}

dsp["Modify Space - Mirrow: two channels swap sides "] = {
cmds = { exe = “modify”, mode = “space 2”, tip = “MIRROR: the data in the two channels swaps sides, a utility for a quick Left/Right swap” },
}

dsp[“Modify Space - Narrow: Narrow the stereo image of a sound”] = {
cmds = { exe = “modify”, mode = “space 4”, tip = “A way to restrict the spatial location of a sound in the horizontal plane, this program allows you to narrow the spread of a stereo field” },
arg1 = { name = “narrowing”, min = -1,0, max = 1,0, tip = “make the stereo image less wide” },
}

dsp[“Modify Speed - Vary speed & pitch of a sound”] = {
cmds = { exe = “modify”, mode = “speed 1”, tip = “Speed modification processes change the duration and the pitch of the sound together. Thus a faster speed causes a higher pitch, a slower speed a lower pitch.MODIFY SPEED offers a range of functions which affect the speed of the soundfile. Perhaps it will be most often used for transposition. Modes 1 and 2 both accept either single values or the names of time-varying breakpoint files with time transposition pairs. The single values act as constants and transpose the whole soundfile up or down by the given amount. In the breakpoint files, transposition can be almost instantaneous (almost same time, different transposition value), or gradual, creating glissandi (different time, different transposition value). No transposition between times is a third possibility (different time, same transposition value). Transposition which also changes the speed, and therefore the pitch, of the soundfile greatly alters the character of the sound. It is often very interesting to hear what a sound will be like 1, 2 or even 3 octaves below its original pitch. Deep, rich tones can be achieved in this way. These tones can slowly rise or descend if created with a time-varying breakpoint file e.g., moving an octave up or down over the time of the whole sound (airplane takeoff sounds, etc.)” },
arg1 = { name = “speed”, min = 0, max = 4, tip = “transposition value (ratio) expressed as a floating point multiplier” },
}

dsp[“Modify Speed - Vary speed & pitch by (fractional) number of semitones”] = {
cmds = { exe = “modify”, mode = “speed 2”, tip =“Speed modification processes change the duration and the pitch of the sound together. Thus a faster speed causes a higher pitch, a slower speed a lower pitch.MODIFY SPEED offers a range of functions which affect the speed of the soundfile. Perhaps it will be most often used for transposition. Modes 1 and 2 both accept either single values or the names of time-varying breakpoint files with time transposition pairs. The single values act as constants and transpose the whole soundfile up or down by the given amount. In the breakpoint files, transposition can be almost instantaneous (almost same time, different transposition value), or gradual, creating glissandi (different time, different transposition value). No transposition between times is a third possibility (different time, same transposition value). Transposition which also changes the speed, and therefore the pitch, of the soundfile greatly alters the character of the sound. It is often very interesting to hear what a sound will be like 1, 2 or even 3 octaves below its original pitch. Deep, rich tones can be achieved in this way. These tones can slowly rise or descend if created with a time-varying breakpoint file e.g., moving an octave up or down over the time of the whole sound (airplane takeoff sounds, etc.)” },
arg1 = { name = “semitone-transpos”, min = -12, max = 12, tip = " transposition value in positive or negative number of semitones; e.g., 12 raises the sound by an octave, and -12 lowers it by an octave. NB: use 0 (semitones) for no transposition." },
}

dsp[“Modify Speed - Accelerate or decelerate a sound”] = {
cmds = { exe = “modify”, mode = “speed 5” },
arg1 = { name = “accel”, min = 0, max = 100, tip = “multiplication of speed to be reached by goaltime – i.e., a transposition ratio” },
arg2 = { name = “goaltime”, min = 0, max = 30, tip = “time in outfile at which the accelerated speed is to be reached.” },
arg3 = { name = “starttime”, switch = “-s”, min = 0, max = 10, tip = “time in infile / outfile at which the acceleration begins” },
}

dsp[“Modify Speed -Add vibrato to a sound”] = {
cmds = { exe = “modify”, mode = “speed 6”, tip = “The vibrato created in Mode 6 is a frequency modulation. Given the very wide ranges allowed, this function is immensely powerful. A slow vibrate with a large vibdepth will swing the original sound wildly – increase vibrate and it really ‘flaps in the breeze’ (like a flag in the wind). A fast vibrate with a reasonably tight vibdepth, e.g., a minor 3rd, will produce a fluttering effect.” },
arg1 = { name = “vibrate”, min = 0,0, max = 120,0, tip = “the rate of vibrato shaking in cyles-per-second (Range: 0.0 to 120.0)” },
arg2 = { name = “vibdepth”, min = 0,0, max = 96,0, tip = “vibrato depth (pitch shift from centre) in [possibly fractional] semitones (Range: 0.0 to 96.0)” },
}

dsp[“Modify Stack -Create a mix that stacks transposed versions of source on top of one another “] = {
cmds = { exe = “modify”, mode = “stack”, tip = “New sounds can be developed from existing sources by stacking transposed copes of the original on top of each other. This is particularly successful where the source sound has a clearly defined attack at or near the start of the sound and then dies away gradually. If the copies are lined up in such a way that their attacks coincide exactly, the new sound will psycho-acoustically merge into a single sound event with harmonic content (rather than a chord made up of several sounds). The meaning of this is very precise: one is lining up the soundfiles at their perceived beginning, i.e., its attack, not the start of each soundfile. This is achieved by adjusting the start times of the transposed soundfiles.bMODIFY STACK is a very important program. It enables you to construct ‘larger’ versions of sounds by superimposing transposed versions on top of one another. Furthermore, it does this in such a way as to maximise the fusion of the layered sound by synchronising the attacks. This relates to a basic technique of orchestral scoring (where it is called ‘doubling’). It is a form of automatic mixing involving one soundfile.Because of the way the program functions, this is, however, quite a different process from transposing and mixing sounds to produce chords. (Doing this in the Spectral Domain, where transposition can be done without affecting duration, still has a place.) Here, if the attack points are made to coincide, the new sound-object is an integral whole, rather than a ‘chord’ made up of the transposed stack components: that is, the components fuse and cannot be separated in perception, as they can with a chord played, for example, on a piano keyboard.Also note that, as a Time Domain process, the higher transpositions end sooner than the lower ones. Use Spectral Domain transpositon along with SUBMIX MIX to assemble transposed versions of the same sound when equal length is important.Very low transpositions could produce an extremely long output. The dur parameter enables you to specify a much shorter outfile length. You can usually get an idea of the harmonic content of the output from the first few seconds.” },
arg1 = { name = “transpos”, min = 0, max = 12, tip = “transpos is the transposition in semitones between successive copies” },
arg2 = { name = “count”, min = 0, max = 100, tip = " the number of copies in the stack” },
arg4 = { name = “lean”, min = 0, max = 10, tip = “the loudness of the highest component, relative to the lowest (may be > 1)” },
arg5 = { name = “attack-offset”, min = 0, max = 50, tip = “adjusts the time at which the attack of each sound occurs” },
arg6 = { name = “gain”, min = 0,1, max = 10, tip = “an overall amplifying gain factor on the output sound; some reduction (less than 1) may be needed. (It may also be > 1.) Range: 0.1 to 10” },
arg7 = { name = “dur”, min = 0, max = 1, tip = “how much of the output to make (a proportion, from 0 to 1)” },
arg7 = { name = “-s”, switch = “-s”, tip = " see the relative levels of the layers in the stack” },
}

  
Maybe instead of having to scroll through the docs text it is possible for the tool gui to auto-adjust so all text fits in view? If to much work, no worries :-) .   
  
edit;  
  
at second thought, that might be too much text for some of the descriptions, maybe a button/toggle to show all text, similar to the question mark button inside the 'Track dsp' panel is a better idea?

Really strange, I can’t replicate this at all. What output do you get if you run this command in the terminal when there is no sample selected:

print(renoise.song().selected_sample)  

Also can you try changing line 125 in main.lua to:

dofile ("definitions.lua")  

Does that make any difference?

Originally thought of doing this as a pop up window launched by a button next to the pop-up list, but then I thought it was too many clicks and it would be handy to be able to see a description straight away. I can get it to resize based on the text so not a problem to do that either. There is also the option to load the url from the docs that come with CDP so a button could launch the detailed doc and a brief description in the tool… choices, choices!

Also will add the updated definitions to the next version, post any updated ones on here and I’ll keep it in sync, I won’t be adding any new definitions myself while I work on the code. Thanks to you I have plenty of definitions here to try out… Cheers

I get:

\>\>\> print(renoise.song().selected\_sample)  
userdata: 0x13E123E0 (Sample object)  

Nope, gives;

When I do the correct start-up procedure, loading the script after importing a sample first, I can make it produce this error notice every time I choose the ‘Modify Revecho - Stadium Echo’ preset:

Clicking away this bug, the gui remains open and when selecting a process that previously worked, it throws up another bug;

Maybe the bugs are related, not sure what I’m doing wrong in the definitions file for stadium echo?

edit;

this is my latest definition content;

[details=“Click to view contents”] ```
–[[
Instructions for definitions

You do not need to specify the infile or outfile these are handled by the tool.

Name the preset within the square brackets and in quotation marks after dsp[] e.g. dsp[“Preset name”]
The name can be anything but try and keep it the same or similar to the CDP reference documentation.

cmds

exe - The name of the CDP executable (exclude the .exe extension)
mode - The first part of the command argument that comes after the exe and before infile, outfile

arg1 to arg…n

name - The name displayed in the GUI (STRING)
switch - The switch flag, use only if it is a command switch e.g “-s” (STRING)
min - The minimum value of the range (NUMBER)
max - The maximum value of the range (NUMBER)
def - The default value the preset loads with (OPTIONAL NUMBER)
tip - The tool tip for the GUI control (OPTIONAL STRING)

Additional functions are available that give info about the sample

srate() - Gives the sample rate
cycles() - Gives the number of wavecycles (same as number of zero crossings/2)

–]]

dsp = {} – Do not edit this


– PRESET DEFINITIONS - afta8 –

dsp[“Filter Bank 1 - Harmonic”] = {
cmds = { exe = “filter”, mode = “bank 1”, tip = “The harmonic series is formed by multiplying a given frequency by an ascending series of integers: 1, 2, 3, 4, etc. The harmonic relationships produced are sonorous, but depart from the structure of triadic chords higher in the series. This Mode builds this type of harmonic relationship onto lofrq, which may be the actual pitch of a pitched tone or any arbitrary pitch. Because this is being done with a filter process, other sonic material is cleaned away, so a cleaner (and possibly quieter) sound may result, with more complex noise elements removed. Quite a bit of gain may be required – values of 40 or 50+ in this situation will not be unusual. Set hifrq as high as possible less too few harmonics are produced. This clean sound may provide a good input for spectral time-stretching, for example, to achieve a well-tuned sound with a minimum of artefacts.” },
arg1 = { name = “Q”, min = 0.001, max = 10000, tip = “Sets the Q of the effect” },
arg2 = { name = “Gain”, min = 0.001, max = 10000, def = 25 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Scatter”, switch = “-s”, min = 0, max = 1, tip = “Random scatter of frequencies” },
arg6 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 2 - Alt Harmonic”] = {
cmds = { exe = “filter”, mode = “bank 2”, tip = “This will be like Mode 1 but with every other harmonic omitted: the odd numbered partials are retained. The resulting sound will probably sound more ‘hollow’.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg6 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 3 - Sub Harmonic”] = {
cmds = { exe = “filter”, mode = “bank 3”, tip = “The ‘subharmonic series’ is the intervallic inverse of the harmonic series. Thus the departure from triadic-type intervals increases as the series descends. The resulting sound has a deeper tone and is somewhat hollow and somewhat inharmonic.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg6 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 4 - Harmonic Linear”] = {
cmds = { exe = “filter”, mode = “bank 4”, tip = “The offset in Hz is added to each harmonic. This will displace them so that they will no longer be exact multiples of the fundamental. This means that the cycles of the waveforms no longer line up at nodes, which introduces an ‘inharmonic’ dimension into the sound, heard as an increase in timbral components.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Offset (Hz)”, min = 10, max = srate()/3 },
arg6 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg7 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 5 - Filter Intervals”] = {
cmds = { exe = “filter”, mode = “bank 5”, tip = “Here we depart from the harmonic series and simply divide up the specified frequency range into an equal number filters: how many is specified by the user with param. The first effect this equal spacing will have is to create inharmonic (rather than integer multiple) relationships between the partials. A low number of filters will produce an ‘open’ sound, and a high number of filters will produce a denser, richer sound. These might be very interesting sounds to timestretch.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “No. Filters”, min = 1, max = 100 },
arg6 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg7 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 6 - Semitone Intervals”] = {
cmds = { exe = “filter”, mode = “bank 6”, tip = “By specifying the interval (in semitones), we in effect repeat these intervals within the frequency space between lofrq and hifrq, thus producing complex chords composed of the same interval ‘piled up’. This is a quick way to ‘harmonise’ a sound, with the resulting density dependent on the size of the interval. It is well worth re-running this function, entering intervals from 1 to 7, for example, to hear what kind of transformations will be produced. Some unexpected resonances may result; they could be filtered out later.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Semitones”, min = 1, max = 12 },
arg6 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg7 = { name = “Double”, switch = “-d” }
}


dsp[“Filter Phasing 1 - Allpass Filter”] = {
cmds = { exe = “filter”, mode = “phasing 1” },
arg1 = { name = “Gain”, min = -1, max = 1 },
arg2 = { name = “Delay”, min = 0.045, max = 1644.35 },
arg3 = { name = “PreScale”, switch = “-s”, min = 0, max = 1 },
arg4 = { name = “Linear”, switch = “-l” }
}

dsp[“Filter Phasing 2 - Phasing Effect”] = {
cmds = { exe = “filter”, mode = “phasing 1”, tip = “The ‘phasing effect’ is a kind of sweeping band passing through the sound, such as is sometimes heard when aeroplanes fly overhead, and is much used in popular music.Increasing the gain factor has some effect on the reverberant quality of the sound. So does increasing the delay time. The sound will still sound quite dry with delay < 20 (ms). Between about 20 and 45 ms there is a touch of resonance in the sound. Around 50 ms there is significant echoey reverberation (though somewhat granulated), and after 100 ms we start to hear larger portions of the sound repeating.Overall, the degree of reverberant effect is controlled by increasing both the gain and delay parameters in tandem” },
arg1 = { name = “Gain”, min = -1, max = 1 },
arg2 = { name = “Delay”, min = 0.045, max = 1644.35 },
arg3 = { name = “PreScale”, switch = “-s”, min = 0, max = 1 },
arg4 = { name = “Linear”, switch = “-l” }
}

dsp[“Filter Phasing 2 - Phasing Effect”] = {
cmds = { exe = “filter”, mode = “phasing 1”, tip = “The ‘phasing effect’ is a kind of sweeping band passing through the sound, such as is sometimes heard when aeroplanes fly overhead, and is much used in popular music.Increasing the gain factor has some effect on the reverberant quality of the sound. So does increasing the delay time. The sound will still sound quite dry with delay < 20 (ms). Between about 20 and 45 ms there is a touch of resonance in the sound. Around 50 ms there is significant echoey reverberation (though somewhat granulated), and after 100 ms we start to hear larger portions of the sound repeating.Overall, the degree of reverberant effect is controlled by increasing both the gain and delay parameters in tandem” },
arg1 = { name = “Gain”, min = -1, max = 1 },
arg2 = { name = “Delay”, min = 0.045, max = 1644.35 },
arg3 = { name = “PreScale”, switch = “-s”, min = 0, max = 1 },
arg4 = { name = “Linear”, switch = “-l” }
}


dsp[“Filter Sweeping 1 - High Pass”] = {
cmds = { exe = “filter”, mode = “sweeping 1”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.”
},
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}

dsp[“Filter Sweeping 2 - Low Pass”] = {
cmds = { exe = “filter”, mode = “sweeping 2”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.” },
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}

dsp[“Filter Sweeping 3 - Band Pass”] = {
cmds = { exe = “filter”, mode = “sweeping 3”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.” },
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}

dsp[“Filter Sweeping 4 - Notch”] = {
cmds = { exe = “filter”, mode = “sweeping 4”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.” },
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}


– Djeroek –

dsp[“Distort Average - average the waveshape over N wavecycles”] = {
cmds = { exe = “distort”, mode = “average”, tip = “DISTORT AVERAGE performs a mathematical averaging of the data in cyclecnt pseudo-wavecycles. The effect is more akin to a loss of resolution than the blurring which might be expected. Values below 10 retain some semblance of the original, while values of, for example, 100 seem to create a kind of ‘sample hold’ effect. For modest distortion, values 5 or less are recommended.” },
arg1 = { name = “cyclecnt”, min = 1, max = 6000, tip = “number of cycles over which to average (Range: > 1)” },
arg2 = { name = “maxwavelen”, switch = “-m”, min = 0, max = 1, tip = “maximum permissible wavelength in seconds (Default: 0.50)” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 1000, tip = “(integer) number of wavecycles to skip at start of file” },
}

dsp[“Distort Divide - Distortion by dividing wavecycle frequency”] = {
cmds = { exe = “distort”, mode = “divide”, tip = “Without altering duration, this process effectively lowers the sound while adding a rough texture.This is a useful form of distortion because it roughens the sound without being too violent about it” },
arg1 = { name = “N”, min = 2, max = 16, tip = “divider (Range: integer only, 2 to 16)” },
arg2 = { name = “-i”, switch = “-i”, tip = “use waveform interpolation: slower but cleaner” },
}

dsp[“Distort Fractal - Superimpose miniature copies of source wavecycles onto themselves”] = {
cmds = { exe = “distort”, mode = “fractal”, tip = “Note the very wide range of scaling. Because it is a divisor, the larger the value of scale the shorter will be the miniature copies to be superimposed. These superimposed copies can be made to increase (be careful!) or decrease in amplitude with the loudness parameter. Using a value of 1.0 maintains the original amplitude of the infile, which will be heard as pretty much as the original, but with the superimpositions on top of it. Loudness is therefore a means of balancing the input and the processed sound components.This is a powerful and somewhat wild tool for producing distortion effects. The higher the value of scaling, the more the superimposed copies appear as a sheen of distortion above the original sound.” },
arg1 = { name = “scaling”, min = 2, max = srate()/2, tip = “(integer) division of scale of source wave (Range: 2 to sample_rate/2)” },
arg2 = { name = “loudness”, min = 0, max = 10, tip = “loudness of scaled component relative to source (Loudness of source is reckoned to be 1.0)” },
arg3 = { name = “pre_attenuation”, switch = “-p”, tip = “apply attenuation to infile before processing” },
}

dsp["Distort Interpolate - Time-stretch file by repeating wavecycles and interpolating between them "] = {
cmds = { exe = “distort”, mode = “interpolate”, tip = “With this process, the shape of a ‘wavecycle’ is transformed into that of the next over multiplier repetitions. Note that this is waveshape-based interpolation, not a spectral interpolation, and that the length of the ‘wavecycle’ is also transformed by the process. The effect of the transformation is drastic, leading to a strongly granular outfile. The length of the outfile increases in step with the value of multiplier, as does the apparent pitchiness.The interpolation process adds a modulatory quality to the output, so that the successive wavecycles gliss and bend as they flow into one another. Even so, as multiplier increases, the perception of separate ‘grains’, i.e., ‘wavecycles’ increases. A value of 32, for example, changes the sound to a strange stream of modulating tones.” },
arg1 = { name = “multiplier”, min = 0, max = 50, tip = “(integer) number of times each ‘wavecycle’ repeats” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 20, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Multiply - Distortion by multiplying wavecycle frequency”] = {
cmds = { exe = “distort”, mode = “multiply”, tip = “The duration of the sound is not changed, only the frequency of the ‘wavecycles’, with the result that the pitch rises.The distortion is relatively mild, in that the original sound remains recognisable. However, the surface is textured and the pitch rises with each increase in the value of N. DISTORT MULTIPLY can be used, for example, to create high, modulating, grainy vocal sounds.” },
arg1 = { name = “N”, min = 2, max = 16, tip = “multiplier (Range: 2 to 16, integer only)” },
arg2 = { name = “-s”, switch = “-s”, tip = “smoothing (try this if glitches appear)” },
}

dsp[“Distort Omit – Omit A out of every B wavecycles, replacing them with silence”] = {
cmds = { exe = “distort”, mode = “omit”, tip = “Because the omitted ‘wavecyles’ are replaced by silence, the overall duration of the sound does not change. The larger the proportion of ‘wavecycles’ omitted from B, of course, the more distorted the the sound becomes. This distortion is like a rough texturing, rather than the highly modulatory results of some of the other processes.This process can be used, therefore, to achieve a rough texturing with no loss of duration.” },
arg1 = { name = “A”, min = 0, max = 5000, tip = “number of wavecycles to omit” },
arg2 = { name = “B”, min = 0, max = 5000, tip = “size of group of ‘wavecycles’ out of which to omit A wavecycles” },
}

dsp[“Distort Overload – Clip the signal with noise or a (possibly timevarying) waveform”] = {
cmds = { exe = “distort”, mode = “overload 1”, tip = “The clip-level parameter is rather like a ‘gate’ level. If the signal level is already high, anything over, for example, 0.1 is likely to push it into distortion, and values considerably higher than this will make it heavily distorted. However, if it only distorts, Trevor advises me, when it reaches a level of, for example, 0.99, it is not going to be distorted very often. The sound doesn’t actually have amplitude overload, because it is distorted by ‘slicing off’ the top (clipping) where it would have overloaded. The sound becomes loud and ‘strained’, like a voice which is shouting too loudly.Given the trials made so far, this can be a fairly subtle effect, but the words ‘straining’, ‘loud’, ‘uncompromising’ seem appropriate as the amplitude gets pushed towards the top of the range.” },
arg1 = { name = “clip-level”, min = 0, max = 1, tip = “level at which the signal is to be clipped (Range: 0 to 1) The signal level is renormalised after clipping.” },
arg2 = { name = “depth”, min = 0, max = 1, tip = “depth of the pattern of distortion imposed on clipped stretches of the signal. (Range: 0 to 1)” },
}

dsp[“Distort Overload – Clip the signal with noise or a (possibly timevarying) waveform”] = {
cmds = { exe = “distort”, mode = “overload 2”, tip = “The clip-level parameter is rather like a ‘gate’ level. If the signal level is already high, anything over, for example, 0.1 is likely to push it into distortion, and values considerably higher than this will make it heavily distorted. However, if it only distorts, Trevor advises me, when it reaches a level of, for example, 0.99, it is not going to be distorted very often. The sound doesn’t actually have amplitude overload, because it is distorted by ‘slicing off’ the top (clipping) where it would have overloaded. The sound becomes loud and ‘strained’, like a voice which is shouting too loudly. Mode 2 can add an extra ringing sound as the value for freq gets higher, e.g., 2000Hz and beyond. Given the trials made so far, this can be a fairly subtle effect, but the words ‘straining’, ‘loud’, ‘uncompromising’ seem appropriate as the amplitude gets pushed towards the top of the range.” },
arg1 = { name = “clip-level”, min = 0, max = 1, tip = “level at which the signal is to be clipped (Range: 0 to 1) The signal level is renormalised after clipping.” },
arg2 = { name = “depth”, min = 0, max = 1, tip = “depth of the pattern of distortion imposed on clipped stretches of the signal. (Range: 0 to 1)” },
arg3 = { name = “freq”, min = 0, max = 22500, tip = “frequency of the waveform imposed on clipped stretches of the signal” },
}

dsp[“Distort Pitch - Pitchwarp wavecycles of sound”] = {
cmds = { exe = “distort”, mode = “pitch”, tip = “The random up/down movement of the ‘wavecycles’ within the total octvary range produces a great deal of bending of the sound, especially if the original alters its pitch a good deal. It is better, therefore, to start with relatively small values for octvary – e.g., less than 1 – so that you start to use this function with some degree of control over the results.The full power of DISTORT PITCH doesn’t really come into its own until time-varying parameters are used, especially for cyclecnt. Large values for the latter will serve to slow down the rate of change. DISTORT PITCH is useful for creating ‘flexitones’ (to coin a term) – with distortion, of course.” },
arg1 = { name = “octvary”, min = 0,0, max = 8,0, tip = “maximum possible transposition up or down in (fractions of) octaves (Range > 0.0 to 8.0)” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “mamimum number of ‘wavecycles’ between the generation of transposition values (Range: > 1, Default: 64)” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Pulsed - Impose impulse-train on a sound”] = {
cmds = { exe = “distort”, mode = “pulsed 1”, tip = “Distort a sound by imposing a series of impulses on the source, or on a specific waveset segment of the source. An impulse is like a brief event created by a sharp envelope on the sound. The sound inside the impulse might glissando slightly, as if whatever is causing the impulsion has warped the sound by its impact.” },
arg1 = { name = “stime”, min = 0.001, max = 10, tip = “time in the source sound where the impulses begin” },
arg2 = { name = “dur”, min = 0.001, max = 10, tip = “length of time that the impulses continue” },
arg3 = { name = “frq”, min = 0, max = 1000, tip = “number of impulses per second” },
arg4 = { name = “frand”, min = 0, max = 12, tip = “number of semitones by which to randomise the frequency of the impulses” },
arg5 = { name = “trand”, min = 0, max = 10, tip = “amount of time in seconds by which to randomise the relative time positions of amplitude peaks and troughs from impulse to impulse” },
arg6 = { name = “arand”, min = 0, max = 1, tip = “randomisation of the amplitude shape created by the peaks and troughs from impulse to impulse” },
arg7 = { name = “transp”, min = 0, max = 1, tip = “transposition contour of sound inside each impulse” },
arg8 = { name = “tranrand”, min = 0, max = 1, tip = “randomisation of transposition contour from impulse to impulse” },
arg9 = { name = “-s”, switch = “-s”, tip = “keep start of source sound, before impulses begin (if any)” },
arg10 = { name = “-e”, switch = “-e”, tip = “keep end of source sound, after impulses end (if any)” },
}

dsp["Distort Pulsed - Imposed regular pulsations on a sound "] = {
cmds = { exe = “distort”, mode = “pulsed 2”, tip = “Distort a sound by imposing a series of impulses on the source, or on a specific waveset segment of the source. An impulse is like a brief event created by a sharp envelope on the sound. The sound inside the impulse might glissando slightly, as if whatever is causing the impulsion has warped the sound by its impact.” },
arg1 = { name = “stime”, min = 0.001, max = 10, tip = “time in the source sound where the impulses begin” },
arg2 = { name = “dur”, min = 0.001, max = 10, tip = “length of time that the impulses continue” },
arg3 = { name = “frq”, min = 0, max = 1000, tip = “number of impulses per second” },
arg4 = { name = “frand”, min = 0, max = 12, tip = “number of semitones by which to randomise the frequency of the impulses” },
arg5 = { name = “trand”, min = 0, max = 10, tip = “amount of time in seconds by which to randomise the relative time positions of amplitude peaks and troughs from impulse to impulse” },
arg6 = { name = “arand”, min = 0, max = 1, tip = “randomisation of the amplitude shape created by the peaks and troughs from impulse to impulse” },
arg7 = { name = “cycletime”, min = 0, max = 10, tip = “duration in seconds of wavecycles to grab as sound substance inside the impulses” },
arg8 = { name = “transp”, min = 0, max = 1, tip = “transposition contour of sound inside each impulse” },
arg9 = { name = “tranrand”, min = 0, max = 1, tip = “randomisation of transposition contour from impulse to impulse” },
arg10 = { name = “-s”, switch = “-s”, tip = “keep start of source sound, before impulses begin (if any)” },
arg11 = { name = “-e”, switch = “-e”, tip = “keep end of source sound, after impulses end (if any)” },
}

dsp[“Distort Reform - Convert to fixed level square wave”] = {
cmds = { exe = “distort”, mode = “reform 1”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to square wave”] = {
cmds = { exe = “distort”, mode = “reform 2”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to fixed level triangular wave”] = {
cmds = { exe = “distort”, mode = “reform 3”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to triangular wave”] = {
cmds = { exe = “distort”, mode = “reform 4”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to inverted half-cycles”] = {
cmds = { exe = “distort”, mode = “reform 5”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to click streams”] = {
cmds = { exe = “distort”, mode = “reform 6”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to sinusoid”] = {
cmds = { exe = “distort”, mode = “reform 7”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Exaggerate waveform contour”] = {
cmds = { exe = “distort”, mode = “reform 8”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
arg1 = { name = “exaggeration”, min = 0,000002, max = 40, tip = “exaggeration factor (Range: 0.000002 to 40.0)” },
}

dsp[“Distort Repeat - Timestretch soundfile by repeating wavecycles”] = {
cmds = { exe = “distort”, mode = “repeat”, tip = “The repetition of the ‘wavecycles’ stretches out the sound, making it both longer and more granular in texture. This granularity is increased if (increasingly larger) groups of cyclecnt ‘wavecycles’ are used: then the whole group repeats multiplier times. DISTORT REPEAT produces long, grainy (distorted) sounds. The sense of stretching out the original is very apparent.A significant application of DISTORT REPEAT is that, by increasing the cyclecnt factor, one crosses the pitch-perception boundary: that is, starting with a noisy sound in which all the wavecycles are randomly different, one ends up with, for example, 7 repetitions of the same wavecycle, followed by 7 of another and so on – and each of these comprise sufficient repetitions for us to hear pitch. Thus the noise source becomes a string of pitch beads, each of arbitrary timbre. With a cyclecnt of, for example, 128, one can even get a slowish random melody.” },
arg1 = { name = “multiplier”, min = 0,0, max = 50, tip = “number of times (integer) each ‘wavecycle’ (group) repeats” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “number of ‘wavecycles’ (integer) in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = "number of ‘wavecyles’ (integer) to skip at start of file " },
}

dsp[“Distort Repeat 2 - Repeat wavecycles without time-stretching”] = {
cmds = { exe = “distort”, mode = “repeat2”, tip = “Repeating the ‘wavecycles’ without time-stretching (as in DISTORT REPEAT) enables you to increase the strength of the distortion with the multiplier parameter without making the output file any longer than the original. Larger values for cyclecnt increases the length of infile that is affected. Higher values for multiplier increase the distortion, while higher values for cyclecnt increase the length of infile that is processed as one unit. Thus we could have: a low value for multiplier coupled with a high value for cyclecnt – this will produce a bit of distortion while the source remains recognisable, a high value for multiplier coupled with a low value for cyclecnt – this will produces a great deal of distortion, but the effect is limited because only a few cycles are affected as a unit. High values for both parameters – this appears to create the most distortion” },
arg1 = { name = “multiplier”, min = 0,0, max = 50, tip = “number of times (integer) each ‘wavecycle’ (group) repeats” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “number of ‘wavecycles’ (integer) in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = "number of ‘wavecyles’ (integer) to skip at start of file " },
}

dsp[“Distort Replace – The strongest wavecycle in a cyclecnt group replaces the others”] = {
cmds = { exe = “distort”, mode = “replace”, tip = “The replacing action serves to simplify the sound. Note that the single strong ‘wavecycle’ in the group will take the place of several others, which will be deleted. This simplification becomes extreme when the cyclecnt is high, leading to a ‘sample-hold’ kind of stepped effect. Time-varying cyclecnt makes it possible to introduce gradual change. With DISTORT REPLACE we can achieve a simplification of the sound, up to very clear ‘sample-hold’ type stepped tones” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 5000, tip = “(integer) size of group of ‘wavecycles’” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “number of ‘wavecyles’ (integer) to skip at start of file” },
}

dsp["Distort Replim – Timestretch by repeating wavecycles (below a specified frequency) “] = {
cmds = { exe = “distort”, mode = “replim”, tip = “This function is like DISTORT REPEAT, but with a slight change. Here the length of wavecycle to be affected can be set. Thus, if you set a mid-range frequency, only those below that frequency will repeat, and the others (above the frequency) will be discarded (filtered out). Hence the name ‘REP-LIM’, meaning ‘repeat (with a) limit’. DISTORT REPLIM is therefore like a filtering program that also repeats wavecycles. In the DISTORT set, the wavecycles are wavelengths that occur between zero crossings, so distortion also occurs. It is helpful to remember that wavelength is inversely proportional to frequency. Wavelength is the actual physical length of the oscillation, and frequency is the number of cycles that occur in one second (i.e., Hertz). These two aspects of sound are inversely proportional to one another: P = 1/f. For example, a sound oscillating at 100 Hz will have a period, i.e., a wavelength of 1/100 meters = 0.01 meters (0.39 inch). A sound oscillating at 1000Hz will have a wavelength of 1/1000 meters = 0.001 meters (0.039 inch). Short wavecycles are therefore higher in pitch and long ones are lower in pitch. When the frequency setting for DISTORT REPLIM is high, the filter point is set higher and more of the sound will be retained. Here we are dealing with ‘pseudo-wavecycles’ (portions of soundfile between zero crossings), which is what introduces distortion into the equation.The net result of the function is to create repetition distortion while filtering out a user-definable amount of the higher frequencies. Remember that the relative amounts of high and low frequencies in the infile will affect the results.” },
arg1 = { name = “multiplier”, min = 0.001, max = 100, tip = “the number of times each wavecycle (group) repeats (Integer)” },
arg2 = { name = “cyclecnt”, switch = “-c”, min = 0, max = 5000, tip = “the number of wavecycles in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = " the number of wavecycles to skip at the beginning of the soundfile” },
arg4 = { name = “hilim”, switch = “-f”, min = 0, max = 22500, tip = “the frequency below which cycles are counted” },
}

dsp[“Distort Reverse - Cycle-reversal distortion in which the wavecycles are reversed in groups”] = {
cmds = { exe = “distort”, mode = “reverse”, tip = “Here the original soundfile is grouped into a series of ‘wavecycles’ with cyclecnt ‘wavecycles’ in each group. Then each of these groups of ‘wavecycles’ is reversed. The term ‘distortion’ here is something of a misnomer, because no distortion process is applied to the ‘wvecycles’ themselves. Instead, cyclecnt sets the number of ‘wavecycles’ which are to be copied in reverse as a group to the outfile. For example, if cyclecnt = 3, 15 ‘wavecycles’ reversed in groups of 3 will assume the order: 3-2-1, 6-5-4, 9-8-7, 12-11-10, 15-14-13. Thus, not only is the sound material backwards, but the reversed 1st ‘wavecycle’ is now adjacent to the reversed 6th ‘wavecycle’. This mimics the classical tape studio technique of cutting up a length of tape into segments (of varying lengths), reversing the segments, and joining up the reversed pieces. The result will be similar to a random brassage because of the differing lengths of the ‘wavecycles’. The process moves steadily through the infile from beginning to end, so the normal order of the (reversed) events is preserved. It is surprising how normal the output can be. With mid-range values for cyclecnt (say, 30 to 100), one hears the original breaking up, but only with very large values for cyclecnt does one hear the sound sweeping backwards in large swathes. Again, it is a question of ‘resolution’: the size of the units being manipulated. A small value for cyclecnt will produce a grainy result, mid-values a ‘broken up’ result, and large values swathes of reversed sound. If the value for cyclecnt exceeds the number of ‘wavecycles’ in the infile, you will be told that the ‘sound source is too short…’. DISTORT CYCLECNT returns the number of ‘wavecycles’ in a sound, should you want to provide a value for cyclecnt which is right up to the limit. Reversing the output of DISTORT REVERSE turns the cyclecnt groups back the other way while reading the whole soundfile from back to front, producing an interesting mixture of forwards and backwards! Using the time-varying option for cyclecnt provides an opportunity for dramatic or gradual changes in the output.” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 10000, tip = “number of ‘wavecycles’ in a reversed group (Range: > 0)” },
}

dsp[“Distort Telescope - Time-contract sound by telescoping N wavecycles into 1”] = {
cmds = { exe = “distort”, mode = “telescope”, tip = “Although at first rather like DISTORT OMIT, here the ‘wavecycles’ are not deleted as such. Instead, they are superimposed (i.e., mixed) onto each other, with shorter ‘wavecycles’ being stretched to fit the longest one in each group of cyclecnt ‘wavecycles’. The outfile will usually be much shorter than the infile and can be reduced to a mere blip with this process. The -a flag tells the program to telescope to the average ‘wavecycle’ length, rather than to the longest. Since the longest ‘wavecycle’ in each group is compressed by this method, the outfile will be even shorter. Interesting results can be achieved with small values for cyclecnt, the output tending to have a ‘mushy’ quality. It responds well to pitched material, producing a singing, if mushy, tone.” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 1000, tip = “the number of ‘wavecycles’ in a group” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “number of ‘wavecyles’ (integer) to skip at start of file” },
arg3 = { name = “-a”, switch = “-a”, tip = “telescope to an average ‘wavecycle’ length (Default: telescope to the longest ‘wavecycle’ length)” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles below freq”] = {
cmds = { exe = “distort”, mode = “filter 1”, tip = “Period and frequency are inverse functions. Therefore it is possible to relate the length of a ‘wavecycle’ to the frequency it would have were it to recur regularly. This program therefore filters by removing ‘wavecycles’ shorter or longer than those relating to a specific, user-defined, frequency. The duration of the outfile is affected by this process: because ‘wavecycles’ are being removed, the outfile will be shorter, by varying degrees. The aural effect of the DISTORT FILTER process is actually like gating. In gating, you can imagine a horizontal line drawn through the time/amplitude display of a soundfile. If the peaks above the line are retained (by filtering out lower frequencies), you just hear them (joined up). Similarly, if you filter out above the line, the peaks are gone, leaving the lower sound material (joined up). The difference here is that the process is operating on ‘pseudo-wavecycles’ according to their length, so here the results are more unpredictable and also distort the sound to some degree, depending on where the horizontal line – the frequency variable(s) – is drawn. Technically, the process is akin to low-, high- and band-pass filters, but aurally it is more like gating. You can therefore use this procedure to cut out some and distort other material in a sound.” },
arg1 = { name = “freq”, min = 10,0, max = 22050.0, tip = “frequency in Hz (Range: 10.0 to 22050.0)” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles above freq”] = {
cmds = { exe = “distort”, mode = “filter 2”, tip = “Period and frequency are inverse functions. Therefore it is possible to relate the length of a ‘wavecycle’ to the frequency it would have were it to recur regularly. This program therefore filters by removing ‘wavecycles’ shorter or longer than those relating to a specific, user-defined, frequency. The duration of the outfile is affected by this process: because ‘wavecycles’ are being removed, the outfile will be shorter, by varying degrees. The aural effect of the DISTORT FILTER process is actually like gating. In gating, you can imagine a horizontal line drawn through the time/amplitude display of a soundfile. If the peaks above the line are retained (by filtering out lower frequencies), you just hear them (joined up). Similarly, if you filter out above the line, the peaks are gone, leaving the lower sound material (joined up). The difference here is that the process is operating on ‘pseudo-wavecycles’ according to their length, so here the results are more unpredictable and also distort the sound to some degree, depending on where the horizontal line – the frequency variable(s) – is drawn. Technically, the process is akin to low-, high- and band-pass filters, but aurally it is more like gating. You can therefore use this procedure to cut out some and distort other material in a sound.” },
arg1 = { name = “freq”, min = 10,0, max = 22050.0, tip = “frequency in Hz (Range: 10.0 to 22050.0)” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles below & above freq”] = {
cmds = { exe = “distort”, mode = “filter 3”, tip = “Period and frequency are inverse functions. Therefore it is possible to relate the length of a ‘wavecycle’ to the frequency it would have were it to recur regularly. This program therefore filters by removing ‘wavecycles’ shorter or longer than those relating to a specific, user-defined, frequency. The duration of the outfile is affected by this process: because ‘wavecycles’ are being removed, the outfile will be shorter, by varying degrees. The aural effect of the DISTORT FILTER process is actually like gating. In gating, you can imagine a horizontal line drawn through the time/amplitude display of a soundfile. If the peaks above the line are retained (by filtering out lower frequencies), you just hear them (joined up). Similarly, if you filter out above the line, the peaks are gone, leaving the lower sound material (joined up). The difference here is that the process is operating on ‘pseudo-wavecycles’ according to their length, so here the results are more unpredictable and also distort the sound to some degree, depending on where the horizontal line – the frequency variable(s) – is drawn. Technically, the process is akin to low-, high- and band-pass filters, but aurally it is more like gating. You can therefore use this procedure to cut out some and distort other material in a sound.” },
arg1 = { name = “freq1”, min = 0,0, max = 22050.0, tip = “frequency in Hz to delete below” },
arg2 = { name = “freq2”, min = 0,0, max = 22050,0, tip = “frequency in Hz to delete above” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}


dsp[“Modify Brassage - Pitchshift - Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 1” },
arg1 = { name = “pitchshift”, min = -0,12, max = 12, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
}

dsp[“Modify Brassage - Timestretch -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 2” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
}

dsp[“Modify Brassage - Reverb -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 3” },
arg1 = { name = “density”, min = 0,0, max = 1000, tip = “amount of grain overlap (Range: > 0)” },
arg2 = { name = “pitch”, min = -0,33, max = 0,33, tip = “transposition factor (Range: -0.33 to 0.33)” },
arg3 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg4 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
}

dsp[“Modify Brassage - Scramble -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 4” },
arg1 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg2 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
}

dsp[“Modify Brassage - Granulate -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 5” },
arg1 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg2 = { name = “-d”, switch = “-d” },
}

dsp[“Modify Brassage - Brassage -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 6” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
arg2 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg3 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg4 = { name = “pitchshift”, min = -0,33, max = 0,33, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
arg5 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg6 = { name = “space”, min = 0, max = 1, tip = “spatial position – set stereo position” },
arg7 = { name = “bsplice”, min = 0, max = 1000, tip = “length of start-splices on grains in ms (Default: 5)” },
arg8 = { name = “esplice”, min = 0, max = 1000, tip = “length of end-splices on grains in ms (Default: 5)” },
arg9 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
arg10 = { name = “jitter”, switch = “-j”, min = 0, max = 1, tip = “randomisation of grain position” },
arg11 = { name = “outlength”, switch = “-l”, min = 0, max = 10, tip = “maximum outfile length (if end of data is not reached)” },
arg12 = { name = “channel”, switch = “-c”, min = 0, max = 2, tip = " extract and work on just one channel of a stereo input (Range: 1 or 2) Set channel to 0 (the Default) for this parameter to be ignored." },
arg13 = { name = “-d”, switch = “-d” },
arg14 = { name = “-x”, switch = “-x”, tip = “do exponential splices (Default: linear)” },
arg15 = { name = “-n”, switch = “-n”, tip = “no interpolation for pitch values (quick but dirty)” },
}

dsp[“Modify Brassage - Full Monty -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 7” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
arg2 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg3 = { name = “hvelocity”, min = 0,0, max = 5000,0 },
arg4 = { name = “hdensity”, min = 0,0, max = 5000,0 },
arg5 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg6 = { name = “pitchshift”, min = -0,33, max = 0,33, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
arg7 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg8 = { name = “space”, min = 0, max = 1, tip = “spatial position – set stereo position” },
arg9 = { name = “bsplice”, min = 0, max = 1000, tip = “length of start-splices on grains in ms (Default: 5)” },
arg10 = { name = “esplice”, min = 0, max = 1000, tip = “length of end-splices on grains in ms (Default: 5)” },
arg11 = { name = “hgrainsize”, min = 0, max = 5000 },
arg12 = { name = “hpitchshift”, min = -0,33, max = 0,33 },
arg13 = { name = “hamp”, min = 0, max = 1 },
arg14 = { name = “hspace”, min = 0, max = 2 },
arg15 = { name = “hbsplice”, min = 0, max = 1000 },
arg16 = { name = “hesplice”, min = 0, max = 1000 },
arg17 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
arg18 = { name = “jitter”, switch = “-j”, min = 0, max = 1, tip = “randomisation of grain position” },
arg19 = { name = “outlength”, switch = “-l”, min = 0, max = 10, tip = “maximum outfile length (if end of data is not reached)” },
arg20 = { name = “channel”, switch = “-c”, min = 0, max = 2, tip = " extract and work on just one channel of a stereo input (Range: 1 or 2) Set channel to 0 (the Default) for this parameter to be ignored." },
arg21 = { name = “-d”, switch = “-d” },
arg22 = { name = “-x”, switch = “-x”, tip = “do exponential splices (Default: linear)” },
arg23 = { name = “-n”, switch = “-n”, tip = “no interpolation for pitch values (quick but dirty)” },
}

dsp[“Modify Loudness - Alter gain of sound”] = {
cmds = { exe = “modify”, mode = “loudness 1” },
arg1 = { name = “gain”, min = 0,0, max = 100,0, tip = “adjust level by factor gain” },
}

dsp[“Modify Loudness - Alter dB-gain of sound”] = {
cmds = { exe = “modify”, mode = “loudness 2” },
arg1 = { name = “gain”, min = -96, max = 96, tip = “level expressed in dB (Range: -96dB to 96dB). NB: every drop of -6dB halves the previous level.” },
}

dsp[“Modify Loudness - Normalise”] = {
cmds = { exe = “modify”, mode = “loudness 3” },
arg1 = { name = “level”, switch = “-l”, min = 0, max = 1, tip = “force level (if necessary) to the maximum possible, or to the level given (Range: 0 to 1).” },
}

dsp[“Modify Loudness - Force level”] = {
cmds = { exe = “modify”, mode = “loudness 4” },
arg1 = { name = “level”, switch = “-l”, min = 0, max = 1, tip = “force level to maximum possible, or to the level given (Range: 0 to 1)” },
}

dsp[“Modify Loudness - Invert Phase”] = {
cmds = { exe = “modify”, mode = “loudness 6” },
}

dsp[“Phase - Invert phase”] = {
cmds = { exe = “phase”, mode = “phase 1”, tip = “Playback of the output inverted soundfile shows that there is no audible difference from the input soundfile. However, if you mix the original sound with the phase inverted sound, you will generate a silent output: positive and negative amplitude values cancel out. However, if you mix the input and output with an offset, you get signal and hear an overlap of the two soundfiles (the cancelling out does not fully happen). You can try this with SUBMIX MERGE.” },
}

dsp[“Phase - Stereo Enhance stereo file”] = {
cmds = { exe = “phase”, mode = “phase 2”, tip = “This mode is supposed to be a means of creating an enhanced stereo image by suppressing any aspects of the Left image which have bled to the Right, by adding (part of) the phase inverted Left signal on the Right, and vice versa. I (T Wishart) learned of this idea from a mixing engineer I met in France, but I’m still not convinced that this achieves anything except in very special circumstances (with particular types of material). The output may sound the same as the input, except perhaps on the largest PA systems.” },
arg1 = { name = “transfer”, switch = “-t”, min = 0, max = 1, tip = “amount of signal to be used in phase-cancellation.” },
}

dsp[“Modify Radical - Reverse”] = {
cmds = { exe = “modify”, mode = “radical 1”, tip = “Sound plays backwards, the soundfile is re-written back to front: starting at the end and ending at the beginning.” },
}

dsp[“Modify Radical - Shred”] = {
cmds = { exe = “modify”, mode = “radical 2”, tip = “The soundfile is (randomly) segmented, and these segments reordered by means of a permutation process. As the number of repeats increases, it gets more and more jumbled, literally ‘reducing it to shreds’. The -n adds splicing that results in a smoother output.” },
arg1 = { name = “repeats”, min = 0, max = 1000, tip = “number of repeats of shredding process” },
arg2 = { name = “chunklen”, min = 0, max = 500, tip = “average length of chunks to cut and permutate” },
arg3 = { name = “scatter”, switch = “-s”, min = 0, max = 10, tip = “randomisation of cuts (Range: 0 to K, where K = duration of infile/chunklen Default = 1)” },
arg4 = { name = “-n”, switch = “-n”, tip = “use this flag for a smoother output” },
}

dsp[“Modify Radical - Scrub back and forth”] = {
cmds = { exe = “modify”, mode = “radical 3”, tip = “This is an acceleration/deceleration process which models an editing procedure used in the ‘classical’ tape studio: the desired edit point was found by turning the tape spools by hand so that the tape moved (very slowly!) across the tape head. You could hear locate exactly where silence began or ended, where clicks came etc., although the sound was very low because of the slow speed.The SCRUB function could also be used creatively, to create extreme speed modifications of the source sound on the tape, e.g. an abrupt acceleration-deceleration as the tape went from not-moving, to fast-moving, to stopped as the hands jerked the tape across the heads.” },
arg1 = { name = “dur”, min = 0, max = 10, tip = “minimum length of outfile required” },
arg2 = { name = “down”, switch = “-l”, min = 0, max = 12, tip = “lowest downward tranposition in semitones” },
arg3 = { name = “up”, switch = “-h”, min = 0, max = 12, tip = " highest upward transposition in semitones" },
arg4 = { name = “start”, switch = “-s”, tip = "scrubs start before time start seconds " },
arg5 = { name = “end”, switch = “-e”, tip = “scrubs end after time end” },
}

dsp[“Modify Radical - Lose resolution”] = {
cmds = { exe = “modify”, mode = “radical 4”, tip = “LOSE RES: Reducing the sample rate reduces the level of the Nyquist frequency (sample_rate/2), thereby lowering the frequency level which can be safely handling during processing. Lowering bit-resolution reduces the precision of the numerical expression of the data, making the digital ‘quantisation’ of the sonic material coarser. This means that time-varying information is lost.” },
arg1 = { name = “bit_resolution”, min = 0, max = 16 },
arg2 = { name = “srate_division”, min = 1, max = 256, tip = “Range: 1 to 256 Default 1 (normal)” },
}

dsp[“Modify Radical - Ring Modulate”] = {
cmds = { exe = “modify”, mode = “radical 5”, tip = “RING MODULATION: multiplies two (bipolar) signals. In this case, one signal is a soundfile and the other is a modulating_frq. This creates two ‘sidebands’ which are the sum and the difference of the two signals, while the carrier signal disappears. The result is a timbrally ‘hollow’ sound. (See Curtis Roads, The Computer Music Tutorial, pp. 215-220).” },
arg1 = { name = “modulating-frq”, min = 0, max = 44100, tip = “number of cycles per second” },
}

dsp[“Modify Revecho - Standard delay”] = {
cmds = { exe = “modify”, mode = “revecho 1”, tip = “Mode 1 provides a standard delay. If a smooth echoey effect is wanted, be careful to keep mix on the low side. Remember that delay is given in milliseconds; after 60ms or so, one begins to hear a strong reverberation; after 100 ms the reverberation begins to ‘bounce’, and by 200 ms one begins to hear distinct echoes. Delay times greater than 1000 will cause repetitions of (all or much of) the sound. Don’t forget to lengthen the tail to match the delay time.The mix parameter, in adding in the delayed signal, increases the reverberant effect. With a short delay time, this can sound like the reverberation which occurs in an enclosed space. Feedback has a similar effect, becoming very pronounced towards a value of 1.0 – rather like the ‘feedback’ which occurs when a microphone is placed facing a loudspeaker. The operation of a standard delay line in Mode 1 ranges from modest reverberation to echo effects. The reverberations, however, tend easily towards rough edges, so for smoother reverbs, look to the programs listed below.” },
arg1 = { name = “delay”, min = 0, max = 5000, tip = “delay time, in milliseconds” },
arg2 = { name = “mix”, min = 0, max = 1, tip = " amount of delayed signal in final mix: 0 gives ‘dry’ result (Range: 0 to 1)" },
arg4 = { name = “feedback”, min = -1,0, max = 1,0, tip = “produces resonances related to delay time (with short times) (Range: -1.0 to 1.0)” },
arg5 = { name = “tail”, min = -1,0, max = 1,0, tip = “time to allow decayed signal to decay to zero (Range: -1.0 to 1.0)” },
arg6 = { name = “prescale”, switch = “-p”, tip = “prescales input level, to avoid overload” },
arg7 = { name = “-i”, switch = “-i”, tip = “inverts the dry signal (for phasing effects)” },
}

dsp[“Modify Revecho - Varying delay”] = {
cmds = { exe = “modify”, mode = “revecho 2” },
arg1 = { name = “delay”, min = 0, max = 5000, tip = “delay time, in milliseconds” },
arg2 = { name = “mix”, min = 0, max = 1, tip = " amount of delayed signal in final mix: 0 gives ‘dry’ result (Range: 0 to 1)" },
arg4 = { name = “feedback”, min = -1,0, max = 1,0, tip = “produces resonances related to delay time (with short times) (Range: -1.0 to 1.0)” },
arg5 = { name = “lfomod”, min = 0, max = 1, tip = “depth of the delay-variation sweep (Range: 0 to 1)” },
arg6 = { name = “lfofreq”, min = -50, max = 50, tip = “frequency of the delay-variation sweep (negative values give random oscillations)” },
arg7 = { name = “lfophase”, min = 0, max = 1, tip = “start-phase of the delay-variation sweep (Range: 0 to 1)” },
arg8 = { name = “lfodelay”, min = 0, max = 10, tip = “time in seconds before the delay-variation sweep begins” },
arg9 = { name = “tail”, min = -1,0, max = 1,0, tip = “time to allow decayed signal to decay to zero (Range: -1.0 to 1.0)” },
arg10 = { name = “prescale”, switch = “-p”, tip = “prescales input level, to avoid overload” },
arg11 = { name = “seed”, switch = “-s”, min = 0, max = 100, tip = "non-zero value gives reproducible output (with the same seed) where random oscillations are used " },
}

dsp[“Modify Revecho - Stadium Echo”] = {
cmds = { exe = “modify”, mode = “revecho 3”, tip = “This creates a stereo outfile, bouncing the signal between speakers with a very prominent delay factor. The idea is that you hear the signal bouncing around the ‘stadium’. The defaults work quite nicely, but you can intensify the effect by multiplying the delay time with the size parameter. Note that this is a multiple, so values less than 0 (multiplied with the default time of 0.1 sec) will decrease the delay time. Beyond size = 2, you are likely to run into insufficient buffer space, so if you really want longer delay times, you will have to increase the buffer size with ‘set CDP_MEMORY_BBSIZE=…’ (bear in mind the RAM capacity of your machine). (The default buffer size is 1 Mbyte and the units are in ‘k’: e.g., a BBSIZE of 3000 units is 3 Mbyte)” },
arg1 = { name = “gain”, switch = “-g”, min = 0, max = 1, tip = “to apply to input signal (Default: 0.645654)” },
arg2 = { name = “roll_off”, switch = “-r”, min = 0, max = 10, def = 1, tip = “rate of loss of level across stadium (Default: 1))” },
arg4 = { name = “size”, switch = “-s”, min = 0, max = 10, tip = “multiplies average time between echoes (the Default time between echoes of 0.1 sec)” },
arg5 = { name = “count”, switch = “-e”, min = 0, max = 23, tip = “number of stadium echoes (Default and max: 23)” },
}

dsp[“Modify Space - pan”] = {
cmds = { exe = “modify”, mode = “space 1”, tip = “Adjusts the amplitude levels of the two channels so as to create spatial illusions. A time pan breakpoint file is used to create movement. Mode1 PAN: control of sound in 3-D space has been a basic procedure when composing with ‘sound’ material, especially when these are drawn from nature/the environment. The assumption here is that you are thinking about the placement and movement of sound as an integral part of your compositional process. In this case, we are dealing with building these procedures into the sound itself. There is a further aspect external to the sound itself, achieved by ‘mixing’ (superimposing sounds and writing a new soundfile) and ‘diffusion’ (sound placement during playback achieved by manipulating the pan controls on a mixer).” },
arg1 = { name = “pan”, min = -1,0, max = 1,0, tip = “floating point value to specify location between the pair of stereo speakers, or breakpoint file of time pan pairs. Range: -1.0 to 1.0; 0.0 is centre.” },
arg2 = { name = “prescale”, switch = “-p”, min = 0, max = 1, tip = “gain factor multiplier with which to adjust the input level (Default: 0.7)” },
}

dsp["Modify Space - Mirrow: two channels swap sides "] = {
cmds = { exe = “modify”, mode = “space 2”, tip = “MIRROR: the data in the two channels swaps sides, a utility for a quick Left/Right swap” },
}

dsp[“Modify Space - Narrow: Narrow the stereo image of a sound”] = {
cmds = { exe = “modify”, mode = “space 4”, tip = “A way to restrict the spatial location of a sound in the horizontal plane, this program allows you to narrow the spread of a stereo field” },
arg1 = { name = “narrowing”, min = -1,0, max = 1,0, tip = “make the stereo image less wide” },
}

dsp[“Modify Speed - Vary speed & pitch of a sound”] = {
cmds = { exe = “modify”, mode = “speed 1”, tip = “Speed modification processes change the duration and the pitch of the sound together. Thus a faster speed causes a higher pitch, a slower speed a lower pitch.MODIFY SPEED offers a range of functions which affect the speed of the soundfile. Perhaps it will be most often used for transposition. Modes 1 and 2 both accept either single values or the names of time-varying breakpoint files with time transposition pairs. The single values act as constants and transpose the whole soundfile up or down by the given amount. In the breakpoint files, transposition can be almost instantaneous (almost same time, different transposition value), or gradual, creating glissandi (different time, different transposition value). No transposition between times is a third possibility (different time, same transposition value). Transposition which also changes the speed, and therefore the pitch, of the soundfile greatly alters the character of the sound. It is often very interesting to hear what a sound will be like 1, 2 or even 3 octaves below its original pitch. Deep, rich tones can be achieved in this way. These tones can slowly rise or descend if created with a time-varying breakpoint file e.g., moving an octave up or down over the time of the whole sound (airplane takeoff sounds, etc.)” },
arg1 = { name = “speed”, min = 0, max = 4, tip = “transposition value (ratio) expressed as a floating point multiplier” },
}

dsp[“Modify Speed - Vary speed & pitch by (fractional) number of semitones”] = {
cmds = { exe = “modify”, mode = “speed 2”, tip =“Speed modification processes change the duration and the pitch of the sound together. Thus a faster speed causes a higher pitch, a slower speed a lower pitch.MODIFY SPEED offers a range of functions which affect the speed of the soundfile. Perhaps it will be most often used for transposition. Modes 1 and 2 both accept either single values or the names of time-varying breakpoint files with time transposition pairs. The single values act as constants and transpose the whole soundfile up or down by the given amount. In the breakpoint files, transposition can be almost instantaneous (almost same time, different transposition value), or gradual, creating glissandi (different time, different transposition value). No transposition between times is a third possibility (different time, same transposition value). Transposition which also changes the speed, and therefore the pitch, of the soundfile greatly alters the character of the sound. It is often very interesting to hear what a sound will be like 1, 2 or even 3 octaves below its original pitch. Deep, rich tones can be achieved in this way. These tones can slowly rise or descend if created with a time-varying breakpoint file e.g., moving an octave up or down over the time of the whole sound (airplane takeoff sounds, etc.)” },
arg1 = { name = “semitone-transpos”, min = -12, max = 12, tip = " transposition value in positive or negative number of semitones; e.g., 12 raises the sound by an octave, and -12 lowers it by an octave. NB: use 0 (semitones) for no transposition." },
}

dsp[“Modify Speed - Accelerate or decelerate a sound”] = {
cmds = { exe = “modify”, mode = “speed 5” },
arg1 = { name = “accel”, min = 0, max = 100, tip = “multiplication of speed to be reached by goaltime – i.e., a transposition ratio” },
arg2 = { name = “goaltime”, min = 0, max = 30, tip = “time in outfile at which the accelerated speed is to be reached.” },
arg3 = { name = “starttime”, switch = “-s”, min = 0, max = 10, tip = “time in infile / outfile at which the acceleration begins” },
}

dsp[“Modify Speed -Add vibrato to a sound”] = {
cmds = { exe = “modify”, mode = “speed 6”, tip = “The vibrato created in Mode 6 is a frequency modulation. Given the very wide ranges allowed, this function is immensely powerful. A slow vibrate with a large vibdepth will swing the original sound wildly – increase vibrate and it really ‘flaps in the breeze’ (like a flag in the wind). A fast vibrate with a reasonably tight vibdepth, e.g., a minor 3rd, will produce a fluttering effect.” },
arg1 = { name = “vibrate”, min = 0,0, max = 120,0, tip = “the rate of vibrato shaking in cyles-per-second (Range: 0.0 to 120.0)” },
arg2 = { name = “vibdepth”, min = 0,0, max = 96,0, tip = “vibrato depth (pitch shift from centre) in [possibly fractional] semitones (Range: 0.0 to 96.0)” },
}

dsp[“Modify Stack -Create a mix that stacks transposed versions of source on top of one another “] = {
cmds = { exe = “modify”, mode = “stack”, tip = “New sounds can be developed from existing sources by stacking transposed copes of the original on top of each other. This is particularly successful where the source sound has a clearly defined attack at or near the start of the sound and then dies away gradually. If the copies are lined up in such a way that their attacks coincide exactly, the new sound will psycho-acoustically merge into a single sound event with harmonic content (rather than a chord made up of several sounds). The meaning of this is very precise: one is lining up the soundfiles at their perceived beginning, i.e., its attack, not the start of each soundfile. This is achieved by adjusting the start times of the transposed soundfiles. MODIFY STACK is a very important program. It enables you to construct ‘larger’ versions of sounds by superimposing transposed versions on top of one another. Furthermore, it does this in such a way as to maximise the fusion of the layered sound by synchronising the attacks. This relates to a basic technique of orchestral scoring (where it is called ‘doubling’). It is a form of automatic mixing involving one soundfile.Because of the way the program functions, this is, however, quite a different process from transposing and mixing sounds to produce chords. (Doing this in the Spectral Domain, where transposition can be done without affecting duration, still has a place.) Here, if the attack points are made to coincide, the new sound-object is an integral whole, rather than a ‘chord’ made up of the transposed stack components: that is, the components fuse and cannot be separated in perception, as they can with a chord played, for example, on a piano keyboard.Also note that, as a Time Domain process, the higher transpositions end sooner than the lower ones. Use Spectral Domain transpositon along with SUBMIX MIX to assemble transposed versions of the same sound when equal length is important.Very low transpositions could produce an extremely long output. The dur parameter enables you to specify a much shorter outfile length. You can usually get an idea of the harmonic content of the output from the first few seconds.” },
arg1 = { name = “transpos”, min = 0, max = 12, tip = “transpos is the transposition in semitones between successive copies” },
arg2 = { name = “count”, min = 0, max = 100, tip = " the number of copies in the stack” },
arg4 = { name = “lean”, min = 0, max = 10, tip = “the loudness of the highest component, relative to the lowest (may be > 1)” },
arg5 = { name = “attack-offset”, min = 0, max = 50, tip = “adjusts the time at which the attack of each sound occurs” },
arg6 = { name = “gain”, min = 0,1, max = 10, tip = “an overall amplifying gain factor on the output sound; some reduction (less than 1) may be needed. (It may also be > 1.) Range: 0.1 to 10” },
arg7 = { name = “dur”, min = 0, max = 1, tip = “how much of the output to make (a proportion, from 0 to 1)” },
arg7 = { name = “-s”, switch = “-s”, tip = " see the relative levels of the layers in the stack” },
}


dsp["Envel Attack – Emphasize the attack of a sound "] = {
cmds = { exe = “envel”, mode = “attack 1”, tip = “Set attack point where sound level first exceeds gate level.” },
arg1 = { name = “gate”, min = 0, max = 1, tip = "level (threshold) to be reached for the attack point to be recognised (Range: 0 to 1). " },
arg2 = { name = “Gain”, min = 0.001, max = 2,0, set = “floating point multiplier by which to amplify the signal at the attack point (< 1 reduces the signal; > 1 amplifies the signal).” },
arg3 = { name = “onset”, min = 5, max = 32767, tip = “attack onset duration in milliseconds, i.e., the ‘sharpness’ of the attack (Range:5ms to 32767ms). " },
arg4 = { name = “decay”, min = 5, max = 20000, tip = “attack decay duration in milliseconds (Range: 5 to < duration of infile).” },
arg5 = { name = “envtype”, switch = “-t”, min = 0, max = 1, tip = " type of envelope: 0 linear, 1 exponential (Default)” },
}

dsp[“Envel Attack – Emphasize the attack of a sound 2”] = {
cmds = { exe = “envel”, mode = “attack 2”, tip = “Attack point at maximum level at your ‘approx-time’ (+/- 200 ms).” },
arg1 = { name = “time”, min = 0, max = 10, tip = “time (approximate or exact) of the attack point, in seconds” },
arg2 = { name = “Gain”, min = 0.001, max = 2,0, set = “floating point multiplier by which to amplify the signal at the attack point (< 1 reduces the signal; > 1 amplifies the signal). " },
arg3 = { name = “onset”, min = 5, max = 32767, tip = “attack onset duration in milliseconds, i.e., the ‘sharpness’ of the attack (Range:5ms to 32767ms).” },
arg4 = { name = “decay”, min = 5, max = 20000, tip = “attack decay duration in milliseconds (Range: 5 to < duration of infile).” },
arg5 = { name = “envtype”, switch = “-t”, min = 0, max = 1, tip = " type of envelope: 0 linear, 1 exponential (Default)” },
}

dsp[“Envel Attack – Emphasize the attack of a sound 3”] = {
cmds = { exe = “envel”, mode = “attack 3”, tip = “Attack point at your ‘exact-time’.” },
arg1 = { name = “time”, min = 0, max = 10, tip = “time (approximate or exact) of the attack point, in seconds” },
arg2 = { name = “Gain”, min = 0.001, max = 2,0, set = “floating point multiplier by which to amplify the signal at the attack point (< 1 reduces the signal; > 1 amplifies the signal).” },
arg3 = { name = “onset”, min = 5, max = 32767, tip = "attack onset duration in milliseconds, i.e., the ‘sharpness’ of the attack (Range:5ms to 32767ms). " },
arg4 = { name = “decay”, min = 5, max = 20000, tip = “attack decay duration in milliseconds (Range: 5 to < duration of infile).The decay portion of the attack is also set in milliseconds. " },
arg5 = { name = “envtype”, switch = “-t”, min = 0, max = 1, tip = " type of envelope: 0 linear, 1 exponential (Default)” },
}

dsp[“Envel Attack – Emphasize the attack of a sound 4”] = {
cmds = { exe = “envel”, mode = “attack 3”, tip = "Attack point at maximum level in the soundfile " },
arg1 = { name = “Gain”, min = 0.001, max = 2,0, set = "floating point multiplier by which to amplify the signal at the attack point (< 1 reduces the signal; > 1 amplifies the signal). " },
arg2 = { name = “onset”, min = 5, max = 32767, tip = “attack onset duration in milliseconds, i.e., the ‘sharpness’ of the attack (Range:5ms to 32767ms). " },
arg3 = { name = “decay”, min = 5, max = 20000, tip = “attack decay duration in milliseconds (Range: 5 to < duration of infile).” },
arg4 = { name = “envtype”, switch = “-t”, min = 0, max = 1, tip = " type of envelope: 0 linear, 1 exponential (Default)” },
}

dsp["Envel Curtail - Curtail a soundfile by fading to zero at some time within it “] = {
cmds = { exe = “envel”, mode = “curtail 1”, tip = “specify the precise times at which the file is to begin and end.” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “fadeend”, min = 0, max = 50, set = “time at which to complete the fade” },
arg3 = { name = “envtype”, min = 0, max = 1, tip = “type of envelope shape for the fade, 0 linear, 1 exponential” },
arg4 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes” },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 2”] = {
cmds = { exe = “envel”, mode = “curtail 2”, tip = “specify the duration of the fade and when it begins.” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “fade-dur”, min = 0, max = 50, set = “time at which to complete the fade” },
arg3 = { name = “envtype”, min = 0, max = 1, tip = “type of envelope shape for the fade, 0 linear, 1 exponential” },
arg4 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 3”] = {
cmds = { exe = “envel”, mode = “curtail 3”, tip = “specify when the fade begins and fade to the existing end of insndfile” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “envtype”, min = 0, max = 1, tip = “type of envelope shape for the fade, 0 linear, 1 exponential” },
arg3 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 4”] = {
cmds = { exe = “envel”, mode = “curtail 4”, tip = “specify the precise times at which the file is to begin and end, and apply a doubly exponential (steeper) editing slope” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “fadeend”, min = 0, max = 50, set = “time at which to complete the fade” },
arg3 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 5”] = {
cmds = { exe = “envel”, mode = “curtail 5”, tip = “specify the duration of the fade and when it begins, and apply a doubly exponential (steeper) editing slope” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “fade-dur”, min = 0, max = 50, set = “time at which to complete the fade” },
arg3 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 6”] = {
cmds = { exe = “envel”, mode = “curtail 6”, tip = “Specify when the fade begins and fade to the existing end of insndfile, applying a doubly exponential (steeper) editing slope” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Dovetail - Dovetail a soundfile by enveloping its beginning and end”] = {
cmds = { exe = “envel”, mode = “dovetail 1”, tip = “a choice of linear or exponential slopes at the beginning and the end” },
arg1 = { name = “infadedur”, min = 0, max = 50, tip = “duration of the fade-in at the start of the file” },
arg2 = { name = “outfadedur”, min = 0, max = 50, tip = “duration of the fade-out at the end of the file” },
arg3 = { name = “intype”, min = 0, max = 1, tip = “envelope shape for the fade-in at the start of the file; intype = 0: linear fade, intype = 1: exponential fade (the Default)” },
arg4 = { name = “outtype”, min = 0, max = 1, tip = “envelope shape for the fade-out, at the end of the file; outtype = 0: linear fade, outtype = 1: exponential fade (the Default)” },
arg5 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = “identifies the type of time unit being used: times = 0: is seconds (the Default), times = 1: times are in samples, times = 2: times are in grouped-samples” },
}

dsp[“Envel Dovetail - Dovetail a soundfile by enveloping its beginning and end 2”] = {
cmds = { exe = “envel”, mode = “dovetail 2”, tip = “a doubly exponential slope (steeper) is applied to the beginning and the end” },
arg1 = { name = “infadedur”, min = 0, max = 50, tip = “duration of the fade-in at the start of the file” },
arg2 = { name = “outfadedur”, min = 0, max = 50, tip = “duration of the fade-out at the end of the file” },
arg3 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = “identifies the type of time unit being used: times = 0: is seconds (the Default), times = 1: times are in samples, times = 2: times are in grouped-samples” },
}

Really? with no sample selected I get ‘nil’ - I depend on getting that result to set the tool up properly so thats probably the cause. The rest of the errors might be related to this as well. I’m going to borrow a windows laptop from work tomorrow so I’ll test it out on that, see if I can get it working properly.

There is an error in the definition for this one. You have a jump from arg2 to arg4 and this breaks it, if you number them consecutively it should work.

sorry, my default new song apparently had an empty sample selected, removing the sample, and running again in terminal gives nil indeed!

Thanks, will fix.

edit;

new definitions;

[details=“Click to view contents”] ```
–[[
Instructions for definitions

You do not need to specify the infile or outfile these are handled by the tool.

Name the preset within the square brackets and in quotation marks after dsp[] e.g. dsp[“Preset name”]
The name can be anything but try and keep it the same or similar to the CDP reference documentation.

cmds

exe - The name of the CDP executable (exclude the .exe extension)
mode - The first part of the command argument that comes after the exe and before infile, outfile

arg1 to arg…n

name - The name displayed in the GUI (STRING)
switch - The switch flag, use only if it is a command switch e.g “-s” (STRING)
min - The minimum value of the range (NUMBER)
max - The maximum value of the range (NUMBER)
def - The default value the preset loads with (OPTIONAL NUMBER)
tip - The tool tip for the GUI control (OPTIONAL STRING)

Additional functions are available that give info about the sample

srate() - Gives the sample rate
cycles() - Gives the number of wavecycles (same as number of zero crossings/2)

–]]

dsp = {} – Do not edit this


– PRESET DEFINITIONS - afta8 –

dsp[“Filter Bank 1 - Harmonic”] = {
cmds = { exe = “filter”, mode = “bank 1”, tip = “The harmonic series is formed by multiplying a given frequency by an ascending series of integers: 1, 2, 3, 4, etc. The harmonic relationships produced are sonorous, but depart from the structure of triadic chords higher in the series. This Mode builds this type of harmonic relationship onto lofrq, which may be the actual pitch of a pitched tone or any arbitrary pitch. Because this is being done with a filter process, other sonic material is cleaned away, so a cleaner (and possibly quieter) sound may result, with more complex noise elements removed. Quite a bit of gain may be required – values of 40 or 50+ in this situation will not be unusual. Set hifrq as high as possible less too few harmonics are produced. This clean sound may provide a good input for spectral time-stretching, for example, to achieve a well-tuned sound with a minimum of artefacts.” },
arg1 = { name = “Q”, min = 0.001, max = 10000, tip = “Sets the Q of the effect” },
arg2 = { name = “Gain”, min = 0.001, max = 10000, def = 25 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Scatter”, switch = “-s”, min = 0, max = 1, tip = “Random scatter of frequencies” },
arg6 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 2 - Alt Harmonic”] = {
cmds = { exe = “filter”, mode = “bank 2”, tip = “This will be like Mode 1 but with every other harmonic omitted: the odd numbered partials are retained. The resulting sound will probably sound more ‘hollow’.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg6 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 3 - Sub Harmonic”] = {
cmds = { exe = “filter”, mode = “bank 3”, tip = “The ‘subharmonic series’ is the intervallic inverse of the harmonic series. Thus the departure from triadic-type intervals increases as the series descends. The resulting sound has a deeper tone and is somewhat hollow and somewhat inharmonic.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg6 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 4 - Harmonic Linear”] = {
cmds = { exe = “filter”, mode = “bank 4”, tip = “The offset in Hz is added to each harmonic. This will displace them so that they will no longer be exact multiples of the fundamental. This means that the cycles of the waveforms no longer line up at nodes, which introduces an ‘inharmonic’ dimension into the sound, heard as an increase in timbral components.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Offset (Hz)”, min = 10, max = srate()/3 },
arg6 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg7 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 5 - Filter Intervals”] = {
cmds = { exe = “filter”, mode = “bank 5”, tip = “Here we depart from the harmonic series and simply divide up the specified frequency range into an equal number filters: how many is specified by the user with param. The first effect this equal spacing will have is to create inharmonic (rather than integer multiple) relationships between the partials. A low number of filters will produce an ‘open’ sound, and a high number of filters will produce a denser, richer sound. These might be very interesting sounds to timestretch.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “No. Filters”, min = 1, max = 100 },
arg6 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg7 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 6 - Semitone Intervals”] = {
cmds = { exe = “filter”, mode = “bank 6”, tip = “By specifying the interval (in semitones), we in effect repeat these intervals within the frequency space between lofrq and hifrq, thus producing complex chords composed of the same interval ‘piled up’. This is a quick way to ‘harmonise’ a sound, with the resulting density dependent on the size of the interval. It is well worth re-running this function, entering intervals from 1 to 7, for example, to hear what kind of transformations will be produced. Some unexpected resonances may result; they could be filtered out later.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Semitones”, min = 1, max = 12 },
arg6 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg7 = { name = “Double”, switch = “-d” }
}


dsp[“Filter Phasing 1 - Allpass Filter”] = {
cmds = { exe = “filter”, mode = “phasing 1” },
arg1 = { name = “Gain”, min = -1, max = 1 },
arg2 = { name = “Delay”, min = 0.045, max = 1644.35 },
arg3 = { name = “PreScale”, switch = “-s”, min = 0, max = 1 },
arg4 = { name = “Linear”, switch = “-l” }
}

dsp[“Filter Phasing 2 - Phasing Effect”] = {
cmds = { exe = “filter”, mode = “phasing 1”, tip = “The ‘phasing effect’ is a kind of sweeping band passing through the sound, such as is sometimes heard when aeroplanes fly overhead, and is much used in popular music.Increasing the gain factor has some effect on the reverberant quality of the sound. So does increasing the delay time. The sound will still sound quite dry with delay < 20 (ms). Between about 20 and 45 ms there is a touch of resonance in the sound. Around 50 ms there is significant echoey reverberation (though somewhat granulated), and after 100 ms we start to hear larger portions of the sound repeating.Overall, the degree of reverberant effect is controlled by increasing both the gain and delay parameters in tandem” },
arg1 = { name = “Gain”, min = -1, max = 1 },
arg2 = { name = “Delay”, min = 0.045, max = 1644.35 },
arg3 = { name = “PreScale”, switch = “-s”, min = 0, max = 1 },
arg4 = { name = “Linear”, switch = “-l” }
}

dsp[“Filter Phasing 2 - Phasing Effect”] = {
cmds = { exe = “filter”, mode = “phasing 1”, tip = “The ‘phasing effect’ is a kind of sweeping band passing through the sound, such as is sometimes heard when aeroplanes fly overhead, and is much used in popular music.Increasing the gain factor has some effect on the reverberant quality of the sound. So does increasing the delay time. The sound will still sound quite dry with delay < 20 (ms). Between about 20 and 45 ms there is a touch of resonance in the sound. Around 50 ms there is significant echoey reverberation (though somewhat granulated), and after 100 ms we start to hear larger portions of the sound repeating.Overall, the degree of reverberant effect is controlled by increasing both the gain and delay parameters in tandem” },
arg1 = { name = “Gain”, min = -1, max = 1 },
arg2 = { name = “Delay”, min = 0.045, max = 1644.35 },
arg3 = { name = “PreScale”, switch = “-s”, min = 0, max = 1 },
arg4 = { name = “Linear”, switch = “-l” }
}


dsp[“Filter Sweeping 1 - High Pass”] = {
cmds = { exe = “filter”, mode = “sweeping 1”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.”
},
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}

dsp[“Filter Sweeping 2 - Low Pass”] = {
cmds = { exe = “filter”, mode = “sweeping 2”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.” },
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}

dsp[“Filter Sweeping 3 - Band Pass”] = {
cmds = { exe = “filter”, mode = “sweeping 3”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.” },
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}

dsp[“Filter Sweeping 4 - Notch”] = {
cmds = { exe = “filter”, mode = “sweeping 4”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.” },
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}


– Djeroek –

dsp[“Distort Average - average the waveshape over N wavecycles”] = {
cmds = { exe = “distort”, mode = “average”, tip = “DISTORT AVERAGE performs a mathematical averaging of the data in cyclecnt pseudo-wavecycles. The effect is more akin to a loss of resolution than the blurring which might be expected. Values below 10 retain some semblance of the original, while values of, for example, 100 seem to create a kind of ‘sample hold’ effect. For modest distortion, values 5 or less are recommended.” },
arg1 = { name = “cyclecnt”, min = 1, max = 6000, tip = “number of cycles over which to average (Range: > 1)” },
arg2 = { name = “maxwavelen”, switch = “-m”, min = 0, max = 1, tip = “maximum permissible wavelength in seconds (Default: 0.50)” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 1000, tip = “(integer) number of wavecycles to skip at start of file” },
}

dsp[“Distort Divide - Distortion by dividing wavecycle frequency”] = {
cmds = { exe = “distort”, mode = “divide”, tip = “Without altering duration, this process effectively lowers the sound while adding a rough texture.This is a useful form of distortion because it roughens the sound without being too violent about it” },
arg1 = { name = “N”, min = 2, max = 16, tip = “divider (Range: integer only, 2 to 16)” },
arg2 = { name = “-i”, switch = “-i”, tip = “use waveform interpolation: slower but cleaner” },
}

dsp[“Distort Fractal - Superimpose miniature copies of source wavecycles onto themselves”] = {
cmds = { exe = “distort”, mode = “fractal”, tip = “Note the very wide range of scaling. Because it is a divisor, the larger the value of scale the shorter will be the miniature copies to be superimposed. These superimposed copies can be made to increase (be careful!) or decrease in amplitude with the loudness parameter. Using a value of 1.0 maintains the original amplitude of the infile, which will be heard as pretty much as the original, but with the superimpositions on top of it. Loudness is therefore a means of balancing the input and the processed sound components.This is a powerful and somewhat wild tool for producing distortion effects. The higher the value of scaling, the more the superimposed copies appear as a sheen of distortion above the original sound.” },
arg1 = { name = “scaling”, min = 2, max = srate()/2, tip = “(integer) division of scale of source wave (Range: 2 to sample_rate/2)” },
arg2 = { name = “loudness”, min = 0, max = 10, tip = “loudness of scaled component relative to source (Loudness of source is reckoned to be 1.0)” },
arg3 = { name = “pre_attenuation”, switch = “-p”, tip = “apply attenuation to infile before processing” },
}

dsp["Distort Interpolate - Time-stretch file by repeating wavecycles and interpolating between them "] = {
cmds = { exe = “distort”, mode = “interpolate”, tip = “With this process, the shape of a ‘wavecycle’ is transformed into that of the next over multiplier repetitions. Note that this is waveshape-based interpolation, not a spectral interpolation, and that the length of the ‘wavecycle’ is also transformed by the process. The effect of the transformation is drastic, leading to a strongly granular outfile. The length of the outfile increases in step with the value of multiplier, as does the apparent pitchiness.The interpolation process adds a modulatory quality to the output, so that the successive wavecycles gliss and bend as they flow into one another. Even so, as multiplier increases, the perception of separate ‘grains’, i.e., ‘wavecycles’ increases. A value of 32, for example, changes the sound to a strange stream of modulating tones.” },
arg1 = { name = “multiplier”, min = 0, max = 50, tip = “(integer) number of times each ‘wavecycle’ repeats” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 20, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Multiply - Distortion by multiplying wavecycle frequency”] = {
cmds = { exe = “distort”, mode = “multiply”, tip = “The duration of the sound is not changed, only the frequency of the ‘wavecycles’, with the result that the pitch rises.The distortion is relatively mild, in that the original sound remains recognisable. However, the surface is textured and the pitch rises with each increase in the value of N. DISTORT MULTIPLY can be used, for example, to create high, modulating, grainy vocal sounds.” },
arg1 = { name = “N”, min = 2, max = 16, tip = “multiplier (Range: 2 to 16, integer only)” },
arg2 = { name = “-s”, switch = “-s”, tip = “smoothing (try this if glitches appear)” },
}

dsp[“Distort Omit – Omit A out of every B wavecycles, replacing them with silence”] = {
cmds = { exe = “distort”, mode = “omit”, tip = “Because the omitted ‘wavecyles’ are replaced by silence, the overall duration of the sound does not change. The larger the proportion of ‘wavecycles’ omitted from B, of course, the more distorted the the sound becomes. This distortion is like a rough texturing, rather than the highly modulatory results of some of the other processes.This process can be used, therefore, to achieve a rough texturing with no loss of duration.” },
arg1 = { name = “A”, min = 0, max = 5000, tip = “number of wavecycles to omit” },
arg2 = { name = “B”, min = 0, max = 5000, tip = “size of group of ‘wavecycles’ out of which to omit A wavecycles” },
}

dsp[“Distort Overload – Clip the signal with noise or a (possibly timevarying) waveform”] = {
cmds = { exe = “distort”, mode = “overload 1”, tip = “The clip-level parameter is rather like a ‘gate’ level. If the signal level is already high, anything over, for example, 0.1 is likely to push it into distortion, and values considerably higher than this will make it heavily distorted. However, if it only distorts, Trevor advises me, when it reaches a level of, for example, 0.99, it is not going to be distorted very often. The sound doesn’t actually have amplitude overload, because it is distorted by ‘slicing off’ the top (clipping) where it would have overloaded. The sound becomes loud and ‘strained’, like a voice which is shouting too loudly.Given the trials made so far, this can be a fairly subtle effect, but the words ‘straining’, ‘loud’, ‘uncompromising’ seem appropriate as the amplitude gets pushed towards the top of the range.” },
arg1 = { name = “clip-level”, min = 0, max = 1, tip = “level at which the signal is to be clipped (Range: 0 to 1) The signal level is renormalised after clipping.” },
arg2 = { name = “depth”, min = 0, max = 1, tip = “depth of the pattern of distortion imposed on clipped stretches of the signal. (Range: 0 to 1)” },
}

dsp[“Distort Overload – Clip the signal with noise or a (possibly timevarying) waveform”] = {
cmds = { exe = “distort”, mode = “overload 2”, tip = “The clip-level parameter is rather like a ‘gate’ level. If the signal level is already high, anything over, for example, 0.1 is likely to push it into distortion, and values considerably higher than this will make it heavily distorted. However, if it only distorts, Trevor advises me, when it reaches a level of, for example, 0.99, it is not going to be distorted very often. The sound doesn’t actually have amplitude overload, because it is distorted by ‘slicing off’ the top (clipping) where it would have overloaded. The sound becomes loud and ‘strained’, like a voice which is shouting too loudly. Mode 2 can add an extra ringing sound as the value for freq gets higher, e.g., 2000Hz and beyond. Given the trials made so far, this can be a fairly subtle effect, but the words ‘straining’, ‘loud’, ‘uncompromising’ seem appropriate as the amplitude gets pushed towards the top of the range.” },
arg1 = { name = “clip-level”, min = 0, max = 1, tip = “level at which the signal is to be clipped (Range: 0 to 1) The signal level is renormalised after clipping.” },
arg2 = { name = “depth”, min = 0, max = 1, tip = “depth of the pattern of distortion imposed on clipped stretches of the signal. (Range: 0 to 1)” },
arg3 = { name = “freq”, min = 0, max = 22500, tip = “frequency of the waveform imposed on clipped stretches of the signal” },
}

dsp[“Distort Pitch - Pitchwarp wavecycles of sound”] = {
cmds = { exe = “distort”, mode = “pitch”, tip = “The random up/down movement of the ‘wavecycles’ within the total octvary range produces a great deal of bending of the sound, especially if the original alters its pitch a good deal. It is better, therefore, to start with relatively small values for octvary – e.g., less than 1 – so that you start to use this function with some degree of control over the results.The full power of DISTORT PITCH doesn’t really come into its own until time-varying parameters are used, especially for cyclecnt. Large values for the latter will serve to slow down the rate of change. DISTORT PITCH is useful for creating ‘flexitones’ (to coin a term) – with distortion, of course.” },
arg1 = { name = “octvary”, min = 0,0, max = 8,0, tip = “maximum possible transposition up or down in (fractions of) octaves (Range > 0.0 to 8.0)” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “mamimum number of ‘wavecycles’ between the generation of transposition values (Range: > 1, Default: 64)” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Pulsed - Impose impulse-train on a sound”] = {
cmds = { exe = “distort”, mode = “pulsed 1”, tip = “Distort a sound by imposing a series of impulses on the source, or on a specific waveset segment of the source. An impulse is like a brief event created by a sharp envelope on the sound. The sound inside the impulse might glissando slightly, as if whatever is causing the impulsion has warped the sound by its impact.” },
arg1 = { name = “stime”, min = 0.001, max = 10, tip = “time in the source sound where the impulses begin” },
arg2 = { name = “dur”, min = 0.001, max = 10, tip = “length of time that the impulses continue” },
arg3 = { name = “frq”, min = 0, max = 1000, tip = “number of impulses per second” },
arg4 = { name = “frand”, min = 0, max = 12, tip = “number of semitones by which to randomise the frequency of the impulses” },
arg5 = { name = “trand”, min = 0, max = 10, tip = “amount of time in seconds by which to randomise the relative time positions of amplitude peaks and troughs from impulse to impulse” },
arg6 = { name = “arand”, min = 0, max = 1, tip = “randomisation of the amplitude shape created by the peaks and troughs from impulse to impulse” },
arg7 = { name = “transp”, min = 0, max = 1, tip = “transposition contour of sound inside each impulse” },
arg8 = { name = “tranrand”, min = 0, max = 1, tip = “randomisation of transposition contour from impulse to impulse” },
arg9 = { name = “-s”, switch = “-s”, tip = “keep start of source sound, before impulses begin (if any)” },
arg10 = { name = “-e”, switch = “-e”, tip = “keep end of source sound, after impulses end (if any)” },
}

dsp["Distort Pulsed - Imposed regular pulsations on a sound "] = {
cmds = { exe = “distort”, mode = “pulsed 2”, tip = “Distort a sound by imposing a series of impulses on the source, or on a specific waveset segment of the source. An impulse is like a brief event created by a sharp envelope on the sound. The sound inside the impulse might glissando slightly, as if whatever is causing the impulsion has warped the sound by its impact.” },
arg1 = { name = “stime”, min = 0.001, max = 10, tip = “time in the source sound where the impulses begin” },
arg2 = { name = “dur”, min = 0.001, max = 10, tip = “length of time that the impulses continue” },
arg3 = { name = “frq”, min = 0, max = 1000, tip = “number of impulses per second” },
arg4 = { name = “frand”, min = 0, max = 12, tip = “number of semitones by which to randomise the frequency of the impulses” },
arg5 = { name = “trand”, min = 0, max = 10, tip = “amount of time in seconds by which to randomise the relative time positions of amplitude peaks and troughs from impulse to impulse” },
arg6 = { name = “arand”, min = 0, max = 1, tip = “randomisation of the amplitude shape created by the peaks and troughs from impulse to impulse” },
arg7 = { name = “cycletime”, min = 0, max = 10, tip = “duration in seconds of wavecycles to grab as sound substance inside the impulses” },
arg8 = { name = “transp”, min = 0, max = 1, tip = “transposition contour of sound inside each impulse” },
arg9 = { name = “tranrand”, min = 0, max = 1, tip = “randomisation of transposition contour from impulse to impulse” },
arg10 = { name = “-s”, switch = “-s”, tip = “keep start of source sound, before impulses begin (if any)” },
arg11 = { name = “-e”, switch = “-e”, tip = “keep end of source sound, after impulses end (if any)” },
}

dsp[“Distort Reform - Convert to fixed level square wave”] = {
cmds = { exe = “distort”, mode = “reform 1”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to square wave”] = {
cmds = { exe = “distort”, mode = “reform 2”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to fixed level triangular wave”] = {
cmds = { exe = “distort”, mode = “reform 3”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to triangular wave”] = {
cmds = { exe = “distort”, mode = “reform 4”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to inverted half-cycles”] = {
cmds = { exe = “distort”, mode = “reform 5”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to click streams”] = {
cmds = { exe = “distort”, mode = “reform 6”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to sinusoid”] = {
cmds = { exe = “distort”, mode = “reform 7”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Exaggerate waveform contour”] = {
cmds = { exe = “distort”, mode = “reform 8”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
arg1 = { name = “exaggeration”, min = 0,000002, max = 40, tip = “exaggeration factor (Range: 0.000002 to 40.0)” },
}

dsp[“Distort Repeat - Timestretch soundfile by repeating wavecycles”] = {
cmds = { exe = “distort”, mode = “repeat”, tip = “The repetition of the ‘wavecycles’ stretches out the sound, making it both longer and more granular in texture. This granularity is increased if (increasingly larger) groups of cyclecnt ‘wavecycles’ are used: then the whole group repeats multiplier times. DISTORT REPEAT produces long, grainy (distorted) sounds. The sense of stretching out the original is very apparent.A significant application of DISTORT REPEAT is that, by increasing the cyclecnt factor, one crosses the pitch-perception boundary: that is, starting with a noisy sound in which all the wavecycles are randomly different, one ends up with, for example, 7 repetitions of the same wavecycle, followed by 7 of another and so on – and each of these comprise sufficient repetitions for us to hear pitch. Thus the noise source becomes a string of pitch beads, each of arbitrary timbre. With a cyclecnt of, for example, 128, one can even get a slowish random melody.” },
arg1 = { name = “multiplier”, min = 0,0, max = 50, tip = “number of times (integer) each ‘wavecycle’ (group) repeats” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “number of ‘wavecycles’ (integer) in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = "number of ‘wavecyles’ (integer) to skip at start of file " },
}

dsp[“Distort Repeat 2 - Repeat wavecycles without time-stretching”] = {
cmds = { exe = “distort”, mode = “repeat2”, tip = “Repeating the ‘wavecycles’ without time-stretching (as in DISTORT REPEAT) enables you to increase the strength of the distortion with the multiplier parameter without making the output file any longer than the original. Larger values for cyclecnt increases the length of infile that is affected. Higher values for multiplier increase the distortion, while higher values for cyclecnt increase the length of infile that is processed as one unit. Thus we could have: a low value for multiplier coupled with a high value for cyclecnt – this will produce a bit of distortion while the source remains recognisable, a high value for multiplier coupled with a low value for cyclecnt – this will produces a great deal of distortion, but the effect is limited because only a few cycles are affected as a unit. High values for both parameters – this appears to create the most distortion” },
arg1 = { name = “multiplier”, min = 0,0, max = 50, tip = “number of times (integer) each ‘wavecycle’ (group) repeats” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “number of ‘wavecycles’ (integer) in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = "number of ‘wavecyles’ (integer) to skip at start of file " },
}

dsp[“Distort Replace – The strongest wavecycle in a cyclecnt group replaces the others”] = {
cmds = { exe = “distort”, mode = “replace”, tip = “The replacing action serves to simplify the sound. Note that the single strong ‘wavecycle’ in the group will take the place of several others, which will be deleted. This simplification becomes extreme when the cyclecnt is high, leading to a ‘sample-hold’ kind of stepped effect. Time-varying cyclecnt makes it possible to introduce gradual change. With DISTORT REPLACE we can achieve a simplification of the sound, up to very clear ‘sample-hold’ type stepped tones” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 5000, tip = “(integer) size of group of ‘wavecycles’” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “number of ‘wavecyles’ (integer) to skip at start of file” },
}

dsp["Distort Replim – Timestretch by repeating wavecycles (below a specified frequency) “] = {
cmds = { exe = “distort”, mode = “replim”, tip = “This function is like DISTORT REPEAT, but with a slight change. Here the length of wavecycle to be affected can be set. Thus, if you set a mid-range frequency, only those below that frequency will repeat, and the others (above the frequency) will be discarded (filtered out). Hence the name ‘REP-LIM’, meaning ‘repeat (with a) limit’. DISTORT REPLIM is therefore like a filtering program that also repeats wavecycles. In the DISTORT set, the wavecycles are wavelengths that occur between zero crossings, so distortion also occurs. It is helpful to remember that wavelength is inversely proportional to frequency. Wavelength is the actual physical length of the oscillation, and frequency is the number of cycles that occur in one second (i.e., Hertz). These two aspects of sound are inversely proportional to one another: P = 1/f. For example, a sound oscillating at 100 Hz will have a period, i.e., a wavelength of 1/100 meters = 0.01 meters (0.39 inch). A sound oscillating at 1000Hz will have a wavelength of 1/1000 meters = 0.001 meters (0.039 inch). Short wavecycles are therefore higher in pitch and long ones are lower in pitch. When the frequency setting for DISTORT REPLIM is high, the filter point is set higher and more of the sound will be retained. Here we are dealing with ‘pseudo-wavecycles’ (portions of soundfile between zero crossings), which is what introduces distortion into the equation.The net result of the function is to create repetition distortion while filtering out a user-definable amount of the higher frequencies. Remember that the relative amounts of high and low frequencies in the infile will affect the results.” },
arg1 = { name = “multiplier”, min = 0.001, max = 100, tip = “the number of times each wavecycle (group) repeats (Integer)” },
arg2 = { name = “cyclecnt”, switch = “-c”, min = 0, max = 5000, tip = “the number of wavecycles in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = " the number of wavecycles to skip at the beginning of the soundfile” },
arg4 = { name = “hilim”, switch = “-f”, min = 0, max = 22500, tip = “the frequency below which cycles are counted” },
}

dsp[“Distort Reverse - Cycle-reversal distortion in which the wavecycles are reversed in groups”] = {
cmds = { exe = “distort”, mode = “reverse”, tip = “Here the original soundfile is grouped into a series of ‘wavecycles’ with cyclecnt ‘wavecycles’ in each group. Then each of these groups of ‘wavecycles’ is reversed. The term ‘distortion’ here is something of a misnomer, because no distortion process is applied to the ‘wvecycles’ themselves. Instead, cyclecnt sets the number of ‘wavecycles’ which are to be copied in reverse as a group to the outfile. For example, if cyclecnt = 3, 15 ‘wavecycles’ reversed in groups of 3 will assume the order: 3-2-1, 6-5-4, 9-8-7, 12-11-10, 15-14-13. Thus, not only is the sound material backwards, but the reversed 1st ‘wavecycle’ is now adjacent to the reversed 6th ‘wavecycle’. This mimics the classical tape studio technique of cutting up a length of tape into segments (of varying lengths), reversing the segments, and joining up the reversed pieces. The result will be similar to a random brassage because of the differing lengths of the ‘wavecycles’. The process moves steadily through the infile from beginning to end, so the normal order of the (reversed) events is preserved. It is surprising how normal the output can be. With mid-range values for cyclecnt (say, 30 to 100), one hears the original breaking up, but only with very large values for cyclecnt does one hear the sound sweeping backwards in large swathes. Again, it is a question of ‘resolution’: the size of the units being manipulated. A small value for cyclecnt will produce a grainy result, mid-values a ‘broken up’ result, and large values swathes of reversed sound. If the value for cyclecnt exceeds the number of ‘wavecycles’ in the infile, you will be told that the ‘sound source is too short…’. DISTORT CYCLECNT returns the number of ‘wavecycles’ in a sound, should you want to provide a value for cyclecnt which is right up to the limit. Reversing the output of DISTORT REVERSE turns the cyclecnt groups back the other way while reading the whole soundfile from back to front, producing an interesting mixture of forwards and backwards! Using the time-varying option for cyclecnt provides an opportunity for dramatic or gradual changes in the output.” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 10000, tip = “number of ‘wavecycles’ in a reversed group (Range: > 0)” },
}

dsp[“Distort Telescope - Time-contract sound by telescoping N wavecycles into 1”] = {
cmds = { exe = “distort”, mode = “telescope”, tip = “Although at first rather like DISTORT OMIT, here the ‘wavecycles’ are not deleted as such. Instead, they are superimposed (i.e., mixed) onto each other, with shorter ‘wavecycles’ being stretched to fit the longest one in each group of cyclecnt ‘wavecycles’. The outfile will usually be much shorter than the infile and can be reduced to a mere blip with this process. The -a flag tells the program to telescope to the average ‘wavecycle’ length, rather than to the longest. Since the longest ‘wavecycle’ in each group is compressed by this method, the outfile will be even shorter. Interesting results can be achieved with small values for cyclecnt, the output tending to have a ‘mushy’ quality. It responds well to pitched material, producing a singing, if mushy, tone.” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 1000, tip = “the number of ‘wavecycles’ in a group” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “number of ‘wavecyles’ (integer) to skip at start of file” },
arg3 = { name = “-a”, switch = “-a”, tip = “telescope to an average ‘wavecycle’ length (Default: telescope to the longest ‘wavecycle’ length)” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles below freq”] = {
cmds = { exe = “distort”, mode = “filter 1”, tip = “Period and frequency are inverse functions. Therefore it is possible to relate the length of a ‘wavecycle’ to the frequency it would have were it to recur regularly. This program therefore filters by removing ‘wavecycles’ shorter or longer than those relating to a specific, user-defined, frequency. The duration of the outfile is affected by this process: because ‘wavecycles’ are being removed, the outfile will be shorter, by varying degrees. The aural effect of the DISTORT FILTER process is actually like gating. In gating, you can imagine a horizontal line drawn through the time/amplitude display of a soundfile. If the peaks above the line are retained (by filtering out lower frequencies), you just hear them (joined up). Similarly, if you filter out above the line, the peaks are gone, leaving the lower sound material (joined up). The difference here is that the process is operating on ‘pseudo-wavecycles’ according to their length, so here the results are more unpredictable and also distort the sound to some degree, depending on where the horizontal line – the frequency variable(s) – is drawn. Technically, the process is akin to low-, high- and band-pass filters, but aurally it is more like gating. You can therefore use this procedure to cut out some and distort other material in a sound.” },
arg1 = { name = “freq”, min = 10,0, max = 22050.0, tip = “frequency in Hz (Range: 10.0 to 22050.0)” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles above freq”] = {
cmds = { exe = “distort”, mode = “filter 2”, tip = “Period and frequency are inverse functions. Therefore it is possible to relate the length of a ‘wavecycle’ to the frequency it would have were it to recur regularly. This program therefore filters by removing ‘wavecycles’ shorter or longer than those relating to a specific, user-defined, frequency. The duration of the outfile is affected by this process: because ‘wavecycles’ are being removed, the outfile will be shorter, by varying degrees. The aural effect of the DISTORT FILTER process is actually like gating. In gating, you can imagine a horizontal line drawn through the time/amplitude display of a soundfile. If the peaks above the line are retained (by filtering out lower frequencies), you just hear them (joined up). Similarly, if you filter out above the line, the peaks are gone, leaving the lower sound material (joined up). The difference here is that the process is operating on ‘pseudo-wavecycles’ according to their length, so here the results are more unpredictable and also distort the sound to some degree, depending on where the horizontal line – the frequency variable(s) – is drawn. Technically, the process is akin to low-, high- and band-pass filters, but aurally it is more like gating. You can therefore use this procedure to cut out some and distort other material in a sound.” },
arg1 = { name = “freq”, min = 10,0, max = 22050.0, tip = “frequency in Hz (Range: 10.0 to 22050.0)” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles below & above freq”] = {
cmds = { exe = “distort”, mode = “filter 3”, tip = “Period and frequency are inverse functions. Therefore it is possible to relate the length of a ‘wavecycle’ to the frequency it would have were it to recur regularly. This program therefore filters by removing ‘wavecycles’ shorter or longer than those relating to a specific, user-defined, frequency. The duration of the outfile is affected by this process: because ‘wavecycles’ are being removed, the outfile will be shorter, by varying degrees. The aural effect of the DISTORT FILTER process is actually like gating. In gating, you can imagine a horizontal line drawn through the time/amplitude display of a soundfile. If the peaks above the line are retained (by filtering out lower frequencies), you just hear them (joined up). Similarly, if you filter out above the line, the peaks are gone, leaving the lower sound material (joined up). The difference here is that the process is operating on ‘pseudo-wavecycles’ according to their length, so here the results are more unpredictable and also distort the sound to some degree, depending on where the horizontal line – the frequency variable(s) – is drawn. Technically, the process is akin to low-, high- and band-pass filters, but aurally it is more like gating. You can therefore use this procedure to cut out some and distort other material in a sound.” },
arg1 = { name = “freq1”, min = 0,0, max = 22050.0, tip = “frequency in Hz to delete below” },
arg2 = { name = “freq2”, min = 0,0, max = 22050,0, tip = “frequency in Hz to delete above” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}


dsp[“Modify Brassage - Pitchshift - Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 1” },
arg1 = { name = “pitchshift”, min = -0,12, max = 12, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
}

dsp[“Modify Brassage - Timestretch -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 2” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
}

dsp[“Modify Brassage - Reverb -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 3” },
arg1 = { name = “density”, min = 0,0, max = 1000, tip = “amount of grain overlap (Range: > 0)” },
arg2 = { name = “pitch”, min = -0,33, max = 0,33, tip = “transposition factor (Range: -0.33 to 0.33)” },
arg3 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg4 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
}

dsp[“Modify Brassage - Scramble -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 4” },
arg1 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg2 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
}

dsp[“Modify Brassage - Granulate -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 5” },
arg1 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg2 = { name = “-d”, switch = “-d” },
}

dsp[“Modify Brassage - Brassage -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 6” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
arg2 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg3 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg4 = { name = “pitchshift”, min = -0,33, max = 0,33, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
arg5 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg6 = { name = “space”, min = 0, max = 1, tip = “spatial position – set stereo position” },
arg7 = { name = “bsplice”, min = 0, max = 1000, tip = “length of start-splices on grains in ms (Default: 5)” },
arg8 = { name = “esplice”, min = 0, max = 1000, tip = “length of end-splices on grains in ms (Default: 5)” },
arg9 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
arg10 = { name = “jitter”, switch = “-j”, min = 0, max = 1, tip = “randomisation of grain position” },
arg11 = { name = “outlength”, switch = “-l”, min = 0, max = 10, tip = “maximum outfile length (if end of data is not reached)” },
arg12 = { name = “channel”, switch = “-c”, min = 0, max = 2, tip = " extract and work on just one channel of a stereo input (Range: 1 or 2) Set channel to 0 (the Default) for this parameter to be ignored." },
arg13 = { name = “-d”, switch = “-d” },
arg14 = { name = “-x”, switch = “-x”, tip = “do exponential splices (Default: linear)” },
arg15 = { name = “-n”, switch = “-n”, tip = “no interpolation for pitch values (quick but dirty)” },
}

dsp[“Modify Brassage - Full Monty -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 7” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
arg2 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg3 = { name = “hvelocity”, min = 0,0, max = 5000,0 },
arg4 = { name = “hdensity”, min = 0,0, max = 5000,0 },
arg5 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg6 = { name = “pitchshift”, min = -0,33, max = 0,33, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
arg7 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg8 = { name = “space”, min = 0, max = 1, tip = “spatial position – set stereo position” },
arg9 = { name = “bsplice”, min = 0, max = 1000, tip = “length of start-splices on grains in ms (Default: 5)” },
arg10 = { name = “esplice”, min = 0, max = 1000, tip = “length of end-splices on grains in ms (Default: 5)” },
arg11 = { name = “hgrainsize”, min = 0, max = 5000 },
arg12 = { name = “hpitchshift”, min = -0,33, max = 0,33 },
arg13 = { name = “hamp”, min = 0, max = 1 },
arg14 = { name = “hspace”, min = 0, max = 2 },
arg15 = { name = “hbsplice”, min = 0, max = 1000 },
arg16 = { name = “hesplice”, min = 0, max = 1000 },
arg17 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
arg18 = { name = “jitter”, switch = “-j”, min = 0, max = 1, tip = “randomisation of grain position” },
arg19 = { name = “outlength”, switch = “-l”, min = 0, max = 10, tip = “maximum outfile length (if end of data is not reached)” },
arg20 = { name = “channel”, switch = “-c”, min = 0, max = 2, tip = " extract and work on just one channel of a stereo input (Range: 1 or 2) Set channel to 0 (the Default) for this parameter to be ignored." },
arg21 = { name = “-d”, switch = “-d” },
arg22 = { name = “-x”, switch = “-x”, tip = “do exponential splices (Default: linear)” },
arg23 = { name = “-n”, switch = “-n”, tip = “no interpolation for pitch values (quick but dirty)” },
}

dsp[“Modify Loudness - Alter gain of sound”] = {
cmds = { exe = “modify”, mode = “loudness 1” },
arg1 = { name = “gain”, min = 0,0, max = 100,0, tip = “adjust level by factor gain” },
}

dsp[“Modify Loudness - Alter dB-gain of sound”] = {
cmds = { exe = “modify”, mode = “loudness 2” },
arg1 = { name = “gain”, min = -96, max = 96, tip = “level expressed in dB (Range: -96dB to 96dB). NB: every drop of -6dB halves the previous level.” },
}

dsp[“Modify Loudness - Normalise”] = {
cmds = { exe = “modify”, mode = “loudness 3” },
arg1 = { name = “level”, switch = “-l”, min = 0, max = 1, tip = “force level (if necessary) to the maximum possible, or to the level given (Range: 0 to 1).” },
}

dsp[“Modify Loudness - Force level”] = {
cmds = { exe = “modify”, mode = “loudness 4” },
arg1 = { name = “level”, switch = “-l”, min = 0, max = 1, tip = “force level to maximum possible, or to the level given (Range: 0 to 1)” },
}

dsp[“Modify Loudness - Invert Phase”] = {
cmds = { exe = “modify”, mode = “loudness 6” },
}

dsp[“Phase - Invert phase”] = {
cmds = { exe = “phase”, mode = “phase 1”, tip = “Playback of the output inverted soundfile shows that there is no audible difference from the input soundfile. However, if you mix the original sound with the phase inverted sound, you will generate a silent output: positive and negative amplitude values cancel out. However, if you mix the input and output with an offset, you get signal and hear an overlap of the two soundfiles (the cancelling out does not fully happen). You can try this with SUBMIX MERGE.” },
}

dsp[“Phase - Stereo Enhance stereo file”] = {
cmds = { exe = “phase”, mode = “phase 2”, tip = “This mode is supposed to be a means of creating an enhanced stereo image by suppressing any aspects of the Left image which have bled to the Right, by adding (part of) the phase inverted Left signal on the Right, and vice versa. I (T Wishart) learned of this idea from a mixing engineer I met in France, but I’m still not convinced that this achieves anything except in very special circumstances (with particular types of material). The output may sound the same as the input, except perhaps on the largest PA systems.” },
arg1 = { name = “transfer”, switch = “-t”, min = 0, max = 1, tip = “amount of signal to be used in phase-cancellation.” },
}

dsp[“Modify Radical - Reverse”] = {
cmds = { exe = “modify”, mode = “radical 1”, tip = “Sound plays backwards, the soundfile is re-written back to front: starting at the end and ending at the beginning.” },
}

dsp[“Modify Radical - Shred”] = {
cmds = { exe = “modify”, mode = “radical 2”, tip = “The soundfile is (randomly) segmented, and these segments reordered by means of a permutation process. As the number of repeats increases, it gets more and more jumbled, literally ‘reducing it to shreds’. The -n adds splicing that results in a smoother output.” },
arg1 = { name = “repeats”, min = 0, max = 1000, tip = “number of repeats of shredding process” },
arg2 = { name = “chunklen”, min = 0, max = 500, tip = “average length of chunks to cut and permutate” },
arg3 = { name = “scatter”, switch = “-s”, min = 0, max = 10, tip = “randomisation of cuts (Range: 0 to K, where K = duration of infile/chunklen Default = 1)” },
arg4 = { name = “-n”, switch = “-n”, tip = “use this flag for a smoother output” },
}

dsp[“Modify Radical - Scrub back and forth”] = {
cmds = { exe = “modify”, mode = “radical 3”, tip = “This is an acceleration/deceleration process which models an editing procedure used in the ‘classical’ tape studio: the desired edit point was found by turning the tape spools by hand so that the tape moved (very slowly!) across the tape head. You could hear locate exactly where silence began or ended, where clicks came etc., although the sound was very low because of the slow speed.The SCRUB function could also be used creatively, to create extreme speed modifications of the source sound on the tape, e.g. an abrupt acceleration-deceleration as the tape went from not-moving, to fast-moving, to stopped as the hands jerked the tape across the heads.” },
arg1 = { name = “dur”, min = 0, max = 10, tip = “minimum length of outfile required” },
arg2 = { name = “down”, switch = “-l”, min = 0, max = 12, tip = “lowest downward tranposition in semitones” },
arg3 = { name = “up”, switch = “-h”, min = 0, max = 12, tip = " highest upward transposition in semitones" },
arg4 = { name = “start”, switch = “-s”, tip = "scrubs start before time start seconds " },
arg5 = { name = “end”, switch = “-e”, tip = “scrubs end after time end” },
}

dsp[“Modify Radical - Lose resolution”] = {
cmds = { exe = “modify”, mode = “radical 4”, tip = “LOSE RES: Reducing the sample rate reduces the level of the Nyquist frequency (sample_rate/2), thereby lowering the frequency level which can be safely handling during processing. Lowering bit-resolution reduces the precision of the numerical expression of the data, making the digital ‘quantisation’ of the sonic material coarser. This means that time-varying information is lost.” },
arg1 = { name = “bit_resolution”, min = 0, max = 16 },
arg2 = { name = “srate_division”, min = 1, max = 256, tip = “Range: 1 to 256 Default 1 (normal)” },
}

dsp[“Modify Radical - Ring Modulate”] = {
cmds = { exe = “modify”, mode = “radical 5”, tip = “RING MODULATION: multiplies two (bipolar) signals. In this case, one signal is a soundfile and the other is a modulating_frq. This creates two ‘sidebands’ which are the sum and the difference of the two signals, while the carrier signal disappears. The result is a timbrally ‘hollow’ sound. (See Curtis Roads, The Computer Music Tutorial, pp. 215-220).” },
arg1 = { name = “modulating-frq”, min = 0, max = 44100, tip = “number of cycles per second” },
}

dsp[“Modify Revecho - Standard delay”] = {
cmds = { exe = “modify”, mode = “revecho 1”, tip = “Mode 1 provides a standard delay. If a smooth echoey effect is wanted, be careful to keep mix on the low side. Remember that delay is given in milliseconds; after 60ms or so, one begins to hear a strong reverberation; after 100 ms the reverberation begins to ‘bounce’, and by 200 ms one begins to hear distinct echoes. Delay times greater than 1000 will cause repetitions of (all or much of) the sound. Don’t forget to lengthen the tail to match the delay time.The mix parameter, in adding in the delayed signal, increases the reverberant effect. With a short delay time, this can sound like the reverberation which occurs in an enclosed space. Feedback has a similar effect, becoming very pronounced towards a value of 1.0 – rather like the ‘feedback’ which occurs when a microphone is placed facing a loudspeaker. The operation of a standard delay line in Mode 1 ranges from modest reverberation to echo effects. The reverberations, however, tend easily towards rough edges, so for smoother reverbs, look to the programs listed below.” },
arg1 = { name = “delay”, min = 0, max = 5000, tip = “delay time, in milliseconds” },
arg2 = { name = “mix”, min = 0, max = 1, tip = " amount of delayed signal in final mix: 0 gives ‘dry’ result (Range: 0 to 1)" },
arg3 = { name = “feedback”, min = -1,0, max = 1,0, tip = “produces resonances related to delay time (with short times) (Range: -1.0 to 1.0)” },
arg4 = { name = “tail”, min = -1,0, max = 1,0, tip = “time to allow decayed signal to decay to zero (Range: -1.0 to 1.0)” },
arg5 = { name = “prescale”, switch = “-p”, tip = “prescales input level, to avoid overload” },
arg6 = { name = “-i”, switch = “-i”, tip = “inverts the dry signal (for phasing effects)” },
}

dsp[“Modify Revecho - Varying delay”] = {
cmds = { exe = “modify”, mode = “revecho 2” },
arg1 = { name = “delay”, min = 0, max = 5000, tip = “delay time, in milliseconds” },
arg2 = { name = “mix”, min = 0, max = 1, tip = " amount of delayed signal in final mix: 0 gives ‘dry’ result (Range: 0 to 1)" },
arg3 = { name = “feedback”, min = -1,0, max = 1,0, tip = “produces resonances related to delay time (with short times) (Range: -1.0 to 1.0)” },
arg4 = { name = “lfomod”, min = 0, max = 1, tip = “depth of the delay-variation sweep (Range: 0 to 1)” },
arg5 = { name = “lfofreq”, min = -50, max = 50, tip = “frequency of the delay-variation sweep (negative values give random oscillations)” },
arg6 = { name = “lfophase”, min = 0, max = 1, tip = “start-phase of the delay-variation sweep (Range: 0 to 1)” },
arg7 = { name = “lfodelay”, min = 0, max = 10, tip = “time in seconds before the delay-variation sweep begins” },
arg8 = { name = “tail”, min = -1,0, max = 1,0, tip = “time to allow decayed signal to decay to zero (Range: -1.0 to 1.0)” },
arg9 = { name = “prescale”, switch = “-p”, tip = “prescales input level, to avoid overload” },
arg10 = { name = “seed”, switch = “-s”, min = 0, max = 100, tip = "non-zero value gives reproducible output (with the same seed) where random oscillations are used " },
}

dsp[“Modify Revecho - Stadium Echo”] = {
cmds = { exe = “modify”, mode = “revecho 3”, tip = “This creates a stereo outfile, bouncing the signal between speakers with a very prominent delay factor. The idea is that you hear the signal bouncing around the ‘stadium’. The defaults work quite nicely, but you can intensify the effect by multiplying the delay time with the size parameter. Note that this is a multiple, so values less than 0 (multiplied with the default time of 0.1 sec) will decrease the delay time. Beyond size = 2, you are likely to run into insufficient buffer space, so if you really want longer delay times, you will have to increase the buffer size with ‘set CDP_MEMORY_BBSIZE=…’ (bear in mind the RAM capacity of your machine). (The default buffer size is 1 Mbyte and the units are in ‘k’: e.g., a BBSIZE of 3000 units is 3 Mbyte)” },
arg1 = { name = “gain”, switch = “-g”, min = 0, max = 1, tip = “to apply to input signal (Default: 0.645654)” },
arg2 = { name = “roll_off”, switch = “-r”, min = 0, max = 10, def = 1, tip = “rate of loss of level across stadium (Default: 1))” },
arg3 = { name = “size”, switch = “-s”, min = 0, max = 10, tip = “multiplies average time between echoes (the Default time between echoes of 0.1 sec)” },
arg4 = { name = “count”, switch = “-e”, min = 0, max = 23, tip = “number of stadium echoes (Default and max: 23)” },
}

dsp[“Modify Space - pan”] = {
cmds = { exe = “modify”, mode = “space 1”, tip = “Adjusts the amplitude levels of the two channels so as to create spatial illusions. A time pan breakpoint file is used to create movement. Mode1 PAN: control of sound in 3-D space has been a basic procedure when composing with ‘sound’ material, especially when these are drawn from nature/the environment. The assumption here is that you are thinking about the placement and movement of sound as an integral part of your compositional process. In this case, we are dealing with building these procedures into the sound itself. There is a further aspect external to the sound itself, achieved by ‘mixing’ (superimposing sounds and writing a new soundfile) and ‘diffusion’ (sound placement during playback achieved by manipulating the pan controls on a mixer).” },
arg1 = { name = “pan”, min = -1,0, max = 1,0, tip = “floating point value to specify location between the pair of stereo speakers, or breakpoint file of time pan pairs. Range: -1.0 to 1.0; 0.0 is centre.” },
arg2 = { name = “prescale”, switch = “-p”, min = 0, max = 1, tip = “gain factor multiplier with which to adjust the input level (Default: 0.7)” },
}

dsp["Modify Space - Mirrow: two channels swap sides "] = {
cmds = { exe = “modify”, mode = “space 2”, tip = “MIRROR: the data in the two channels swaps sides, a utility for a quick Left/Right swap” },
}

dsp[“Modify Space - Narrow: Narrow the stereo image of a sound”] = {
cmds = { exe = “modify”, mode = “space 4”, tip = “A way to restrict the spatial location of a sound in the horizontal plane, this program allows you to narrow the spread of a stereo field” },
arg1 = { name = “narrowing”, min = -1,0, max = 1,0, tip = “make the stereo image less wide” },
}

dsp[“Modify Speed - Vary speed & pitch of a sound”] = {
cmds = { exe = “modify”, mode = “speed 1”, tip = “Speed modification processes change the duration and the pitch of the sound together. Thus a faster speed causes a higher pitch, a slower speed a lower pitch.MODIFY SPEED offers a range of functions which affect the speed of the soundfile. Perhaps it will be most often used for transposition. Modes 1 and 2 both accept either single values or the names of time-varying breakpoint files with time transposition pairs. The single values act as constants and transpose the whole soundfile up or down by the given amount. In the breakpoint files, transposition can be almost instantaneous (almost same time, different transposition value), or gradual, creating glissandi (different time, different transposition value). No transposition between times is a third possibility (different time, same transposition value). Transposition which also changes the speed, and therefore the pitch, of the soundfile greatly alters the character of the sound. It is often very interesting to hear what a sound will be like 1, 2 or even 3 octaves below its original pitch. Deep, rich tones can be achieved in this way. These tones can slowly rise or descend if created with a time-varying breakpoint file e.g., moving an octave up or down over the time of the whole sound (airplane takeoff sounds, etc.)” },
arg1 = { name = “speed”, min = 0, max = 4, tip = “transposition value (ratio) expressed as a floating point multiplier” },
}

dsp[“Modify Speed - Vary speed & pitch by (fractional) number of semitones”] = {
cmds = { exe = “modify”, mode = “speed 2”, tip =“Speed modification processes change the duration and the pitch of the sound together. Thus a faster speed causes a higher pitch, a slower speed a lower pitch.MODIFY SPEED offers a range of functions which affect the speed of the soundfile. Perhaps it will be most often used for transposition. Modes 1 and 2 both accept either single values or the names of time-varying breakpoint files with time transposition pairs. The single values act as constants and transpose the whole soundfile up or down by the given amount. In the breakpoint files, transposition can be almost instantaneous (almost same time, different transposition value), or gradual, creating glissandi (different time, different transposition value). No transposition between times is a third possibility (different time, same transposition value). Transposition which also changes the speed, and therefore the pitch, of the soundfile greatly alters the character of the sound. It is often very interesting to hear what a sound will be like 1, 2 or even 3 octaves below its original pitch. Deep, rich tones can be achieved in this way. These tones can slowly rise or descend if created with a time-varying breakpoint file e.g., moving an octave up or down over the time of the whole sound (airplane takeoff sounds, etc.)” },
arg1 = { name = “semitone-transpos”, min = -12, max = 12, tip = " transposition value in positive or negative number of semitones; e.g., 12 raises the sound by an octave, and -12 lowers it by an octave. NB: use 0 (semitones) for no transposition." },
}

dsp[“Modify Speed - Accelerate or decelerate a sound”] = {
cmds = { exe = “modify”, mode = “speed 5” },
arg1 = { name = “accel”, min = 0, max = 100, tip = “multiplication of speed to be reached by goaltime – i.e., a transposition ratio” },
arg2 = { name = “goaltime”, min = 0, max = 30, tip = “time in outfile at which the accelerated speed is to be reached.” },
arg3 = { name = “starttime”, switch = “-s”, min = 0, max = 10, tip = “time in infile / outfile at which the acceleration begins” },
}

dsp[“Modify Speed - Add vibrato to a sound”] = {
cmds = { exe = “modify”, mode = “speed 6”, tip = “The vibrato created in Mode 6 is a frequency modulation. Given the very wide ranges allowed, this function is immensely powerful. A slow vibrate with a large vibdepth will swing the original sound wildly – increase vibrate and it really ‘flaps in the breeze’ (like a flag in the wind). A fast vibrate with a reasonably tight vibdepth, e.g., a minor 3rd, will produce a fluttering effect.” },
arg1 = { name = “vibrate”, min = 0,0, max = 120,0, tip = “the rate of vibrato shaking in cyles-per-second (Range: 0.0 to 120.0)” },
arg2 = { name = “vibdepth”, min = 0,0, max = 96,0, tip = “vibrato depth (pitch shift from centre) in [possibly fractional] semitones (Range: 0.0 to 96.0)” },
}

dsp[“Modify Stack - Create a mix that stacks transposed versions of source on top of one another “] = {
cmds = { exe = “modify”, mode = “stack”, tip = “New sounds can be developed from existing sources by stacking transposed copes of the original on top of each other. This is particularly successful where the source sound has a clearly defined attack at or near the start of the sound and then dies away gradually. If the copies are lined up in such a way that their attacks coincide exactly, the new sound will psycho-acoustically merge into a single sound event with harmonic content (rather than a chord made up of several sounds). The meaning of this is very precise: one is lining up the soundfiles at their perceived beginning, i.e., its attack, not the start of each soundfile. This is achieved by adjusting the start times of the transposed soundfiles. MODIFY STACK is a very important program. It enables you to construct ‘larger’ versions of sounds by superimposing transposed versions on top of one another. Furthermore, it does this in such a way as to maximise the fusion of the layered sound by synchronising the attacks. This relates to a basic technique of orchestral scoring (where it is called ‘doubling’). It is a form of automatic mixing involving one soundfile.Because of the way the program functions, this is, however, quite a different process from transposing and mixing sounds to produce chords. (Doing this in the Spectral Domain, where transposition can be done without affecting duration, still has a place.) Here, if the attack points are made to coincide, the new sound-object is an integral whole, rather than a ‘chord’ made up of the transposed stack components: that is, the components fuse and cannot be separated in perception, as they can with a chord played, for example, on a piano keyboard.Also note that, as a Time Domain process, the higher transpositions end sooner than the lower ones. Use Spectral Domain transpositon along with SUBMIX MIX to assemble transposed versions of the same sound when equal length is important.Very low transpositions could produce an extremely long output. The dur parameter enables you to specify a much shorter outfile length. You can usually get an idea of the harmonic content of the output from the first few seconds.” },
arg1 = { name = “transpos”, min = 0, max = 12, tip = “transpos is the transposition in semitones between successive copies” },
arg2 = { name = “count”, min = 0, max = 100, tip = " the number of copies in the stack” },
arg4 = { name = “lean”, min = 0, max = 10, tip = “the loudness of the highest component, relative to the lowest (may be > 1)” },
arg5 = { name = “attack-offset”, min = 0, max = 50, tip = “adjusts the time at which the attack of each sound occurs” },
arg6 = { name = “gain”, min = 0,1, max = 10, tip = “an overall amplifying gain factor on the output sound; some reduction (less than 1) may be needed. (It may also be > 1.) Range: 0.1 to 10” },
arg7 = { name = “dur”, min = 0, max = 1, tip = “how much of the output to make (a proportion, from 0 to 1)” },
arg7 = { name = “-s”, switch = “-s”, tip = " see the relative levels of the layers in the stack” },
}


dsp["Envel Attack - Emphasize the attack of a sound "] = {
cmds = { exe = “envel”, mode = “attack 1”, tip = “Set attack point where sound level first exceeds gate level.” },
arg1 = { name = “gate”, min = 0, max = 1, tip = "level (threshold) to be reached for the attack point to be recognised (Range: 0 to 1). " },
arg2 = { name = “Gain”, min = 0.001, max = 2,0, set = “floating point multiplier by which to amplify the signal at the attack point (< 1 reduces the signal; > 1 amplifies the signal).” },
arg3 = { name = “onset”, min = 5, max = 32767, tip = “attack onset duration in milliseconds, i.e., the ‘sharpness’ of the attack (Range:5ms to 32767ms). " },
arg4 = { name = “decay”, min = 5, max = 20000, tip = “attack decay duration in milliseconds (Range: 5 to < duration of infile).” },
arg5 = { name = “envtype”, switch = “-t”, min = 0, max = 1, tip = " type of envelope: 0 linear, 1 exponential (Default)” },
}

dsp[“Envel Attack - Emphasize the attack of a sound 2”] = {
cmds = { exe = “envel”, mode = “attack 2”, tip = “Attack point at maximum level at your ‘approx-time’ (+/- 200 ms).” },
arg1 = { name = “time”, min = 0, max = 10, tip = “time (approximate or exact) of the attack point, in seconds” },
arg2 = { name = “Gain”, min = 0.001, max = 2,0, set = “floating point multiplier by which to amplify the signal at the attack point (< 1 reduces the signal; > 1 amplifies the signal). " },
arg3 = { name = “onset”, min = 5, max = 32767, tip = “attack onset duration in milliseconds, i.e., the ‘sharpness’ of the attack (Range:5ms to 32767ms).” },
arg4 = { name = “decay”, min = 5, max = 20000, tip = “attack decay duration in milliseconds (Range: 5 to < duration of infile).” },
arg5 = { name = “envtype”, switch = “-t”, min = 0, max = 1, tip = " type of envelope: 0 linear, 1 exponential (Default)” },
}

dsp[“Envel Attack - Emphasize the attack of a sound 3”] = {
cmds = { exe = “envel”, mode = “attack 3”, tip = “Attack point at your ‘exact-time’.” },
arg1 = { name = “time”, min = 0, max = 10, tip = “time (approximate or exact) of the attack point, in seconds” },
arg2 = { name = “Gain”, min = 0.001, max = 2,0, set = “floating point multiplier by which to amplify the signal at the attack point (< 1 reduces the signal; > 1 amplifies the signal).” },
arg3 = { name = “onset”, min = 5, max = 32767, tip = "attack onset duration in milliseconds, i.e., the ‘sharpness’ of the attack (Range:5ms to 32767ms). " },
arg4 = { name = “decay”, min = 5, max = 20000, tip = “attack decay duration in milliseconds (Range: 5 to < duration of infile).The decay portion of the attack is also set in milliseconds. " },
arg5 = { name = “envtype”, switch = “-t”, min = 0, max = 1, tip = " type of envelope: 0 linear, 1 exponential (Default)” },
}

dsp[“Envel Attack - Emphasize the attack of a sound 4”] = {
cmds = { exe = “envel”, mode = “attack 3”, tip = "Attack point at maximum level in the soundfile " },
arg1 = { name = “Gain”, min = 0.001, max = 2,0, set = "floating point multiplier by which to amplify the signal at the attack point (< 1 reduces the signal; > 1 amplifies the signal). " },
arg2 = { name = “onset”, min = 5, max = 32767, tip = “attack onset duration in milliseconds, i.e., the ‘sharpness’ of the attack (Range:5ms to 32767ms). " },
arg3 = { name = “decay”, min = 5, max = 20000, tip = “attack decay duration in milliseconds (Range: 5 to < duration of infile).” },
arg4 = { name = “envtype”, switch = “-t”, min = 0, max = 1, tip = " type of envelope: 0 linear, 1 exponential (Default)” },
}

dsp["Envel Curtail - Curtail a soundfile by fading to zero at some time within it “] = {
cmds = { exe = “envel”, mode = “curtail 1”, tip = “specify the precise times at which the file is to begin and end.” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “fadeend”, min = 0, max = 50, set = “time at which to complete the fade” },
arg3 = { name = “envtype”, min = 0, max = 1, tip = “type of envelope shape for the fade, 0 linear, 1 exponential” },
arg4 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes” },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 2”] = {
cmds = { exe = “envel”, mode = “curtail 2”, tip = “specify the duration of the fade and when it begins.” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “fade-dur”, min = 0, max = 50, set = “time at which to complete the fade” },
arg3 = { name = “envtype”, min = 0, max = 1, tip = “type of envelope shape for the fade, 0 linear, 1 exponential” },
arg4 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 3”] = {
cmds = { exe = “envel”, mode = “curtail 3”, tip = “specify when the fade begins and fade to the existing end of insndfile” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “envtype”, min = 0, max = 1, tip = “type of envelope shape for the fade, 0 linear, 1 exponential” },
arg3 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 4”] = {
cmds = { exe = “envel”, mode = “curtail 4”, tip = “specify the precise times at which the file is to begin and end, and apply a doubly exponential (steeper) editing slope” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “fadeend”, min = 0, max = 50, set = “time at which to complete the fade” },
arg3 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 5”] = {
cmds = { exe = “envel”, mode = “curtail 5”, tip = “specify the duration of the fade and when it begins, and apply a doubly exponential (steeper) editing slope” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “fade-dur”, min = 0, max = 50, set = “time at which to complete the fade” },
arg3 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 6”] = {
cmds = { exe = “envel”, mode = “curtail 6”, tip = “Specify when the fade begins and fade to the existing end of insndfile, applying a doubly exponential (steeper) editing slope” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Dovetail - Dovetail a soundfile by enveloping its beginning and end”] = {
cmds = { exe = “envel”, mode = “dovetail 1”, tip = “a choice of linear or exponential slopes at the beginning and the end” },
arg1 = { name = “infadedur”, min = 0, max = 50, tip = “duration of the fade-in at the start of the file” },
arg2 = { name = “outfadedur”, min = 0, max = 50, tip = “duration of the fade-out at the end of the file” },
arg3 = { name = “intype”, min = 0, max = 1, tip = “envelope shape for the fade-in at the start of the file; intype = 0: linear fade, intype = 1: exponential fade (the Default)” },
arg4 = { name = “outtype”, min = 0, max = 1, tip = “envelope shape for the fade-out, at the end of the file; outtype = 0: linear fade, outtype = 1: exponential fade (the Default)” },
arg5 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = “identifies the type of time unit being used: times = 0: is seconds (the Default), times = 1: times are in samples, times = 2: times are in grouped-samples” },
}

dsp[“Envel Dovetail - Dovetail a soundfile by enveloping its beginning and end 2”] = {
cmds = { exe = “envel”, mode = “dovetail 2”, tip = “a doubly exponential slope (steeper) is applied to the beginning and the end” },
arg1 = { name = “infadedur”, min = 0, max = 50, tip = “duration of the fade-in at the start of the file” },
arg2 = { name = “outfadedur”, min = 0, max = 50, tip = “duration of the fade-out at the end of the file” },
arg3 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = “identifies the type of time unit being used: times = 0: is seconds (the Default), times = 1: times are in samples, times = 2: times are in grouped-samples” },
}


dsp[“Envel Pluck - Pluck the start of a sound (Mono files only)”] = {
cmds = { exe = “envel”, mode = “pluck”, tip = “Although similar to ENVEL ATTACK, ENVEL PLUCK differs in that the attack imposed on the soundfile also has the noise and decay characteristics associated with plucked sounds. To pluck the sound, ENVEL PLUCK creates a ‘pluck’ constructed from a number of wavecycles and splices it into the beginning of the sound. To achieve this, it needs a goal wavecycle to pluck towards: this is located at startsamp.We can get an idea of what is going on here by reviewing how the Karplus-Strong pluck algorithm used in Csound works. It achieves a pluck effect by iteratively filtering a block of noise until it becomes pitched. It does this because noise components are an essential ingredient of a plucked sound. ENVEL PLUCK achieves the same effect by working backwards – backwards because it is starting with an existing sound. The process is to repeat wavelen backwards a number of times towards the beginning of the soundfile, becoming noisier as it goes.” },
arg1 = { name = “startsamp”, min = 0, max = 5000, tip = “is where the pluck effect links into the sound. It will usually be a little after the beginning of the sound, not at the very beginning, because we want the pluck to link smoothly into stable signal.” },
arg2 = { name = “wavelen”, min = 2, max = 2205, tip = "the number of (absolute) samples in the wavelength of the pluck effect; its value is the number of samples in a waveform starting at startsamp in the infile " },
arg3 = { name = “atkcycles”, switch = “-a”, min = 2, max = 32767, tip = “the number of wavecycles in the pluck attack” },
arg4 = { name = “decayrate”, switch = “-d”, min = 1, max = 64, tip = “rate of decay of the pluck effect” },
}

dsp["Envel Warp - Normalise the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 1”, tip = “NORMALISE; Expand envelope so that the highest envelope point is at the maximum possible amplitude value.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
}

dsp["Envel Warp - Reverse the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 2”, tip = “Reverse the envelope in time.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
}

dsp["Envel Warp - Exaggerate the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 3”, tip = “Exaggerate the envelope contour” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “exaggerate”, min = 0, max = 50, tip = “Range: > 0.0 < 1, low values are boosted = 1, no change, > 1, high values are boosted” },
}

dsp["Envel Warp - Attenuate the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 4”, tip = “Reduce the amplitude of an envelope.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “attenuation”, min = 0, max = 1, tip = “multiplier by which to scale down the envelope. Range: 0 to 1” },
}

dsp["Envel Warp - Lift the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 5”, tip = “Raise the envelope by a fixed amount” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “lift”, min = 0, max = 1, tip = “amount to add to each amplitude value. Range: 0 to 1” },
}

dsp["Envel Warp - Timestretch the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 6”, tip = “Stretch or compress an envelope in time.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “timestretch”, min = 0, max = 20, tip = “multiplier by which to stretch the envelope. Range: > 0.0 < 1.0 compresses the envelope in time, = 1.0 no change, > 1.0 stretches the envelope in time” },
}

dsp["Envel Warp - Flatten the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 7”, tip = “Even out the envelope contour.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “flatten”, min = 1, max = 5000, tip = “number of envelope values over which to average.” },
}

dsp["Envel Warp - Gate the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 8”, tip = “Zero lower portion of envelope.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “gate”, min = 0, max = 1, tip = “levels less than gate are set to 0. Range: 0 to 1.” },
arg3 = { name = “smoothing”, min = 0, max = 32767, tip = “smoothing – excises segments with an amplitude less than smoothing. Range: 0 to 32767.” },
}

dsp["Envel Warp - Invert the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 9”, tip = “Turn envelope upside down: negative values become positive, and positive values become negative.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “gate”, min = 0, max = 1, tip = “levels less than gate are set to 0. Range: 0 to < mirror.” },
arg3 = { name = “mirror”, min = 0, max = 1, tip = “reflection point: all values other than those below gate, both above and below mirror, are inverted to the other side of mirror. Range: > gate to 1.” },
}

dsp["Envel Warp - Limit the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 10”, tip = “Squeeze down amplitude into a specified range.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “limit”, min = 0, max = 1, tip = “upper limit of range; amplitude values which were above limit are scaled down such that ‘maxamp’ becomes limit. Range: > threshold to 1.” },
arg3 = { name = “threshold”, min = 0, max = 1, tip = “lower limit of range; only values above threshold are affected. Range: 0 to limit.” },
}

dsp["Envel Warp - Corrugate the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 11”, tip = “Tighten the peaks into close-set ridges by taking troughs (downward dips) in the envelope to zero.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “trofdel”, min = 0, max = 32767, tip = “number of windows to set to zero per trough. Range: 1 to < peak_separation.” },
arg3 = { name = “peak_separation”, min = 2, max = 32767, tip = “minimum number of windows per peak. Range: 2 to 32767.” },
}

dsp["Envel Warp - Expand the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 12”, tip = “Inflate the envelope” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “gate”, min = 0, max = 1, tip = “levels below gate are set to 0. Range: 0 to threshold.” },
arg3 = { name = “threshold”, min = 0, max = 1, tip = “lower limit of range: amplitude values that were above gate and below threshold are scaled up such that the minimum level becomes threshold. Range: gate to 1” },
arg4 = { name = “smoothing”, min = 0, max = 32767, tip = “Excises low-level segments which are less than smoothing windows in length. Range: 0 to 32767. 0 turns off the smoothing effect.” },
}

dsp["Envel Warp - Trigger the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 13”, tip = “Create a new envelope of sudden on bursts, triggered by the rate of rise of the current envelope.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “gate”, min = 0, max = 1, tip = “the average level must be above gate before triggering can occur. Range: 0 to 1.” },
arg3 = { name = “rise”, min = 0, max = 1, tip = “minimum loudness-step before triggering can occur. Range: 0 to 1.” },
arg4 = { name = “dur”, min = 0, max = 1000, tip = “maximum duration over which the rise can take place before triggering can occur. Range: must be >= the envelope window duration.” },
}

dsp["Envel Warp - Ceiling of the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 14”, tip = “Force envelope up to its maximum level, everywhere.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
}

dsp["Envel Warp - Duck the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 15”, tip = “Create ‘ducking’ envelope: envelope kept below a set level.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “gate”, min = 0, max = 1, tip = “highest level allowed for the envelope. Range: 0 to 1.” },
arg3 = { name = “threshold”, min = 0, max = 1, tip = “Amplitude level the envelope must reach before ‘ducking’ is applied. Range: 0 to 1.” },
}

dsp[“Envel Swell - Cause sound to fade in to and out from a peak moment”] = {
cmds = { exe = “envel”, mode = “swell”, tip = " his is a generic envelope type which can be applied very easily by specifying the time of the peak moment and the shape to be applied.The peak moment (peaktime) can be the location of the maximum amplitude in the soundfile, which can be found with SNDINFO MAXSAMP). It could also be any other place in the file that you define. For example, you can take a completely flat sound (in terms of loudness) and make it swell to a peak (at any point you want) and die away again. The linear peaktype produces a less gradual fade. This function makes it easy to create an audible peak anywhere in a soundfile, and implement a swell to and from it without having to create a breakpoint file." },
arg1 = { name = “peaktime”, min = 0, max = 20, tip = “time in infile at which the peak moment is located.” },
arg2 = { name = “peaktype”, min = 0, max = 1, tip = “type of swell shape: 0 (linear) or 1 (exponential – the Default)” },
}

dsp[“Topantail2 Topantail - Fade both the beginning and end of a sound”] = {
cmds = { exe = “topantail2”, mode = “topantail”, tip = “TOPANTAIL2 provides another approach to extracting part of a soundfile by using gate levels. In this case it trims away signal before and after the extracted portion. The ‘backtracking’ function moves the initial cut point earlier in the sound, thus retaining some of the sound which may be below the startgate’s level.” },
arg1 = { name = “startgate”, min = 0, max = 1, tip = “level at start before which sound is to be removed. (Range: 0 to 1, Default: 0.001)” },
arg2 = { name = “endgate”, min = 0, max = 1, tip = “level at end after which sound is to be removed. (Range: 0 to 1, Default: 0.001)” },
arg3 = { name = “splicelen”, switch = “-s”, min = 0, max = 1000, tip = “splice length in milliseconds” },
arg4 = { name = “backtrack”, switch = “-b”, min = 0, max = 1000, tip = “backtrack in time from the initial gate point(found by the program) to an earlier splice point, in milliseconds” },
}

dsp[“Envel Tremolo - Tremolo a sound linearly between frequencies”] = {
cmds = { exe = “envel”, mode = “tremolo 1”, tip = “Tremolo is a pulsation in the amplitude of a sound. The frequency of the tremolo is the rate of the amplitude pulsation. (‘Vibrato’ is a frequency displacement.) This technique is familiar to us as a feature of various singing styles, and also as a control available on synthesisers. It can be used to enliven or enrich a sound, or to create more marked flutter effects, such as the ‘flutter-tongue’ technique on a wind instrument” },
arg1 = { name = “freq”, min = 0, max = 500, tip = “frequency of the tremolo (a low frequency oscillation: Range: 0 to 500)” },
arg2 = { name = “depth”, min = 0,0, max = 1,0, tip = “frequency displacement of the oscillation (Range: 0 to 1; the Default is 0.250)” },
arg3 = { name = “gain”, min = 0, max = 1, tip = “the overall signal gain, or envelope (Range 0 to 1; the Default is 1)” },
}

dsp[“Envel Tremolo - Tremolo a sound logarithmically”] = {
cmds = { exe = “envel”, mode = “tremolo 2”, tip = “Tremolo is a pulsation in the amplitude of a sound. The frequency of the tremolo is the rate of the amplitude pulsation. (‘Vibrato’ is a frequency displacement.) This technique is familiar to us as a feature of various singing styles, and also as a control available on synthesisers. It can be used to enliven or enrich a sound, or to create more marked flutter effects, such as the ‘flutter-tongue’ technique on a wind instrument” },
arg1 = { name = “freq”, min = 0, max = 500, tip = “frequency of the tremolo (a low frequency oscillation: Range: 0 to 500)” },
arg2 = { name = “depth”, min = 0,0, max = 1,0, tip = “frequency displacement of the oscillation (Range: 0 to 1; the Default is 0.250)” },
arg3 = { name = “gain”, min = 0, max = 1, tip = “the overall signal gain, or envelope (Range 0 to 1; the Default is 1)” },
}

dsp[“Tremolo Tremolo - Apply width-controlled tremolo to a soundfile linearly”] = {
cmds = { exe = “tremolo”, mode = “tremolo 1”, tip = "This applies tremolo to a soundfile with the added ability to narrow (‘squeeze’) the width of the tremolo segments " },
arg1 = { name = “freq”, min = 0, max = 500, tip = “frequency of the tremolo (a low frequency oscillation: Range: 0 to 500)” },
arg2 = { name = “depth”, min = 0,0, max = 1,0, tip = “frequency displacement of the oscillation (Range: 0 to 1; the Default is 0.250)” },
arg3 = { name = “gain”, min = 0, max = 1, tip = “the overall signal gain, or envelope (Range 0 to 1; the Default is 1)” },
arg4 = { name = “fineness”, min = 1, max = 10, tip = “squeeze the width of the tremolo: an integer value >= 1” },
}

dsp[“Tremolo Tremolo - Apply width-controlled tremolo to a soundfile logaritmically”] = {
cmds = { exe = “tremolo”, mode = “tremolo 2”, tip = "This applies tremolo to a soundfile with the added ability to narrow (‘squeeze’) the width of the tremolo segments " },
arg1 = { name = “freq”, min = 0, max = 500, tip = “frequency of the tremolo (a low frequency oscillation: Range: 0 to 500)” },
arg2 = { name = “depth”, min = 0,0, max = 1,0, tip = “frequency displacement of the oscillation (Range: 0 to 1; the Default is 0.250)” },
arg3 = { name = “gain”, min = 0, max = 1, tip = “the overall signal gain, or envelope (Range 0 to 1; the Default is 1)” },
arg4 = { name = “fineness”, min = 1, max = 10, tip = “squeeze the width of the tremolo: an integer value >= 1” },
}

Gotcha! That empty sample was causing the bug… Should be fixed now, see attached.
Also updated definitions to include your last set up to ‘tremolo tremolo’

I’ve also changed the way definitions are loaded in this so restart Renoise before running this for the first time.

Cheers!

yep, that did it :)

Am trying to do the multi-channel reverb at the moment, but can’t stop it from crashing the CDP process. I think because I need to specify a mode in your script definition, while this particular process doesn’t have a mode!

Is there a way you can have a cmds line in your script without the mode portion?

Btw this is the reverb definition that doesn’t work here;

dsp["Reverb - Multi-Channel reverb "] = {   
 cmds = { exe = "reverb", mode = "", tip = " REVERB implements the now classic Schroeder/Moorer model, consisting of six comb filters in parallel, followed by four allpass filters in series. The comb filters generate the dense reverberation, and the allpass filters (with much shorter delay times) apply further smearing of the echoes to minimize the spectral colouration of the comb filters. A further allpass is applied to each output channel, each with a different randomly-chosen delay time. Each comb filter contains a simple low-pass filter to simulate high-frequency absorption - this also affects the overall reverberation time. A preset set of early reflections as defined by Moorer is incorporated; this can be replaced by a user-defined set either hand-written or created using ROOMRESP. The delay times for the filters are preset to suit a 'medium room' model, as suggested by Moorer. In most situations the user will not want to change these; however the option is provided to change these times by means of a simple text file." },  
 arg1 = { name = "N", switch = "-c", min = 0, max = 16, def = 2, tip = "create outfile with N channels (Range: 1 <= N < 16; Default = 2)" },  
 arg2 = { name = "N", switch = "-H", min = 0, max = 44100, tip = "Apply Highcut filter to infile with cutoff frequency NHz(6dB per octave)" },  
 arg3 = { name = "N", switch = "-L", min = 0, max = 44100, tip = "apply Lowcut filter to infile with cutoff frequency NHz (12dB per octave)" },  
 arg4 = { name = "N", switch = "-p", min = 0, max = 1000, tip = "set reverb predelay to N msecs (shifts early reflections)" },  
 arg5 = { name = "egain", min = 0,0, max = 1,0, tip = "set level of early reflections (Range: 0.0 to 1.0)" },  
 arg6 = { name = "mix", mix = 0,0, max = 1,0, tip = "balance of direct and reverb signal (Range: 1.0 [weighted towards direct signal] to 0.0 [weighted towards reverb signal])" },  
 arg7 = { name = "rvbtime", min = 0, max = 20, tip = "reverb decay time (to -60dB) in seconds" },  
 arg8 = { name = "absorb", min = 0,0, max = 1,0, tip = "degree of hf damping to suggest roomsize (Range: 0.0 to 1.0)" },  
 arg9 = { name = "lpfreq", min = 0, max = 44100, tip = "lowpass filter cutoff frequency in Hz applied at input to reverb" },  
 arg10 = { name = "trailertime", min = 0, max = 20, tip = "time in seconds added to outfile for reverb tail" },   
  
}  
  

If I leave out mode from the cmds line, I get a bug notice, but maybe there is another reason why reverb.exe crashes?

edit;

btw I’m not sure if its worth updating the definition file using cycle() for bunch of stuff, I think it is only calculated on tool launch (not updated when you load another sample or switch definition presets) and can take quite some time calculating when booting the script on larger samples. Just did a bunch of edits replacing fixed cyclecnt max values with cycle() and had to click away ‘the script is taking to long…blah blah’ notice during boot :) , reverted the definition file back to before.

Feature request;

Would it be possible to only have the tool work on the selection in the sample editor instead of always the complete sample?

Thanks :yeah:

You need to leave mode in there for now, but I can make it optional, will look at this later

Yeah it rescans every time you launch the GUI, it shouldn’t need to rescan if you change preset as the cycle count remains the same. If you change the sample then yes you will need to relaunch the tool (for now). I can probably optimise it to work faster. There is also a ‘cyclecnt’ function that comes with CDP which will most likely be a lot faster but it only outputs to the terminal and I haven’t yet found a way to parse the output back to a Renoise tool… will need to figure this out eventually when I get onto the PVOC and other analysis stuff.

Yes, I am working on a way for mono commands to operate on stereo samples, when I’ve done this the same code will also let you do sample selections.

Nice :drummer:

Definitions update;

[details=“Click to view contents”] ```
–[[
Instructions for definitions

You do not need to specify the infile or outfile these are handled by the tool.

Name the preset within the square brackets and in quotation marks after dsp[] e.g. dsp[“Preset name”]
The name can be anything but try and keep it the same or similar to the CDP reference documentation.

cmds

exe - The name of the CDP executable (exclude the .exe extension)
mode - The first part of the command argument that comes after the exe and before infile, outfile

arg1 to arg…n

name - The name displayed in the GUI (STRING)
switch - The switch flag, use only if it is a command switch e.g “-s” (STRING)
min - The minimum value of the range (NUMBER)
max - The maximum value of the range (NUMBER)
def - The default value the preset loads with (OPTIONAL NUMBER)
tip - The tool tip for the GUI control (OPTIONAL STRING)

Additional functions are available that give info about the sample

srate() - Gives the sample rate
cycles() - Gives the number of wavecycles (same as number of zero crossings/2)

–]]

dsp = {} – Do not edit this


– PRESET DEFINITIONS - afta8 –

dsp[“Filter Bank 1 - Harmonic”] = {
cmds = { exe = “filter”, mode = “bank 1”, tip = “The harmonic series is formed by multiplying a given frequency by an ascending series of integers: 1, 2, 3, 4, etc. The harmonic relationships produced are sonorous, but depart from the structure of triadic chords higher in the series. This Mode builds this type of harmonic relationship onto lofrq, which may be the actual pitch of a pitched tone or any arbitrary pitch. Because this is being done with a filter process, other sonic material is cleaned away, so a cleaner (and possibly quieter) sound may result, with more complex noise elements removed. Quite a bit of gain may be required – values of 40 or 50+ in this situation will not be unusual. Set hifrq as high as possible less too few harmonics are produced. This clean sound may provide a good input for spectral time-stretching, for example, to achieve a well-tuned sound with a minimum of artefacts.” },
arg1 = { name = “Q”, min = 0.001, max = 10000, tip = “Sets the Q of the effect” },
arg2 = { name = “Gain”, min = 0.001, max = 10000, def = 25 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Scatter”, switch = “-s”, min = 0, max = 1, tip = “Random scatter of frequencies” },
arg6 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 2 - Alt Harmonic”] = {
cmds = { exe = “filter”, mode = “bank 2”, tip = “This will be like Mode 1 but with every other harmonic omitted: the odd numbered partials are retained. The resulting sound will probably sound more ‘hollow’.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg6 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 3 - Sub Harmonic”] = {
cmds = { exe = “filter”, mode = “bank 3”, tip = “The ‘subharmonic series’ is the intervallic inverse of the harmonic series. Thus the departure from triadic-type intervals increases as the series descends. The resulting sound has a deeper tone and is somewhat hollow and somewhat inharmonic.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg6 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 4 - Harmonic Linear”] = {
cmds = { exe = “filter”, mode = “bank 4”, tip = “The offset in Hz is added to each harmonic. This will displace them so that they will no longer be exact multiples of the fundamental. This means that the cycles of the waveforms no longer line up at nodes, which introduces an ‘inharmonic’ dimension into the sound, heard as an increase in timbral components.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Offset (Hz)”, min = 10, max = srate()/3 },
arg6 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg7 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 5 - Filter Intervals”] = {
cmds = { exe = “filter”, mode = “bank 5”, tip = “Here we depart from the harmonic series and simply divide up the specified frequency range into an equal number filters: how many is specified by the user with param. The first effect this equal spacing will have is to create inharmonic (rather than integer multiple) relationships between the partials. A low number of filters will produce an ‘open’ sound, and a high number of filters will produce a denser, richer sound. These might be very interesting sounds to timestretch.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “No. Filters”, min = 1, max = 100 },
arg6 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg7 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 6 - Semitone Intervals”] = {
cmds = { exe = “filter”, mode = “bank 6”, tip = “By specifying the interval (in semitones), we in effect repeat these intervals within the frequency space between lofrq and hifrq, thus producing complex chords composed of the same interval ‘piled up’. This is a quick way to ‘harmonise’ a sound, with the resulting density dependent on the size of the interval. It is well worth re-running this function, entering intervals from 1 to 7, for example, to hear what kind of transformations will be produced. Some unexpected resonances may result; they could be filtered out later.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Semitones”, min = 1, max = 12 },
arg6 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg7 = { name = “Double”, switch = “-d” }
}


dsp[“Filter Phasing 1 - Allpass Filter”] = {
cmds = { exe = “filter”, mode = “phasing 1” },
arg1 = { name = “Gain”, min = -1, max = 1 },
arg2 = { name = “Delay”, min = 0.045, max = 1644.35 },
arg3 = { name = “PreScale”, switch = “-s”, min = 0, max = 1 },
arg4 = { name = “Linear”, switch = “-l” }
}

dsp[“Filter Phasing 2 - Phasing Effect”] = {
cmds = { exe = “filter”, mode = “phasing 1”, tip = “The ‘phasing effect’ is a kind of sweeping band passing through the sound, such as is sometimes heard when aeroplanes fly overhead, and is much used in popular music.Increasing the gain factor has some effect on the reverberant quality of the sound. So does increasing the delay time. The sound will still sound quite dry with delay < 20 (ms). Between about 20 and 45 ms there is a touch of resonance in the sound. Around 50 ms there is significant echoey reverberation (though somewhat granulated), and after 100 ms we start to hear larger portions of the sound repeating.Overall, the degree of reverberant effect is controlled by increasing both the gain and delay parameters in tandem” },
arg1 = { name = “Gain”, min = -1, max = 1 },
arg2 = { name = “Delay”, min = 0.045, max = 1644.35 },
arg3 = { name = “PreScale”, switch = “-s”, min = 0, max = 1 },
arg4 = { name = “Linear”, switch = “-l” }
}

dsp[“Filter Phasing 2 - Phasing Effect”] = {
cmds = { exe = “filter”, mode = “phasing 1”, tip = “The ‘phasing effect’ is a kind of sweeping band passing through the sound, such as is sometimes heard when aeroplanes fly overhead, and is much used in popular music.Increasing the gain factor has some effect on the reverberant quality of the sound. So does increasing the delay time. The sound will still sound quite dry with delay < 20 (ms). Between about 20 and 45 ms there is a touch of resonance in the sound. Around 50 ms there is significant echoey reverberation (though somewhat granulated), and after 100 ms we start to hear larger portions of the sound repeating.Overall, the degree of reverberant effect is controlled by increasing both the gain and delay parameters in tandem” },
arg1 = { name = “Gain”, min = -1, max = 1 },
arg2 = { name = “Delay”, min = 0.045, max = 1644.35 },
arg3 = { name = “PreScale”, switch = “-s”, min = 0, max = 1 },
arg4 = { name = “Linear”, switch = “-l” }
}


dsp[“Filter Sweeping 1 - High Pass”] = {
cmds = { exe = “filter”, mode = “sweeping 1”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.”
},
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}

dsp[“Filter Sweeping 2 - Low Pass”] = {
cmds = { exe = “filter”, mode = “sweeping 2”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.” },
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}

dsp[“Filter Sweeping 3 - Band Pass”] = {
cmds = { exe = “filter”, mode = “sweeping 3”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.” },
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}

dsp[“Filter Sweeping 4 - Notch”] = {
cmds = { exe = “filter”, mode = “sweeping 4”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.” },
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}


– Djeroek –

dsp[“Distort Average - average the waveshape over N wavecycles”] = {
cmds = { exe = “distort”, mode = “average”, tip = “DISTORT AVERAGE performs a mathematical averaging of the data in cyclecnt pseudo-wavecycles. The effect is more akin to a loss of resolution than the blurring which might be expected. Values below 10 retain some semblance of the original, while values of, for example, 100 seem to create a kind of ‘sample hold’ effect. For modest distortion, values 5 or less are recommended.” },
arg1 = { name = “cyclecnt”, min = 1, max = 6000, tip = “number of cycles over which to average (Range: > 1)” },
arg2 = { name = “maxwavelen”, switch = “-m”, min = 0, max = 1, tip = “maximum permissible wavelength in seconds (Default: 0.50)” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 1000, tip = “(integer) number of wavecycles to skip at start of file” },
}

dsp[“Distort Divide - Distortion by dividing wavecycle frequency”] = {
cmds = { exe = “distort”, mode = “divide”, tip = “Without altering duration, this process effectively lowers the sound while adding a rough texture.This is a useful form of distortion because it roughens the sound without being too violent about it” },
arg1 = { name = “N”, min = 2, max = 16, tip = “divider (Range: integer only, 2 to 16)” },
arg2 = { name = “-i”, switch = “-i”, tip = “use waveform interpolation: slower but cleaner” },
}

dsp[“Distort Fractal - Superimpose miniature copies of source wavecycles onto themselves”] = {
cmds = { exe = “distort”, mode = “fractal”, tip = “Note the very wide range of scaling. Because it is a divisor, the larger the value of scale the shorter will be the miniature copies to be superimposed. These superimposed copies can be made to increase (be careful!) or decrease in amplitude with the loudness parameter. Using a value of 1.0 maintains the original amplitude of the infile, which will be heard as pretty much as the original, but with the superimpositions on top of it. Loudness is therefore a means of balancing the input and the processed sound components.This is a powerful and somewhat wild tool for producing distortion effects. The higher the value of scaling, the more the superimposed copies appear as a sheen of distortion above the original sound.” },
arg1 = { name = “scaling”, min = 2, max = srate()/2, tip = “(integer) division of scale of source wave (Range: 2 to sample_rate/2)” },
arg2 = { name = “loudness”, min = 0, max = 10, tip = “loudness of scaled component relative to source (Loudness of source is reckoned to be 1.0)” },
arg3 = { name = “pre_attenuation”, switch = “-p”, tip = “apply attenuation to infile before processing” },
}

dsp["Distort Interpolate - Time-stretch file by repeating wavecycles and interpolating between them "] = {
cmds = { exe = “distort”, mode = “interpolate”, tip = “With this process, the shape of a ‘wavecycle’ is transformed into that of the next over multiplier repetitions. Note that this is waveshape-based interpolation, not a spectral interpolation, and that the length of the ‘wavecycle’ is also transformed by the process. The effect of the transformation is drastic, leading to a strongly granular outfile. The length of the outfile increases in step with the value of multiplier, as does the apparent pitchiness.The interpolation process adds a modulatory quality to the output, so that the successive wavecycles gliss and bend as they flow into one another. Even so, as multiplier increases, the perception of separate ‘grains’, i.e., ‘wavecycles’ increases. A value of 32, for example, changes the sound to a strange stream of modulating tones.” },
arg1 = { name = “multiplier”, min = 0, max = 50, tip = “(integer) number of times each ‘wavecycle’ repeats” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 20, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Multiply - Distortion by multiplying wavecycle frequency”] = {
cmds = { exe = “distort”, mode = “multiply”, tip = “The duration of the sound is not changed, only the frequency of the ‘wavecycles’, with the result that the pitch rises.The distortion is relatively mild, in that the original sound remains recognisable. However, the surface is textured and the pitch rises with each increase in the value of N. DISTORT MULTIPLY can be used, for example, to create high, modulating, grainy vocal sounds.” },
arg1 = { name = “N”, min = 2, max = 16, tip = “multiplier (Range: 2 to 16, integer only)” },
arg2 = { name = “-s”, switch = “-s”, tip = “smoothing (try this if glitches appear)” },
}

dsp[“Distort Omit – Omit A out of every B wavecycles, replacing them with silence”] = {
cmds = { exe = “distort”, mode = “omit”, tip = “Because the omitted ‘wavecyles’ are replaced by silence, the overall duration of the sound does not change. The larger the proportion of ‘wavecycles’ omitted from B, of course, the more distorted the the sound becomes. This distortion is like a rough texturing, rather than the highly modulatory results of some of the other processes.This process can be used, therefore, to achieve a rough texturing with no loss of duration.” },
arg1 = { name = “A”, min = 0, max = 5000, tip = “number of wavecycles to omit” },
arg2 = { name = “B”, min = 0, max = 5000, tip = “size of group of ‘wavecycles’ out of which to omit A wavecycles” },
}

dsp[“Distort Overload – Clip the signal with noise or a (possibly timevarying) waveform”] = {
cmds = { exe = “distort”, mode = “overload 1”, tip = “The clip-level parameter is rather like a ‘gate’ level. If the signal level is already high, anything over, for example, 0.1 is likely to push it into distortion, and values considerably higher than this will make it heavily distorted. However, if it only distorts, Trevor advises me, when it reaches a level of, for example, 0.99, it is not going to be distorted very often. The sound doesn’t actually have amplitude overload, because it is distorted by ‘slicing off’ the top (clipping) where it would have overloaded. The sound becomes loud and ‘strained’, like a voice which is shouting too loudly.Given the trials made so far, this can be a fairly subtle effect, but the words ‘straining’, ‘loud’, ‘uncompromising’ seem appropriate as the amplitude gets pushed towards the top of the range.” },
arg1 = { name = “clip-level”, min = 0, max = 1, tip = “level at which the signal is to be clipped (Range: 0 to 1) The signal level is renormalised after clipping.” },
arg2 = { name = “depth”, min = 0, max = 1, tip = “depth of the pattern of distortion imposed on clipped stretches of the signal. (Range: 0 to 1)” },
}

dsp[“Distort Overload – Clip the signal with noise or a (possibly timevarying) waveform”] = {
cmds = { exe = “distort”, mode = “overload 2”, tip = “The clip-level parameter is rather like a ‘gate’ level. If the signal level is already high, anything over, for example, 0.1 is likely to push it into distortion, and values considerably higher than this will make it heavily distorted. However, if it only distorts, Trevor advises me, when it reaches a level of, for example, 0.99, it is not going to be distorted very often. The sound doesn’t actually have amplitude overload, because it is distorted by ‘slicing off’ the top (clipping) where it would have overloaded. The sound becomes loud and ‘strained’, like a voice which is shouting too loudly. Mode 2 can add an extra ringing sound as the value for freq gets higher, e.g., 2000Hz and beyond. Given the trials made so far, this can be a fairly subtle effect, but the words ‘straining’, ‘loud’, ‘uncompromising’ seem appropriate as the amplitude gets pushed towards the top of the range.” },
arg1 = { name = “clip-level”, min = 0, max = 1, tip = “level at which the signal is to be clipped (Range: 0 to 1) The signal level is renormalised after clipping.” },
arg2 = { name = “depth”, min = 0, max = 1, tip = “depth of the pattern of distortion imposed on clipped stretches of the signal. (Range: 0 to 1)” },
arg3 = { name = “freq”, min = 0, max = 22500, tip = “frequency of the waveform imposed on clipped stretches of the signal” },
}

dsp[“Distort Pitch - Pitchwarp wavecycles of sound”] = {
cmds = { exe = “distort”, mode = “pitch”, tip = “The random up/down movement of the ‘wavecycles’ within the total octvary range produces a great deal of bending of the sound, especially if the original alters its pitch a good deal. It is better, therefore, to start with relatively small values for octvary – e.g., less than 1 – so that you start to use this function with some degree of control over the results.The full power of DISTORT PITCH doesn’t really come into its own until time-varying parameters are used, especially for cyclecnt. Large values for the latter will serve to slow down the rate of change. DISTORT PITCH is useful for creating ‘flexitones’ (to coin a term) – with distortion, of course.” },
arg1 = { name = “octvary”, min = 0,0, max = 8,0, tip = “maximum possible transposition up or down in (fractions of) octaves (Range > 0.0 to 8.0)” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “mamimum number of ‘wavecycles’ between the generation of transposition values (Range: > 1, Default: 64)” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Pulsed - Impose impulse-train on a sound”] = {
cmds = { exe = “distort”, mode = “pulsed 1”, tip = “Distort a sound by imposing a series of impulses on the source, or on a specific waveset segment of the source. An impulse is like a brief event created by a sharp envelope on the sound. The sound inside the impulse might glissando slightly, as if whatever is causing the impulsion has warped the sound by its impact.” },
arg1 = { name = “stime”, min = 0.001, max = 10, tip = “time in the source sound where the impulses begin” },
arg2 = { name = “dur”, min = 0.001, max = 10, tip = “length of time that the impulses continue” },
arg3 = { name = “frq”, min = 0, max = 1000, tip = “number of impulses per second” },
arg4 = { name = “frand”, min = 0, max = 12, tip = “number of semitones by which to randomise the frequency of the impulses” },
arg5 = { name = “trand”, min = 0, max = 10, tip = “amount of time in seconds by which to randomise the relative time positions of amplitude peaks and troughs from impulse to impulse” },
arg6 = { name = “arand”, min = 0, max = 1, tip = “randomisation of the amplitude shape created by the peaks and troughs from impulse to impulse” },
arg7 = { name = “transp”, min = 0, max = 1, tip = “transposition contour of sound inside each impulse” },
arg8 = { name = “tranrand”, min = 0, max = 1, tip = “randomisation of transposition contour from impulse to impulse” },
arg9 = { name = “-s”, switch = “-s”, tip = “keep start of source sound, before impulses begin (if any)” },
arg10 = { name = “-e”, switch = “-e”, tip = “keep end of source sound, after impulses end (if any)” },
}

dsp["Distort Pulsed - Imposed regular pulsations on a sound "] = {
cmds = { exe = “distort”, mode = “pulsed 2”, tip = “Distort a sound by imposing a series of impulses on the source, or on a specific waveset segment of the source. An impulse is like a brief event created by a sharp envelope on the sound. The sound inside the impulse might glissando slightly, as if whatever is causing the impulsion has warped the sound by its impact.” },
arg1 = { name = “stime”, min = 0.001, max = 10, tip = “time in the source sound where the impulses begin” },
arg2 = { name = “dur”, min = 0.001, max = 10, tip = “length of time that the impulses continue” },
arg3 = { name = “frq”, min = 0, max = 1000, tip = “number of impulses per second” },
arg4 = { name = “frand”, min = 0, max = 12, tip = “number of semitones by which to randomise the frequency of the impulses” },
arg5 = { name = “trand”, min = 0, max = 10, tip = “amount of time in seconds by which to randomise the relative time positions of amplitude peaks and troughs from impulse to impulse” },
arg6 = { name = “arand”, min = 0, max = 1, tip = “randomisation of the amplitude shape created by the peaks and troughs from impulse to impulse” },
arg7 = { name = “cycletime”, min = 0, max = 10, tip = “duration in seconds of wavecycles to grab as sound substance inside the impulses” },
arg8 = { name = “transp”, min = 0, max = 1, tip = “transposition contour of sound inside each impulse” },
arg9 = { name = “tranrand”, min = 0, max = 1, tip = “randomisation of transposition contour from impulse to impulse” },
arg10 = { name = “-s”, switch = “-s”, tip = “keep start of source sound, before impulses begin (if any)” },
arg11 = { name = “-e”, switch = “-e”, tip = “keep end of source sound, after impulses end (if any)” },
}

dsp[“Distort Reform - Convert to fixed level square wave”] = {
cmds = { exe = “distort”, mode = “reform 1”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to square wave”] = {
cmds = { exe = “distort”, mode = “reform 2”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to fixed level triangular wave”] = {
cmds = { exe = “distort”, mode = “reform 3”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to triangular wave”] = {
cmds = { exe = “distort”, mode = “reform 4”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to inverted half-cycles”] = {
cmds = { exe = “distort”, mode = “reform 5”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to click streams”] = {
cmds = { exe = “distort”, mode = “reform 6”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to sinusoid”] = {
cmds = { exe = “distort”, mode = “reform 7”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Exaggerate waveform contour”] = {
cmds = { exe = “distort”, mode = “reform 8”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
arg1 = { name = “exaggeration”, min = 0,000002, max = 40, tip = “exaggeration factor (Range: 0.000002 to 40.0)” },
}

dsp[“Distort Repeat - Timestretch soundfile by repeating wavecycles”] = {
cmds = { exe = “distort”, mode = “repeat”, tip = “The repetition of the ‘wavecycles’ stretches out the sound, making it both longer and more granular in texture. This granularity is increased if (increasingly larger) groups of cyclecnt ‘wavecycles’ are used: then the whole group repeats multiplier times. DISTORT REPEAT produces long, grainy (distorted) sounds. The sense of stretching out the original is very apparent.A significant application of DISTORT REPEAT is that, by increasing the cyclecnt factor, one crosses the pitch-perception boundary: that is, starting with a noisy sound in which all the wavecycles are randomly different, one ends up with, for example, 7 repetitions of the same wavecycle, followed by 7 of another and so on – and each of these comprise sufficient repetitions for us to hear pitch. Thus the noise source becomes a string of pitch beads, each of arbitrary timbre. With a cyclecnt of, for example, 128, one can even get a slowish random melody.” },
arg1 = { name = “multiplier”, min = 0,0, max = 50, tip = “number of times (integer) each ‘wavecycle’ (group) repeats” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “number of ‘wavecycles’ (integer) in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = "number of ‘wavecyles’ (integer) to skip at start of file " },
}

dsp[“Distort Repeat 2 - Repeat wavecycles without time-stretching”] = {
cmds = { exe = “distort”, mode = “repeat2”, tip = “Repeating the ‘wavecycles’ without time-stretching (as in DISTORT REPEAT) enables you to increase the strength of the distortion with the multiplier parameter without making the output file any longer than the original. Larger values for cyclecnt increases the length of infile that is affected. Higher values for multiplier increase the distortion, while higher values for cyclecnt increase the length of infile that is processed as one unit. Thus we could have: a low value for multiplier coupled with a high value for cyclecnt – this will produce a bit of distortion while the source remains recognisable, a high value for multiplier coupled with a low value for cyclecnt – this will produces a great deal of distortion, but the effect is limited because only a few cycles are affected as a unit. High values for both parameters – this appears to create the most distortion” },
arg1 = { name = “multiplier”, min = 0,0, max = 50, tip = “number of times (integer) each ‘wavecycle’ (group) repeats” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “number of ‘wavecycles’ (integer) in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = "number of ‘wavecyles’ (integer) to skip at start of file " },
}

dsp[“Distort Replace – The strongest wavecycle in a cyclecnt group replaces the others”] = {
cmds = { exe = “distort”, mode = “replace”, tip = “The replacing action serves to simplify the sound. Note that the single strong ‘wavecycle’ in the group will take the place of several others, which will be deleted. This simplification becomes extreme when the cyclecnt is high, leading to a ‘sample-hold’ kind of stepped effect. Time-varying cyclecnt makes it possible to introduce gradual change. With DISTORT REPLACE we can achieve a simplification of the sound, up to very clear ‘sample-hold’ type stepped tones” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 5000, tip = “(integer) size of group of ‘wavecycles’” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “number of ‘wavecyles’ (integer) to skip at start of file” },
}

dsp["Distort Replim – Timestretch by repeating wavecycles (below a specified frequency) “] = {
cmds = { exe = “distort”, mode = “replim”, tip = “This function is like DISTORT REPEAT, but with a slight change. Here the length of wavecycle to be affected can be set. Thus, if you set a mid-range frequency, only those below that frequency will repeat, and the others (above the frequency) will be discarded (filtered out). Hence the name ‘REP-LIM’, meaning ‘repeat (with a) limit’. DISTORT REPLIM is therefore like a filtering program that also repeats wavecycles. In the DISTORT set, the wavecycles are wavelengths that occur between zero crossings, so distortion also occurs. It is helpful to remember that wavelength is inversely proportional to frequency. Wavelength is the actual physical length of the oscillation, and frequency is the number of cycles that occur in one second (i.e., Hertz). These two aspects of sound are inversely proportional to one another: P = 1/f. For example, a sound oscillating at 100 Hz will have a period, i.e., a wavelength of 1/100 meters = 0.01 meters (0.39 inch). A sound oscillating at 1000Hz will have a wavelength of 1/1000 meters = 0.001 meters (0.039 inch). Short wavecycles are therefore higher in pitch and long ones are lower in pitch. When the frequency setting for DISTORT REPLIM is high, the filter point is set higher and more of the sound will be retained. Here we are dealing with ‘pseudo-wavecycles’ (portions of soundfile between zero crossings), which is what introduces distortion into the equation.The net result of the function is to create repetition distortion while filtering out a user-definable amount of the higher frequencies. Remember that the relative amounts of high and low frequencies in the infile will affect the results.” },
arg1 = { name = “multiplier”, min = 0.001, max = 100, tip = “the number of times each wavecycle (group) repeats (Integer)” },
arg2 = { name = “cyclecnt”, switch = “-c”, min = 0, max = 5000, tip = “the number of wavecycles in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = " the number of wavecycles to skip at the beginning of the soundfile” },
arg4 = { name = “hilim”, switch = “-f”, min = 0, max = 22500, tip = “the frequency below which cycles are counted” },
}

dsp[“Distort Reverse - Cycle-reversal distortion in which the wavecycles are reversed in groups”] = {
cmds = { exe = “distort”, mode = “reverse”, tip = “Here the original soundfile is grouped into a series of ‘wavecycles’ with cyclecnt ‘wavecycles’ in each group. Then each of these groups of ‘wavecycles’ is reversed. The term ‘distortion’ here is something of a misnomer, because no distortion process is applied to the ‘wvecycles’ themselves. Instead, cyclecnt sets the number of ‘wavecycles’ which are to be copied in reverse as a group to the outfile. For example, if cyclecnt = 3, 15 ‘wavecycles’ reversed in groups of 3 will assume the order: 3-2-1, 6-5-4, 9-8-7, 12-11-10, 15-14-13. Thus, not only is the sound material backwards, but the reversed 1st ‘wavecycle’ is now adjacent to the reversed 6th ‘wavecycle’. This mimics the classical tape studio technique of cutting up a length of tape into segments (of varying lengths), reversing the segments, and joining up the reversed pieces. The result will be similar to a random brassage because of the differing lengths of the ‘wavecycles’. The process moves steadily through the infile from beginning to end, so the normal order of the (reversed) events is preserved. It is surprising how normal the output can be. With mid-range values for cyclecnt (say, 30 to 100), one hears the original breaking up, but only with very large values for cyclecnt does one hear the sound sweeping backwards in large swathes. Again, it is a question of ‘resolution’: the size of the units being manipulated. A small value for cyclecnt will produce a grainy result, mid-values a ‘broken up’ result, and large values swathes of reversed sound. If the value for cyclecnt exceeds the number of ‘wavecycles’ in the infile, you will be told that the ‘sound source is too short…’. DISTORT CYCLECNT returns the number of ‘wavecycles’ in a sound, should you want to provide a value for cyclecnt which is right up to the limit. Reversing the output of DISTORT REVERSE turns the cyclecnt groups back the other way while reading the whole soundfile from back to front, producing an interesting mixture of forwards and backwards! Using the time-varying option for cyclecnt provides an opportunity for dramatic or gradual changes in the output.” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 10000, tip = “number of ‘wavecycles’ in a reversed group (Range: > 0)” },
}

dsp[“Distort Telescope - Time-contract sound by telescoping N wavecycles into 1”] = {
cmds = { exe = “distort”, mode = “telescope”, tip = “Although at first rather like DISTORT OMIT, here the ‘wavecycles’ are not deleted as such. Instead, they are superimposed (i.e., mixed) onto each other, with shorter ‘wavecycles’ being stretched to fit the longest one in each group of cyclecnt ‘wavecycles’. The outfile will usually be much shorter than the infile and can be reduced to a mere blip with this process. The -a flag tells the program to telescope to the average ‘wavecycle’ length, rather than to the longest. Since the longest ‘wavecycle’ in each group is compressed by this method, the outfile will be even shorter. Interesting results can be achieved with small values for cyclecnt, the output tending to have a ‘mushy’ quality. It responds well to pitched material, producing a singing, if mushy, tone.” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 1000, tip = “the number of ‘wavecycles’ in a group” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “number of ‘wavecyles’ (integer) to skip at start of file” },
arg3 = { name = “-a”, switch = “-a”, tip = “telescope to an average ‘wavecycle’ length (Default: telescope to the longest ‘wavecycle’ length)” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles below freq”] = {
cmds = { exe = “distort”, mode = “filter 1”, tip = “Period and frequency are inverse functions. Therefore it is possible to relate the length of a ‘wavecycle’ to the frequency it would have were it to recur regularly. This program therefore filters by removing ‘wavecycles’ shorter or longer than those relating to a specific, user-defined, frequency. The duration of the outfile is affected by this process: because ‘wavecycles’ are being removed, the outfile will be shorter, by varying degrees. The aural effect of the DISTORT FILTER process is actually like gating. In gating, you can imagine a horizontal line drawn through the time/amplitude display of a soundfile. If the peaks above the line are retained (by filtering out lower frequencies), you just hear them (joined up). Similarly, if you filter out above the line, the peaks are gone, leaving the lower sound material (joined up). The difference here is that the process is operating on ‘pseudo-wavecycles’ according to their length, so here the results are more unpredictable and also distort the sound to some degree, depending on where the horizontal line – the frequency variable(s) – is drawn. Technically, the process is akin to low-, high- and band-pass filters, but aurally it is more like gating. You can therefore use this procedure to cut out some and distort other material in a sound.” },
arg1 = { name = “freq”, min = 10,0, max = 22050.0, tip = “frequency in Hz (Range: 10.0 to 22050.0)” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles above freq”] = {
cmds = { exe = “distort”, mode = “filter 2”, tip = “Period and frequency are inverse functions. Therefore it is possible to relate the length of a ‘wavecycle’ to the frequency it would have were it to recur regularly. This program therefore filters by removing ‘wavecycles’ shorter or longer than those relating to a specific, user-defined, frequency. The duration of the outfile is affected by this process: because ‘wavecycles’ are being removed, the outfile will be shorter, by varying degrees. The aural effect of the DISTORT FILTER process is actually like gating. In gating, you can imagine a horizontal line drawn through the time/amplitude display of a soundfile. If the peaks above the line are retained (by filtering out lower frequencies), you just hear them (joined up). Similarly, if you filter out above the line, the peaks are gone, leaving the lower sound material (joined up). The difference here is that the process is operating on ‘pseudo-wavecycles’ according to their length, so here the results are more unpredictable and also distort the sound to some degree, depending on where the horizontal line – the frequency variable(s) – is drawn. Technically, the process is akin to low-, high- and band-pass filters, but aurally it is more like gating. You can therefore use this procedure to cut out some and distort other material in a sound.” },
arg1 = { name = “freq”, min = 10,0, max = 22050.0, tip = “frequency in Hz (Range: 10.0 to 22050.0)” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles below & above freq”] = {
cmds = { exe = “distort”, mode = “filter 3”, tip = “Period and frequency are inverse functions. Therefore it is possible to relate the length of a ‘wavecycle’ to the frequency it would have were it to recur regularly. This program therefore filters by removing ‘wavecycles’ shorter or longer than those relating to a specific, user-defined, frequency. The duration of the outfile is affected by this process: because ‘wavecycles’ are being removed, the outfile will be shorter, by varying degrees. The aural effect of the DISTORT FILTER process is actually like gating. In gating, you can imagine a horizontal line drawn through the time/amplitude display of a soundfile. If the peaks above the line are retained (by filtering out lower frequencies), you just hear them (joined up). Similarly, if you filter out above the line, the peaks are gone, leaving the lower sound material (joined up). The difference here is that the process is operating on ‘pseudo-wavecycles’ according to their length, so here the results are more unpredictable and also distort the sound to some degree, depending on where the horizontal line – the frequency variable(s) – is drawn. Technically, the process is akin to low-, high- and band-pass filters, but aurally it is more like gating. You can therefore use this procedure to cut out some and distort other material in a sound.” },
arg1 = { name = “freq1”, min = 0,0, max = 22050.0, tip = “frequency in Hz to delete below” },
arg2 = { name = “freq2”, min = 0,0, max = 22050,0, tip = “frequency in Hz to delete above” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}


dsp[“Modify Brassage - Pitchshift - Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 1” },
arg1 = { name = “pitchshift”, min = -0,12, max = 12, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
}

dsp[“Modify Brassage - Timestretch -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 2” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
}

dsp[“Modify Brassage - Reverb -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 3” },
arg1 = { name = “density”, min = 0,0, max = 1000, tip = “amount of grain overlap (Range: > 0)” },
arg2 = { name = “pitch”, min = -0,33, max = 0,33, tip = “transposition factor (Range: -0.33 to 0.33)” },
arg3 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg4 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
}

dsp[“Modify Brassage - Scramble -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 4” },
arg1 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg2 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
}

dsp[“Modify Brassage - Granulate -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 5” },
arg1 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg2 = { name = “-d”, switch = “-d” },
}

dsp[“Modify Brassage - Brassage -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 6” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
arg2 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg3 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg4 = { name = “pitchshift”, min = -0,33, max = 0,33, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
arg5 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg6 = { name = “space”, min = 0, max = 1, tip = “spatial position – set stereo position” },
arg7 = { name = “bsplice”, min = 0, max = 1000, tip = “length of start-splices on grains in ms (Default: 5)” },
arg8 = { name = “esplice”, min = 0, max = 1000, tip = “length of end-splices on grains in ms (Default: 5)” },
arg9 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
arg10 = { name = “jitter”, switch = “-j”, min = 0, max = 1, tip = “randomisation of grain position” },
arg11 = { name = “outlength”, switch = “-l”, min = 0, max = 10, tip = “maximum outfile length (if end of data is not reached)” },
arg12 = { name = “channel”, switch = “-c”, min = 0, max = 2, tip = " extract and work on just one channel of a stereo input (Range: 1 or 2) Set channel to 0 (the Default) for this parameter to be ignored." },
arg13 = { name = “-d”, switch = “-d” },
arg14 = { name = “-x”, switch = “-x”, tip = “do exponential splices (Default: linear)” },
arg15 = { name = “-n”, switch = “-n”, tip = “no interpolation for pitch values (quick but dirty)” },
}

dsp[“Modify Brassage - Full Monty -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 7” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
arg2 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg3 = { name = “hvelocity”, min = 0,0, max = 5000,0 },
arg4 = { name = “hdensity”, min = 0,0, max = 5000,0 },
arg5 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg6 = { name = “pitchshift”, min = -0,33, max = 0,33, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
arg7 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg8 = { name = “space”, min = 0, max = 1, tip = “spatial position – set stereo position” },
arg9 = { name = “bsplice”, min = 0, max = 1000, tip = “length of start-splices on grains in ms (Default: 5)” },
arg10 = { name = “esplice”, min = 0, max = 1000, tip = “length of end-splices on grains in ms (Default: 5)” },
arg11 = { name = “hgrainsize”, min = 0, max = 5000 },
arg12 = { name = “hpitchshift”, min = -0,33, max = 0,33 },
arg13 = { name = “hamp”, min = 0, max = 1 },
arg14 = { name = “hspace”, min = 0, max = 2 },
arg15 = { name = “hbsplice”, min = 0, max = 1000 },
arg16 = { name = “hesplice”, min = 0, max = 1000 },
arg17 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
arg18 = { name = “jitter”, switch = “-j”, min = 0, max = 1, tip = “randomisation of grain position” },
arg19 = { name = “outlength”, switch = “-l”, min = 0, max = 10, tip = “maximum outfile length (if end of data is not reached)” },
arg20 = { name = “channel”, switch = “-c”, min = 0, max = 2, tip = " extract and work on just one channel of a stereo input (Range: 1 or 2) Set channel to 0 (the Default) for this parameter to be ignored." },
arg21 = { name = “-d”, switch = “-d” },
arg22 = { name = “-x”, switch = “-x”, tip = “do exponential splices (Default: linear)” },
arg23 = { name = “-n”, switch = “-n”, tip = “no interpolation for pitch values (quick but dirty)” },
}

dsp[“Modify Loudness - Alter gain of sound”] = {
cmds = { exe = “modify”, mode = “loudness 1” },
arg1 = { name = “gain”, min = 0,0, max = 100,0, tip = “adjust level by factor gain” },
}

dsp[“Modify Loudness - Alter dB-gain of sound”] = {
cmds = { exe = “modify”, mode = “loudness 2” },
arg1 = { name = “gain”, min = -96, max = 96, tip = “level expressed in dB (Range: -96dB to 96dB). NB: every drop of -6dB halves the previous level.” },
}

dsp[“Modify Loudness - Normalise”] = {
cmds = { exe = “modify”, mode = “loudness 3” },
arg1 = { name = “level”, switch = “-l”, min = 0, max = 1, tip = “force level (if necessary) to the maximum possible, or to the level given (Range: 0 to 1).” },
}

dsp[“Modify Loudness - Force level”] = {
cmds = { exe = “modify”, mode = “loudness 4” },
arg1 = { name = “level”, switch = “-l”, min = 0, max = 1, tip = “force level to maximum possible, or to the level given (Range: 0 to 1)” },
}

dsp[“Modify Loudness - Invert Phase”] = {
cmds = { exe = “modify”, mode = “loudness 6” },
}

dsp[“Phase - Invert phase”] = {
cmds = { exe = “phase”, mode = “phase 1”, tip = “Playback of the output inverted soundfile shows that there is no audible difference from the input soundfile. However, if you mix the original sound with the phase inverted sound, you will generate a silent output: positive and negative amplitude values cancel out. However, if you mix the input and output with an offset, you get signal and hear an overlap of the two soundfiles (the cancelling out does not fully happen). You can try this with SUBMIX MERGE.” },
}

dsp[“Phase - Stereo Enhance stereo file”] = {
cmds = { exe = “phase”, mode = “phase 2”, tip = “This mode is supposed to be a means of creating an enhanced stereo image by suppressing any aspects of the Left image which have bled to the Right, by adding (part of) the phase inverted Left signal on the Right, and vice versa. I (T Wishart) learned of this idea from a mixing engineer I met in France, but I’m still not convinced that this achieves anything except in very special circumstances (with particular types of material). The output may sound the same as the input, except perhaps on the largest PA systems.” },
arg1 = { name = “transfer”, switch = “-t”, min = 0, max = 1, tip = “amount of signal to be used in phase-cancellation.” },
}

dsp[“Modify Radical - Reverse”] = {
cmds = { exe = “modify”, mode = “radical 1”, tip = “Sound plays backwards, the soundfile is re-written back to front: starting at the end and ending at the beginning.” },
}

dsp[“Modify Radical - Shred”] = {
cmds = { exe = “modify”, mode = “radical 2”, tip = “The soundfile is (randomly) segmented, and these segments reordered by means of a permutation process. As the number of repeats increases, it gets more and more jumbled, literally ‘reducing it to shreds’. The -n adds splicing that results in a smoother output.” },
arg1 = { name = “repeats”, min = 0, max = 1000, tip = “number of repeats of shredding process” },
arg2 = { name = “chunklen”, min = 0, max = 500, tip = “average length of chunks to cut and permutate” },
arg3 = { name = “scatter”, switch = “-s”, min = 0, max = 10, tip = “randomisation of cuts (Range: 0 to K, where K = duration of infile/chunklen Default = 1)” },
arg4 = { name = “-n”, switch = “-n”, tip = “use this flag for a smoother output” },
}

dsp[“Modify Radical - Scrub back and forth”] = {
cmds = { exe = “modify”, mode = “radical 3”, tip = “This is an acceleration/deceleration process which models an editing procedure used in the ‘classical’ tape studio: the desired edit point was found by turning the tape spools by hand so that the tape moved (very slowly!) across the tape head. You could hear locate exactly where silence began or ended, where clicks came etc., although the sound was very low because of the slow speed.The SCRUB function could also be used creatively, to create extreme speed modifications of the source sound on the tape, e.g. an abrupt acceleration-deceleration as the tape went from not-moving, to fast-moving, to stopped as the hands jerked the tape across the heads.” },
arg1 = { name = “dur”, min = 0, max = 10, tip = “minimum length of outfile required” },
arg2 = { name = “down”, switch = “-l”, min = 0, max = 12, tip = “lowest downward tranposition in semitones” },
arg3 = { name = “up”, switch = “-h”, min = 0, max = 12, tip = " highest upward transposition in semitones" },
arg4 = { name = “start”, switch = “-s”, tip = "scrubs start before time start seconds " },
arg5 = { name = “end”, switch = “-e”, tip = “scrubs end after time end” },
}

dsp[“Modify Radical - Lose resolution”] = {
cmds = { exe = “modify”, mode = “radical 4”, tip = “LOSE RES: Reducing the sample rate reduces the level of the Nyquist frequency (sample_rate/2), thereby lowering the frequency level which can be safely handling during processing. Lowering bit-resolution reduces the precision of the numerical expression of the data, making the digital ‘quantisation’ of the sonic material coarser. This means that time-varying information is lost.” },
arg1 = { name = “bit_resolution”, min = 0, max = 16 },
arg2 = { name = “srate_division”, min = 1, max = 256, tip = “Range: 1 to 256 Default 1 (normal)” },
}

dsp[“Modify Radical - Ring Modulate”] = {
cmds = { exe = “modify”, mode = “radical 5”, tip = “RING MODULATION: multiplies two (bipolar) signals. In this case, one signal is a soundfile and the other is a modulating_frq. This creates two ‘sidebands’ which are the sum and the difference of the two signals, while the carrier signal disappears. The result is a timbrally ‘hollow’ sound. (See Curtis Roads, The Computer Music Tutorial, pp. 215-220).” },
arg1 = { name = “modulating-frq”, min = 0, max = 44100, tip = “number of cycles per second” },
}

dsp[“Modify Revecho - Standard delay”] = {
cmds = { exe = “modify”, mode = “revecho 1”, tip = “Mode 1 provides a standard delay. If a smooth echoey effect is wanted, be careful to keep mix on the low side. Remember that delay is given in milliseconds; after 60ms or so, one begins to hear a strong reverberation; after 100 ms the reverberation begins to ‘bounce’, and by 200 ms one begins to hear distinct echoes. Delay times greater than 1000 will cause repetitions of (all or much of) the sound. Don’t forget to lengthen the tail to match the delay time.The mix parameter, in adding in the delayed signal, increases the reverberant effect. With a short delay time, this can sound like the reverberation which occurs in an enclosed space. Feedback has a similar effect, becoming very pronounced towards a value of 1.0 – rather like the ‘feedback’ which occurs when a microphone is placed facing a loudspeaker. The operation of a standard delay line in Mode 1 ranges from modest reverberation to echo effects. The reverberations, however, tend easily towards rough edges, so for smoother reverbs, look to the programs listed below.” },
arg1 = { name = “delay”, min = 0, max = 5000, tip = “delay time, in milliseconds” },
arg2 = { name = “mix”, min = 0, max = 1, tip = " amount of delayed signal in final mix: 0 gives ‘dry’ result (Range: 0 to 1)" },
arg3 = { name = “feedback”, min = -1,0, max = 1,0, tip = “produces resonances related to delay time (with short times) (Range: -1.0 to 1.0)” },
arg4 = { name = “tail”, min = -1,0, max = 1,0, tip = “time to allow decayed signal to decay to zero (Range: -1.0 to 1.0)” },
arg5 = { name = “prescale”, switch = “-p”, tip = “prescales input level, to avoid overload” },
arg6 = { name = “-i”, switch = “-i”, tip = “inverts the dry signal (for phasing effects)” },
}

dsp[“Modify Revecho - Varying delay”] = {
cmds = { exe = “modify”, mode = “revecho 2” },
arg1 = { name = “delay”, min = 0, max = 5000, tip = “delay time, in milliseconds” },
arg2 = { name = “mix”, min = 0, max = 1, tip = " amount of delayed signal in final mix: 0 gives ‘dry’ result (Range: 0 to 1)" },
arg3 = { name = “feedback”, min = -1,0, max = 1,0, tip = “produces resonances related to delay time (with short times) (Range: -1.0 to 1.0)” },
arg4 = { name = “lfomod”, min = 0, max = 1, tip = “depth of the delay-variation sweep (Range: 0 to 1)” },
arg5 = { name = “lfofreq”, min = -50, max = 50, tip = “frequency of the delay-variation sweep (negative values give random oscillations)” },
arg6 = { name = “lfophase”, min = 0, max = 1, tip = “start-phase of the delay-variation sweep (Range: 0 to 1)” },
arg7 = { name = “lfodelay”, min = 0, max = 10, tip = “time in seconds before the delay-variation sweep begins” },
arg8 = { name = “tail”, min = -1,0, max = 1,0, tip = “time to allow decayed signal to decay to zero (Range: -1.0 to 1.0)” },
arg9 = { name = “prescale”, switch = “-p”, tip = “prescales input level, to avoid overload” },
arg10 = { name = “seed”, switch = “-s”, min = 0, max = 100, tip = "non-zero value gives reproducible output (with the same seed) where random oscillations are used " },
}

dsp[“Modify Revecho - Stadium Echo”] = {
cmds = { exe = “modify”, mode = “revecho 3”, tip = “This creates a stereo outfile, bouncing the signal between speakers with a very prominent delay factor. The idea is that you hear the signal bouncing around the ‘stadium’. The defaults work quite nicely, but you can intensify the effect by multiplying the delay time with the size parameter. Note that this is a multiple, so values less than 0 (multiplied with the default time of 0.1 sec) will decrease the delay time. Beyond size = 2, you are likely to run into insufficient buffer space, so if you really want longer delay times, you will have to increase the buffer size with ‘set CDP_MEMORY_BBSIZE=…’ (bear in mind the RAM capacity of your machine). (The default buffer size is 1 Mbyte and the units are in ‘k’: e.g., a BBSIZE of 3000 units is 3 Mbyte)” },
arg1 = { name = “gain”, switch = “-g”, min = 0, max = 1, tip = “to apply to input signal (Default: 0.645654)” },
arg2 = { name = “roll_off”, switch = “-r”, min = 0, max = 10, def = 1, tip = “rate of loss of level across stadium (Default: 1))” },
arg3 = { name = “size”, switch = “-s”, min = 0, max = 10, tip = “multiplies average time between echoes (the Default time between echoes of 0.1 sec)” },
arg4 = { name = “count”, switch = “-e”, min = 0, max = 23, tip = “number of stadium echoes (Default and max: 23)” },
}

dsp[“Modify Space - pan”] = {
cmds = { exe = “modify”, mode = “space 1”, tip = “Adjusts the amplitude levels of the two channels so as to create spatial illusions. A time pan breakpoint file is used to create movement. Mode1 PAN: control of sound in 3-D space has been a basic procedure when composing with ‘sound’ material, especially when these are drawn from nature/the environment. The assumption here is that you are thinking about the placement and movement of sound as an integral part of your compositional process. In this case, we are dealing with building these procedures into the sound itself. There is a further aspect external to the sound itself, achieved by ‘mixing’ (superimposing sounds and writing a new soundfile) and ‘diffusion’ (sound placement during playback achieved by manipulating the pan controls on a mixer).” },
arg1 = { name = “pan”, min = -1,0, max = 1,0, tip = “floating point value to specify location between the pair of stereo speakers, or breakpoint file of time pan pairs. Range: -1.0 to 1.0; 0.0 is centre.” },
arg2 = { name = “prescale”, switch = “-p”, min = 0, max = 1, tip = “gain factor multiplier with which to adjust the input level (Default: 0.7)” },
}

dsp["Modify Space - Mirrow: two channels swap sides "] = {
cmds = { exe = “modify”, mode = “space 2”, tip = “MIRROR: the data in the two channels swaps sides, a utility for a quick Left/Right swap” },
}

dsp[“Modify Space - Narrow: Narrow the stereo image of a sound”] = {
cmds = { exe = “modify”, mode = “space 4”, tip = “A way to restrict the spatial location of a sound in the horizontal plane, this program allows you to narrow the spread of a stereo field” },
arg1 = { name = “narrowing”, min = -1,0, max = 1,0, tip = “make the stereo image less wide” },
}

dsp[“Modify Speed - Vary speed & pitch of a sound”] = {
cmds = { exe = “modify”, mode = “speed 1”, tip = “Speed modification processes change the duration and the pitch of the sound together. Thus a faster speed causes a higher pitch, a slower speed a lower pitch.MODIFY SPEED offers a range of functions which affect the speed of the soundfile. Perhaps it will be most often used for transposition. Modes 1 and 2 both accept either single values or the names of time-varying breakpoint files with time transposition pairs. The single values act as constants and transpose the whole soundfile up or down by the given amount. In the breakpoint files, transposition can be almost instantaneous (almost same time, different transposition value), or gradual, creating glissandi (different time, different transposition value). No transposition between times is a third possibility (different time, same transposition value). Transposition which also changes the speed, and therefore the pitch, of the soundfile greatly alters the character of the sound. It is often very interesting to hear what a sound will be like 1, 2 or even 3 octaves below its original pitch. Deep, rich tones can be achieved in this way. These tones can slowly rise or descend if created with a time-varying breakpoint file e.g., moving an octave up or down over the time of the whole sound (airplane takeoff sounds, etc.)” },
arg1 = { name = “speed”, min = 0, max = 4, tip = “transposition value (ratio) expressed as a floating point multiplier” },
}

dsp[“Modify Speed - Vary speed & pitch by (fractional) number of semitones”] = {
cmds = { exe = “modify”, mode = “speed 2”, tip =“Speed modification processes change the duration and the pitch of the sound together. Thus a faster speed causes a higher pitch, a slower speed a lower pitch.MODIFY SPEED offers a range of functions which affect the speed of the soundfile. Perhaps it will be most often used for transposition. Modes 1 and 2 both accept either single values or the names of time-varying breakpoint files with time transposition pairs. The single values act as constants and transpose the whole soundfile up or down by the given amount. In the breakpoint files, transposition can be almost instantaneous (almost same time, different transposition value), or gradual, creating glissandi (different time, different transposition value). No transposition between times is a third possibility (different time, same transposition value). Transposition which also changes the speed, and therefore the pitch, of the soundfile greatly alters the character of the sound. It is often very interesting to hear what a sound will be like 1, 2 or even 3 octaves below its original pitch. Deep, rich tones can be achieved in this way. These tones can slowly rise or descend if created with a time-varying breakpoint file e.g., moving an octave up or down over the time of the whole sound (airplane takeoff sounds, etc.)” },
arg1 = { name = “semitone-transpos”, min = -12, max = 12, tip = " transposition value in positive or negative number of semitones; e.g., 12 raises the sound by an octave, and -12 lowers it by an octave. NB: use 0 (semitones) for no transposition." },
}

dsp[“Modify Speed - Accelerate or decelerate a sound”] = {
cmds = { exe = “modify”, mode = “speed 5” },
arg1 = { name = “accel”, min = 0, max = 100, tip = “multiplication of speed to be reached by goaltime – i.e., a transposition ratio” },
arg2 = { name = “goaltime”, min = 0, max = 30, tip = “time in outfile at which the accelerated speed is to be reached.” },
arg3 = { name = “starttime”, switch = “-s”, min = 0, max = 10, tip = “time in infile / outfile at which the acceleration begins” },
}

dsp[“Modify Speed - Add vibrato to a sound”] = {
cmds = { exe = “modify”, mode = “speed 6”, tip = “The vibrato created in Mode 6 is a frequency modulation. Given the very wide ranges allowed, this function is immensely powerful. A slow vibrate with a large vibdepth will swing the original sound wildly – increase vibrate and it really ‘flaps in the breeze’ (like a flag in the wind). A fast vibrate with a reasonably tight vibdepth, e.g., a minor 3rd, will produce a fluttering effect.” },
arg1 = { name = “vibrate”, min = 0,0, max = 120,0, tip = “the rate of vibrato shaking in cyles-per-second (Range: 0.0 to 120.0)” },
arg2 = { name = “vibdepth”, min = 0,0, max = 96,0, tip = “vibrato depth (pitch shift from centre) in [possibly fractional] semitones (Range: 0.0 to 96.0)” },
}

dsp[“Modify Stack - Create a mix that stacks transposed versions of source on top of one another “] = {
cmds = { exe = “modify”, mode = “stack”, tip = “New sounds can be developed from existing sources by stacking transposed copes of the original on top of each other. This is particularly successful where the source sound has a clearly defined attack at or near the start of the sound and then dies away gradually. If the copies are lined up in such a way that their attacks coincide exactly, the new sound will psycho-acoustically merge into a single sound event with harmonic content (rather than a chord made up of several sounds). The meaning of this is very precise: one is lining up the soundfiles at their perceived beginning, i.e., its attack, not the start of each soundfile. This is achieved by adjusting the start times of the transposed soundfiles. MODIFY STACK is a very important program. It enables you to construct ‘larger’ versions of sounds by superimposing transposed versions on top of one another. Furthermore, it does this in such a way as to maximise the fusion of the layered sound by synchronising the attacks. This relates to a basic technique of orchestral scoring (where it is called ‘doubling’). It is a form of automatic mixing involving one soundfile.Because of the way the program functions, this is, however, quite a different process from transposing and mixing sounds to produce chords. (Doing this in the Spectral Domain, where transposition can be done without affecting duration, still has a place.) Here, if the attack points are made to coincide, the new sound-object is an integral whole, rather than a ‘chord’ made up of the transposed stack components: that is, the components fuse and cannot be separated in perception, as they can with a chord played, for example, on a piano keyboard.Also note that, as a Time Domain process, the higher transpositions end sooner than the lower ones. Use Spectral Domain transpositon along with SUBMIX MIX to assemble transposed versions of the same sound when equal length is important.Very low transpositions could produce an extremely long output. The dur parameter enables you to specify a much shorter outfile length. You can usually get an idea of the harmonic content of the output from the first few seconds.” },
arg1 = { name = “transpos”, min = 0, max = 12, tip = “transpos is the transposition in semitones between successive copies” },
arg2 = { name = “count”, min = 0, max = 100, tip = " the number of copies in the stack” },
arg4 = { name = “lean”, min = 0, max = 10, tip = “the loudness of the highest component, relative to the lowest (may be > 1)” },
arg5 = { name = “attack-offset”, min = 0, max = 50, tip = “adjusts the time at which the attack of each sound occurs” },
arg6 = { name = “gain”, min = 0,1, max = 10, tip = “an overall amplifying gain factor on the output sound; some reduction (less than 1) may be needed. (It may also be > 1.) Range: 0.1 to 10” },
arg7 = { name = “dur”, min = 0, max = 1, tip = “how much of the output to make (a proportion, from 0 to 1)” },
arg7 = { name = “-s”, switch = “-s”, tip = " see the relative levels of the layers in the stack” },
}


dsp["Envel Attack - Emphasize the attack of a sound "] = {
cmds = { exe = “envel”, mode = “attack 1”, tip = “Set attack point where sound level first exceeds gate level.” },
arg1 = { name = “gate”, min = 0, max = 1, tip = "level (threshold) to be reached for the attack point to be recognised (Range: 0 to 1). " },
arg2 = { name = “Gain”, min = 0.001, max = 2,0, set = “floating point multiplier by which to amplify the signal at the attack point (< 1 reduces the signal; > 1 amplifies the signal).” },
arg3 = { name = “onset”, min = 5, max = 32767, tip = “attack onset duration in milliseconds, i.e., the ‘sharpness’ of the attack (Range:5ms to 32767ms). " },
arg4 = { name = “decay”, min = 5, max = 20000, tip = “attack decay duration in milliseconds (Range: 5 to < duration of infile).” },
arg5 = { name = “envtype”, switch = “-t”, min = 0, max = 1, tip = " type of envelope: 0 linear, 1 exponential (Default)” },
}

dsp[“Envel Attack - Emphasize the attack of a sound 2”] = {
cmds = { exe = “envel”, mode = “attack 2”, tip = “Attack point at maximum level at your ‘approx-time’ (+/- 200 ms).” },
arg1 = { name = “time”, min = 0, max = 10, tip = “time (approximate or exact) of the attack point, in seconds” },
arg2 = { name = “Gain”, min = 0.001, max = 2,0, set = “floating point multiplier by which to amplify the signal at the attack point (< 1 reduces the signal; > 1 amplifies the signal). " },
arg3 = { name = “onset”, min = 5, max = 32767, tip = “attack onset duration in milliseconds, i.e., the ‘sharpness’ of the attack (Range:5ms to 32767ms).” },
arg4 = { name = “decay”, min = 5, max = 20000, tip = “attack decay duration in milliseconds (Range: 5 to < duration of infile).” },
arg5 = { name = “envtype”, switch = “-t”, min = 0, max = 1, tip = " type of envelope: 0 linear, 1 exponential (Default)” },
}

dsp[“Envel Attack - Emphasize the attack of a sound 3”] = {
cmds = { exe = “envel”, mode = “attack 3”, tip = “Attack point at your ‘exact-time’.” },
arg1 = { name = “time”, min = 0, max = 10, tip = “time (approximate or exact) of the attack point, in seconds” },
arg2 = { name = “Gain”, min = 0.001, max = 2,0, set = “floating point multiplier by which to amplify the signal at the attack point (< 1 reduces the signal; > 1 amplifies the signal).” },
arg3 = { name = “onset”, min = 5, max = 32767, tip = "attack onset duration in milliseconds, i.e., the ‘sharpness’ of the attack (Range:5ms to 32767ms). " },
arg4 = { name = “decay”, min = 5, max = 20000, tip = “attack decay duration in milliseconds (Range: 5 to < duration of infile).The decay portion of the attack is also set in milliseconds. " },
arg5 = { name = “envtype”, switch = “-t”, min = 0, max = 1, tip = " type of envelope: 0 linear, 1 exponential (Default)” },
}

dsp[“Envel Attack - Emphasize the attack of a sound 4”] = {
cmds = { exe = “envel”, mode = “attack 3”, tip = "Attack point at maximum level in the soundfile " },
arg1 = { name = “Gain”, min = 0.001, max = 2,0, set = "floating point multiplier by which to amplify the signal at the attack point (< 1 reduces the signal; > 1 amplifies the signal). " },
arg2 = { name = “onset”, min = 5, max = 32767, tip = “attack onset duration in milliseconds, i.e., the ‘sharpness’ of the attack (Range:5ms to 32767ms). " },
arg3 = { name = “decay”, min = 5, max = 20000, tip = “attack decay duration in milliseconds (Range: 5 to < duration of infile).” },
arg4 = { name = “envtype”, switch = “-t”, min = 0, max = 1, tip = " type of envelope: 0 linear, 1 exponential (Default)” },
}

dsp["Envel Curtail - Curtail a soundfile by fading to zero at some time within it “] = {
cmds = { exe = “envel”, mode = “curtail 1”, tip = “specify the precise times at which the file is to begin and end.” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “fadeend”, min = 0, max = 50, set = “time at which to complete the fade” },
arg3 = { name = “envtype”, min = 0, max = 1, tip = “type of envelope shape for the fade, 0 linear, 1 exponential” },
arg4 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes” },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 2”] = {
cmds = { exe = “envel”, mode = “curtail 2”, tip = “specify the duration of the fade and when it begins.” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “fade-dur”, min = 0, max = 50, set = “time at which to complete the fade” },
arg3 = { name = “envtype”, min = 0, max = 1, tip = “type of envelope shape for the fade, 0 linear, 1 exponential” },
arg4 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 3”] = {
cmds = { exe = “envel”, mode = “curtail 3”, tip = “specify when the fade begins and fade to the existing end of insndfile” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “envtype”, min = 0, max = 1, tip = “type of envelope shape for the fade, 0 linear, 1 exponential” },
arg3 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 4”] = {
cmds = { exe = “envel”, mode = “curtail 4”, tip = “specify the precise times at which the file is to begin and end, and apply a doubly exponential (steeper) editing slope” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “fadeend”, min = 0, max = 50, set = “time at which to complete the fade” },
arg3 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 5”] = {
cmds = { exe = “envel”, mode = “curtail 5”, tip = “specify the duration of the fade and when it begins, and apply a doubly exponential (steeper) editing slope” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “fade-dur”, min = 0, max = 50, set = “time at which to complete the fade” },
arg3 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 6”] = {
cmds = { exe = “envel”, mode = “curtail 6”, tip = “Specify when the fade begins and fade to the existing end of insndfile, applying a doubly exponential (steeper) editing slope” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Dovetail - Dovetail a soundfile by enveloping its beginning and end”] = {
cmds = { exe = “envel”, mode = “dovetail 1”, tip = “a choice of linear or exponential slopes at the beginning and the end” },
arg1 = { name = “infadedur”, min = 0, max = 50, tip = “duration of the fade-in at the start of the file” },
arg2 = { name = “outfadedur”, min = 0, max = 50, tip = “duration of the fade-out at the end of the file” },
arg3 = { name = “intype”, min = 0, max = 1, tip = “envelope shape for the fade-in at the start of the file; intype = 0: linear fade, intype = 1: exponential fade (the Default)” },
arg4 = { name = “outtype”, min = 0, max = 1, tip = “envelope shape for the fade-out, at the end of the file; outtype = 0: linear fade, outtype = 1: exponential fade (the Default)” },
arg5 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = “identifies the type of time unit being used: times = 0: is seconds (the Default), times = 1: times are in samples, times = 2: times are in grouped-samples” },
}

dsp[“Envel Dovetail - Dovetail a soundfile by enveloping its beginning and end 2”] = {
cmds = { exe = “envel”, mode = “dovetail 2”, tip = “a doubly exponential slope (steeper) is applied to the beginning and the end” },
arg1 = { name = “infadedur”, min = 0, max = 50, tip = “duration of the fade-in at the start of the file” },
arg2 = { name = “outfadedur”, min = 0, max = 50, tip = “duration of the fade-out at the end of the file” },
arg3 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = “identifies the type of time unit being used: times = 0: is seconds (the Default), times = 1: times are in samples, times = 2: times are in grouped-samples” },
}


dsp[“Envel Pluck - Pluck the start of a sound (Mono files only)”] = {
cmds = { exe = “envel”, mode = “pluck”, tip = “Although similar to ENVEL ATTACK, ENVEL PLUCK differs in that the attack imposed on the soundfile also has the noise and decay characteristics associated with plucked sounds. To pluck the sound, ENVEL PLUCK creates a ‘pluck’ constructed from a number of wavecycles and splices it into the beginning of the sound. To achieve this, it needs a goal wavecycle to pluck towards: this is located at startsamp.We can get an idea of what is going on here by reviewing how the Karplus-Strong pluck algorithm used in Csound works. It achieves a pluck effect by iteratively filtering a block of noise until it becomes pitched. It does this because noise components are an essential ingredient of a plucked sound. ENVEL PLUCK achieves the same effect by working backwards – backwards because it is starting with an existing sound. The process is to repeat wavelen backwards a number of times towards the beginning of the soundfile, becoming noisier as it goes.” },
arg1 = { name = “startsamp”, min = 0, max = 5000, tip = “is where the pluck effect links into the sound. It will usually be a little after the beginning of the sound, not at the very beginning, because we want the pluck to link smoothly into stable signal.” },
arg2 = { name = “wavelen”, min = 2, max = 2205, tip = "the number of (absolute) samples in the wavelength of the pluck effect; its value is the number of samples in a waveform starting at startsamp in the infile " },
arg3 = { name = “atkcycles”, switch = “-a”, min = 2, max = 32767, tip = “the number of wavecycles in the pluck attack” },
arg4 = { name = “decayrate”, switch = “-d”, min = 1, max = 64, tip = “rate of decay of the pluck effect” },
}

dsp["Envel Warp - Normalise the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 1”, tip = “NORMALISE; Expand envelope so that the highest envelope point is at the maximum possible amplitude value.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
}

dsp["Envel Warp - Reverse the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 2”, tip = “Reverse the envelope in time.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
}

dsp["Envel Warp - Exaggerate the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 3”, tip = “Exaggerate the envelope contour” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “exaggerate”, min = 0, max = 50, tip = “Range: > 0.0 < 1, low values are boosted = 1, no change, > 1, high values are boosted” },
}

dsp["Envel Warp - Attenuate the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 4”, tip = “Reduce the amplitude of an envelope.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “attenuation”, min = 0, max = 1, tip = “multiplier by which to scale down the envelope. Range: 0 to 1” },
}

dsp["Envel Warp - Lift the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 5”, tip = “Raise the envelope by a fixed amount” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “lift”, min = 0, max = 1, tip = “amount to add to each amplitude value. Range: 0 to 1” },
}

dsp["Envel Warp - Timestretch the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 6”, tip = “Stretch or compress an envelope in time.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “timestretch”, min = 0, max = 20, tip = “multiplier by which to stretch the envelope. Range: > 0.0 < 1.0 compresses the envelope in time, = 1.0 no change, > 1.0 stretches the envelope in time” },
}

dsp["Envel Warp - Flatten the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 7”, tip = “Even out the envelope contour.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “flatten”, min = 1, max = 5000, tip = “number of envelope values over which to average.” },
}

dsp["Envel Warp - Gate the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 8”, tip = “Zero lower portion of envelope.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “gate”, min = 0, max = 1, tip = “levels less than gate are set to 0. Range: 0 to 1.” },
arg3 = { name = “smoothing”, min = 0, max = 32767, tip = “smoothing – excises segments with an amplitude less than smoothing. Range: 0 to 32767.” },
}

dsp["Envel Warp - Invert the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 9”, tip = “Turn envelope upside down: negative values become positive, and positive values become negative.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “gate”, min = 0, max = 1, tip = “levels less than gate are set to 0. Range: 0 to < mirror.” },
arg3 = { name = “mirror”, min = 0, max = 1, tip = “reflection point: all values other than those below gate, both above and below mirror, are inverted to the other side of mirror. Range: > gate to 1.” },
}

dsp["Envel Warp - Limit the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 10”, tip = “Squeeze down amplitude into a specified range.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “limit”, min = 0, max = 1, tip = “upper limit of range; amplitude values which were above limit are scaled down such that ‘maxamp’ becomes limit. Range: > threshold to 1.” },
arg3 = { name = “threshold”, min = 0, max = 1, tip = “lower limit of range; only values above threshold are affected. Range: 0 to limit.” },
}

dsp["Envel Warp - Corrugate the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 11”, tip = “Tighten the peaks into close-set ridges by taking troughs (downward dips) in the envelope to zero.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “trofdel”, min = 0, max = 32767, tip = “number of windows to set to zero per trough. Range: 1 to < peak_separation.” },
arg3 = { name = “peak_separation”, min = 2, max = 32767, tip = “minimum number of windows per peak. Range: 2 to 32767.” },
}

dsp["Envel Warp - Expand the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 12”, tip = “Inflate the envelope” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “gate”, min = 0, max = 1, tip = “levels below gate are set to 0. Range: 0 to threshold.” },
arg3 = { name = “threshold”, min = 0, max = 1, tip = “lower limit of range: amplitude values that were above gate and below threshold are scaled up such that the minimum level becomes threshold. Range: gate to 1” },
arg4 = { name = “smoothing”, min = 0, max = 32767, tip = “Excises low-level segments which are less than smoothing windows in length. Range: 0 to 32767. 0 turns off the smoothing effect.” },
}

dsp["Envel Warp - Trigger the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 13”, tip = “Create a new envelope of sudden on bursts, triggered by the rate of rise of the current envelope.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “gate”, min = 0, max = 1, tip = “the average level must be above gate before triggering can occur. Range: 0 to 1.” },
arg3 = { name = “rise”, min = 0, max = 1, tip = “minimum loudness-step before triggering can occur. Range: 0 to 1.” },
arg4 = { name = “dur”, min = 0, max = 1000, tip = “maximum duration over which the rise can take place before triggering can occur. Range: must be >= the envelope window duration.” },
}

dsp["Envel Warp - Ceiling of the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 14”, tip = “Force envelope up to its maximum level, everywhere.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
}

dsp["Envel Warp - Duck the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 15”, tip = “Create ‘ducking’ envelope: envelope kept below a set level.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “gate”, min = 0, max = 1, tip = “highest level allowed for the envelope. Range: 0 to 1.” },
arg3 = { name = “threshold”, min = 0, max = 1, tip = “Amplitude level the envelope must reach before ‘ducking’ is applied. Range: 0 to 1.” },
}

dsp[“Envel Swell - Cause sound to fade in to and out from a peak moment”] = {
cmds = { exe = “envel”, mode = “swell”, tip = " his is a generic envelope type which can be applied very easily by specifying the time of the peak moment and the shape to be applied.The peak moment (peaktime) can be the location of the maximum amplitude in the soundfile, which can be found with SNDINFO MAXSAMP). It could also be any other place in the file that you define. For example, you can take a completely flat sound (in terms of loudness) and make it swell to a peak (at any point you want) and die away again. The linear peaktype produces a less gradual fade. This function makes it easy to create an audible peak anywhere in a soundfile, and implement a swell to and from it without having to create a breakpoint file." },
arg1 = { name = “peaktime”, min = 0, max = 20, tip = “time in infile at which the peak moment is located.” },
arg2 = { name = “peaktype”, min = 0, max = 1, tip = “type of swell shape: 0 (linear) or 1 (exponential – the Default)” },
}

dsp[“Topantail2 Topantail - Fade both the beginning and end of a sound”] = {
cmds = { exe = “topantail2”, mode = “topantail”, tip = “TOPANTAIL2 provides another approach to extracting part of a soundfile by using gate levels. In this case it trims away signal before and after the extracted portion. The ‘backtracking’ function moves the initial cut point earlier in the sound, thus retaining some of the sound which may be below the startgate’s level.” },
arg1 = { name = “startgate”, min = 0, max = 1, tip = “level at start before which sound is to be removed. (Range: 0 to 1, Default: 0.001)” },
arg2 = { name = “endgate”, min = 0, max = 1, tip = “level at end after which sound is to be removed. (Range: 0 to 1, Default: 0.001)” },
arg3 = { name = “splicelen”, switch = “-s”, min = 0, max = 1000, tip = “splice length in milliseconds” },
arg4 = { name = “backtrack”, switch = “-b”, min = 0, max = 1000, tip = “backtrack in time from the initial gate point(found by the program) to an earlier splice point, in milliseconds” },
}

dsp[“Envel Tremolo - Tremolo a sound linearly between frequencies”] = {
cmds = { exe = “envel”, mode = “tremolo 1”, tip = “Tremolo is a pulsation in the amplitude of a sound. The frequency of the tremolo is the rate of the amplitude pulsation. (‘Vibrato’ is a frequency displacement.) This technique is familiar to us as a feature of various singing styles, and also as a control available on synthesisers. It can be used to enliven or enrich a sound, or to create more marked flutter effects, such as the ‘flutter-tongue’ technique on a wind instrument” },
arg1 = { name = “freq”, min = 0, max = 500, tip = “frequency of the tremolo (a low frequency oscillation: Range: 0 to 500)” },
arg2 = { name = “depth”, min = 0,0, max = 1,0, tip = “frequency displacement of the oscillation (Range: 0 to 1; the Default is 0.250)” },
arg3 = { name = “gain”, min = 0, max = 1, tip = “the overall signal gain, or envelope (Range 0 to 1; the Default is 1)” },
}

dsp[“Envel Tremolo - Tremolo a sound logarithmically”] = {
cmds = { exe = “envel”, mode = “tremolo 2”, tip = “Tremolo is a pulsation in the amplitude of a sound. The frequency of the tremolo is the rate of the amplitude pulsation. (‘Vibrato’ is a frequency displacement.) This technique is familiar to us as a feature of various singing styles, and also as a control available on synthesisers. It can be used to enliven or enrich a sound, or to create more marked flutter effects, such as the ‘flutter-tongue’ technique on a wind instrument” },
arg1 = { name = “freq”, min = 0, max = 500, tip = “frequency of the tremolo (a low frequency oscillation: Range: 0 to 500)” },
arg2 = { name = “depth”, min = 0,0, max = 1,0, tip = “frequency displacement of the oscillation (Range: 0 to 1; the Default is 0.250)” },
arg3 = { name = “gain”, min = 0, max = 1, tip = “the overall signal gain, or envelope (Range 0 to 1; the Default is 1)” },
}

dsp[“Tremolo Tremolo - Apply width-controlled tremolo to a soundfile linearly”] = {
cmds = { exe = “tremolo”, mode = “tremolo 1”, tip = "This applies tremolo to a soundfile with the added ability to narrow (‘squeeze’) the width of the tremolo segments " },
arg1 = { name = “freq”, min = 0, max = 500, tip = “frequency of the tremolo (a low frequency oscillation: Range: 0 to 500)” },
arg2 = { name = “depth”, min = 0,0, max = 1,0, tip = “frequency displacement of the oscillation (Range: 0 to 1; the Default is 0.250)” },
arg3 = { name = “gain”, min = 0, max = 1, tip = “the overall signal gain, or envelope (Range 0 to 1; the Default is 1)” },
arg4 = { name = “fineness”, min = 1, max = 10, tip = “squeeze the width of the tremolo: an integer value >= 1” },
}

dsp[“Tremolo Tremolo - Apply width-controlled tremolo to a soundfile logaritmically”] = {
cmds = { exe = “tremolo”, mode = “tremolo 2”, tip = "This applies tremolo to a soundfile with the added ability to narrow (‘squeeze’) the width of the tremolo segments " },
arg1 = { name = “freq”, min = 0, max = 500, tip = “frequency of the tremolo (a low frequency oscillation: Range: 0 to 500)” },
arg2 = { name = “depth”, min = 0,0, max = 1,0, tip = “frequency displacement of the oscillation (Range: 0 to 1; the Default is 0.250)” },
arg3 = { name = “gain”, min = 0, max = 1, tip = “the overall signal gain, or envelope (Range 0 to 1; the Default is 1)” },
arg4 = { name = “fineness”, min = 1, max = 10, tip = “squeeze the width of the tremolo: an integer value >= 1” },
}


dsp["[doesn’t work yet] Reverb - Multi-Channel reverb “] = {
cmds = { exe = “reverb”, mode = “0”, tip = " REVERB implements the now classic Schroeder/Moorer model, consisting of six comb filters in parallel, followed by four allpass filters in series. The comb filters generate the dense reverberation, and the allpass filters (with much shorter delay times) apply further smearing of the echoes to minimize the spectral colouration of the comb filters. A further allpass is applied to each output channel, each with a different randomly-chosen delay time. Each comb filter contains a simple low-pass filter to simulate high-frequency absorption - this also affects the overall reverberation time. A preset set of early reflections as defined by Moorer is incorporated; this can be replaced by a user-defined set either hand-written or created using ROOMRESP. The delay times for the filters are preset to suit a ‘medium room’ model, as suggested by Moorer. In most situations the user will not want to change these; however the option is provided to change these times by means of a simple text file.” },
arg1 = { name = “N”, switch = “-c”, min = 0, max = 16, def = 2, tip = “create outfile with N channels (Range: 1 <= N < 16; Default = 2)” },
arg2 = { name = “N”, switch = “-H”, min = 0, max = 44100, tip = “Apply Highcut filter to infile with cutoff frequency NHz(6dB per octave)” },
arg3 = { name = “N”, switch = “-L”, min = 0, max = 44100, tip = “apply Lowcut filter to infile with cutoff frequency NHz (12dB per octave)” },
arg4 = { name = “N”, switch = “-p”, min = 0, max = 1000, tip = “set reverb predelay to N msecs (shifts early reflections)” },
arg5 = { name = “egain”, min = 0,0, max = 1,0, tip = “set level of early reflections (Range: 0.0 to 1.0)” },
arg6 = { name = “mix”, mix = 0,0, max = 1,0, tip = “balance of direct and reverb signal (Range: 1.0 [weighted towards direct signal] to 0.0 [weighted towards reverb signal])” },
arg7 = { name = “rvbtime”, min = 0, max = 20, tip = “reverb decay time (to -60dB) in seconds” },
arg8 = { name = “absorb”, min = 0,0, max = 1,0, tip = “degree of hf damping to suggest roomsize (Range: 0.0 to 1.0)” },
arg9 = { name = “lpfreq”, min = 0, max = 22050, tip = “lowpass filter cutoff frequency in Hz applied at input to reverb” },
arg10 = { name = “trailertime”, min = 0, max = 20, tip = “time in seconds added to outfile for reverb tail” },
}

dsp["[doesn’t work yet] Roomverb - Multi-channel reverb with room simulation "] = {
cmds = { exe = “roomverb”, mode = “”, tip = “Although many of the parameters are the same as those for REVERB (q.v), the program operates very differently. Rather than use comb filters in parallel, ROOMVERB uses a variable network of ‘nested’ allpass filters inside an overall feedback loop. This has the effect of increasing the density of the reverberation over time, as is characteristic of most ‘real’ acoustic spaces. It is therefore dedicated more specifically to that task than is REVERB. Nevertheless, as the roomsize and feedback parameters are independently controllable, some unusal effects can still be created. For authentic reverb, it is important that the feedback level is not set too high, otherwise audible pulsations can be heard at the start of the reverberation. These can be mitigated to a degree by running REVERB several times in parallel, with slightly different reverb times, and mixing the results, or combining into a multi-channel file. Conversely, it is also possible to create an ‘infinite reverb’ effect by setting the feedback level to 1.0.The preset early reflections for a given room size are the same as those in REVERB.” },
arg1 = { name = “predelay”, switch = “-p”, min = 0, max = 5000, tip = “override early reflections delay in milliseconds” },
arg2 = { name = “N”, switch = “-c”, min = 0, max = 16, def = 2, tip = “create outfile with N channels (Range: 1 <= N < 16; Default = 2)” },
arg3 = { name = “N”, switch = “-H”, min = 0, max = 22050, tip = “Apply Highcut filter to infile with cutoff frequency NHz(6dB per octave)” },
arg4 = { name = “N”, switch = “-L”, min = 0, max = 22050, tip = “apply Lowcut filter to infile with cutoff frequency NHz (12dB per octave)” },
arg5 = { name = “rmsize”, min = 1, max = 3, tip = “1 (small), 2 (medium), or 3 (large)” },
arg5 = { name = “egain”, min = 0,0, max = 1,0, tip = “set level of early reflections (Range: 0.0 to 1.0)” },
arg6 = { name = “mix”, mix = 0,0, max = 1,0, tip = “balance of direct and reverb signal (Range: 1.0 [weighted towards direct signal] to 0.0 [weighted towards reverb signal])” },
arg7 = { name = “fback”, min = 0, max = 1, tip = “reverb feedback level: controls decaytime (Range: 0.0 to 1.0)” },
arg8 = { name = “absorb”, min = 0,0, max = 1,0, tip = “degree of hf damping to suggest roomsize (Range: 0.0 to 1.0)” },
arg9 = { name = “lpfreq”, min = 0, max = 22050, tip = “lowpass filter cutoff frequency in Hz applied at input to reverb” },
arg10 = { name = “trailertime”, min = 0, max = 20, tip = “time in seconds added to outfile for reverb tail” },
}

dsp["[doesn’t work yet] Tapdelay - stereo multi-echo generator with feedback"] = {
cmds = { exe = “tapdelay”, mode = “”, tip = "The principle behind a tapped delay line is that whereas in a standard delay line (e.g., 1 second long) the ouput is taken at the end, in a tapped delay line extra outputs are also taken at intermediate points, such as 0.1 secs, 0.3 secs and 0.75 secs. "
},
arg1 = { name = “tapgain”, min = 0.0001, max = 1,0, tip = “gain factor applied to output from delay line (Range: > 0.0; typical value: 0.25)” },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “feedback”, min = -1,0, max = 1,0, tip = “delayed signal fed back into the input (Range: -1.0 to 1.0)” },
arg4 = { name = “mix”, min = 0,0, max = 1,0, tip = “proportion of source mixed with delay output (Range: 0.0 to < 1.0)” },
arg5 = { name = “trailtime”, min = 0, max = 10, tip = “extra time in seconds (beyond infile duration) for delays to play out” },
}

dsp["[doesn’t work?] Cantor - Cut holes in a sound in the manner of a cantor set (holes within holes within holes (hole-size = %))"] = {
cmds = { exe = “cantor”, mode = “set 1”, tip = “CANTOR gradually cuts a hole in the central third of the input sound, which must be mono, a ‘hole’ being a reduction in level (see SNDREPORT FINDHOLE). It then cuts holes in the central third of the remaining segments, and so on. The output soundfile consists of a sequence of sounds with more and more holes cut in it. Note that Mode 3 uses superimposed vibrato envelopes as well. " },
arg1 = { name = “holesize”, min = 0.0001, max = 100, tip = " the percentage of current segment-time taken up by a hole.” },
arg2 = { name = “holedig”, min = 0, max = 1, tip = “the depth of each cut as the hole is gradually created. Range: >0 to 1” },
arg3 = { name = “depth-trig”, min = 0, max = 1, tip = " the level depth of the hole triggering the next hole-cuttin" },
arg4 = { name = “splicelen”, min = 0, max = 1000, tip = “splicelength in milliseconds” },
arg5 = { name = “maxdur”, min = 0, max = 20, tip = “the maximum output duration of all the output sound” },
arg6 = { name = “-e”, switch = “-e”, tip = “extend the sound beyond the splicelen limits” },
}

dsp["[doesn’t work?] Cantor - Cut holes in a sound in the manner of a cantor set (holes within holes within holes (hole-size = fixed))"] = {
cmds = { exe = “cantor”, mode = “set 2”, tip = “CANTOR gradually cuts a hole in the central third of the input sound, which must be mono, a ‘hole’ being a reduction in level (see SNDREPORT FINDHOLE). It then cuts holes in the central third of the remaining segments, and so on. The output soundfile consists of a sequence of sounds with more and more holes cut in it. Note that Mode 3 uses superimposed vibrato envelopes as well. " },
arg1 = { name = “holesize”, min = 0.0001, max = 10, tip = " the (fixed) duration of the holes.” },
arg2 = { name = “holedig”, min = 0, max = 1, tip = “the depth of each cut as the hole is gradually created. Range: >0 to 1” },
arg3 = { name = “depth-trig”, min = 0, max = 1, tip = " the level depth of the hole triggering the next hole-cuttin" },
arg4 = { name = “splicelen”, min = 0, max = 1000, tip = “splicelength in milliseconds” },
arg5 = { name = “maxdur”, min = 0, max = 20, tip = “the maximum output duration of all the output sound” },
arg6 = { name = “-e”, switch = “-e”, tip = “extend the sound beyond the splicelen limits” },
}

dsp["[doesn’t work?] Cantor - Cut holes in a sound in the manner of a cantor set (holes within holes within holes (hole-size = vibrato))"] = {
cmds = { exe = “cantor”, mode = “set 3”, tip = “CANTOR gradually cuts a hole in the central third of the input sound, which must be mono, a ‘hole’ being a reduction in level (see SNDREPORT FINDHOLE). It then cuts holes in the central third of the remaining segments, and so on. The output soundfile consists of a sequence of sounds with more and more holes cut in it. Note that Mode 3 uses superimposed vibrato envelopes as well. " },
arg1 = { name = “holelev”, min = 0.0001, max = 1, tip = “the level of signal at the base of the holes” },
arg2 = { name = “holedig”, min = 0, max = 1, tip = “the depth of each cut as the hole is gradually created. Range: >0 to 1” },
arg3 = { name = “layercnt”, min = 0, max = 500, tip = “the number of vibrato layers used” },
arg4 = { name = “layerdec”, min = 0, max = 100, tip = " the depth of the next vibrato in relation to the previous one” },
arg5 = { name = “maxdur”, min = 0, max = 20, tip = “the maximum output duration of all the output sound” },
}

dsp["Constrict - Shorten the durations of any zero-level sections in a sound "] = {
cmds = { exe = “constrict”, mode = “constrict”, tip = “This is a form of time-contraction which does not time-stretch the sonic-substance of the source. Note that the constriction is a percentage. Thus: 50 will halve the silent gaps, 75 will take away three quarters of the silent gaps, 20 will reduce them to one-fifth their original length, 100 will eliminate the silences, 150 will cause the non-silent portions to overlap by half the duration of the original silences. It works only with soundfiles which contain areas of zero-level signal which can be contracted by the process.CONSTRICT can be used to take a sequence of rapidfile events separated by silences and make them even tighter.” },
arg1 = { name = “constriction”, min = 0, max = 200, tip = “percentage deletion of zero-level areas.” },
}

dsp[“Sfedit - Cut and keep a segment of a sound (Time in seconds)”] = {
cmds = { exe = “sfedit”, mode = “cut 1”, tip = “The start and end locations for a block of sound are specified, and that block is saved as a new soundfile. A long splice will give a smooth cutoff, a short splice an abrupt cutoff, and a zerio splice will usually produce a click. The splice window is applied to both the beginning and the end of the sound, so cannot be larger than half the length of the block. This function presumes the use of a graphic sound editor in order precisely to locate the places at which to begin end the block to be cut. Musical Applications; simply save a favoured portion of a soundfile, select a short, timbrally evolving, section of a soundfile and time-stretch it, cut part of the result and time-stretch again, etc. process a portion of a sound, and then reinsert it into the original. For example, isolate key portions of two sounds and pre-process each of them in preparation for a morph-transition; then reinsert them into their respective original soundfiles and do the morph, collect segments of various soundfiles in preparation for making a musical collage” },
arg1 = { name = “start”, min = 0, max = 20, tip = “time in infile where segment to keep begins” },
arg2 = { name = “end”, min = 0, max = 40, tip = “time in infile where segment to keep ends” },
arg3 = { name = “splice”, switch = “-w”, min = 0, max = 1000, tip = "splice window in milliseconds (Default: 15ms) " },
}

dsp[“Sfedit - Cut and keep the end portion of a sound (Time in seconds)”] = {
cmds = { exe = “sfedit”, mode = “cutend 1”, tip = “This function enables you to use a specified length of the last section of a sound without having to work out where that length begins. You just specify the length you want. Needless to say, it has to be shorter than the whole soundfile. Musical Applications; The way a sound ends varies a great deal and often has extra attributes, such as resonance, reverb or echoes. This material can therefore be useful in itself. For example, a piano tone starts percussively and ends gradually if left to ring on. When reversed, the sound swells, sounding very much like an organ. SFEDIT CUTEND can quickly cut the end portion, starting automatically after the beginning. Given a generous splice envelope and reversed with MODIFY RADICAL Mode 1, it can become quite a different sound altogether.” },
arg1 = { name = “length”, min = 0, max = 100, tip = “length of sound to keep, ending at the end of infile” },
arg2 = { name = “splice”, switch = “-w”, min = 0, max = 1000, tip = "splice window in milliseconds (Default: 15ms) " },
}

dsp[“Sfedit - Remove a segment from a soundfile and close up the gap”] = {
cmds = { exe = “sfedit”, mode = “excise 1”, tip = “Here the block start and end points mark a block to be removed. The size of the splice determines the smoothness (long splice) or abruptness (short splice) of the cuts. A zero splice usually creates a click at the splice point, except in the special case where the signal is zero. The splice ‘window’ enables the use to reshape the amplitude envelope at the point where the cuts are made. Musical Applications; A frequent use of this program will be to remove silence, glitches, or otherwise unwanted material from a sound. It could also be used to chop up a sound in a rough sort of way in order to create unexpected juxtapositions of material, e.g., words.” },
arg1 = { name = “start”, min = 0, max = 20, tip = “time in infile where segment to remove begins” },
arg2 = { name = “end”, min = 0, max = 40, tip = “time in infile where segment to remove ends” },
arg3 = { name = “splice”, switch = “-w”, min = 0, max = 1000, tip = "splice window in milliseconds (Default: 15ms) " },
}

dsp[“Sfedit - Insert silence into a sound (overwriting or spreading the sound apart)”] = {
cmds = { exe = “sfedit”, mode = “insil 1”, tip = “This process will create a gap in the infile at a specified point in time, either pushing apart or overwriting the original sound for the duration of the silence. Musical Applications; This can be used at the beginning of a sound to ‘hard-wire’ a gap into a mix. Another application would be to spread the timing of two events in a sound by a specified amount.” },
arg1 = { name = “time”, min = 0, max = 20, tip = “time in seconds in infile at which the silence is to begin” },
arg2 = { name = “duration”, min = 0, max = 40, tip = “length of silence in seconds” },
arg3 = { name = “splice”, switch = “-w”, min = 0, max = 1000, tip = "splice window in milliseconds (Default: 15ms) " },
arg4 = { name = “-o”, switch = “-o”, tip = “overwrite the original file with the inserted file (Default: the silence pushes the infile apart)” },
arg5 = { name = “-s”, switch = “-s”, tip = "retains any silence written over file end (Default: rejects silence added at file end) "},
}

dsp["[doesn’t work yet] Isolate Disjunct portions of soundfile are specified by dB loudness and saved to separate files"] = {
cmds = { exe = “isolate”, mode = “isolate 3”, tip = “ISOLATE is similar to PARTITION in that the primary operation is to cut a soundfile into disjunct pieces and assign these to different output soundfiles. It does this in a special way so that the time-position of these pieces in the original soundfile is retained: silence is inserted between the cut pieces in the outputs to achieve this (‘silent surrounds’). The result is that the disjunct pieces can be reassembled in their original positions (remixed with everything synchronised at time zero): One difference between ISOLATE and PARTITION is that the number of output files is user-defined in PARTITION and worked out by the program, depending on the Mode selected, in ISOLATE. Another different is that Modes 1, 2 and 3 of ISOLATE generate a file containing all the materials left over after cutting. This is also used in reconstructing the original (now-treated) soundfile. However, the main difference between ISOLATE and PARTITION is how the disjunct pieces are identified. In PARTITION there are automatic processes for this, but the number of output files is user-defined by the outcnt parameter, and the durations are controlled by the groupcnt or dur parameters. In ISOLATE the user specifies start end times for the pieces in a textfile: the cutsfile (Modes 1-2) or specifies a list of (increasing) times in splicefile Modes 4-5, or they are picked up by level thresholds (dBon and dBoff (Mode 3). You are advised to familiarise yourself with the way the different Modes create different numbers of output soundfiles containing different numbers of segments.” },
arg1 = { name = “outnam”, min = 0, max = 10, def = 0, tip = “generic root name for the output soundfiles. Numerals starting at 0 are appended to distinguish the outputs.” },
arg2 = { name = “dBon”, min = 0, max = 140, tip = “the dB level at which a segment is recognised” },
arg3 = { name = “dBoff”, min = 0, max = 140, tip = “the dB level at which a recognised segment is triggered to end” },
arg4 = { name = “splice”, switch = “-s”, min = 0, max = 500, tip = " the length of the splice in milliseconds (Range: 0 to 500. Default: 15)" },
arg5 = { name = “min”, switch = “-m”, min = 2, max = 1000, tip = “the minimum duration in milliseconds of segments to accept (Range: > 2 * splice)”},
}

dsp["[doesn’t work?] Sfedit - Noisecut, suppress noise in a (mono) sound file, replacing with silence"] = {
cmds = { exe = “sfedit”, mode = “noisecut”, tip = “This process was developed after many attempts to automatically separate the noise constituents (sibilants etc.) from speech whilst trying to track the pitch of the other material. It uses a filter to recognise the presence of sibilants in the speech and allows vowels (and strongly pitched iteratives) to be separated – in place (i.e., remaining at their original time) – from the speech stream. Alternatively, the sibilants (i.e., noise) can be similarly extracted, in place. This is the -n option. Musical applications; One way to apply this function is to use it to treat the pitched and unpitched components in a stream of events in different ways. You could first separate the pitched and noise elements (using this program in its two different senses). Then you might add tremolo to the pitched elements and after this reintroduce the unmodified noise elements by mixing them with the undulating tones.” },
arg1 = { name = “splicelen”, min = 0, max = 1000, tip = “duration of splice slopes, in milliseconds” },
arg2 = { name = “noisfrq”, min = 0, max = 22050, tip = “frequency above which the signal is regarded as noise (try 6000 Hz)” },
arg3 = { name = “maxnoise”, min = 1000, max = 22050, tip = “the maximum duration in milliseconds of any noise segments permitted to remain, i.e., NOT replaced. Range: 1000 to 22050ms” },
arg4 = { name = “mintone”, min = 0, max = 50, tip = “the minimum duration in milliseconds of any non-noise segments to be retained. Range: 0 to 50ms” },
arg5 = { name = “-n”, switch = “-n”, tip = "option to retain noise rather than non-noise "},
}

dsp[“Prefix Silence - Add silence to the beginning of a soundfile”] = {
cmds = { exe = “prefix”, mode = “silence”, tip = “PREFIX SILENCE simply places the specified duration of silence at the beginning of the infile. Musical Applications; This can be a straightforward way to create a gap between soundfiles, or time an entry. The utility might come in handy when running batch files” },
arg1 = { name = “dur”, min = 0, max = 10, tip = “duration of silence to add” },
}

dsp["[doesn’t work?] Sfedit - Randchunks, cut chunks from a soundfile, randomly "] = {
cmds = { exe = “sfedit”, mode = “randchunks”, tip = “SFEDIT RANDCHUNKS is like SFEDIT RANDCUTS but enables you to be more specific about the number of chunks (chunkcnt) and their length (minchunk and the optional maxchunk). Each chunk is saved as a new soundfile, with a name derived from the name of the infile. Musical applications; The number and length controls make it possible to make a controlled number of chunks of random length within a specified range. The ability to focus on the start of the soundfile enables you to explore the qualities of the attack portion of the sound.” },
arg1 = { name = “chunkcnt”, min = 0, max = 100, tip = “the number of chunks to cut” },
arg2 = { name = “minchunk”, min = 0, max = 10, tip = “the minimum length of the chunks, in seconds” },
arg3 = { name = “maxchunk”, switch = “-m”, min = 0, max = 5, tip = “the maximum lengths of the chunks, in seconds” },
arg4 = { name = “-l”, switch = “-l”, tip = “chunks chosen are evenly distributed over the file (Default: random distribution)” },
arg5 = { name = “-s”, switch = “-s”, tip = "all chunks start at the beginning of the file " },
}

dsp["[doesn’t work?] Sfedit - Randcuts - Cut soundfile into pieces with cuts at random times"] = {
cmds = { exe = “sfedit”, mode = “randcuts”, tip = “SFEDIT RANDCUTS provides a way to cut up a soundfile into several portions of a specified average length, saving each as a separate soundfile. The amount of difference in the lengths can be adjusted with the scattering parameter: the regularity of the lengths gets less and less as scatter increases. Musical applications; This could be a way of multiplying source material when a given soundfile has sufficient variation in its contents to justify the procedure.” },
arg1 = { name = “average-chunklen”, min = 0, max = 100, tip = “the average length of the chunks to cut” },
arg2 = { name = “scattering”, min = 0, max = 8, tip = “controls the amount of variation in the length of the cuts (Range: 0 to 8)” },
}

dsp["[doesn’t work?] Sfedit - Shrink from end - Repeat a sound, shortening it on each repetition"] = {
cmds = { exe = “shrink”, mode = “shrink 1”, tip = “With SHRINK a sound is repeated, and at each repetition it gets shorter in duration because some of it is removed.” },
arg1 = { name = “shrinkage”, min = 0,0, max = 10, tip = “shortening factor of sound from one repeat to the next. Shrinkage stops once envents become too short short splices.” },
arg2 = { name = “gap”, min = 0, max = 50, tip = “initial timestep between output events” },
arg3 = { name = “contract”, min = 0, max = 1, tip = “shortening of gaps between output events: 1.0 = events are equally spaced, < 1.0 = events become closer together.” },
arg4 = { name = “dur”, min = 0, max = 20, tip = “the (minimum) duration of the output” },
arg5 = { name = “spl”, min = 0, max = 1000, tip = “splice length in milliseconds” },
arg6 = { name = “small”, switch = “-s”, min = 0, max = 10, tip = “the minimum sound length, after which sounds are of equal length” },
arg7 = { name = “min”, switch = “-m”, min = 0, max = 10, tip = “the minimum event separation, after which events are regular in time” },
arg8 = { name = “rnd”, switch = “-r”, min = 0, max = 10, tip = “randomisation of timings after which events are regular in time” },
arg9 = { name = “-n”, switch = “-n”, tip = “equalise the maximum level of output events (if possible)” },
arg10 = { name = “i”, switch = “-i”, tip = “Inverse: reverse each segment in the output.” },
}

dsp["[doesn’t work?] Sfedit - Shrink around midpoint - Repeat a sound, shortening it on each repetition"] = {
cmds = { exe = “shrink”, mode = “shrink 2”, tip = “With SHRINK a sound is repeated, and at each repetition it gets shorter in duration because some of it is removed.” },
arg1 = { name = “shrinkage”, min = 0,0, max = 10, tip = “shortening factor of sound from one repeat to the next. Shrinkage stops once envents become too short short splices.” },
arg2 = { name = “gap”, min = 0, max = 50, tip = “initial timestep between output events” },
arg3 = { name = “contract”, min = 0, max = 1, tip = “shortening of gaps between output events: 1.0 = events are equally spaced, < 1.0 = events become closer together.” },
arg4 = { name = “dur”, min = 0, max = 20, tip = “the (minimum) duration of the output” },
arg5 = { name = “spl”, min = 0, max = 1000, tip = “splice length in milliseconds” },
arg6 = { name = “small”, switch = “-s”, min = 0, max = 10, tip = “the minimum sound length, after which sounds are of equal length” },
arg7 = { name = “min”, switch = “-m”, min = 0, max = 10, tip = “the minimum event separation, after which events are regular in time” },
arg8 = { name = “rnd”, switch = “-r”, min = 0, max = 10, tip = “randomisation of timings after which events are regular in time” },
arg9 = { name = “-n”, switch = “-n”, tip = “equalise the maximum level of output events (if possible)” },
arg10 = { name = “i”, switch = “-i”, tip = “Inverse: reverse each segment in the output.” },
}

dsp["[doesn’t work?] Sfedit - Shrink from start - Repeat a sound, shortening it on each repetition"] = {
cmds = { exe = “shrink”, mode = “shrink 3”, tip = “With SHRINK a sound is repeated, and at each repetition it gets shorter in duration because some of it is removed.” },
arg1 = { name = “shrinkage”, min = 0,0, max = 10, tip = “shortening factor of sound from one repeat to the next. Shrinkage stops once envents become too short short splices.” },
arg2 = { name = “gap”, min = 0, max = 50, tip = “initial timestep between output events” },
arg3 = { name = “contract”, min = 0, max = 1, tip = “shortening of gaps between output events: 1.0 = events are equally spaced, < 1.0 = events become closer together.” },
arg4 = { name = “dur”, min = 0, max = 20, tip = “the (minimum) duration of the output” },
arg5 = { name = “spl”, min = 0, max = 1000, tip = “splice length in milliseconds” },
arg6 = { name = “small”, switch = “-s”, min = 0, max = 10, tip = “the minimum sound length, after which sounds are of equal length” },
arg7 = { name = “min”, switch = “-m”, min = 0, max = 10, tip = “the minimum event separation, after which events are regular in time” },
arg8 = { name = “rnd”, switch = “-r”, min = 0, max = 10, tip = “randomisation of timings after which events are regular in time” },
arg9 = { name = “-n”, switch = “-n”, tip = “equalise the maximum level of output events (if possible)” },
arg10 = { name = “i”, switch = “-i”, tip = “Inverse: reverse each segment in the output.” },
}

dsp["[doesn’t work?] Sfedit - Shrink from specified time - Repeat a sound, shortening it on each repetition"] = {
cmds = { exe = “shrink”, mode = “shrink 4”, tip = “With SHRINK a sound is repeated, and at each repetition it gets shorter in duration because some of it is removed.” },
arg1 = { name = “time”, min = 0, max = 10, tip = “time around which shrinkage takes place” },
arg2 = { name = “shrinkage”, min = 0,0, max = 10, tip = “shortening factor of sound from one repeat to the next. Shrinkage stops once envents become too short short splices.” },
arg3 = { name = “gap”, min = 0, max = 50, tip = “initial timestep between output events” },
arg4 = { name = “contract”, min = 0, max = 1, tip = “shortening of gaps between output events: 1.0 = events are equally spaced, < 1.0 = events become closer together.” },
arg5 = { name = “dur”, min = 0, max = 20, tip = “the (minimum) duration of the output” },
arg6 = { name = “spl”, min = 0, max = 1000, tip = “splice length in milliseconds” },
arg7 = { name = “small”, switch = “-s”, min = 0, max = 10, tip = “the minimum sound length, after which sounds are of equal length” },
arg8 = { name = “min”, switch = “-m”, min = 0, max = 10, tip = “the minimum event separation, after which events are regular in time” },
arg9 = { name = “rnd”, switch = “-r”, min = 0, max = 10, tip = “randomisation of timings after which events are regular in time” },
arg10 = { name = “-n”, switch = “-n”, tip = “equalise the maximum level of output events (if possible)” },
arg11 = { name = “i”, switch = “-i”, tip = “Inverse: reverse each segment in the output.” },
}

  
Notice a bunch of non-working presets in the bottom of the list, not sure if I haven't found the right settings for these particular processes yet, or am sending the arguments wrong values, not sure why nothing is returned as output?

Cool, added these to latest update, also optimised the cycles() function so it should work faster, try it out and let me know if its any better than the last one, however we will have to live with this for large samples until I figure out how to use the CDP function.

I’ll look at these later this evening, sooo many functions now, its great, thanks

would it work with linux?? :panic: great works :drummer:

Guys you rock :yeah:/>
Gonna test definitions to reveal some range bugs etc
Thanks!

Haven’t used the new cycles with all possibilities yet + am a n00b how to actually use it :-), will see.

Won’t be hard to find them as with a lot of parameters it has been trial and error, using common sense, guess work, just putting a value there as the docs aren’t consistent revealing the actual ranges! For example sometimes a time range is in seconds, sometimes ms, sometimes samples et cetera. I also made a few definitions, that didn’t do anything, than I find out the .exe isn’t present in the progs folder *facepalm*, or .exe’s are named slightly different than how they are described in the docs (roomverb.exe vs rmverb.exe).

It can also look that a process doesn’t work, but this is because certain ranges relate, can’t be bigger or smaller than other ranges, have to be set smaller than actual sound-length et cetera.

Any ways feel free to go through the docs file:///C:/cdpr7/docs/html/ccdpndex.htm and cross-check the definitions if you come across funny stuff.

edit;

new definitions;

[details=“Click to view contents”] ```
–[[
Instructions for definitions

You do not need to specify the infile or outfile these are handled by the tool.

Name the preset within the square brackets and in quotation marks after dsp[] e.g. dsp[“Preset name”]
The name can be anything but try and keep it the same or similar to the CDP reference documentation.

cmds

exe - The name of the CDP executable (exclude the .exe extension)
mode - The first part of the command argument that comes after the exe and before infile, outfile

arg1 to arg…n

name - The name displayed in the GUI (STRING)
switch - The switch flag, use only if it is a command switch e.g “-s” (STRING)
min - The minimum value of the range (NUMBER)
max - The maximum value of the range (NUMBER)
def - The default value the preset loads with (OPTIONAL NUMBER)
tip - The tool tip for the GUI control (OPTIONAL STRING)

Additional functions are available that give info about the sample

srate() - Gives the sample rate
cycles() - Gives the number of wavecycles (same as number of zero crossings/2)

–]]

dsp = {} – Do not edit this


– PRESET DEFINITIONS - afta8 –

dsp[“Filter Bank 1 - Harmonic”] = {
cmds = { exe = “filter”, mode = “bank 1”, tip = “The harmonic series is formed by multiplying a given frequency by an ascending series of integers: 1, 2, 3, 4, etc. The harmonic relationships produced are sonorous, but depart from the structure of triadic chords higher in the series. This Mode builds this type of harmonic relationship onto lofrq, which may be the actual pitch of a pitched tone or any arbitrary pitch. Because this is being done with a filter process, other sonic material is cleaned away, so a cleaner (and possibly quieter) sound may result, with more complex noise elements removed. Quite a bit of gain may be required – values of 40 or 50+ in this situation will not be unusual. Set hifrq as high as possible less too few harmonics are produced. This clean sound may provide a good input for spectral time-stretching, for example, to achieve a well-tuned sound with a minimum of artefacts.” },
arg1 = { name = “Q”, min = 0.001, max = 10000, tip = “Sets the Q of the effect” },
arg2 = { name = “Gain”, min = 0.001, max = 10000, def = 25 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Scatter”, switch = “-s”, min = 0, max = 1, tip = “Random scatter of frequencies” },
arg6 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 2 - Alt Harmonic”] = {
cmds = { exe = “filter”, mode = “bank 2”, tip = “This will be like Mode 1 but with every other harmonic omitted: the odd numbered partials are retained. The resulting sound will probably sound more ‘hollow’.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg6 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 3 - Sub Harmonic”] = {
cmds = { exe = “filter”, mode = “bank 3”, tip = “The ‘subharmonic series’ is the intervallic inverse of the harmonic series. Thus the departure from triadic-type intervals increases as the series descends. The resulting sound has a deeper tone and is somewhat hollow and somewhat inharmonic.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg6 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 4 - Harmonic Linear”] = {
cmds = { exe = “filter”, mode = “bank 4”, tip = “The offset in Hz is added to each harmonic. This will displace them so that they will no longer be exact multiples of the fundamental. This means that the cycles of the waveforms no longer line up at nodes, which introduces an ‘inharmonic’ dimension into the sound, heard as an increase in timbral components.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Offset (Hz)”, min = 10, max = srate()/3 },
arg6 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg7 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 5 - Filter Intervals”] = {
cmds = { exe = “filter”, mode = “bank 5”, tip = “Here we depart from the harmonic series and simply divide up the specified frequency range into an equal number filters: how many is specified by the user with param. The first effect this equal spacing will have is to create inharmonic (rather than integer multiple) relationships between the partials. A low number of filters will produce an ‘open’ sound, and a high number of filters will produce a denser, richer sound. These might be very interesting sounds to timestretch.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “No. Filters”, min = 1, max = 100 },
arg6 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg7 = { name = “Double”, switch = “-d” }
}

dsp[“Filter Bank 6 - Semitone Intervals”] = {
cmds = { exe = “filter”, mode = “bank 6”, tip = “By specifying the interval (in semitones), we in effect repeat these intervals within the frequency space between lofrq and hifrq, thus producing complex chords composed of the same interval ‘piled up’. This is a quick way to ‘harmonise’ a sound, with the resulting density dependent on the size of the interval. It is well worth re-running this function, entering intervals from 1 to 7, for example, to hear what kind of transformations will be produced. Some unexpected resonances may result; they could be filtered out later.” },
arg1 = { name = “Q”, min = 0.001, max = 10000 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/3 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/3 },
arg5 = { name = “Semitones”, min = 1, max = 12 },
arg6 = { name = “Scatter”, switch = “-s”, min = 0, max = 1 },
arg7 = { name = “Double”, switch = “-d” }
}


dsp[“Filter Phasing 1 - Allpass Filter”] = {
cmds = { exe = “filter”, mode = “phasing 1” },
arg1 = { name = “Gain”, min = -1, max = 1 },
arg2 = { name = “Delay”, min = 0.045, max = 1644.35 },
arg3 = { name = “PreScale”, switch = “-s”, min = 0, max = 1 },
arg4 = { name = “Linear”, switch = “-l” }
}

dsp[“Filter Phasing 2 - Phasing Effect”] = {
cmds = { exe = “filter”, mode = “phasing 1”, tip = “The ‘phasing effect’ is a kind of sweeping band passing through the sound, such as is sometimes heard when aeroplanes fly overhead, and is much used in popular music.Increasing the gain factor has some effect on the reverberant quality of the sound. So does increasing the delay time. The sound will still sound quite dry with delay < 20 (ms). Between about 20 and 45 ms there is a touch of resonance in the sound. Around 50 ms there is significant echoey reverberation (though somewhat granulated), and after 100 ms we start to hear larger portions of the sound repeating.Overall, the degree of reverberant effect is controlled by increasing both the gain and delay parameters in tandem” },
arg1 = { name = “Gain”, min = -1, max = 1 },
arg2 = { name = “Delay”, min = 0.045, max = 1644.35 },
arg3 = { name = “PreScale”, switch = “-s”, min = 0, max = 1 },
arg4 = { name = “Linear”, switch = “-l” }
}

dsp[“Filter Phasing 2 - Phasing Effect”] = {
cmds = { exe = “filter”, mode = “phasing 1”, tip = “The ‘phasing effect’ is a kind of sweeping band passing through the sound, such as is sometimes heard when aeroplanes fly overhead, and is much used in popular music.Increasing the gain factor has some effect on the reverberant quality of the sound. So does increasing the delay time. The sound will still sound quite dry with delay < 20 (ms). Between about 20 and 45 ms there is a touch of resonance in the sound. Around 50 ms there is significant echoey reverberation (though somewhat granulated), and after 100 ms we start to hear larger portions of the sound repeating.Overall, the degree of reverberant effect is controlled by increasing both the gain and delay parameters in tandem” },
arg1 = { name = “Gain”, min = -1, max = 1 },
arg2 = { name = “Delay”, min = 0.045, max = 1644.35 },
arg3 = { name = “PreScale”, switch = “-s”, min = 0, max = 1 },
arg4 = { name = “Linear”, switch = “-l” }
}


dsp[“Filter Sweeping 1 - High Pass”] = {
cmds = { exe = “filter”, mode = “sweeping 1”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.”
},
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}

dsp[“Filter Sweeping 2 - Low Pass”] = {
cmds = { exe = “filter”, mode = “sweeping 2”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.” },
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}

dsp[“Filter Sweeping 3 - Band Pass”] = {
cmds = { exe = “filter”, mode = “sweeping 3”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.” },
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}

dsp[“Filter Sweeping 4 - Notch”] = {
cmds = { exe = “filter”, mode = “sweeping 4”, tip = “This filter is most effective in Band-pass or Low-pass mode, with low acuity. It is difficult to get a result in High-pass mode. A tight filter makes the sweep more audible, but too tight and it may appear as a thin sine wave (resonance) which doesn’t really connect with the sound.A fairly long soundfile and a fairly broad range of frequencies gives this function something to work with. Watch for overflows and reduce the gain as necessary.” },
arg1 = { name = “Acuity”, min = 0.0001, max = 1 },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “LoFrq”, min = 10, max = srate()/2 },
arg4 = { name = “HiFrq”, min = 10, max = srate()/2 },
arg5 = { name = “SweepFrq”, min = 0, max = 200 },
arg6 = { name = “Phase”, switch = “-p”, min = 0, max = 1 },
}


– Djeroek –

dsp[“Distort Average - average the waveshape over N wavecycles”] = {
cmds = { exe = “distort”, mode = “average”, tip = “DISTORT AVERAGE performs a mathematical averaging of the data in cyclecnt pseudo-wavecycles. The effect is more akin to a loss of resolution than the blurring which might be expected. Values below 10 retain some semblance of the original, while values of, for example, 100 seem to create a kind of ‘sample hold’ effect. For modest distortion, values 5 or less are recommended.” },
arg1 = { name = “cyclecnt”, min = 1, max = 6000, tip = “number of cycles over which to average (Range: > 1)” },
arg2 = { name = “maxwavelen”, switch = “-m”, min = 0, max = 1, tip = “maximum permissible wavelength in seconds (Default: 0.50)” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 1000, tip = “(integer) number of wavecycles to skip at start of file” },
}

dsp[“Distort Divide - Distortion by dividing wavecycle frequency”] = {
cmds = { exe = “distort”, mode = “divide”, tip = “Without altering duration, this process effectively lowers the sound while adding a rough texture.This is a useful form of distortion because it roughens the sound without being too violent about it” },
arg1 = { name = “N”, min = 2, max = 16, tip = “divider (Range: integer only, 2 to 16)” },
arg2 = { name = “-i”, switch = “-i”, tip = “use waveform interpolation: slower but cleaner” },
}

dsp[“Distort Fractal - Superimpose miniature copies of source wavecycles onto themselves”] = {
cmds = { exe = “distort”, mode = “fractal”, tip = “Note the very wide range of scaling. Because it is a divisor, the larger the value of scale the shorter will be the miniature copies to be superimposed. These superimposed copies can be made to increase (be careful!) or decrease in amplitude with the loudness parameter. Using a value of 1.0 maintains the original amplitude of the infile, which will be heard as pretty much as the original, but with the superimpositions on top of it. Loudness is therefore a means of balancing the input and the processed sound components.This is a powerful and somewhat wild tool for producing distortion effects. The higher the value of scaling, the more the superimposed copies appear as a sheen of distortion above the original sound.” },
arg1 = { name = “scaling”, min = 2, max = srate()/2, tip = “(integer) division of scale of source wave (Range: 2 to sample_rate/2)” },
arg2 = { name = “loudness”, min = 0, max = 10, tip = “loudness of scaled component relative to source (Loudness of source is reckoned to be 1.0)” },
arg3 = { name = “pre_attenuation”, switch = “-p”, tip = “apply attenuation to infile before processing” },
}

dsp["Distort Interpolate - Time-stretch file by repeating wavecycles and interpolating between them "] = {
cmds = { exe = “distort”, mode = “interpolate”, tip = “With this process, the shape of a ‘wavecycle’ is transformed into that of the next over multiplier repetitions. Note that this is waveshape-based interpolation, not a spectral interpolation, and that the length of the ‘wavecycle’ is also transformed by the process. The effect of the transformation is drastic, leading to a strongly granular outfile. The length of the outfile increases in step with the value of multiplier, as does the apparent pitchiness.The interpolation process adds a modulatory quality to the output, so that the successive wavecycles gliss and bend as they flow into one another. Even so, as multiplier increases, the perception of separate ‘grains’, i.e., ‘wavecycles’ increases. A value of 32, for example, changes the sound to a strange stream of modulating tones.” },
arg1 = { name = “multiplier”, min = 0, max = 50, tip = “(integer) number of times each ‘wavecycle’ repeats” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 20, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Multiply - Distortion by multiplying wavecycle frequency”] = {
cmds = { exe = “distort”, mode = “multiply”, tip = “The duration of the sound is not changed, only the frequency of the ‘wavecycles’, with the result that the pitch rises.The distortion is relatively mild, in that the original sound remains recognisable. However, the surface is textured and the pitch rises with each increase in the value of N. DISTORT MULTIPLY can be used, for example, to create high, modulating, grainy vocal sounds.” },
arg1 = { name = “N”, min = 2, max = 16, tip = “multiplier (Range: 2 to 16, integer only)” },
arg2 = { name = “-s”, switch = “-s”, tip = “smoothing (try this if glitches appear)” },
}

dsp[“Distort Omit – Omit A out of every B wavecycles, replacing them with silence”] = {
cmds = { exe = “distort”, mode = “omit”, tip = “Because the omitted ‘wavecyles’ are replaced by silence, the overall duration of the sound does not change. The larger the proportion of ‘wavecycles’ omitted from B, of course, the more distorted the the sound becomes. This distortion is like a rough texturing, rather than the highly modulatory results of some of the other processes.This process can be used, therefore, to achieve a rough texturing with no loss of duration.” },
arg1 = { name = “A”, min = 0, max = 5000, tip = “number of wavecycles to omit” },
arg2 = { name = “B”, min = 0, max = 5000, tip = “size of group of ‘wavecycles’ out of which to omit A wavecycles” },
}

dsp[“Distort Overload – Clip the signal with noise or a (possibly timevarying) waveform”] = {
cmds = { exe = “distort”, mode = “overload 1”, tip = “The clip-level parameter is rather like a ‘gate’ level. If the signal level is already high, anything over, for example, 0.1 is likely to push it into distortion, and values considerably higher than this will make it heavily distorted. However, if it only distorts, Trevor advises me, when it reaches a level of, for example, 0.99, it is not going to be distorted very often. The sound doesn’t actually have amplitude overload, because it is distorted by ‘slicing off’ the top (clipping) where it would have overloaded. The sound becomes loud and ‘strained’, like a voice which is shouting too loudly.Given the trials made so far, this can be a fairly subtle effect, but the words ‘straining’, ‘loud’, ‘uncompromising’ seem appropriate as the amplitude gets pushed towards the top of the range.” },
arg1 = { name = “clip-level”, min = 0, max = 1, tip = “level at which the signal is to be clipped (Range: 0 to 1) The signal level is renormalised after clipping.” },
arg2 = { name = “depth”, min = 0, max = 1, tip = “depth of the pattern of distortion imposed on clipped stretches of the signal. (Range: 0 to 1)” },
}

dsp[“Distort Overload – Clip the signal with noise or a (possibly timevarying) waveform”] = {
cmds = { exe = “distort”, mode = “overload 2”, tip = “The clip-level parameter is rather like a ‘gate’ level. If the signal level is already high, anything over, for example, 0.1 is likely to push it into distortion, and values considerably higher than this will make it heavily distorted. However, if it only distorts, Trevor advises me, when it reaches a level of, for example, 0.99, it is not going to be distorted very often. The sound doesn’t actually have amplitude overload, because it is distorted by ‘slicing off’ the top (clipping) where it would have overloaded. The sound becomes loud and ‘strained’, like a voice which is shouting too loudly. Mode 2 can add an extra ringing sound as the value for freq gets higher, e.g., 2000Hz and beyond. Given the trials made so far, this can be a fairly subtle effect, but the words ‘straining’, ‘loud’, ‘uncompromising’ seem appropriate as the amplitude gets pushed towards the top of the range.” },
arg1 = { name = “clip-level”, min = 0, max = 1, tip = “level at which the signal is to be clipped (Range: 0 to 1) The signal level is renormalised after clipping.” },
arg2 = { name = “depth”, min = 0, max = 1, tip = “depth of the pattern of distortion imposed on clipped stretches of the signal. (Range: 0 to 1)” },
arg3 = { name = “freq”, min = 0, max = 22500, tip = “frequency of the waveform imposed on clipped stretches of the signal” },
}

dsp[“Distort Pitch - Pitchwarp wavecycles of sound”] = {
cmds = { exe = “distort”, mode = “pitch”, tip = “The random up/down movement of the ‘wavecycles’ within the total octvary range produces a great deal of bending of the sound, especially if the original alters its pitch a good deal. It is better, therefore, to start with relatively small values for octvary – e.g., less than 1 – so that you start to use this function with some degree of control over the results.The full power of DISTORT PITCH doesn’t really come into its own until time-varying parameters are used, especially for cyclecnt. Large values for the latter will serve to slow down the rate of change. DISTORT PITCH is useful for creating ‘flexitones’ (to coin a term) – with distortion, of course.” },
arg1 = { name = “octvary”, min = 0,0, max = 8,0, tip = “maximum possible transposition up or down in (fractions of) octaves (Range > 0.0 to 8.0)” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “mamimum number of ‘wavecycles’ between the generation of transposition values (Range: > 1, Default: 64)” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Pulsed - Impose impulse-train on a sound”] = {
cmds = { exe = “distort”, mode = “pulsed 1”, tip = “Distort a sound by imposing a series of impulses on the source, or on a specific waveset segment of the source. An impulse is like a brief event created by a sharp envelope on the sound. The sound inside the impulse might glissando slightly, as if whatever is causing the impulsion has warped the sound by its impact.” },
arg1 = { name = “stime”, min = 0.001, max = 10, tip = “time in the source sound where the impulses begin” },
arg2 = { name = “dur”, min = 0.001, max = 10, tip = “length of time that the impulses continue” },
arg3 = { name = “frq”, min = 0, max = 1000, tip = “number of impulses per second” },
arg4 = { name = “frand”, min = 0, max = 12, tip = “number of semitones by which to randomise the frequency of the impulses” },
arg5 = { name = “trand”, min = 0, max = 10, tip = “amount of time in seconds by which to randomise the relative time positions of amplitude peaks and troughs from impulse to impulse” },
arg6 = { name = “arand”, min = 0, max = 1, tip = “randomisation of the amplitude shape created by the peaks and troughs from impulse to impulse” },
arg7 = { name = “transp”, min = 0, max = 1, tip = “transposition contour of sound inside each impulse” },
arg8 = { name = “tranrand”, min = 0, max = 1, tip = “randomisation of transposition contour from impulse to impulse” },
arg9 = { name = “-s”, switch = “-s”, tip = “keep start of source sound, before impulses begin (if any)” },
arg10 = { name = “-e”, switch = “-e”, tip = “keep end of source sound, after impulses end (if any)” },
}

dsp["Distort Pulsed - Imposed regular pulsations on a sound "] = {
cmds = { exe = “distort”, mode = “pulsed 2”, tip = “Distort a sound by imposing a series of impulses on the source, or on a specific waveset segment of the source. An impulse is like a brief event created by a sharp envelope on the sound. The sound inside the impulse might glissando slightly, as if whatever is causing the impulsion has warped the sound by its impact.” },
arg1 = { name = “stime”, min = 0.001, max = 10, tip = “time in the source sound where the impulses begin” },
arg2 = { name = “dur”, min = 0.001, max = 10, tip = “length of time that the impulses continue” },
arg3 = { name = “frq”, min = 0, max = 1000, tip = “number of impulses per second” },
arg4 = { name = “frand”, min = 0, max = 12, tip = “number of semitones by which to randomise the frequency of the impulses” },
arg5 = { name = “trand”, min = 0, max = 10, tip = “amount of time in seconds by which to randomise the relative time positions of amplitude peaks and troughs from impulse to impulse” },
arg6 = { name = “arand”, min = 0, max = 1, tip = “randomisation of the amplitude shape created by the peaks and troughs from impulse to impulse” },
arg7 = { name = “cycletime”, min = 0, max = 10, tip = “duration in seconds of wavecycles to grab as sound substance inside the impulses” },
arg8 = { name = “transp”, min = 0, max = 1, tip = “transposition contour of sound inside each impulse” },
arg9 = { name = “tranrand”, min = 0, max = 1, tip = “randomisation of transposition contour from impulse to impulse” },
arg10 = { name = “-s”, switch = “-s”, tip = “keep start of source sound, before impulses begin (if any)” },
arg11 = { name = “-e”, switch = “-e”, tip = “keep end of source sound, after impulses end (if any)” },
}

dsp[“Distort Reform - Convert to fixed level square wave”] = {
cmds = { exe = “distort”, mode = “reform 1”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to square wave”] = {
cmds = { exe = “distort”, mode = “reform 2”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to fixed level triangular wave”] = {
cmds = { exe = “distort”, mode = “reform 3”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to triangular wave”] = {
cmds = { exe = “distort”, mode = “reform 4”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to inverted half-cycles”] = {
cmds = { exe = “distort”, mode = “reform 5”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to click streams”] = {
cmds = { exe = “distort”, mode = “reform 6”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Convert to sinusoid”] = {
cmds = { exe = “distort”, mode = “reform 7”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
}

dsp[“Distort Reform - Exaggerate waveform contour”] = {
cmds = { exe = “distort”, mode = “reform 8”, tip = “This process reads each ‘wavecycle’ (sound inbetween zero crossings) and replaces it with a different waveform of the same length. Several waveform options are provided. Those which do not fix the amplitude level respond to the varying amplitude levels of each successive wavecycle, thus producing an additional (and arbitrary) distortion feature.The ‘fixed level’ options produce consistently loud output.The ‘click’ option replaces each ‘wavecycle’ with a mishmash of square pulses several samples long (random sizes), which sounds a bit like a rattle.The ‘sinusoid’ option, as might be expected, is relatively smooth. It is actually a subtle form of filtering. The sine waves vary in length and amplitude because they are based on ‘wavecycles’ and because only some of the ‘wavecycles’ are replaced.The ‘exaggeration’ option just seems to add a surface buzz.” },
arg1 = { name = “exaggeration”, min = 0,000002, max = 40, tip = “exaggeration factor (Range: 0.000002 to 40.0)” },
}

dsp[“Distort Repeat - Timestretch soundfile by repeating wavecycles”] = {
cmds = { exe = “distort”, mode = “repeat”, tip = “The repetition of the ‘wavecycles’ stretches out the sound, making it both longer and more granular in texture. This granularity is increased if (increasingly larger) groups of cyclecnt ‘wavecycles’ are used: then the whole group repeats multiplier times. DISTORT REPEAT produces long, grainy (distorted) sounds. The sense of stretching out the original is very apparent.A significant application of DISTORT REPEAT is that, by increasing the cyclecnt factor, one crosses the pitch-perception boundary: that is, starting with a noisy sound in which all the wavecycles are randomly different, one ends up with, for example, 7 repetitions of the same wavecycle, followed by 7 of another and so on – and each of these comprise sufficient repetitions for us to hear pitch. Thus the noise source becomes a string of pitch beads, each of arbitrary timbre. With a cyclecnt of, for example, 128, one can even get a slowish random melody.” },
arg1 = { name = “multiplier”, min = 0,0, max = 50, tip = “number of times (integer) each ‘wavecycle’ (group) repeats” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “number of ‘wavecycles’ (integer) in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = "number of ‘wavecyles’ (integer) to skip at start of file " },
}

dsp[“Distort Repeat 2 - Repeat wavecycles without time-stretching”] = {
cmds = { exe = “distort”, mode = “repeat2”, tip = “Repeating the ‘wavecycles’ without time-stretching (as in DISTORT REPEAT) enables you to increase the strength of the distortion with the multiplier parameter without making the output file any longer than the original. Larger values for cyclecnt increases the length of infile that is affected. Higher values for multiplier increase the distortion, while higher values for cyclecnt increase the length of infile that is processed as one unit. Thus we could have: a low value for multiplier coupled with a high value for cyclecnt – this will produce a bit of distortion while the source remains recognisable, a high value for multiplier coupled with a low value for cyclecnt – this will produces a great deal of distortion, but the effect is limited because only a few cycles are affected as a unit. High values for both parameters – this appears to create the most distortion” },
arg1 = { name = “multiplier”, min = 0,0, max = 50, tip = “number of times (integer) each ‘wavecycle’ (group) repeats” },
arg2 = { name = “cyclelen”, switch = “-c”, min = 1, max = 5000, tip = “number of ‘wavecycles’ (integer) in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = "number of ‘wavecyles’ (integer) to skip at start of file " },
}

dsp[“Distort Replace – The strongest wavecycle in a cyclecnt group replaces the others”] = {
cmds = { exe = “distort”, mode = “replace”, tip = “The replacing action serves to simplify the sound. Note that the single strong ‘wavecycle’ in the group will take the place of several others, which will be deleted. This simplification becomes extreme when the cyclecnt is high, leading to a ‘sample-hold’ kind of stepped effect. Time-varying cyclecnt makes it possible to introduce gradual change. With DISTORT REPLACE we can achieve a simplification of the sound, up to very clear ‘sample-hold’ type stepped tones” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 5000, tip = “(integer) size of group of ‘wavecycles’” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “number of ‘wavecyles’ (integer) to skip at start of file” },
}

dsp["Distort Replim – Timestretch by repeating wavecycles (below a specified frequency) “] = {
cmds = { exe = “distort”, mode = “replim”, tip = “This function is like DISTORT REPEAT, but with a slight change. Here the length of wavecycle to be affected can be set. Thus, if you set a mid-range frequency, only those below that frequency will repeat, and the others (above the frequency) will be discarded (filtered out). Hence the name ‘REP-LIM’, meaning ‘repeat (with a) limit’. DISTORT REPLIM is therefore like a filtering program that also repeats wavecycles. In the DISTORT set, the wavecycles are wavelengths that occur between zero crossings, so distortion also occurs. It is helpful to remember that wavelength is inversely proportional to frequency. Wavelength is the actual physical length of the oscillation, and frequency is the number of cycles that occur in one second (i.e., Hertz). These two aspects of sound are inversely proportional to one another: P = 1/f. For example, a sound oscillating at 100 Hz will have a period, i.e., a wavelength of 1/100 meters = 0.01 meters (0.39 inch). A sound oscillating at 1000Hz will have a wavelength of 1/1000 meters = 0.001 meters (0.039 inch). Short wavecycles are therefore higher in pitch and long ones are lower in pitch. When the frequency setting for DISTORT REPLIM is high, the filter point is set higher and more of the sound will be retained. Here we are dealing with ‘pseudo-wavecycles’ (portions of soundfile between zero crossings), which is what introduces distortion into the equation.The net result of the function is to create repetition distortion while filtering out a user-definable amount of the higher frequencies. Remember that the relative amounts of high and low frequencies in the infile will affect the results.” },
arg1 = { name = “multiplier”, min = 0.001, max = 100, tip = “the number of times each wavecycle (group) repeats (Integer)” },
arg2 = { name = “cyclecnt”, switch = “-c”, min = 0, max = 5000, tip = “the number of wavecycles in repeated groups” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = " the number of wavecycles to skip at the beginning of the soundfile” },
arg4 = { name = “hilim”, switch = “-f”, min = 0, max = 22500, tip = “the frequency below which cycles are counted” },
}

dsp[“Distort Reverse - Cycle-reversal distortion in which the wavecycles are reversed in groups”] = {
cmds = { exe = “distort”, mode = “reverse”, tip = “Here the original soundfile is grouped into a series of ‘wavecycles’ with cyclecnt ‘wavecycles’ in each group. Then each of these groups of ‘wavecycles’ is reversed. The term ‘distortion’ here is something of a misnomer, because no distortion process is applied to the ‘wvecycles’ themselves. Instead, cyclecnt sets the number of ‘wavecycles’ which are to be copied in reverse as a group to the outfile. For example, if cyclecnt = 3, 15 ‘wavecycles’ reversed in groups of 3 will assume the order: 3-2-1, 6-5-4, 9-8-7, 12-11-10, 15-14-13. Thus, not only is the sound material backwards, but the reversed 1st ‘wavecycle’ is now adjacent to the reversed 6th ‘wavecycle’. This mimics the classical tape studio technique of cutting up a length of tape into segments (of varying lengths), reversing the segments, and joining up the reversed pieces. The result will be similar to a random brassage because of the differing lengths of the ‘wavecycles’. The process moves steadily through the infile from beginning to end, so the normal order of the (reversed) events is preserved. It is surprising how normal the output can be. With mid-range values for cyclecnt (say, 30 to 100), one hears the original breaking up, but only with very large values for cyclecnt does one hear the sound sweeping backwards in large swathes. Again, it is a question of ‘resolution’: the size of the units being manipulated. A small value for cyclecnt will produce a grainy result, mid-values a ‘broken up’ result, and large values swathes of reversed sound. If the value for cyclecnt exceeds the number of ‘wavecycles’ in the infile, you will be told that the ‘sound source is too short…’. DISTORT CYCLECNT returns the number of ‘wavecycles’ in a sound, should you want to provide a value for cyclecnt which is right up to the limit. Reversing the output of DISTORT REVERSE turns the cyclecnt groups back the other way while reading the whole soundfile from back to front, producing an interesting mixture of forwards and backwards! Using the time-varying option for cyclecnt provides an opportunity for dramatic or gradual changes in the output.” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 10000, tip = “number of ‘wavecycles’ in a reversed group (Range: > 0)” },
}

dsp[“Distort Telescope - Time-contract sound by telescoping N wavecycles into 1”] = {
cmds = { exe = “distort”, mode = “telescope”, tip = “Although at first rather like DISTORT OMIT, here the ‘wavecycles’ are not deleted as such. Instead, they are superimposed (i.e., mixed) onto each other, with shorter ‘wavecycles’ being stretched to fit the longest one in each group of cyclecnt ‘wavecycles’. The outfile will usually be much shorter than the infile and can be reduced to a mere blip with this process. The -a flag tells the program to telescope to the average ‘wavecycle’ length, rather than to the longest. Since the longest ‘wavecycle’ in each group is compressed by this method, the outfile will be even shorter. Interesting results can be achieved with small values for cyclecnt, the output tending to have a ‘mushy’ quality. It responds well to pitched material, producing a singing, if mushy, tone.” },
arg1 = { name = “cyclecnt”, min = 0,0, max = 1000, tip = “the number of ‘wavecycles’ in a group” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “number of ‘wavecyles’ (integer) to skip at start of file” },
arg3 = { name = “-a”, switch = “-a”, tip = “telescope to an average ‘wavecycle’ length (Default: telescope to the longest ‘wavecycle’ length)” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles below freq”] = {
cmds = { exe = “distort”, mode = “filter 1”, tip = “Period and frequency are inverse functions. Therefore it is possible to relate the length of a ‘wavecycle’ to the frequency it would have were it to recur regularly. This program therefore filters by removing ‘wavecycles’ shorter or longer than those relating to a specific, user-defined, frequency. The duration of the outfile is affected by this process: because ‘wavecycles’ are being removed, the outfile will be shorter, by varying degrees. The aural effect of the DISTORT FILTER process is actually like gating. In gating, you can imagine a horizontal line drawn through the time/amplitude display of a soundfile. If the peaks above the line are retained (by filtering out lower frequencies), you just hear them (joined up). Similarly, if you filter out above the line, the peaks are gone, leaving the lower sound material (joined up). The difference here is that the process is operating on ‘pseudo-wavecycles’ according to their length, so here the results are more unpredictable and also distort the sound to some degree, depending on where the horizontal line – the frequency variable(s) – is drawn. Technically, the process is akin to low-, high- and band-pass filters, but aurally it is more like gating. You can therefore use this procedure to cut out some and distort other material in a sound.” },
arg1 = { name = “freq”, min = 10,0, max = 22050.0, tip = “frequency in Hz (Range: 10.0 to 22050.0)” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles above freq”] = {
cmds = { exe = “distort”, mode = “filter 2”, tip = “Period and frequency are inverse functions. Therefore it is possible to relate the length of a ‘wavecycle’ to the frequency it would have were it to recur regularly. This program therefore filters by removing ‘wavecycles’ shorter or longer than those relating to a specific, user-defined, frequency. The duration of the outfile is affected by this process: because ‘wavecycles’ are being removed, the outfile will be shorter, by varying degrees. The aural effect of the DISTORT FILTER process is actually like gating. In gating, you can imagine a horizontal line drawn through the time/amplitude display of a soundfile. If the peaks above the line are retained (by filtering out lower frequencies), you just hear them (joined up). Similarly, if you filter out above the line, the peaks are gone, leaving the lower sound material (joined up). The difference here is that the process is operating on ‘pseudo-wavecycles’ according to their length, so here the results are more unpredictable and also distort the sound to some degree, depending on where the horizontal line – the frequency variable(s) – is drawn. Technically, the process is akin to low-, high- and band-pass filters, but aurally it is more like gating. You can therefore use this procedure to cut out some and distort other material in a sound.” },
arg1 = { name = “freq”, min = 10,0, max = 22050.0, tip = “frequency in Hz (Range: 10.0 to 22050.0)” },
arg2 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}

dsp[“Distort Filter - Time-contract a sound by filtering out wavecycles below & above freq”] = {
cmds = { exe = “distort”, mode = “filter 3”, tip = “Period and frequency are inverse functions. Therefore it is possible to relate the length of a ‘wavecycle’ to the frequency it would have were it to recur regularly. This program therefore filters by removing ‘wavecycles’ shorter or longer than those relating to a specific, user-defined, frequency. The duration of the outfile is affected by this process: because ‘wavecycles’ are being removed, the outfile will be shorter, by varying degrees. The aural effect of the DISTORT FILTER process is actually like gating. In gating, you can imagine a horizontal line drawn through the time/amplitude display of a soundfile. If the peaks above the line are retained (by filtering out lower frequencies), you just hear them (joined up). Similarly, if you filter out above the line, the peaks are gone, leaving the lower sound material (joined up). The difference here is that the process is operating on ‘pseudo-wavecycles’ according to their length, so here the results are more unpredictable and also distort the sound to some degree, depending on where the horizontal line – the frequency variable(s) – is drawn. Technically, the process is akin to low-, high- and band-pass filters, but aurally it is more like gating. You can therefore use this procedure to cut out some and distort other material in a sound.” },
arg1 = { name = “freq1”, min = 0,0, max = 22050.0, tip = “frequency in Hz to delete below” },
arg2 = { name = “freq2”, min = 0,0, max = 22050,0, tip = “frequency in Hz to delete above” },
arg3 = { name = “skipcycles”, switch = “-s”, min = 0, max = 5000, tip = “(integer) number of ‘wavecycles’ to skip at start of file” },
}


dsp[“Modify Brassage - Pitchshift - Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 1” },
arg1 = { name = “pitchshift”, min = -0,12, max = 12, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
}

dsp[“Modify Brassage - Timestretch -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 2” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
}

dsp[“Modify Brassage - Reverb -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 3” },
arg1 = { name = “density”, min = 0,0, max = 1000, tip = “amount of grain overlap (Range: > 0)” },
arg2 = { name = “pitch”, min = -0,33, max = 0,33, tip = “transposition factor (Range: -0.33 to 0.33)” },
arg3 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg4 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
}

dsp[“Modify Brassage - Scramble -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 4” },
arg1 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg2 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
}

dsp[“Modify Brassage - Granulate -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 5” },
arg1 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg2 = { name = “-d”, switch = “-d” },
}

dsp[“Modify Brassage - Brassage -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 6” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
arg2 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg3 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg4 = { name = “pitchshift”, min = -0,33, max = 0,33, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
arg5 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg6 = { name = “space”, min = 0, max = 1, tip = “spatial position – set stereo position” },
arg7 = { name = “bsplice”, min = 0, max = 1000, tip = “length of start-splices on grains in ms (Default: 5)” },
arg8 = { name = “esplice”, min = 0, max = 1000, tip = “length of end-splices on grains in ms (Default: 5)” },
arg9 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
arg10 = { name = “jitter”, switch = “-j”, min = 0, max = 1, tip = “randomisation of grain position” },
arg11 = { name = “outlength”, switch = “-l”, min = 0, max = 10, tip = “maximum outfile length (if end of data is not reached)” },
arg12 = { name = “channel”, switch = “-c”, min = 0, max = 2, tip = " extract and work on just one channel of a stereo input (Range: 1 or 2) Set channel to 0 (the Default) for this parameter to be ignored." },
arg13 = { name = “-d”, switch = “-d” },
arg14 = { name = “-x”, switch = “-x”, tip = “do exponential splices (Default: linear)” },
arg15 = { name = “-n”, switch = “-n”, tip = “no interpolation for pitch values (quick but dirty)” },
}

dsp[“Modify Brassage - Full Monty -Granular reconstitution of soundfile”] = {
cmds = { exe = “modify”, mode = “brassage 7” },
arg1 = { name = “velocity”, min = 0,0, max = 1,0, tip = “stretch or compress the infile in time, while retaining the same pitch” },
arg2 = { name = “density”, min = 0,0, max = 1000,0, tip = “amount of grain overlap” },
arg3 = { name = “hvelocity”, min = 0,0, max = 5000,0 },
arg4 = { name = “hdensity”, min = 0,0, max = 5000,0 },
arg5 = { name = “grainsize”, min = 2,0, max = 1997,12, tip = “size of the grains in milliseconds” },
arg6 = { name = “pitchshift”, min = -0,33, max = 0,33, tip = “shift the pitch of infile while retaining (more or less) the same duration” },
arg7 = { name = “amp”, min = 0, max = 1, tip = “gain applied to the grains (Range: 0 to 1; Default: 1.0)” },
arg8 = { name = “space”, min = 0, max = 1, tip = “spatial position – set stereo position” },
arg9 = { name = “bsplice”, min = 0, max = 1000, tip = “length of start-splices on grains in ms (Default: 5)” },
arg10 = { name = “esplice”, min = 0, max = 1000, tip = “length of end-splices on grains in ms (Default: 5)” },
arg11 = { name = “hgrainsize”, min = 0, max = 5000 },
arg12 = { name = “hpitchshift”, min = -0,33, max = 0,33 },
arg13 = { name = “hamp”, min = 0, max = 1 },
arg14 = { name = “hspace”, min = 0, max = 2 },
arg15 = { name = “hbsplice”, min = 0, max = 1000 },
arg16 = { name = “hesplice”, min = 0, max = 1000 },
arg17 = { name = “range”, switch = “-r”, min = 0,0, max = 1000,0 },
arg18 = { name = “jitter”, switch = “-j”, min = 0, max = 1, tip = “randomisation of grain position” },
arg19 = { name = “outlength”, switch = “-l”, min = 0, max = 10, tip = “maximum outfile length (if end of data is not reached)” },
arg20 = { name = “channel”, switch = “-c”, min = 0, max = 2, tip = " extract and work on just one channel of a stereo input (Range: 1 or 2) Set channel to 0 (the Default) for this parameter to be ignored." },
arg21 = { name = “-d”, switch = “-d” },
arg22 = { name = “-x”, switch = “-x”, tip = “do exponential splices (Default: linear)” },
arg23 = { name = “-n”, switch = “-n”, tip = “no interpolation for pitch values (quick but dirty)” },
}

dsp[“Modify Loudness - Alter gain of sound”] = {
cmds = { exe = “modify”, mode = “loudness 1” },
arg1 = { name = “gain”, min = 0,0, max = 100,0, tip = “adjust level by factor gain” },
}

dsp[“Modify Loudness - Alter dB-gain of sound”] = {
cmds = { exe = “modify”, mode = “loudness 2” },
arg1 = { name = “gain”, min = -96, max = 96, tip = “level expressed in dB (Range: -96dB to 96dB). NB: every drop of -6dB halves the previous level.” },
}

dsp[“Modify Loudness - Normalise”] = {
cmds = { exe = “modify”, mode = “loudness 3” },
arg1 = { name = “level”, switch = “-l”, min = 0, max = 1, tip = “force level (if necessary) to the maximum possible, or to the level given (Range: 0 to 1).” },
}

dsp[“Modify Loudness - Force level”] = {
cmds = { exe = “modify”, mode = “loudness 4” },
arg1 = { name = “level”, switch = “-l”, min = 0, max = 1, tip = “force level to maximum possible, or to the level given (Range: 0 to 1)” },
}

dsp[“Modify Loudness - Invert Phase”] = {
cmds = { exe = “modify”, mode = “loudness 6” },
}

dsp[“Phase - Invert phase”] = {
cmds = { exe = “phase”, mode = “phase 1”, tip = “Playback of the output inverted soundfile shows that there is no audible difference from the input soundfile. However, if you mix the original sound with the phase inverted sound, you will generate a silent output: positive and negative amplitude values cancel out. However, if you mix the input and output with an offset, you get signal and hear an overlap of the two soundfiles (the cancelling out does not fully happen). You can try this with SUBMIX MERGE.” },
}

dsp[“Phase - Stereo Enhance stereo file”] = {
cmds = { exe = “phase”, mode = “phase 2”, tip = “This mode is supposed to be a means of creating an enhanced stereo image by suppressing any aspects of the Left image which have bled to the Right, by adding (part of) the phase inverted Left signal on the Right, and vice versa. I (T Wishart) learned of this idea from a mixing engineer I met in France, but I’m still not convinced that this achieves anything except in very special circumstances (with particular types of material). The output may sound the same as the input, except perhaps on the largest PA systems.” },
arg1 = { name = “transfer”, switch = “-t”, min = 0, max = 1, tip = “amount of signal to be used in phase-cancellation.” },
}

dsp[“Modify Radical - Reverse”] = {
cmds = { exe = “modify”, mode = “radical 1”, tip = “Sound plays backwards, the soundfile is re-written back to front: starting at the end and ending at the beginning.” },
}

dsp[“Modify Radical - Shred”] = {
cmds = { exe = “modify”, mode = “radical 2”, tip = “The soundfile is (randomly) segmented, and these segments reordered by means of a permutation process. As the number of repeats increases, it gets more and more jumbled, literally ‘reducing it to shreds’. The -n adds splicing that results in a smoother output.” },
arg1 = { name = “repeats”, min = 0, max = 1000, tip = “number of repeats of shredding process” },
arg2 = { name = “chunklen”, min = 0, max = 500, tip = “average length of chunks to cut and permutate” },
arg3 = { name = “scatter”, switch = “-s”, min = 0, max = 10, tip = “randomisation of cuts (Range: 0 to K, where K = duration of infile/chunklen Default = 1)” },
arg4 = { name = “-n”, switch = “-n”, tip = “use this flag for a smoother output” },
}

dsp[“Modify Radical - Scrub back and forth”] = {
cmds = { exe = “modify”, mode = “radical 3”, tip = “This is an acceleration/deceleration process which models an editing procedure used in the ‘classical’ tape studio: the desired edit point was found by turning the tape spools by hand so that the tape moved (very slowly!) across the tape head. You could hear locate exactly where silence began or ended, where clicks came etc., although the sound was very low because of the slow speed.The SCRUB function could also be used creatively, to create extreme speed modifications of the source sound on the tape, e.g. an abrupt acceleration-deceleration as the tape went from not-moving, to fast-moving, to stopped as the hands jerked the tape across the heads.” },
arg1 = { name = “dur”, min = 0, max = 10, tip = “minimum length of outfile required” },
arg2 = { name = “down”, switch = “-l”, min = 0, max = 12, tip = “lowest downward tranposition in semitones” },
arg3 = { name = “up”, switch = “-h”, min = 0, max = 12, tip = " highest upward transposition in semitones" },
arg4 = { name = “start”, switch = “-s”, tip = "scrubs start before time start seconds " },
arg5 = { name = “end”, switch = “-e”, tip = “scrubs end after time end” },
}

dsp[“Modify Radical - Lose resolution”] = {
cmds = { exe = “modify”, mode = “radical 4”, tip = “LOSE RES: Reducing the sample rate reduces the level of the Nyquist frequency (sample_rate/2), thereby lowering the frequency level which can be safely handling during processing. Lowering bit-resolution reduces the precision of the numerical expression of the data, making the digital ‘quantisation’ of the sonic material coarser. This means that time-varying information is lost.” },
arg1 = { name = “bit_resolution”, min = 0, max = 16 },
arg2 = { name = “srate_division”, min = 1, max = 256, tip = “Range: 1 to 256 Default 1 (normal)” },
}

dsp[“Modify Radical - Ring Modulate”] = {
cmds = { exe = “modify”, mode = “radical 5”, tip = “RING MODULATION: multiplies two (bipolar) signals. In this case, one signal is a soundfile and the other is a modulating_frq. This creates two ‘sidebands’ which are the sum and the difference of the two signals, while the carrier signal disappears. The result is a timbrally ‘hollow’ sound. (See Curtis Roads, The Computer Music Tutorial, pp. 215-220).” },
arg1 = { name = “modulating-frq”, min = 0, max = 44100, tip = “number of cycles per second” },
}

dsp[“Modify Revecho - Standard delay”] = {
cmds = { exe = “modify”, mode = “revecho 1”, tip = “Mode 1 provides a standard delay. If a smooth echoey effect is wanted, be careful to keep mix on the low side. Remember that delay is given in milliseconds; after 60ms or so, one begins to hear a strong reverberation; after 100 ms the reverberation begins to ‘bounce’, and by 200 ms one begins to hear distinct echoes. Delay times greater than 1000 will cause repetitions of (all or much of) the sound. Don’t forget to lengthen the tail to match the delay time.The mix parameter, in adding in the delayed signal, increases the reverberant effect. With a short delay time, this can sound like the reverberation which occurs in an enclosed space. Feedback has a similar effect, becoming very pronounced towards a value of 1.0 – rather like the ‘feedback’ which occurs when a microphone is placed facing a loudspeaker. The operation of a standard delay line in Mode 1 ranges from modest reverberation to echo effects. The reverberations, however, tend easily towards rough edges, so for smoother reverbs, look to the programs listed below.” },
arg1 = { name = “delay”, min = 0, max = 5000, tip = “delay time, in milliseconds” },
arg2 = { name = “mix”, min = 0, max = 1, tip = " amount of delayed signal in final mix: 0 gives ‘dry’ result (Range: 0 to 1)" },
arg3 = { name = “feedback”, min = -1,0, max = 1,0, tip = “produces resonances related to delay time (with short times) (Range: -1.0 to 1.0)” },
arg4 = { name = “tail”, min = -1,0, max = 1,0, tip = “time to allow decayed signal to decay to zero (Range: -1.0 to 1.0)” },
arg5 = { name = “prescale”, switch = “-p”, tip = “prescales input level, to avoid overload” },
arg6 = { name = “-i”, switch = “-i”, tip = “inverts the dry signal (for phasing effects)” },
}

dsp[“Modify Revecho - Varying delay”] = {
cmds = { exe = “modify”, mode = “revecho 2” },
arg1 = { name = “delay”, min = 0, max = 5000, tip = “delay time, in milliseconds” },
arg2 = { name = “mix”, min = 0, max = 1, tip = " amount of delayed signal in final mix: 0 gives ‘dry’ result (Range: 0 to 1)" },
arg3 = { name = “feedback”, min = -1,0, max = 1,0, tip = “produces resonances related to delay time (with short times) (Range: -1.0 to 1.0)” },
arg4 = { name = “lfomod”, min = 0, max = 1, tip = “depth of the delay-variation sweep (Range: 0 to 1)” },
arg5 = { name = “lfofreq”, min = -50, max = 50, tip = “frequency of the delay-variation sweep (negative values give random oscillations)” },
arg6 = { name = “lfophase”, min = 0, max = 1, tip = “start-phase of the delay-variation sweep (Range: 0 to 1)” },
arg7 = { name = “lfodelay”, min = 0, max = 10, tip = “time in seconds before the delay-variation sweep begins” },
arg8 = { name = “tail”, min = -1,0, max = 1,0, tip = “time to allow decayed signal to decay to zero (Range: -1.0 to 1.0)” },
arg9 = { name = “prescale”, switch = “-p”, tip = “prescales input level, to avoid overload” },
arg10 = { name = “seed”, switch = “-s”, min = 0, max = 100, tip = "non-zero value gives reproducible output (with the same seed) where random oscillations are used " },
}

dsp[“Modify Revecho - Stadium Echo”] = {
cmds = { exe = “modify”, mode = “revecho 3”, tip = “This creates a stereo outfile, bouncing the signal between speakers with a very prominent delay factor. The idea is that you hear the signal bouncing around the ‘stadium’. The defaults work quite nicely, but you can intensify the effect by multiplying the delay time with the size parameter. Note that this is a multiple, so values less than 0 (multiplied with the default time of 0.1 sec) will decrease the delay time. Beyond size = 2, you are likely to run into insufficient buffer space, so if you really want longer delay times, you will have to increase the buffer size with ‘set CDP_MEMORY_BBSIZE=…’ (bear in mind the RAM capacity of your machine). (The default buffer size is 1 Mbyte and the units are in ‘k’: e.g., a BBSIZE of 3000 units is 3 Mbyte)” },
arg1 = { name = “gain”, switch = “-g”, min = 0, max = 1, tip = “to apply to input signal (Default: 0.645654)” },
arg2 = { name = “roll_off”, switch = “-r”, min = 0, max = 10, def = 1, tip = “rate of loss of level across stadium (Default: 1))” },
arg3 = { name = “size”, switch = “-s”, min = 0, max = 10, tip = “multiplies average time between echoes (the Default time between echoes of 0.1 sec)” },
arg4 = { name = “count”, switch = “-e”, min = 0, max = 23, tip = “number of stadium echoes (Default and max: 23)” },
}

dsp[“Modify Space - pan”] = {
cmds = { exe = “modify”, mode = “space 1”, tip = “Adjusts the amplitude levels of the two channels so as to create spatial illusions. A time pan breakpoint file is used to create movement. Mode1 PAN: control of sound in 3-D space has been a basic procedure when composing with ‘sound’ material, especially when these are drawn from nature/the environment. The assumption here is that you are thinking about the placement and movement of sound as an integral part of your compositional process. In this case, we are dealing with building these procedures into the sound itself. There is a further aspect external to the sound itself, achieved by ‘mixing’ (superimposing sounds and writing a new soundfile) and ‘diffusion’ (sound placement during playback achieved by manipulating the pan controls on a mixer).” },
arg1 = { name = “pan”, min = -1,0, max = 1,0, tip = “floating point value to specify location between the pair of stereo speakers, or breakpoint file of time pan pairs. Range: -1.0 to 1.0; 0.0 is centre.” },
arg2 = { name = “prescale”, switch = “-p”, min = 0, max = 1, tip = “gain factor multiplier with which to adjust the input level (Default: 0.7)” },
}

dsp["Modify Space - Mirrow: two channels swap sides "] = {
cmds = { exe = “modify”, mode = “space 2”, tip = “MIRROR: the data in the two channels swaps sides, a utility for a quick Left/Right swap” },
}

dsp[“Modify Space - Narrow: Narrow the stereo image of a sound”] = {
cmds = { exe = “modify”, mode = “space 4”, tip = “A way to restrict the spatial location of a sound in the horizontal plane, this program allows you to narrow the spread of a stereo field” },
arg1 = { name = “narrowing”, min = -1,0, max = 1,0, tip = “make the stereo image less wide” },
}

dsp[“Modify Speed - Vary speed & pitch of a sound”] = {
cmds = { exe = “modify”, mode = “speed 1”, tip = “Speed modification processes change the duration and the pitch of the sound together. Thus a faster speed causes a higher pitch, a slower speed a lower pitch.MODIFY SPEED offers a range of functions which affect the speed of the soundfile. Perhaps it will be most often used for transposition. Modes 1 and 2 both accept either single values or the names of time-varying breakpoint files with time transposition pairs. The single values act as constants and transpose the whole soundfile up or down by the given amount. In the breakpoint files, transposition can be almost instantaneous (almost same time, different transposition value), or gradual, creating glissandi (different time, different transposition value). No transposition between times is a third possibility (different time, same transposition value). Transposition which also changes the speed, and therefore the pitch, of the soundfile greatly alters the character of the sound. It is often very interesting to hear what a sound will be like 1, 2 or even 3 octaves below its original pitch. Deep, rich tones can be achieved in this way. These tones can slowly rise or descend if created with a time-varying breakpoint file e.g., moving an octave up or down over the time of the whole sound (airplane takeoff sounds, etc.)” },
arg1 = { name = “speed”, min = 0, max = 4, tip = “transposition value (ratio) expressed as a floating point multiplier” },
}

dsp[“Modify Speed - Vary speed & pitch by (fractional) number of semitones”] = {
cmds = { exe = “modify”, mode = “speed 2”, tip =“Speed modification processes change the duration and the pitch of the sound together. Thus a faster speed causes a higher pitch, a slower speed a lower pitch.MODIFY SPEED offers a range of functions which affect the speed of the soundfile. Perhaps it will be most often used for transposition. Modes 1 and 2 both accept either single values or the names of time-varying breakpoint files with time transposition pairs. The single values act as constants and transpose the whole soundfile up or down by the given amount. In the breakpoint files, transposition can be almost instantaneous (almost same time, different transposition value), or gradual, creating glissandi (different time, different transposition value). No transposition between times is a third possibility (different time, same transposition value). Transposition which also changes the speed, and therefore the pitch, of the soundfile greatly alters the character of the sound. It is often very interesting to hear what a sound will be like 1, 2 or even 3 octaves below its original pitch. Deep, rich tones can be achieved in this way. These tones can slowly rise or descend if created with a time-varying breakpoint file e.g., moving an octave up or down over the time of the whole sound (airplane takeoff sounds, etc.)” },
arg1 = { name = “semitone-transpos”, min = -12, max = 12, tip = " transposition value in positive or negative number of semitones; e.g., 12 raises the sound by an octave, and -12 lowers it by an octave. NB: use 0 (semitones) for no transposition." },
}

dsp[“Modify Speed - Accelerate or decelerate a sound”] = {
cmds = { exe = “modify”, mode = “speed 5” },
arg1 = { name = “accel”, min = 0, max = 100, tip = “multiplication of speed to be reached by goaltime – i.e., a transposition ratio” },
arg2 = { name = “goaltime”, min = 0, max = 30, tip = “time in outfile at which the accelerated speed is to be reached.” },
arg3 = { name = “starttime”, switch = “-s”, min = 0, max = 10, tip = “time in infile / outfile at which the acceleration begins” },
}

dsp[“Modify Speed - Add vibrato to a sound”] = {
cmds = { exe = “modify”, mode = “speed 6”, tip = “The vibrato created in Mode 6 is a frequency modulation. Given the very wide ranges allowed, this function is immensely powerful. A slow vibrate with a large vibdepth will swing the original sound wildly – increase vibrate and it really ‘flaps in the breeze’ (like a flag in the wind). A fast vibrate with a reasonably tight vibdepth, e.g., a minor 3rd, will produce a fluttering effect.” },
arg1 = { name = “vibrate”, min = 0,0, max = 120,0, tip = “the rate of vibrato shaking in cyles-per-second (Range: 0.0 to 120.0)” },
arg2 = { name = “vibdepth”, min = 0,0, max = 96,0, tip = “vibrato depth (pitch shift from centre) in [possibly fractional] semitones (Range: 0.0 to 96.0)” },
}

dsp[“Modify Stack - Create a mix that stacks transposed versions of source on top of one another “] = {
cmds = { exe = “modify”, mode = “stack”, tip = “New sounds can be developed from existing sources by stacking transposed copes of the original on top of each other. This is particularly successful where the source sound has a clearly defined attack at or near the start of the sound and then dies away gradually. If the copies are lined up in such a way that their attacks coincide exactly, the new sound will psycho-acoustically merge into a single sound event with harmonic content (rather than a chord made up of several sounds). The meaning of this is very precise: one is lining up the soundfiles at their perceived beginning, i.e., its attack, not the start of each soundfile. This is achieved by adjusting the start times of the transposed soundfiles. MODIFY STACK is a very important program. It enables you to construct ‘larger’ versions of sounds by superimposing transposed versions on top of one another. Furthermore, it does this in such a way as to maximise the fusion of the layered sound by synchronising the attacks. This relates to a basic technique of orchestral scoring (where it is called ‘doubling’). It is a form of automatic mixing involving one soundfile.Because of the way the program functions, this is, however, quite a different process from transposing and mixing sounds to produce chords. (Doing this in the Spectral Domain, where transposition can be done without affecting duration, still has a place.) Here, if the attack points are made to coincide, the new sound-object is an integral whole, rather than a ‘chord’ made up of the transposed stack components: that is, the components fuse and cannot be separated in perception, as they can with a chord played, for example, on a piano keyboard.Also note that, as a Time Domain process, the higher transpositions end sooner than the lower ones. Use Spectral Domain transpositon along with SUBMIX MIX to assemble transposed versions of the same sound when equal length is important.Very low transpositions could produce an extremely long output. The dur parameter enables you to specify a much shorter outfile length. You can usually get an idea of the harmonic content of the output from the first few seconds.” },
arg1 = { name = “transpos”, min = 0, max = 12, tip = “transpos is the transposition in semitones between successive copies” },
arg2 = { name = “count”, min = 0, max = 100, tip = " the number of copies in the stack” },
arg4 = { name = “lean”, min = 0, max = 10, tip = “the loudness of the highest component, relative to the lowest (may be > 1)” },
arg5 = { name = “attack-offset”, min = 0, max = 50, tip = “adjusts the time at which the attack of each sound occurs” },
arg6 = { name = “gain”, min = 0,1, max = 10, tip = “an overall amplifying gain factor on the output sound; some reduction (less than 1) may be needed. (It may also be > 1.) Range: 0.1 to 10” },
arg7 = { name = “dur”, min = 0, max = 1, tip = “how much of the output to make (a proportion, from 0 to 1)” },
arg7 = { name = “-s”, switch = “-s”, tip = " see the relative levels of the layers in the stack” },
}


dsp["Envel Attack - Emphasize the attack of a sound "] = {
cmds = { exe = “envel”, mode = “attack 1”, tip = “Set attack point where sound level first exceeds gate level.” },
arg1 = { name = “gate”, min = 0, max = 1, tip = "level (threshold) to be reached for the attack point to be recognised (Range: 0 to 1). " },
arg2 = { name = “Gain”, min = 0.001, max = 2,0, set = “floating point multiplier by which to amplify the signal at the attack point (< 1 reduces the signal; > 1 amplifies the signal).” },
arg3 = { name = “onset”, min = 5, max = 32767, tip = “attack onset duration in milliseconds, i.e., the ‘sharpness’ of the attack (Range:5ms to 32767ms). " },
arg4 = { name = “decay”, min = 5, max = 20000, tip = “attack decay duration in milliseconds (Range: 5 to < duration of infile).” },
arg5 = { name = “envtype”, switch = “-t”, min = 0, max = 1, tip = " type of envelope: 0 linear, 1 exponential (Default)” },
}

dsp[“Envel Attack - Emphasize the attack of a sound 2”] = {
cmds = { exe = “envel”, mode = “attack 2”, tip = “Attack point at maximum level at your ‘approx-time’ (+/- 200 ms).” },
arg1 = { name = “time”, min = 0, max = 10, tip = “time (approximate or exact) of the attack point, in seconds” },
arg2 = { name = “Gain”, min = 0.001, max = 2,0, set = “floating point multiplier by which to amplify the signal at the attack point (< 1 reduces the signal; > 1 amplifies the signal). " },
arg3 = { name = “onset”, min = 5, max = 32767, tip = “attack onset duration in milliseconds, i.e., the ‘sharpness’ of the attack (Range:5ms to 32767ms).” },
arg4 = { name = “decay”, min = 5, max = 20000, tip = “attack decay duration in milliseconds (Range: 5 to < duration of infile).” },
arg5 = { name = “envtype”, switch = “-t”, min = 0, max = 1, tip = " type of envelope: 0 linear, 1 exponential (Default)” },
}

dsp[“Envel Attack - Emphasize the attack of a sound 3”] = {
cmds = { exe = “envel”, mode = “attack 3”, tip = “Attack point at your ‘exact-time’.” },
arg1 = { name = “time”, min = 0, max = 10, tip = “time (approximate or exact) of the attack point, in seconds” },
arg2 = { name = “Gain”, min = 0.001, max = 2,0, set = “floating point multiplier by which to amplify the signal at the attack point (< 1 reduces the signal; > 1 amplifies the signal).” },
arg3 = { name = “onset”, min = 5, max = 32767, tip = "attack onset duration in milliseconds, i.e., the ‘sharpness’ of the attack (Range:5ms to 32767ms). " },
arg4 = { name = “decay”, min = 5, max = 20000, tip = “attack decay duration in milliseconds (Range: 5 to < duration of infile).The decay portion of the attack is also set in milliseconds. " },
arg5 = { name = “envtype”, switch = “-t”, min = 0, max = 1, tip = " type of envelope: 0 linear, 1 exponential (Default)” },
}

dsp[“Envel Attack - Emphasize the attack of a sound 4”] = {
cmds = { exe = “envel”, mode = “attack 3”, tip = "Attack point at maximum level in the soundfile " },
arg1 = { name = “Gain”, min = 0.001, max = 2,0, set = "floating point multiplier by which to amplify the signal at the attack point (< 1 reduces the signal; > 1 amplifies the signal). " },
arg2 = { name = “onset”, min = 5, max = 32767, tip = “attack onset duration in milliseconds, i.e., the ‘sharpness’ of the attack (Range:5ms to 32767ms). " },
arg3 = { name = “decay”, min = 5, max = 20000, tip = “attack decay duration in milliseconds (Range: 5 to < duration of infile).” },
arg4 = { name = “envtype”, switch = “-t”, min = 0, max = 1, tip = " type of envelope: 0 linear, 1 exponential (Default)” },
}

dsp["Envel Curtail - Curtail a soundfile by fading to zero at some time within it “] = {
cmds = { exe = “envel”, mode = “curtail 1”, tip = “specify the precise times at which the file is to begin and end.” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “fadeend”, min = 0, max = 50, set = “time at which to complete the fade” },
arg3 = { name = “envtype”, min = 0, max = 1, tip = “type of envelope shape for the fade, 0 linear, 1 exponential” },
arg4 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes” },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 2”] = {
cmds = { exe = “envel”, mode = “curtail 2”, tip = “specify the duration of the fade and when it begins.” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “fade-dur”, min = 0, max = 50, set = “time at which to complete the fade” },
arg3 = { name = “envtype”, min = 0, max = 1, tip = “type of envelope shape for the fade, 0 linear, 1 exponential” },
arg4 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 3”] = {
cmds = { exe = “envel”, mode = “curtail 3”, tip = “specify when the fade begins and fade to the existing end of insndfile” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “envtype”, min = 0, max = 1, tip = “type of envelope shape for the fade, 0 linear, 1 exponential” },
arg3 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 4”] = {
cmds = { exe = “envel”, mode = “curtail 4”, tip = “specify the precise times at which the file is to begin and end, and apply a doubly exponential (steeper) editing slope” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “fadeend”, min = 0, max = 50, set = “time at which to complete the fade” },
arg3 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 5”] = {
cmds = { exe = “envel”, mode = “curtail 5”, tip = “specify the duration of the fade and when it begins, and apply a doubly exponential (steeper) editing slope” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “fade-dur”, min = 0, max = 50, set = “time at which to complete the fade” },
arg3 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Curtail - Curtail a soundfile by fading to zero at some time within it 6”] = {
cmds = { exe = “envel”, mode = “curtail 6”, tip = “Specify when the fade begins and fade to the existing end of insndfile, applying a doubly exponential (steeper) editing slope” },
arg1 = { name = “fadestart”, min = 0, max = 50, tip = “time at which to begin the fade” },
arg2 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = " identifies the type of time unit being used: 0 seconds, 1 samples, 2 groupes" },
}

dsp[“Envel Dovetail - Dovetail a soundfile by enveloping its beginning and end”] = {
cmds = { exe = “envel”, mode = “dovetail 1”, tip = “a choice of linear or exponential slopes at the beginning and the end” },
arg1 = { name = “infadedur”, min = 0, max = 50, tip = “duration of the fade-in at the start of the file” },
arg2 = { name = “outfadedur”, min = 0, max = 50, tip = “duration of the fade-out at the end of the file” },
arg3 = { name = “intype”, min = 0, max = 1, tip = “envelope shape for the fade-in at the start of the file; intype = 0: linear fade, intype = 1: exponential fade (the Default)” },
arg4 = { name = “outtype”, min = 0, max = 1, tip = “envelope shape for the fade-out, at the end of the file; outtype = 0: linear fade, outtype = 1: exponential fade (the Default)” },
arg5 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = “identifies the type of time unit being used: times = 0: is seconds (the Default), times = 1: times are in samples, times = 2: times are in grouped-samples” },
}

dsp[“Envel Dovetail - Dovetail a soundfile by enveloping its beginning and end 2”] = {
cmds = { exe = “envel”, mode = “dovetail 2”, tip = “a doubly exponential slope (steeper) is applied to the beginning and the end” },
arg1 = { name = “infadedur”, min = 0, max = 50, tip = “duration of the fade-in at the start of the file” },
arg2 = { name = “outfadedur”, min = 0, max = 50, tip = “duration of the fade-out at the end of the file” },
arg3 = { name = “times”, switch = “-t”, min = 0, max = 2, tip = “identifies the type of time unit being used: times = 0: is seconds (the Default), times = 1: times are in samples, times = 2: times are in grouped-samples” },
}


dsp[“Envel Pluck - Pluck the start of a sound (Mono files only)”] = {
cmds = { exe = “envel”, mode = “pluck”, tip = “Although similar to ENVEL ATTACK, ENVEL PLUCK differs in that the attack imposed on the soundfile also has the noise and decay characteristics associated with plucked sounds. To pluck the sound, ENVEL PLUCK creates a ‘pluck’ constructed from a number of wavecycles and splices it into the beginning of the sound. To achieve this, it needs a goal wavecycle to pluck towards: this is located at startsamp.We can get an idea of what is going on here by reviewing how the Karplus-Strong pluck algorithm used in Csound works. It achieves a pluck effect by iteratively filtering a block of noise until it becomes pitched. It does this because noise components are an essential ingredient of a plucked sound. ENVEL PLUCK achieves the same effect by working backwards – backwards because it is starting with an existing sound. The process is to repeat wavelen backwards a number of times towards the beginning of the soundfile, becoming noisier as it goes.” },
arg1 = { name = “startsamp”, min = 0, max = 5000, tip = “is where the pluck effect links into the sound. It will usually be a little after the beginning of the sound, not at the very beginning, because we want the pluck to link smoothly into stable signal.” },
arg2 = { name = “wavelen”, min = 2, max = 2205, tip = "the number of (absolute) samples in the wavelength of the pluck effect; its value is the number of samples in a waveform starting at startsamp in the infile " },
arg3 = { name = “atkcycles”, switch = “-a”, min = 2, max = 32767, tip = “the number of wavecycles in the pluck attack” },
arg4 = { name = “decayrate”, switch = “-d”, min = 1, max = 64, tip = “rate of decay of the pluck effect” },
}

dsp["Envel Warp - Normalise the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 1”, tip = “NORMALISE; Expand envelope so that the highest envelope point is at the maximum possible amplitude value.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
}

dsp["Envel Warp - Reverse the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 2”, tip = “Reverse the envelope in time.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
}

dsp["Envel Warp - Exaggerate the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 3”, tip = “Exaggerate the envelope contour” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “exaggerate”, min = 0, max = 50, tip = “Range: > 0.0 < 1, low values are boosted = 1, no change, > 1, high values are boosted” },
}

dsp["Envel Warp - Attenuate the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 4”, tip = “Reduce the amplitude of an envelope.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “attenuation”, min = 0, max = 1, tip = “multiplier by which to scale down the envelope. Range: 0 to 1” },
}

dsp["Envel Warp - Lift the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 5”, tip = “Raise the envelope by a fixed amount” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “lift”, min = 0, max = 1, tip = “amount to add to each amplitude value. Range: 0 to 1” },
}

dsp["Envel Warp - Timestretch the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 6”, tip = “Stretch or compress an envelope in time.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “timestretch”, min = 0, max = 20, tip = “multiplier by which to stretch the envelope. Range: > 0.0 < 1.0 compresses the envelope in time, = 1.0 no change, > 1.0 stretches the envelope in time” },
}

dsp["Envel Warp - Flatten the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 7”, tip = “Even out the envelope contour.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “flatten”, min = 1, max = 5000, tip = “number of envelope values over which to average.” },
}

dsp["Envel Warp - Gate the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 8”, tip = “Zero lower portion of envelope.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “gate”, min = 0, max = 1, tip = “levels less than gate are set to 0. Range: 0 to 1.” },
arg3 = { name = “smoothing”, min = 0, max = 32767, tip = “smoothing – excises segments with an amplitude less than smoothing. Range: 0 to 32767.” },
}

dsp["Envel Warp - Invert the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 9”, tip = “Turn envelope upside down: negative values become positive, and positive values become negative.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “gate”, min = 0, max = 1, tip = “levels less than gate are set to 0. Range: 0 to < mirror.” },
arg3 = { name = “mirror”, min = 0, max = 1, tip = “reflection point: all values other than those below gate, both above and below mirror, are inverted to the other side of mirror. Range: > gate to 1.” },
}

dsp["Envel Warp - Limit the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 10”, tip = “Squeeze down amplitude into a specified range.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “limit”, min = 0, max = 1, tip = “upper limit of range; amplitude values which were above limit are scaled down such that ‘maxamp’ becomes limit. Range: > threshold to 1.” },
arg3 = { name = “threshold”, min = 0, max = 1, tip = “lower limit of range; only values above threshold are affected. Range: 0 to limit.” },
}

dsp["Envel Warp - Corrugate the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 11”, tip = “Tighten the peaks into close-set ridges by taking troughs (downward dips) in the envelope to zero.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “trofdel”, min = 0, max = 32767, tip = “number of windows to set to zero per trough. Range: 1 to < peak_separation.” },
arg3 = { name = “peak_separation”, min = 2, max = 32767, tip = “minimum number of windows per peak. Range: 2 to 32767.” },
}

dsp["Envel Warp - Expand the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 12”, tip = “Inflate the envelope” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “gate”, min = 0, max = 1, tip = “levels below gate are set to 0. Range: 0 to threshold.” },
arg3 = { name = “threshold”, min = 0, max = 1, tip = “lower limit of range: amplitude values that were above gate and below threshold are scaled up such that the minimum level becomes threshold. Range: gate to 1” },
arg4 = { name = “smoothing”, min = 0, max = 32767, tip = “Excises low-level segments which are less than smoothing windows in length. Range: 0 to 32767. 0 turns off the smoothing effect.” },
}

dsp["Envel Warp - Trigger the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 13”, tip = “Create a new envelope of sudden on bursts, triggered by the rate of rise of the current envelope.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “gate”, min = 0, max = 1, tip = “the average level must be above gate before triggering can occur. Range: 0 to 1.” },
arg3 = { name = “rise”, min = 0, max = 1, tip = “minimum loudness-step before triggering can occur. Range: 0 to 1.” },
arg4 = { name = “dur”, min = 0, max = 1000, tip = “maximum duration over which the rise can take place before triggering can occur. Range: must be >= the envelope window duration.” },
}

dsp["Envel Warp - Ceiling of the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 14”, tip = “Force envelope up to its maximum level, everywhere.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
}

dsp["Envel Warp - Duck the envelope of a soundfile "] = {
cmds = { exe = “envel”, mode = “warp 15”, tip = “Create ‘ducking’ envelope: envelope kept below a set level.” },
arg1 = { name = “wsize”, min = 0, max = 1000, tip = "the duration of the enveloping window, in milliseconds " },
arg2 = { name = “gate”, min = 0, max = 1, tip = “highest level allowed for the envelope. Range: 0 to 1.” },
arg3 = { name = “threshold”, min = 0, max = 1, tip = “Amplitude level the envelope must reach before ‘ducking’ is applied. Range: 0 to 1.” },
}

dsp[“Envel Swell - Cause sound to fade in to and out from a peak moment”] = {
cmds = { exe = “envel”, mode = “swell”, tip = " his is a generic envelope type which can be applied very easily by specifying the time of the peak moment and the shape to be applied.The peak moment (peaktime) can be the location of the maximum amplitude in the soundfile, which can be found with SNDINFO MAXSAMP). It could also be any other place in the file that you define. For example, you can take a completely flat sound (in terms of loudness) and make it swell to a peak (at any point you want) and die away again. The linear peaktype produces a less gradual fade. This function makes it easy to create an audible peak anywhere in a soundfile, and implement a swell to and from it without having to create a breakpoint file." },
arg1 = { name = “peaktime”, min = 0, max = 20, tip = “time in infile at which the peak moment is located.” },
arg2 = { name = “peaktype”, min = 0, max = 1, tip = “type of swell shape: 0 (linear) or 1 (exponential – the Default)” },
}

dsp[“Topantail2 Topantail - Fade both the beginning and end of a sound”] = {
cmds = { exe = “topantail2”, mode = “topantail”, tip = “TOPANTAIL2 provides another approach to extracting part of a soundfile by using gate levels. In this case it trims away signal before and after the extracted portion. The ‘backtracking’ function moves the initial cut point earlier in the sound, thus retaining some of the sound which may be below the startgate’s level.” },
arg1 = { name = “startgate”, min = 0, max = 1, tip = “level at start before which sound is to be removed. (Range: 0 to 1, Default: 0.001)” },
arg2 = { name = “endgate”, min = 0, max = 1, tip = “level at end after which sound is to be removed. (Range: 0 to 1, Default: 0.001)” },
arg3 = { name = “splicelen”, switch = “-s”, min = 0, max = 1000, tip = “splice length in milliseconds” },
arg4 = { name = “backtrack”, switch = “-b”, min = 0, max = 1000, tip = “backtrack in time from the initial gate point(found by the program) to an earlier splice point, in milliseconds” },
}

dsp[“Envel Tremolo - Tremolo a sound linearly between frequencies”] = {
cmds = { exe = “envel”, mode = “tremolo 1”, tip = “Tremolo is a pulsation in the amplitude of a sound. The frequency of the tremolo is the rate of the amplitude pulsation. (‘Vibrato’ is a frequency displacement.) This technique is familiar to us as a feature of various singing styles, and also as a control available on synthesisers. It can be used to enliven or enrich a sound, or to create more marked flutter effects, such as the ‘flutter-tongue’ technique on a wind instrument” },
arg1 = { name = “freq”, min = 0, max = 500, tip = “frequency of the tremolo (a low frequency oscillation: Range: 0 to 500)” },
arg2 = { name = “depth”, min = 0,0, max = 1,0, tip = “frequency displacement of the oscillation (Range: 0 to 1; the Default is 0.250)” },
arg3 = { name = “gain”, min = 0, max = 1, tip = “the overall signal gain, or envelope (Range 0 to 1; the Default is 1)” },
}

dsp[“Envel Tremolo - Tremolo a sound logarithmically”] = {
cmds = { exe = “envel”, mode = “tremolo 2”, tip = “Tremolo is a pulsation in the amplitude of a sound. The frequency of the tremolo is the rate of the amplitude pulsation. (‘Vibrato’ is a frequency displacement.) This technique is familiar to us as a feature of various singing styles, and also as a control available on synthesisers. It can be used to enliven or enrich a sound, or to create more marked flutter effects, such as the ‘flutter-tongue’ technique on a wind instrument” },
arg1 = { name = “freq”, min = 0, max = 500, tip = “frequency of the tremolo (a low frequency oscillation: Range: 0 to 500)” },
arg2 = { name = “depth”, min = 0,0, max = 1,0, tip = “frequency displacement of the oscillation (Range: 0 to 1; the Default is 0.250)” },
arg3 = { name = “gain”, min = 0, max = 1, tip = “the overall signal gain, or envelope (Range 0 to 1; the Default is 1)” },
}

dsp[“Tremolo Tremolo - Apply width-controlled tremolo to a soundfile linearly”] = {
cmds = { exe = “tremolo”, mode = “tremolo 1”, tip = "This applies tremolo to a soundfile with the added ability to narrow (‘squeeze’) the width of the tremolo segments " },
arg1 = { name = “freq”, min = 0, max = 500, tip = “frequency of the tremolo (a low frequency oscillation: Range: 0 to 500)” },
arg2 = { name = “depth”, min = 0,0, max = 1,0, tip = “frequency displacement of the oscillation (Range: 0 to 1; the Default is 0.250)” },
arg3 = { name = “gain”, min = 0, max = 1, tip = “the overall signal gain, or envelope (Range 0 to 1; the Default is 1)” },
arg4 = { name = “fineness”, min = 1, max = 10, tip = “squeeze the width of the tremolo: an integer value >= 1” },
}

dsp[“Tremolo Tremolo - Apply width-controlled tremolo to a soundfile logaritmically”] = {
cmds = { exe = “tremolo”, mode = “tremolo 2”, tip = "This applies tremolo to a soundfile with the added ability to narrow (‘squeeze’) the width of the tremolo segments " },
arg1 = { name = “freq”, min = 0, max = 500, tip = “frequency of the tremolo (a low frequency oscillation: Range: 0 to 500)” },
arg2 = { name = “depth”, min = 0,0, max = 1,0, tip = “frequency displacement of the oscillation (Range: 0 to 1; the Default is 0.250)” },
arg3 = { name = “gain”, min = 0, max = 1, tip = “the overall signal gain, or envelope (Range 0 to 1; the Default is 1)” },
arg4 = { name = “fineness”, min = 1, max = 10, tip = “squeeze the width of the tremolo: an integer value >= 1” },
}


dsp["[doesn’t work yet] Reverb - Multi-Channel reverb “] = {
cmds = { exe = “reverb”, mode = “0”, tip = " REVERB implements the now classic Schroeder/Moorer model, consisting of six comb filters in parallel, followed by four allpass filters in series. The comb filters generate the dense reverberation, and the allpass filters (with much shorter delay times) apply further smearing of the echoes to minimize the spectral colouration of the comb filters. A further allpass is applied to each output channel, each with a different randomly-chosen delay time. Each comb filter contains a simple low-pass filter to simulate high-frequency absorption - this also affects the overall reverberation time. A preset set of early reflections as defined by Moorer is incorporated; this can be replaced by a user-defined set either hand-written or created using ROOMRESP. The delay times for the filters are preset to suit a ‘medium room’ model, as suggested by Moorer. In most situations the user will not want to change these; however the option is provided to change these times by means of a simple text file.” },
arg1 = { name = “N”, switch = “-c”, min = 0, max = 16, def = 2, tip = “create outfile with N channels (Range: 1 <= N < 16; Default = 2)” },
arg2 = { name = “N”, switch = “-H”, min = 0, max = 44100, tip = “Apply Highcut filter to infile with cutoff frequency NHz(6dB per octave)” },
arg3 = { name = “N”, switch = “-L”, min = 0, max = 44100, tip = “apply Lowcut filter to infile with cutoff frequency NHz (12dB per octave)” },
arg4 = { name = “N”, switch = “-p”, min = 0, max = 1000, tip = “set reverb predelay to N msecs (shifts early reflections)” },
arg5 = { name = “egain”, min = 0,0, max = 1,0, tip = “set level of early reflections (Range: 0.0 to 1.0)” },
arg6 = { name = “mix”, mix = 0,0, max = 1,0, tip = “balance of direct and reverb signal (Range: 1.0 [weighted towards direct signal] to 0.0 [weighted towards reverb signal])” },
arg7 = { name = “rvbtime”, min = 0, max = 20, tip = “reverb decay time (to -60dB) in seconds” },
arg8 = { name = “absorb”, min = 0,0, max = 1,0, tip = “degree of hf damping to suggest roomsize (Range: 0.0 to 1.0)” },
arg9 = { name = “lpfreq”, min = 0, max = 22050, tip = “lowpass filter cutoff frequency in Hz applied at input to reverb” },
arg10 = { name = “trailertime”, min = 0, max = 20, tip = “time in seconds added to outfile for reverb tail” },
}

dsp["[doesn’t work yet] Roomverb - Multi-channel reverb with room simulation "] = {
cmds = { exe = “rmverb”, mode = “”, tip = “Although many of the parameters are the same as those for REVERB (q.v), the program operates very differently. Rather than use comb filters in parallel, ROOMVERB uses a variable network of ‘nested’ allpass filters inside an overall feedback loop. This has the effect of increasing the density of the reverberation over time, as is characteristic of most ‘real’ acoustic spaces. It is therefore dedicated more specifically to that task than is REVERB. Nevertheless, as the roomsize and feedback parameters are independently controllable, some unusal effects can still be created. For authentic reverb, it is important that the feedback level is not set too high, otherwise audible pulsations can be heard at the start of the reverberation. These can be mitigated to a degree by running REVERB several times in parallel, with slightly different reverb times, and mixing the results, or combining into a multi-channel file. Conversely, it is also possible to create an ‘infinite reverb’ effect by setting the feedback level to 1.0.The preset early reflections for a given room size are the same as those in REVERB.” },
arg1 = { name = “predelay”, switch = “-p”, min = 0, max = 5000, tip = “override early reflections delay in milliseconds” },
arg2 = { name = “N”, switch = “-c”, min = 0, max = 16, def = 2, tip = “create outfile with N channels (Range: 1 <= N < 16; Default = 2)” },
arg3 = { name = “N”, switch = “-H”, min = 0, max = 22050, tip = “Apply Highcut filter to infile with cutoff frequency NHz(6dB per octave)” },
arg4 = { name = “N”, switch = “-L”, min = 0, max = 22050, tip = “apply Lowcut filter to infile with cutoff frequency NHz (12dB per octave)” },
arg5 = { name = “rmsize”, min = 1, max = 3, tip = “1 (small), 2 (medium), or 3 (large)” },
arg5 = { name = “egain”, min = 0,0, max = 1,0, tip = “set level of early reflections (Range: 0.0 to 1.0)” },
arg6 = { name = “mix”, mix = 0,0, max = 1,0, tip = “balance of direct and reverb signal (Range: 1.0 [weighted towards direct signal] to 0.0 [weighted towards reverb signal])” },
arg7 = { name = “fback”, min = 0, max = 1, tip = “reverb feedback level: controls decaytime (Range: 0.0 to 1.0)” },
arg8 = { name = “absorb”, min = 0,0, max = 1,0, tip = “degree of hf damping to suggest roomsize (Range: 0.0 to 1.0)” },
arg9 = { name = “lpfreq”, min = 0, max = 22050, tip = “lowpass filter cutoff frequency in Hz applied at input to reverb” },
arg10 = { name = “trailertime”, min = 0, max = 20, tip = “time in seconds added to outfile for reverb tail” },
}

dsp["[doesn’t work yet] Tapdelay - stereo multi-echo generator with feedback"] = {
cmds = { exe = “tapdelay”, mode = “”, tip = "The principle behind a tapped delay line is that whereas in a standard delay line (e.g., 1 second long) the ouput is taken at the end, in a tapped delay line extra outputs are also taken at intermediate points, such as 0.1 secs, 0.3 secs and 0.75 secs. "
},
arg1 = { name = “tapgain”, min = 0.0001, max = 1,0, tip = “gain factor applied to output from delay line (Range: > 0.0; typical value: 0.25)” },
arg2 = { name = “Gain”, min = 0.001, max = 10000 },
arg3 = { name = “feedback”, min = -1,0, max = 1,0, tip = “delayed signal fed back into the input (Range: -1.0 to 1.0)” },
arg4 = { name = “mix”, min = 0,0, max = 1,0, tip = “proportion of source mixed with delay output (Range: 0.0 to < 1.0)” },
arg5 = { name = “trailtime”, min = 0, max = 10, tip = “extra time in seconds (beyond infile duration) for delays to play out” },
}

dsp["[doesn’t work?] Cantor - Cut holes in a sound in the manner of a cantor set (holes within holes within holes (hole-size = %))"] = {
cmds = { exe = “cantor”, mode = “set 1”, tip = “CANTOR gradually cuts a hole in the central third of the input sound, which must be mono, a ‘hole’ being a reduction in level (see SNDREPORT FINDHOLE). It then cuts holes in the central third of the remaining segments, and so on. The output soundfile consists of a sequence of sounds with more and more holes cut in it. Note that Mode 3 uses superimposed vibrato envelopes as well. " },
arg1 = { name = “holesize”, min = 0.0001, max = 100, tip = " the percentage of current segment-time taken up by a hole.” },
arg2 = { name = “holedig”, min = 0, max = 1, tip = “the depth of each cut as the hole is gradually created. Range: >0 to 1” },
arg3 = { name = “depth-trig”, min = 0, max = 1, tip = " the level depth of the hole triggering the next hole-cuttin" },
arg4 = { name = “splicelen”, min = 0, max = 1000, tip = “splicelength in milliseconds” },
arg5 = { name = “maxdur”, min = 0, max = 20, tip = “the maximum output duration of all the output sound” },
arg6 = { name = “-e”, switch = “-e”, tip = “extend the sound beyond the splicelen limits” },
}

dsp["[doesn’t work?] Cantor - Cut holes in a sound in the manner of a cantor set (holes within holes within holes (hole-size = fixed))"] = {
cmds = { exe = “cantor”, mode = “set 2”, tip = “CANTOR gradually cuts a hole in the central third of the input sound, which must be mono, a ‘hole’ being a reduction in level (see SNDREPORT FINDHOLE). It then cuts holes in the central third of the remaining segments, and so on. The output soundfile consists of a sequence of sounds with more and more holes cut in it. Note that Mode 3 uses superimposed vibrato envelopes as well. " },
arg1 = { name = “holesize”, min = 0.0001, max = 10, tip = " the (fixed) duration of the holes.” },
arg2 = { name = “holedig”, min = 0, max = 1, tip = “the depth of each cut as the hole is gradually created. Range: >0 to 1” },
arg3 = { name = “depth-trig”, min = 0, max = 1, tip = " the level depth of the hole triggering the next hole-cuttin" },
arg4 = { name = “splicelen”, min = 0, max = 1000, tip = “splicelength in milliseconds” },
arg5 = { name = “maxdur”, min = 0, max = 20, tip = “the maximum output duration of all the output sound” },
arg6 = { name = “-e”, switch = “-e”, tip = “extend the sound beyond the splicelen limits” },
}

dsp["[doesn’t work?] Cantor - Cut holes in a sound in the manner of a cantor set (holes within holes within holes (hole-size = vibrato))"] = {
cmds = { exe = “cantor”, mode = “set 3”, tip = “CANTOR gradually cuts a hole in the central third of the input sound, which must be mono, a ‘hole’ being a reduction in level (see SNDREPORT FINDHOLE). It then cuts holes in the central third of the remaining segments, and so on. The output soundfile consists of a sequence of sounds with more and more holes cut in it. Note that Mode 3 uses superimposed vibrato envelopes as well. " },
arg1 = { name = “holelev”, min = 0.0001, max = 1, tip = “the level of signal at the base of the holes” },
arg2 = { name = “holedig”, min = 0, max = 1, tip = “the depth of each cut as the hole is gradually created. Range: >0 to 1” },
arg3 = { name = “layercnt”, min = 0, max = 500, tip = “the number of vibrato layers used” },
arg4 = { name = “layerdec”, min = 0, max = 100, tip = " the depth of the next vibrato in relation to the previous one” },
arg5 = { name = “maxdur”, min = 0, max = 20, tip = “the maximum output duration of all the output sound” },
}

dsp["Constrict - Shorten the durations of any zero-level sections in a sound "] = {
cmds = { exe = “constrict”, mode = “constrict”, tip = “This is a form of time-contraction which does not time-stretch the sonic-substance of the source. Note that the constriction is a percentage. Thus: 50 will halve the silent gaps, 75 will take away three quarters of the silent gaps, 20 will reduce them to one-fifth their original length, 100 will eliminate the silences, 150 will cause the non-silent portions to overlap by half the duration of the original silences. It works only with soundfiles which contain areas of zero-level signal which can be contracted by the process.CONSTRICT can be used to take a sequence of rapidfile events separated by silences and make them even tighter.” },
arg1 = { name = “constriction”, min = 0, max = 200, tip = “percentage deletion of zero-level areas.” },
}

dsp[“Sfedit - Cut and keep a segment of a sound (Time in seconds)”] = {
cmds = { exe = “sfedit”, mode = “cut 1”, tip = “The start and end locations for a block of sound are specified, and that block is saved as a new soundfile. A long splice will give a smooth cutoff, a short splice an abrupt cutoff, and a zerio splice will usually produce a click. The splice window is applied to both the beginning and the end of the sound, so cannot be larger than half the length of the block. This function presumes the use of a graphic sound editor in order precisely to locate the places at which to begin end the block to be cut. Musical Applications; simply save a favoured portion of a soundfile, select a short, timbrally evolving, section of a soundfile and time-stretch it, cut part of the result and time-stretch again, etc. process a portion of a sound, and then reinsert it into the original. For example, isolate key portions of two sounds and pre-process each of them in preparation for a morph-transition; then reinsert them into their respective original soundfiles and do the morph, collect segments of various soundfiles in preparation for making a musical collage” },
arg1 = { name = “start”, min = 0, max = 20, tip = “time in infile where segment to keep begins” },
arg2 = { name = “end”, min = 0, max = 40, tip = “time in infile where segment to keep ends” },
arg3 = { name = “splice”, switch = “-w”, min = 0, max = 1000, tip = "splice window in milliseconds (Default: 15ms) " },
}

dsp[“Sfedit - Cut and keep the end portion of a sound (Time in seconds)”] = {
cmds = { exe = “sfedit”, mode = “cutend 1”, tip = “This function enables you to use a specified length of the last section of a sound without having to work out where that length begins. You just specify the length you want. Needless to say, it has to be shorter than the whole soundfile. Musical Applications; The way a sound ends varies a great deal and often has extra attributes, such as resonance, reverb or echoes. This material can therefore be useful in itself. For example, a piano tone starts percussively and ends gradually if left to ring on. When reversed, the sound swells, sounding very much like an organ. SFEDIT CUTEND can quickly cut the end portion, starting automatically after the beginning. Given a generous splice envelope and reversed with MODIFY RADICAL Mode 1, it can become quite a different sound altogether.” },
arg1 = { name = “length”, min = 0, max = 100, tip = “length of sound to keep, ending at the end of infile” },
arg2 = { name = “splice”, switch = “-w”, min = 0, max = 1000, tip = "splice window in milliseconds (Default: 15ms) " },
}

dsp[“Sfedit - Remove a segment from a soundfile and close up the gap”] = {
cmds = { exe = “sfedit”, mode = “excise 1”, tip = “Here the block start and end points mark a block to be removed. The size of the splice determines the smoothness (long splice) or abruptness (short splice) of the cuts. A zero splice usually creates a click at the splice point, except in the special case where the signal is zero. The splice ‘window’ enables the use to reshape the amplitude envelope at the point where the cuts are made. Musical Applications; A frequent use of this program will be to remove silence, glitches, or otherwise unwanted material from a sound. It could also be used to chop up a sound in a rough sort of way in order to create unexpected juxtapositions of material, e.g., words.” },
arg1 = { name = “start”, min = 0, max = 20, tip = “time in infile where segment to remove begins” },
arg2 = { name = “end”, min = 0, max = 40, tip = “time in infile where segment to remove ends” },
arg3 = { name = “splice”, switch = “-w”, min = 0, max = 1000, tip = "splice window in milliseconds (Default: 15ms) " },
}

dsp[“Sfedit - Insert silence into a sound (overwriting or spreading the sound apart)”] = {
cmds = { exe = “sfedit”, mode = “insil 1”, tip = “This process will create a gap in the infile at a specified point in time, either pushing apart or overwriting the original sound for the duration of the silence. Musical Applications; This can be used at the beginning of a sound to ‘hard-wire’ a gap into a mix. Another application would be to spread the timing of two events in a sound by a specified amount.” },
arg1 = { name = “time”, min = 0, max = 20, tip = “time in seconds in infile at which the silence is to begin” },
arg2 = { name = “duration”, min = 0, max = 40, tip = “length of silence in seconds” },
arg3 = { name = “splice”, switch = “-w”, min = 0, max = 1000, tip = "splice window in milliseconds (Default: 15ms) " },
arg4 = { name = “-o”, switch = “-o”, tip = “overwrite the original file with the inserted file (Default: the silence pushes the infile apart)” },
arg5 = { name = “-s”, switch = “-s”, tip = "retains any silence written over file end (Default: rejects silence added at file end) "},
}

dsp["[doesn’t work yet] Isolate Disjunct portions of soundfile are specified by dB loudness and saved to separate files"] = {
cmds = { exe = “isolate”, mode = “isolate 3”, tip = “ISOLATE is similar to PARTITION in that the primary operation is to cut a soundfile into disjunct pieces and assign these to different output soundfiles. It does this in a special way so that the time-position of these pieces in the original soundfile is retained: silence is inserted between the cut pieces in the outputs to achieve this (‘silent surrounds’). The result is that the disjunct pieces can be reassembled in their original positions (remixed with everything synchronised at time zero): One difference between ISOLATE and PARTITION is that the number of output files is user-defined in PARTITION and worked out by the program, depending on the Mode selected, in ISOLATE. Another different is that Modes 1, 2 and 3 of ISOLATE generate a file containing all the materials left over after cutting. This is also used in reconstructing the original (now-treated) soundfile. However, the main difference between ISOLATE and PARTITION is how the disjunct pieces are identified. In PARTITION there are automatic processes for this, but the number of output files is user-defined by the outcnt parameter, and the durations are controlled by the groupcnt or dur parameters. In ISOLATE the user specifies start end times for the pieces in a textfile: the cutsfile (Modes 1-2) or specifies a list of (increasing) times in splicefile Modes 4-5, or they are picked up by level thresholds (dBon and dBoff (Mode 3). You are advised to familiarise yourself with the way the different Modes create different numbers of output soundfiles containing different numbers of segments.” },
arg1 = { name = “outnam”, min = 0, max = 10, def = 0, tip = “generic root name for the output soundfiles. Numerals starting at 0 are appended to distinguish the outputs.” },
arg2 = { name = “dBon”, min = 0, max = 140, tip = “the dB level at which a segment is recognised” },
arg3 = { name = “dBoff”, min = 0, max = 140, tip = “the dB level at which a recognised segment is triggered to end” },
arg4 = { name = “splice”, switch = “-s”, min = 0, max = 500, tip = " the length of the splice in milliseconds (Range: 0 to 500. Default: 15)" },
arg5 = { name = “min”, switch = “-m”, min = 2, max = 1000, tip = “the minimum duration in milliseconds of segments to accept (Range: > 2 * splice)”},
}

dsp["[doesn’t work?] Sfedit - Noisecut, suppress noise in a (mono) sound file, replacing with silence"] = {
cmds = { exe = “sfedit”, mode = “noisecut”, tip = “This process was developed after many attempts to automatically separate the noise constituents (sibilants etc.) from speech whilst trying to track the pitch of the other material. It uses a filter to recognise the presence of sibilants in the speech and allows vowels (and strongly pitched iteratives) to be separated – in place (i.e., remaining at their original time) – from the speech stream. Alternatively, the sibilants (i.e., noise) can be similarly extracted, in place. This is the -n option. Musical applications; One way to apply this function is to use it to treat the pitched and unpitched components in a stream of events in different ways. You could first separate the pitched and noise elements (using this program in its two different senses). Then you might add tremolo to the pitched elements and after this reintroduce the unmodified noise elements by mixing them with the undulating tones.” },
arg1 = { name = “splicelen”, min = 0, max = 1000, tip = “duration of splice slopes, in milliseconds” },
arg2 = { name = “noisfrq”, min = 0, max = 22050, tip = “frequency above which the signal is regarded as noise (try 6000 Hz)” },
arg3 = { name = “maxnoise”, min = 1000, max = 22050, tip = “the maximum duration in milliseconds of any noise segments permitted to remain, i.e., NOT replaced. Range: 1000 to 22050ms” },
arg4 = { name = “mintone”, min = 0, max = 50, tip = “the minimum duration in milliseconds of any non-noise segments to be retained. Range: 0 to 50ms” },
arg5 = { name = “-n”, switch = “-n”, tip = "option to retain noise rather than non-noise "},
}

dsp[“Prefix Silence - Add silence to the beginning of a soundfile”] = {
cmds = { exe = “prefix”, mode = “silence”, tip = “PREFIX SILENCE simply places the specified duration of silence at the beginning of the infile. Musical Applications; This can be a straightforward way to create a gap between soundfiles, or time an entry. The utility might come in handy when running batch files” },
arg1 = { name = “dur”, min = 0, max = 10, tip = “duration of silence to add” },
}

dsp["[doesn’t work?] Sfedit - Randchunks, cut chunks from a soundfile, randomly "] = {
cmds = { exe = “sfedit”, mode = “randchunks”, tip = “SFEDIT RANDCHUNKS is like SFEDIT RANDCUTS but enables you to be more specific about the number of chunks (chunkcnt) and their length (minchunk and the optional maxchunk). Each chunk is saved as a new soundfile, with a name derived from the name of the infile. Musical applications; The number and length controls make it possible to make a controlled number of chunks of random length within a specified range. The ability to focus on the start of the soundfile enables you to explore the qualities of the attack portion of the sound.” },
arg1 = { name = “chunkcnt”, min = 0, max = 100, tip = “the number of chunks to cut” },
arg2 = { name = “minchunk”, min = 0, max = 10, tip = “the minimum length of the chunks, in seconds” },
arg3 = { name = “maxchunk”, switch = “-m”, min = 0, max = 5, tip = “the maximum lengths of the chunks, in seconds” },
arg4 = { name = “-l”, switch = “-l”, tip = “chunks chosen are evenly distributed over the file (Default: random distribution)” },
arg5 = { name = “-s”, switch = “-s”, tip = "all chunks start at the beginning of the file " },
}

dsp["[doesn’t work?] Sfedit - Randcuts - Cut soundfile into pieces with cuts at random times"] = {
cmds = { exe = “sfedit”, mode = “randcuts”, tip = “SFEDIT RANDCUTS provides a way to cut up a soundfile into several portions of a specified average length, saving each as a separate soundfile. The amount of difference in the lengths can be adjusted with the scattering parameter: the regularity of the lengths gets less and less as scatter increases. Musical applications; This could be a way of multiplying source material when a given soundfile has sufficient variation in its contents to justify the procedure.” },
arg1 = { name = “average-chunklen”, min = 0, max = 100, tip = “the average length of the chunks to cut” },
arg2 = { name = “scattering”, min = 0, max = 8, tip = “controls the amount of variation in the length of the cuts (Range: 0 to 8)” },
}

dsp["[doesn’t work?] Sfedit - Shrink from end - Repeat a sound, shortening it on each repetition"] = {
cmds = { exe = “shrink”, mode = “shrink 1”, tip = “With SHRINK a sound is repeated, and at each repetition it gets shorter in duration because some of it is removed.” },
arg1 = { name = “shrinkage”, min = 0,0, max = 10, tip = “shortening factor of sound from one repeat to the next. Shrinkage stops once envents become too short short splices.” },
arg2 = { name = “gap”, min = 0, max = 50, tip = “initial timestep between output events” },
arg3 = { name = “contract”, min = 0, max = 1, tip = “shortening of gaps between output events: 1.0 = events are equally spaced, < 1.0 = events become closer together.” },
arg4 = { name = “dur”, min = 0, max = 20, tip = “the (minimum) duration of the output” },
arg5 = { name = “spl”, min = 0, max = 1000, tip = “splice length in milliseconds” },
arg6 = { name = “small”, switch = “-s”, min = 0, max = 10, tip = “the minimum sound length, after which sounds are of equal length” },
arg7 = { name = “min”, switch = “-m”, min = 0, max = 10, tip = “the minimum event separation, after which events are regular in time” },
arg8 = { name = “rnd”, switch = “-r”, min = 0, max = 10, tip = “randomisation of timings after which events are regular in time” },
arg9 = { name = “-n”, switch = “-n”, tip = “equalise the maximum level of output events (if possible)” },
arg10 = { name = “i”, switch = “-i”, tip = “Inverse: reverse each segment in the output.” },
}

dsp["[doesn’t work?] Sfedit - Shrink around midpoint - Repeat a sound, shortening it on each repetition"] = {
cmds = { exe = “shrink”, mode = “shrink 2”, tip = “With SHRINK a sound is repeated, and at each repetition it gets shorter in duration because some of it is removed.” },
arg1 = { name = “shrinkage”, min = 0,0, max = 10, tip = “shortening factor of sound from one repeat to the next. Shrinkage stops once envents become too short short splices.” },
arg2 = { name = “gap”, min = 0, max = 50, tip = “initial timestep between output events” },
arg3 = { name = “contract”, min = 0, max = 1, tip = “shortening of gaps between output events: 1.0 = events are equally spaced, < 1.0 = events become closer together.” },
arg4 = { name = “dur”, min = 0, max = 20, tip = “the (minimum) duration of the output” },
arg5 = { name = “spl”, min = 0, max = 1000, tip = “splice length in milliseconds” },
arg6 = { name = “small”, switch = “-s”, min = 0, max = 10, tip = “the minimum sound length, after which sounds are of equal length” },
arg7 = { name = “min”, switch = “-m”, min = 0, max = 10, tip = “the minimum event separation, after which events are regular in time” },
arg8 = { name = “rnd”, switch = “-r”, min = 0, max = 10, tip = “randomisation of timings after which events are regular in time” },
arg9 = { name = “-n”, switch = “-n”, tip = “equalise the maximum level of output events (if possible)” },
arg10 = { name = “i”, switch = “-i”, tip = “Inverse: reverse each segment in the output.” },
}

dsp["[doesn’t work?] Sfedit - Shrink from start - Repeat a sound, shortening it on each repetition"] = {
cmds = { exe = “shrink”, mode = “shrink 3”, tip = “With SHRINK a sound is repeated, and at each repetition it gets shorter in duration because some of it is removed.” },
arg1 = { name = “shrinkage”, min = 0,0, max = 10, tip = “shortening factor of sound from one repeat to the next. Shrinkage stops once envents become too short short splices.” },
arg2 = { name = “gap”, min = 0, max = 50, tip = “initial timestep between output events” },
arg3 = { name = “contract”, min = 0, max = 1, tip = “shortening of gaps between output events: 1.0 = events are equally spaced, < 1.0 = events become closer together.” },
arg4 = { name = “dur”, min = 0, max = 20, tip = “the (minimum) duration of the output” },
arg5 = { name = “spl”, min = 0, max = 1000, tip = “splice length in milliseconds” },
arg6 = { name = “small”, switch = “-s”, min = 0, max = 10, tip = “the minimum sound length, after which sounds are of equal length” },
arg7 = { name = “min”, switch = “-m”, min = 0, max = 10, tip = “the minimum event separation, after which events are regular in time” },
arg8 = { name = “rnd”, switch = “-r”, min = 0, max = 10, tip = “randomisation of timings after which events are regular in time” },
arg9 = { name = “-n”, switch = “-n”, tip = “equalise the maximum level of output events (if possible)” },
arg10 = { name = “i”, switch = “-i”, tip = “Inverse: reverse each segment in the output.” },
}

dsp["[doesn’t work?] Sfedit - Shrink from specified time - Repeat a sound, shortening it on each repetition"] = {
cmds = { exe = “shrink”, mode = “shrink 4”, tip = “With SHRINK a sound is repeated, and at each repetition it gets shorter in duration because some of it is removed.” },
arg1 = { name = “time”, min = 0, max = 10, tip = “time around which shrinkage takes place” },
arg2 = { name = “shrinkage”, min = 0,0, max = 10, tip = “shortening factor of sound from one repeat to the next. Shrinkage stops once envents become too short short splices.” },
arg3 = { name = “gap”, min = 0, max = 50, tip = “initial timestep between output events” },
arg4 = { name = “contract”, min = 0, max = 1, tip = “shortening of gaps between output events: 1.0 = events are equally spaced, < 1.0 = events become closer together.” },
arg5 = { name = “dur”, min = 0, max = 20, tip = “the (minimum) duration of the output” },
arg6 = { name = “spl”, min = 0, max = 1000, tip = “splice length in milliseconds” },
arg7 = { name = “small”, switch = “-s”, min = 0, max = 10, tip = “the minimum sound length, after which sounds are of equal length” },
arg8 = { name = “min”, switch = “-m”, min = 0, max = 10, tip = “the minimum event separation, after which events are regular in time” },
arg9 = { name = “rnd”, switch = “-r”, min = 0, max = 10, tip = “randomisation of timings after which events are regular in time” },
arg10 = { name = “-n”, switch = “-n”, tip = “equalise the maximum level of output events (if possible)” },
arg11 = { name = “i”, switch = “-i”, tip = “Inverse: reverse each segment in the output.” },
}


dsp["Silend - Add silence to the end of a soundfile “] = {
cmds = { exe = “silend”, mode = “silend 1”, tip = " Musical Applications; One application is to add silence at the end of each soundfile when assembling a list of soundfiles to be played as one sequence. This puts pauses between the sounds, pauses that are more appropriately placed at the end rather than the beginning.” },
arg1 = { name = “sildur”, min = 0, max = 10, tip = “duration of silence to add” },
}

dsp["Silend - Add silence to the end of a soundfile 2 “] = {
cmds = { exe = “silend”, mode = “silend 2”, tip = " Musical Applications; One application is to add silence at the end of each soundfile when assembling a list of soundfiles to be played as one sequence. This puts pauses between the sounds, pauses that are more appropriately placed at the end rather than the beginning.” },
arg1 = { name = “outdur”, min = 0, max = 30, tip = “duration of silence to add” },
}

dsp["[Doesn’t work?] Stretch - stretch/compress duration of infile without changing the pitch"] = {
cmds = { exe = “stretch time”, mode = “1”, tip = “The key here is to time stretch the sound without altering the pitch. This can be used either to lengthen or compress the duration. Formerly SPECSTR, meaning ‘spectrum time-stretching’, the internal prolongation of spectral data is itself subject to temporal control according to the amount of stretch specified at different times.” },
arg1 = { name = “timestretch”, min = 0, max = 10, tip = “Timestretch is used as a multiple.” },
}

dsp[“Sfedit - Zcut, keep a segment of a MONO soundfile, cutting at zero crossings”] = {
cmds = { exe = “sfedit”, mode = “zcut 1”, tip = “This process uses an alternative method to ‘splice’ the sound segments, cutting them at the nearest zero-crossings in the signal, rather than making a splice slope of default or specified duration . Nevertheless the cuts should be clickless. Musical Applications; This is a different way of cutting out a segment of sound. The start and end times you give are approximate because the nearest zero points will probably not be precisely at those times.” },
arg1 = { name = “start”, min = 0, max = 10, tip = “(approximate) time in the infile where the segment to keep begins” },
arg2 = { name = “end”, min = 0, max = 20, tip = “(approximate) time in the infile where the segment to keep ends” },
}

dsp[“Envnu Expdecay - Produce a true exponential decay to zero on a sound”] = {
cmds = { exe = “envnu”, mode = “expdecay”, tip = “An exponential curve involves a steady increase in the exponent of a number, its ‘power’: 21 = 2, 22 = 4, 23 = 8 – i.e., a progressive doubling, as opposed to a linear curve, which adds a constant value each time: 2 - 4 - 6 - 9 - 10 etc. In the case of an amplitude envelope, 1 is divided by these progressively increasing numbers: 1 ÷ 2 = 0.5, 1 ÷ 4 = 0.25, 1 ÷ 8 = 0.125 etc. This means that the rate of decay will be large to start with and then get progressively less (halving each time). The effect is that the decay slope starts very steeply and gradually becomes less steep as it proceeds to zero. It reaches zero (-100 dB) very gradually so that the tail-off is very smooth – and much of the last part of the soundfile is likely to be less than -50dB.” },
arg1 = { name = “starttime”, min = 0, max = 10, tip = “(time at which the decay begins” },
arg2 = { name = “endtime”, min = 0, max = 20, tip = “(time at which the decay reaches zero” },
}

dsp[“Peakchop - Isolate peaks in a source and play back at a specified tempo”] = {
cmds = { exe = “envnu”, mode = “peakchop 1”, tip = “ENVNU PEAKCHOP first finds the peaks in the source. It then defines an area surrounding/following the peak, whose duration is determined by pkwidth. It then cuts chunks from the source at these places, cutting each chunk independently. This means that the first chunk can extend beyond the beginning of the next chunk(s) to be cut. These chunks are then played back in turn, at the specified tempo” },
arg1 = { name = “wsize”, min = 1, max = 64, tip = “windowsize (in milliseconds) for extracting the envelope (Range: 1 to 64, Default: 50)” },
arg2 = { name = “pkwidth”, min = 0, max = 1000, tip = “width in milliseconds of retained peaks (Range: 0 to 1000, Default: 20ms)” },
arg3 = { name = “risetime”, min = 0, max = 1000, tip = “risetime in milliseconds from zero to peak (Default: 10ms)” },
arg4 = { name = “tempo”, min = 20, max = 3000, tip = “tempo of resulting output (Metronome Mark = events per minute: as is customary, 60 means 1 per second, 120 means 2 per second etc.) (Range: 20 to 3000)” },
arg5 = { name = “gain”, min = 0, max = 1, tip = “lower this if rapid tempo causes peaks to overlap (The program should produce a warning message should clipping result from the settings.) (Range: 0 to 1, Default 1)” },
arg6 = { name = “gate”, switch = “-g”, min = 0, max = 1, tip = “level (relative to max) below which peaks are ignored (Range: 0 to 1, Default: 0)” },
arg7 = { name = “skew”, switch = “-q-”, min = 0, max = 1, tip = “envelope centring on peak (Range: 0 to 1, Default: 0.25)” },
arg8 = { name = “scatter”, switch = “-s”, min = 0, max = 1, tip = “randomisation of transposition contour from impulse to impulse” },
arg9 = { name = “-norm”, switch = “-norm”, min = 0, max = 1, tip = “force peakevent levels towards that of the loudest peak (Range: 0 to 1, Default: 0)” },
arg10 = { name = “repeat”, switch = “-r”, min = 0, max = 256, tip = “number of times peakevents are repeated (Range: 0 to 256, Default: 0)” },
arg11 = { name = “miss”, switch = “-m”, min = 0, max = 64, tip = “use peakevent, then skip the next miss peakevents (Range: 0 to 64, Default: 0)” },
}

dsp[“Extend Baktobak - Join a time-reversed copy of the sound to a normal copy, in that order”] = {
cmds = { exe = “extend”, mode = “baktobak”, tip = “I call the outputs of this process (learnt from Denis Smalley), fugu sounds. There is a particular Japanese fish delicacy, the fugu fish, which has a poisonous liver, but tastes best the nearer to the liver you slice the fish (!). Fugu sounds are made using an attack-resonance source (a sound with a sharp attack which then fades away to nothing). A Reverse copy of the sound is made and then spliced onto the original so the sound now grows from nothing until it reaches a peak of loudness and spectral brightness and then fades once again to zero. Musical applications; If the crossfade is made just before the peak is reached, the sound is less loud and bright in the centre, and in fact a whole sequence of such musically related sounds can be made, each of different loudness/brightness in the centre. This process allows such sounds to be made in a single pass.” },
arg1 = { name = “join_time”, min = 0, max = 10, tip = “time in infile where join-cut is to be made” },
arg2 = { name = “splice-length”, min = 0, max = 2500, tip = “(length of the splice, in milliseconds” },
}

dsp[“Extend Doublets - Divide a sound into segments that repeat, and splice them together”] = {
cmds = { exe = “extend”, mode = “doublets”, tip = "EXTEND DOUBLETS is a ‘slice’ function, like the ones we are familiar with in the visual realm. The difference, here, in the temporal realm, is the repetition parameter. We specify the length of the segments (slices) and the number of times it repeats. What we hear depends, as usual, on the sonic material. With voices or conventional music, the effect will be like the needle getting stuck on a vinyl record: a short passage repeats. With more complex sonic material, we would get a pulsing, mechanical effect. Especially note that the length of the segment (segdur) parameter can vary over time. " },
arg1 = { name = “segdur”, min = 0, max = 10, tip = “duration of segments” },
arg2 = { name = “repets”, min = 0, max = 100, tip = “number of times each segment is repeated” },
arg3 = { name = “-s”, switch = “-s”, tip = “option to have outfile try to stay synchronised with the infile” },
}

dsp[“Extend Drunk - Drunken walk through source file (chosen segments read forwards)”] = {
cmds = { exe = “extend”, mode = “drunk 1”, tip = “Another approach to segmentation, EXTEND DRUNK takes a series of segments selected from the infile and splices them together to form the outfile. The process starts at some time in the file, called the locus and selects a segment, randomly, from within an ‘ambit’. The length of ‘ambit’ is 2 * ambitus, and stretches to both sides of the locus position. Once a segment is read, the program moves (randomly) to a new position in either direction, within the ambit, and not more than step from the start location of the previous segment, from where it starts the next read. This is called a ‘random walk’; hence the name ‘drunk’. The function is based on a drunken walk algorithm implemented by Miller Puckette. While it is doing this walk, one can shift the locus, e.g., progressing slowly through the file. (NB: note above about times in the breakpoint file.) The ‘ambit’ – the portion of the soundfile being used at any one time, can be varied by altering the size of the ambitus, which is one-half the full ‘ambit’ width. The step, which is the maximum distance between the start of one read and the start of the next read (but must lie within the ambit), can also be varied. For example, if the ambitus is small, segments very close to one another will be selected. Or if the step is much smaller than the segment size (a slow clock produces longer segments), selected segments will tend to overlap, producing random echoes or pre-echoes. The length of the segment, determined by the clock parameter is NOT constrained to the size of the ambit, so segments may begin within the ambit and end outside it. Segments which would end beyond the specified outdur are truncated. To summarise, then, locus, ambitus and step all refer to start locations. Clock refers to segment length. The process continues until outdur is filled, which makes it a useful program with which to generate material.” },
arg1 = { name = “outdur”, min = 1, max = 60, tip = “total minimum duration of output soundfile (seconds)” },
arg2 = { name = “locus”, min = 0, max = 25, tip = “time in infile at which the drunken walk occurs (seconds)” },
arg3 = { name = “ambitus”, min = 0, max = 25, tip = “half-width of the region from within which the sound segments are read (seconds)” },
arg4 = { name = “step”, min = 0,002, max = 10, tip = “maximum length of (random) step between segment reads (> 0.002 seconds); this always falls within the ambitus: it is automatically adjusted where too large” },
arg5 = { name = “clock”, min = 0, max = 10, tip = “time between segment reads: this is the segment duration (> splicelen * 2) (seconds)” },
arg6 = { name = “splicelen”, switch = “-s”, min = 0, max = 1000, tip = “length in milliseconds of the splice slope (Default: 15ms)” },
arg7 = { name = “clokrand”, switch = “-c-”, min = 0, max = 1, tip = “randomisation of clock ticks (Range: 0 to 1 Default: 0)” },
arg8 = { name = “overlap”, switch = “-o”, min = 0, max = 0,9900, tip = “mutual overlap of segments in output (Range: 0 to 0.9900 Default: 0)” },
arg9 = { name = “seed”, switch = “-r”, tip = “any set value gives reproducible output” },
}

dsp[“Extend Drunk - Drunken walk 2 through source file (chosen segments read forwards)”] = {
cmds = { exe = “extend”, mode = “drunk 2”, tip = “Another approach to segmentation, EXTEND DRUNK takes a series of segments selected from the infile and splices them together to form the outfile. The process starts at some time in the file, called the locus and selects a segment, randomly, from within an ‘ambit’. The length of ‘ambit’ is 2 * ambitus, and stretches to both sides of the locus position. Once a segment is read, the program moves (randomly) to a new position in either direction, within the ambit, and not more than step from the start location of the previous segment, from where it starts the next read. This is called a ‘random walk’; hence the name ‘drunk’. The function is based on a drunken walk algorithm implemented by Miller Puckette. While it is doing this walk, one can shift the locus, e.g., progressing slowly through the file. (NB: note above about times in the breakpoint file.) The ‘ambit’ – the portion of the soundfile being used at any one time, can be varied by altering the size of the ambitus, which is one-half the full ‘ambit’ width. The step, which is the maximum distance between the start of one read and the start of the next read (but must lie within the ambit), can also be varied. For example, if the ambitus is small, segments very close to one another will be selected. Or if the step is much smaller than the segment size (a slow clock produces longer segments), selected segments will tend to overlap, producing random echoes or pre-echoes. The length of the segment, determined by the clock parameter is NOT constrained to the size of the ambit, so segments may begin within the ambit and end outside it. Segments which would end beyond the specified outdur are truncated. To summarise, then, locus, ambitus and step all refer to start locations. Clock refers to segment length. The process continues until outdur is filled, which makes it a useful program with which to generate material.” },
arg1 = { name = “outdur”, min = 1, max = 60, tip = “total minimum duration of output soundfile (seconds)” },
arg2 = { name = “locus”, min = 0, max = 25, tip = “time in infile at which the drunken walk occurs (seconds)” },
arg3 = { name = “ambitus”, min = 0, max = 25, tip = “half-width of the region from within which the sound segments are read (seconds)” },
arg4 = { name = “step”, min = 0,002, max = 10, tip = “maximum length of (random) step between segment reads (> 0.002 seconds); this always falls within the ambitus: it is automatically adjusted where too large” },
arg5 = { name = “clock”, min = 0, max = 10, tip = “time between segment reads: this is the segment duration (> splicelen * 2) (seconds)” },
arg6 = { name = “mindrnk”, min = 1, max = 32767, tip = “minimum number of clock ticks between sober plays (1 - 32767 Default: 10)” },
arg7 = { name = “maxdrnk”, min = 1, max = 32767, tip = “maximum number of clock ticks between sober plays (1 - 32767 Default: 30)” },
arg8 = { name = “splicelen”, switch = “-s”, min = 0, max = 1000, tip = “length in milliseconds of the splice slope (Default: 15ms)” },
arg9 = { name = “clokrand”, switch = “-c-”, min = 0, max = 1, tip = “randomisation of clock ticks (Range: 0 to 1 Default: 0)” },
arg10 = { name = “overlap”, switch = “-o”, min = 0, max = 0,9900, tip = “mutual overlap of segments in output (Range: 0 to 0.9900 Default: 0)” },
arg11 = { name = “seed”, switch = “-r”, tip = “any set value gives reproducible output” },
arg12 = { name = “losober”, switch = “-l”, min = 0, max = 10, tip = “minimum duration of sober plays (seconds) (Range: > 0 to duration of infile+. If >= duration of infile, all sober plays go to the end of the source.” },
arg13 = { name = “hisober”, switch = “-h”, min = 0, max = 10, tip = "maximum duration of sober plays (seconds) " },
}

dsp["[doesn’t work - no .exe!] Echoes - Repeat a sound with timing and level adjustments between repeats"] = {
cmds = { exe = “echoes”, mode = “echo”, tip = “CDP’s EXTEND LOOP enables you to step through a soundfile while adding each step-segment to an output soundfile. It does not allow you to specify an endtime beyond the end of the input sound (it cuts off). EXTEND REPETITIONS enables you to repeat a whole soundfile, whether overlapping or with a gap between repetitions: i.e., the time of repetition is beyond the end of the input sound. This new ECHOES function complements these two features by placing the repeats after the end of the input soundfile.” },
arg1 = { name = “delay”, min = 0, max = 60, tip = “time in seconds between echo repeats (Range: greater than the length of insndfile to 60 sec.” },
arg2 = { name = “attenuation”, min = 0, max = 1, tip = “relative (diminishing) level of each repeat (Range: 0 to 1)” },
arg3 = { name = “totaldur”, min = 0, max = 120, tip = “maximum output duration (actual duration may be less); it must be a minimum of 2 x delay.” },
arg4 = { name = “rand”, switch = “-r”, min = 0, max = 1, tip = “randomisation of echo times (Range: 0 to 1)” },
arg5 = { name = “cutoff”, switch = “-c”,min = -96,0, max = 0,0, tip = "all chunks start at the beginning of the file " },
}

dsp["[doesn’t work?] Extend Freeze 1 - Freeze a segment of a sound by iteration in a fluid manner"] = {
cmds = { exe = “extend”, mode = “freeze 1”, tip = “Extend a specific part of a sound using the iteration procedure. This tends to give a more convincing time-stretching result than any of the other time-stretch procedures, particularly as the non-time-stretched portions of the sound are not subject to any processing. The internal proportions of a sound event can be manipulated using this process. Musical applications; The start and end times of the freeze enable you to focus on very specific parts of the sound, such as the ‘a’ in ‘star’ or the ‘s’ in ‘star’. With this program you can extend these to form sounds such as ‘staaaaaaaaaaaaaaaaaaaar’ or ‘ssssssssssssssssssstar’. Given the claim that it gives ‘a more convincing time-stretching result than any of the other time-stretch procedures’, it is a program well worth exploring thoroughly.” },
arg1 = { name = “outduration”, min = 1, max = 30, tip = “Desired duration of resultant soundfile.” },
arg2 = { name = “delay”, min = 0, max = 25, tip = “The (average) delay between iterations: <= length of frozen segment.” },
arg3 = { name = “rand”, min = 0, max = 1, tip = “Delaytime randomisation. Range: 0 to 1. Default: 0.” },
arg4 = { name = “pshift”, min = 0, max = 12, tip = “Maximum of random pitchshift of each iteration. Range: 0 to 12 semitones. E.g., 2.5 = 2.5 semitones up or down.” },
arg5 = { name = “ampcut”, min = 0, max = 1, tip = “Maximum of random amplitude reduction on each iteration. Range: 0 to 1. Default: 0.” },
arg6 = { name = “starttime_of_freeze”, min = 0, max = 25, tip = “Time where the frozen segment begins in the original sound.” },
arg7 = { name = “endtime”, min = 0, max = 25, tip = "Time where the frozen segment ends in the original sound. " },
arg8 = { name = “gain”, min = 0, max = 1, tip = “gain, innit.” },
arg9 = { name = “seed”, switch = “-s-”, tip = “The same seed number will produce identical output on rerun. Default: 0 – random sequence is different every time.” },
}

dsp["[doesn’t work?] Extend Freeze 2 - Freeze a segment of a sound by iteration in a fluid manner - specify repetitions"] = {
cmds = { exe = “extend”, mode = “freeze 2”, tip = “Extend a specific part of a sound using the iteration procedure. This tends to give a more convincing time-stretching result than any of the other time-stretch procedures, particularly as the non-time-stretched portions of the sound are not subject to any processing. The internal proportions of a sound event can be manipulated using this process. Musical applications; The start and end times of the freeze enable you to focus on very specific parts of the sound, such as the ‘a’ in ‘star’ or the ‘s’ in ‘star’. With this program you can extend these to form sounds such as ‘staaaaaaaaaaaaaaaaaaaar’ or ‘ssssssssssssssssssstar’. Given the claim that it gives ‘a more convincing time-stretching result than any of the other time-stretch procedures’, it is a program well worth exploring thoroughly.” },
arg1 = { name = “repetitions”, min = 1, max = 30, tip = “Number of repetitions of frozen segment.” },
arg2 = { name = “delay”, min = 0, max = 25, tip = “The (average) delay between iterations: <= length of frozen segment.” },
arg3 = { name = “rand”, min = 0, max = 1, tip = “Delaytime randomisation. Range: 0 to 1. Default: 0.” },
arg4 = { name = “pshift”, min = 0, max = 12, tip = “Maximum of random pitchshift of each iteration. Range: 0 to 12 semitones. E.g., 2.5 = 2.5 semitones up or down.” },
arg5 = { name = “ampcut”, min = 0, max = 1, tip = “Maximum of random amplitude reduction on each iteration. Range: 0 to 1. Default: 0.” },
arg6 = { name = “starttime_of_freeze”, min = 0, max = 25, tip = “Time where the frozen segment begins in the original sound.” },
arg7 = { name = “endtime”, min = 0, max = 25, tip = "Time where the frozen segment ends in the original sound. " },
arg8 = { name = “gain”, min = 0, max = 1, tip = “gain, innit.” },
arg9 = { name = “seed”, switch = “-s-”, tip = “The same seed number will produce identical output on rerun. Default: 0 – random sequence is different every time.” },
}

dsp[“Extend Iterate - Repeat sound with subtle variations to a specified duration”] = {
cmds = { exe = “extend”, mode = “iterate 1”, tip = “EXTEND ITERATE was written as a way of achieving more natural sounding iterations of a soundfile by introducing a randomisation of the delay time between each iterated segment, and slight variations in pitch or amplitude between the segments, as would occur in a naturally iterating source (e.g., a rolled ‘rr’ vocal sound). These randomisations can be selected (e.g., one might omit pitch variation, or not apply randomisation to the delay times), or applied in an exaggerated fashion, to achieve a number of different musical results. The rand parameter introduces slight variations in delay between iterations, which may increase the ‘naturalness’ of the result. Omitting the rand parameter will produce a more mechanical echo effect. The gain parameter allows some control over the amplitude of the mixed portions; the amount of gain suitable is dependent on the amplitude of the signal at the beginning and end of the soundfile (where the repeated units overlap). This can be examined with a soundfile viewer (such as VIEWSF, which can display the amplitude of each individual sample), and the gain adjusted accordingly if the defaults don’t seem to be handling it properly. When randomisation is used, the gain is further reduced in the expectation that there will be a greater degree of overlap. Musical applications; This function produces a series of (usually overlapping) repeats of a soundfile. The nature of the attack portion of the soundfile – sharp or gradual – will greatly affect the way these repetitions are perceived. The use of a very short soundfile, e.g., 0.2 seconds, especially one with a sharp attack, will result in a rapid-fire succession of easily perceived iterations.” },
arg1 = { name = “outduration”, min = 1, max = 30, tip = “length in seconds of outfile” },
arg2 = { name = “delay”, switch = “-d”, min = 0, max = 25, tip = “(average) delay between iterations in seconds (Default: length of infile)” },
arg3 = { name = “rand”, switch = “-r”, min = 0, max = 1, tip = “delay-time randomisation (Range: 0 to 1, Default: 0)” },
arg4 = { name = “pshift”, switch = “-p”, min = 0, max = 12, tip = “maximum random pitchshift of each iteration in semitones (Range: 0 to 12 semitones; e.g., 2.5 = 2.5 semitones up or down)” },
arg5 = { name = “ampcut”, switch = “-a”, min = 0, max = 1, tip = “maximum random amplitude reduction on each iteration (Range: 0 to 1, Default 0)” },
arg6 = { name = “fade”, switch = “-f”, min = 0, max = 1, tip = “(average) amplitude fade between iterations (Range: 0 to 1, Default 0)” },
arg7 = { name = “gain”, switch = “-g”, min = 0, max = 1, tip = “overall gain (Range: 0 to 1, Default: 0, which gives the best guess for no distortion)” },
arg8 = { name = “seed”, switch = “-s-”, tip = “the same seed number will produce identical output on rerun (Default: 0 – the random sequence is different every time)” },
}

dsp[“Extend Iterate - Repeat sound with subtle variations a specific number of times”] = {
cmds = { exe = “extend”, mode = “iterate 2”, tip = “EXTEND ITERATE was written as a way of achieving more natural sounding iterations of a soundfile by introducing a randomisation of the delay time between each iterated segment, and slight variations in pitch or amplitude between the segments, as would occur in a naturally iterating source (e.g., a rolled ‘rr’ vocal sound). These randomisations can be selected (e.g., one might omit pitch variation, or not apply randomisation to the delay times), or applied in an exaggerated fashion, to achieve a number of different musical results. The rand parameter introduces slight variations in delay between iterations, which may increase the ‘naturalness’ of the result. Omitting the rand parameter will produce a more mechanical echo effect. The gain parameter allows some control over the amplitude of the mixed portions; the amount of gain suitable is dependent on the amplitude of the signal at the beginning and end of the soundfile (where the repeated units overlap). This can be examined with a soundfile viewer (such as VIEWSF, which can display the amplitude of each individual sample), and the gain adjusted accordingly if the defaults don’t seem to be handling it properly. When randomisation is used, the gain is further reduced in the expectation that there will be a greater degree of overlap. Musical applications; This function produces a series of (usually overlapping) repeats of a soundfile. The nature of the attack portion of the soundfile – sharp or gradual – will greatly affect the way these repetitions are perceived. The use of a very short soundfile, e.g., 0.2 seconds, especially one with a sharp attack, will result in a rapid-fire succession of easily perceived iterations.” },
arg1 = { name = “repetitions”, min = 1, max = 100, tip = “number of repetitions in the iteration” },
arg2 = { name = “delay”, switch = “-d”, min = 0, max = 25, tip = “(average) delay between iterations in seconds (Default: length of infile)” },
arg3 = { name = “rand”, switch = “-r”, min = 0, max = 1, tip = “delay-time randomisation (Range: 0 to 1, Default: 0)” },
arg4 = { name = “pshift”, switch = “-p”, min = 0, max = 12, tip = “maximum random pitchshift of each iteration in semitones (Range: 0 to 12 semitones; e.g., 2.5 = 2.5 semitones up or down)” },
arg5 = { name = “ampcut”, switch = “-a”, min = 0, max = 1, tip = “maximum random amplitude reduction on each iteration (Range: 0 to 1, Default 0)” },
arg6 = { name = “fade”, switch = “-f”, min = 0, max = 1, tip = “(average) amplitude fade between iterations (Range: 0 to 1, Default 0)” },
arg7 = { name = “gain”, switch = “-g”, min = 0, max = 1, tip = “overall gain (Range: 0 to 1, Default: 0, which gives the best guess for no distortion)” },
arg8 = { name = “seed”, switch = “-s-”, tip = “the same seed number will produce identical output on rerun (Default: 0 – the random sequence is different every time)” },
}

dsp["Extend Loop - 1 Loop (repeat [advancing] segments) inside soundfile "] = {
cmds = { exe = “extend”, mode = “loop 1”, tip = "The key feature of this process is that it joins together, end-to-end, a series of segments taken from the file, each with a splice slope to avoid clicks. These segments are all of the same length, so one way or another, the result may appear to have some degree of regular pulsation. This does not (usually) result from the presence of splices, but rather is a perceptual result caused by the repetition of sonic material. " },
arg1 = { name = “start”, min = 0, max = 30, tip = “time (in seconds) in infile at which the looping process begins” },
arg2 = { name = “len”, min = 0, max = 1000, tip = “length of splice (in milliseconds) (Default: 25ms)” },
arg3 = { name = “step”, min = 0, max = 1000, tip = "advance in infile from the start of one loop to the next (in milliseconds) " },
arg4 = { name = “splen”, switch = “-w”, min = 0, max = 1000, tip = “length of splice (in milliseconds) (Default: 25ms)” },
arg5 = { name = “scat”, switch = “-s”, min = 0, max = 30, tip = “make step advance irregularly, within the timeframe given by scat” },
arg6 = { name = “-b”, switch = “-b”, tip = “play from beginning of infile (even if looping doesn’t begin there)” },
}

dsp["Extend Loop - 2 Loop (repeat [advancing] segments) inside soundfile "] = {
cmds = { exe = “extend”, mode = “loop 2”, tip = "The key feature of this process is that it joins together, end-to-end, a series of segments taken from the file, each with a splice slope to avoid clicks. These segments are all of the same length, so one way or another, the result may appear to have some degree of regular pulsation. This does not (usually) result from the presence of splices, but rather is a perceptual result caused by the repetition of sonic material. " },
arg1 = { name = “dur”, min = 0, max = cycles(), def = 2, tip = “duration of outfile required (in seconds)” },
arg2 = { name = “start”, min = 0, max = 30, tip = “time (in seconds) in infile at which the looping process begins” },
arg3 = { name = “len”, min = 0, max = 1000, tip = “length of splice (in milliseconds) (Default: 25ms)” },
arg4 = { name = “step”, switch = “-l”, min = 0, max = 1000, tip = "advance in infile from the start of one loop to the next (in milliseconds) " },
arg5 = { name = “splen”, switch = “-w”, min = 0, max = 1000, tip = “length of splice (in milliseconds) (Default: 25ms)” },
arg6 = { name = “scat”, switch = “-s”, min = 0, max = 30, tip = “make step advance irregularly, within the timeframe given by scat” },
arg7 = { name = “-b”, switch = “-b”, tip = “play from beginning of infile (even if looping doesn’t begin there)” },
}

dsp["Extend Loop - 3 Loop (repeat [advancing] segments) inside soundfile "] = {
cmds = { exe = “extend”, mode = “loop 3”, tip = "The key feature of this process is that it joins together, end-to-end, a series of segments taken from the file, each with a splice slope to avoid clicks. These segments are all of the same length, so one way or another, the result may appear to have some degree of regular pulsation. This does not (usually) result from the presence of splices, but rather is a perceptual result caused by the repetition of sonic material. " },
arg1 = { name = “cnt”, min = 0, max = 100, tip = “number of loop repeats required” },
arg2 = { name = “start”, min = 0, max = 30, tip = “time (in seconds) in infile at which the looping process begins” },
arg3 = { name = “len”, min = 0, max = 1000, tip = “length of splice (in milliseconds) (Default: 25ms)” },
arg4 = { name = “step”, switch = “-l”, min = 0, max = 1000, tip = "advance in infile from the start of one loop to the next (in milliseconds) " },
arg5 = { name = “splen”, switch = “-w”, min = 0, max = 1000, tip = “length of splice (in milliseconds) (Default: 25ms)” },
arg6 = { name = “scat”, switch = “-s”, min = 0, max = 30, tip = “make step advance irregularly, within the timeframe given by scat” },
arg7 = { name = “-b”, switch = “-b”, tip = “play from beginning of infile (even if looping doesn’t begin there)” },
}

dsp[“Madrid - Spatially syncopate repetitions of the source soundfile(s) - random output file”] = {
cmds = { exe = “madrid”, mode = “madrid 1”, tip = “MADRID achieves its syncopated repetitions by randomly deleting items from the spatially-separated repetition streams. The program sets up several sound streams. In each sound stream the same source sounds are repeated at the same time-interval. By randomly deleting repetitions from the various streams, the output appears to be spatially syncopated, as stress is transferred from one stream to another, or to some combination of streams, changing the apparent spatial location of the source.” },
arg1 = { name = “dur”, min = 1, max = cycles(), def = cycles(), tip = “duration of the output sound” },
arg2 = { name = “ochans”, min = 2, max = 16, def = 2, tip = “number of channels in the output sound (Range 2 to 16)” },
arg3 = { name = “strmcnt”, min = 2, max = 64, tip = “number of spatially distinct streams (2 to 64)” },
arg4 = { name = “delfact”, min = 0, max = 1000, tip = “proportion of items to (randomly) delete. Values between 0 and 1 delete that proportion of events in the various streams. For values greater than 1, the proportion of events at a single location increases.” },
arg5 = { name = “step”, min = 0, max = 60, tip = “time between event repetitions (Range: 0 to 60 sec.)” },
arg6 = { name = “rand”, min = 0, max = 1, tip = " randomisation of step size (Range: 0 to 1)" },
arg7 = { name = “seed”, switch = “-s”, min = 0, max = 1, tip = “value to initialise the randomisation of the delfact deletions. With a non-zero value, rerunning the process with the same parameters will produce the same output. Otherwise, the deletions are always different.” },
arg8 = { name = “-l”, switch = “-l”, tip = “for ochans > 2, the loudspeaker array is assumed to be circular. The -l flag forces the array to be linear, with defined left and right ends.” },
arg9 = { name = “-e”, switch = “-e-”, tip = “allow empty events: i.e., sound is absent at some of the repeat-steps.” },
arg10 = { name = “-r”, switch = “-r”, tip = “randomly permutate the order of input sounds used in the output. (ALL input sounds are used ONCE before the next order permutation is generated.)” },
arg11 = { name = “-R”, switch = “-R”, tip = “randomly select the next input sound: the selection is unrelated to the previous selection” },
}

dsp[“Extend Scramble 1 - Scramble soundfile and write to any given length”] = {
cmds = { exe = “extend”, mode = “scramble 1”, tip = "With EXTEND SCRAMBLE, segments of soundfile are selected from a wide variety of locations in the infile, jumping back and forth a great deal.Mode 1 takes the infile, chooses a random chunk of it, and then chooses another random chunk of it which may overlap with the first choice, then another chunk which may overlap with either of the other two … etc. Then it splices them all together. Thus, any bits of the file may be repeated quite quickly if overlapping material is selected in consecutive chunks, and some bits may not appear at all if never randomly selected. The size of the chunks will be a random length somewhere between minseglen and maxseglen. " },
arg1 = { name = “minseglen”, min = 0, max = cycles(), tip = “minimum chunksize to cut” },
arg2 = { name = “maxseglen”, min = 0,045, max = cycles(), tip = “maximum chunksize to cut (Range: 0.045 to length of infile – must be > minseglen)” },
arg3 = { name = “outdur”, min = 0, max = cycles(), tip = “duration of outfile required (> maxseglen” },
arg4 = { name = “splen”, switch = “-w”, min = 0, max = 1000, tip = “duration of splice in milliseconds Default: 25ms)” },
arg5 = { name = “seed”, switch = “-s”, min = 0, max = 1, tip = “the same seed number will produce identical output on rerun (Default: 0, random sequence is different every time)” },
arg6 = { name = “-b”, switch = “-b”, tip = “force start of outfile to be beginning of infile” },
arg7 = { name = “-e”, switch = “-e”, tip = “force end of outfile to be end of infile” },
}

dsp[“Extend Scramble 2 - Scramble soundfile and write to any given length”] = {
cmds = { exe = “extend”, mode = “scramble 2”, tip = " Mode 2, cuts the entire file into random-length chunks which do not overlap. It arranges these at random. The process is then repeated, but the random cuts are of course in different positions in the file. Consequently, the entire file is used, and used only once, before the process starts to use the file again.In Mode 2 an average chunksize is specified plus a random factor (scatter). The formula which shows what the maximum scatter factor can be reveals that Mode 2 can be used to make chunks which vary a great deal in length. For example, if the infile is 2 seconds long and seglen is 0.3, the maximum value for scatter will be 6.0 (rounded down). (This value was accepted – and worked – even with an outdur of 4.0.)The 2nd Mode also provides the option to rerun with identical output.The ability to write to any length of outfile makes it possible to give the process plenty of time to make full use of the infile." },
arg1 = { name = “seglen”, min = 0, max = cycles(), tip = “average chunksize to cut” },
arg2 = { name = “scatter”, min = 0,045, max = cycles(), tip = "randomisation of chunk lengths (>= 0) Cannot be greater than infilesize/seglen (rounded down) " },
arg3 = { name = “outdur”, min = 0, max = cycles(), tip = “duration of outfile required (> maxseglen” },
arg4 = { name = “splen”, switch = “-w”, min = 0, max = 1000, tip = “duration of splice in milliseconds Default: 25ms)” },
arg5 = { name = “seed”, switch = “-s”, min = 0, max = 1, tip = “the same seed number will produce identical output on rerun (Default: 0, random sequence is different every time)” },
arg6 = { name = “-b”, switch = “-b”, tip = “force start of outfile to be beginning of infile” },
arg7 = { name = “-e”, switch = “-e”, tip = “force end of outfile to be end of infile” },
}

Actually hold off using it for now, I just realised the way I set it up meant it was being calculating this every time it is used in a definition, this will of course take a very long time, it only needs to be done once per sample. Will fix this in next update.