New Tool (3.0): CDP lua tool

Jonas · April 28, 2014, 9:56am

afta8:

Good idea, I will add support for this in the next version. I am also going to add an option for a default value as I am always lowering the gain on some of these. These will be optional fields and an example of an argument definition will look like this:
  
arg2 = { name = "Gain", min = 0.001, max = 10000, def = 10, tip = "Some info" },  
  
You can start adding these now if you want, the next version will pick these up.

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

afta8:

Looking at the distort function I’m guessing the cyclecnt parameter is something to do with the number of cyles in the waveform. I already have code that gets the number of cycles (from EasyTune) so I will add a cycles() function to the next update. Once this is done the range values would look like: min = 1, max = cycles()

In future I can add similar functions that return data about the sample if other processes need it, maybe sample size, channels, etc… whatever is needed really.

The CDP docs aren’t always clear about what the ranges are so in some cases a bit of guess work will be needed. Maybe you can get that info from the Soundshaper software, see what ranges are available in that. I only get Soundloom on mac and could look there but I haven’t figured it out yet, the UI is very unfriendly!

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

Jonas · April 28, 2014, 11:10am

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

[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

afta8 · April 28, 2014, 3:24pm

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

Jonas · April 28, 2014, 3:42pm

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

edit;

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

afta8 · April 28, 2014, 4:48pm

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.

Jonas · April 28, 2014, 6:02pm

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 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” },
}