Sputnki contributions

#1

Objects

Filter

vowel.axs - 3 bandpass filters in parallel, tuned to specific frequencies in order to emulate vowels. Formant dial (and inlet) morphs between various vowels. The other parameters enable further tweaking of filter.
Sounds quite nice and is fairly light (6% dsp load).
You can find more information eventually in this old topic: https://sebiik.github.io/community.axoloti.com.backup/t/subpatch-vowel-filter/219

table

Various math functions fitted to polynomial expansions and put inside a 16bit sdram table object. Size parameter determines how many samples are stored into the table.
Official topic here: https://sebiik.github.io/community.axoloti.com.backup/t/mathematical-functions-fit-to-polynomial-expansions/1301/7
Inside this category you'll find
arcsin_t.axo -
arctan_t.axo - value determines the x range of the function
arcsinh_t.axo - value determines the x range of the function
crossover_hard_t.axo - value determines the size of the gap
crossover_p_t.axo - value determines the size of the gap
crossover_c_t.axo - value determines the size of the gap
slicer.axo sample slicer, see below for further info
slicer i.axo like the previous, but with intlet controls for parameters.

Osc

vosim.axs - inspired by this topic: https://sebiik.github.io/community.axoloti.com.backup/t/vosim-possible-in-axolotl/1335/16?u=sputnki , it's basically a formant oscillator, best results if pitched down near -24/-36, not really light (8% cpu load)
vosim FM.axs - like the previous, but with integrated fm operator
mandelbrot.osc - Oscillator based on the mandelbrot fractal iteration. Check below for info.

Sequencer

Sequencer 16 v2 - one of my first objects, not really a great object but might be useful to some: more informations here https://sebiik.github.io/community.axoloti.com.backup/t/subpatch-16-step-sequencer/237
fibonacci.axo Fibonacci sequencer. Every time trig is activated, the sequencer goes one cycle forward. At every cycle the output is calculated with the formula o=i1+i2, where i2 is the first preceding output, and i1 is the second preceding output. At reset i1=0 , i2=1 unless i1 and i2 are connected. For example, the normal sequence is 1, 1 , 2 , 3, 5, 8, 13, 21, 34, 55, etc..
fibonacci astarb.axo A variation on the fibonacci sequencer. In this case the output is calculated with o=i1*i2, and the default starting i1 and i2 are 1 and 2. Grows very quickly.
pseudo factorial.axo Another variation on the fibonacci sequencer. In this case the output is calculated with o=i*(i+a+1) , where i is the preceding output. a is provided with inlet_a . At reset if inlet_i0 is disconnected, i=1, otherwise i=inlet_i0.
Grows really quickly, may result in overflowing and therefore unexpected big numbers.
euclid.axo Euclidean rhythm generator. Chainable. Notes specifics the number of active steps, rests the number of rests. Inlet in specifics what step to read, like sel i 16/32 or disp/ibar . If outside the range the default inlet will be outputted (like said objects).
Dynamic algorithm, 10% dsp load worst case with 63 notes and 64 rests.
euclid length.axo Like the prevous, but this time you won't have to fiddle with rests: you just have to specify the length of the pattern (also if you set more steps than the pattern length the sequence will be calculated on the max length.
euclid length out.axo Like the previous, but there's an outlet that outputs an integer which you can decode to get the individual steps (use decode bin 8.axo Maximum pattern length=31 ( i know, it's an odd number.)
chorder.axo Stores 8 chords in memory. See the post below for more informations, this is quite a fat object!
chorder adv.axo Like the previous, but allows to individually pitch up or down chords (basically reduces the need for a pitch cv in)
24ppq to bpm.axo This object can be used to detect the bpm speed of a midi clock signal expressed in 24ppq.
Outlets:
-bpm - outputs the integer part of the bpm
-mill - outputs the fractional part of the bpm
-1000bpm - outputs bpm*100
24ppq to phase64.axo This object generates a phase signal that goes from 0 to 64 in 64 beats (16 quarters) when fed with a 24ppq signal.
24ppq to pos Converts a 24ppq counter signal into different subdivisions: quarters, sixteenths and triplet eights.
Length parameter can be used to set the length (in quarters) before resetting the counter (works exactly like divremc).
Cue parameter offsets the incoming signal by a constant number of ppqs.
24ppqrem outputs the cued and divided 24ppq signal.
maestro.axo Melody sequencer object, see below for more information (it's a very big object)

inlet -> +cue -> divremc -> 24ppqrem -> other outputs
clock out dual Midi clock master, also outputs Midi clock, start, stop, and continue messages on two separate Midi devices.
The secondary device can be switched on or off (when off, the behavior is identical to the midi/out/clock by Johannes).
Based on midi/out/clock by Johannes Taelman.

#2

Math

bitcrusher s m.axo A simple bitcrusher module with variable bit size and modulation input (it's just a mod of math/quantize by Johannes, but i see this more useful as an effect)
moved to effect folder

Rectangular windows You should see below for these, as they're more intricated and i wrote a post specialized on them

Knee shape
Distorts the input with a knee shape (see image)
Unipolar input and output, mod input.
Could be useful for asymmetric distortions (see in the picture what happens when you feed a "bent" signal into a math/cos.) useful also for peculiar envelope or lfo shapes, or windows, or phase distortion applications.
Knob determines the position of the knee (vertical position for knee k and knee s and horizontal position for knee h k and knee h s)

knee k.axo
knee s.axo
knee h k.axo
knee h s.axo

knee.png652x545 19.1 KB

combinator.axo
combinator s.axo Perform a bitwise operation between two signals.
output = shift3(shift1(signal 1) X shift2(signal2))
X = and, or, xor (parameter operation)

Logic

encode 4.axo Encode 4 +1 bits into an integer number (the extra bit is for sign) - Range [-16,15]
encode 8.axo Encode 8 +1 bits into an integer number (the extra bit is for sign) - Range [-256,255]
encode 16.axo Encode 16 +1 bits into an integer number (the extra bit is for sign) - Range [-65536,65535]
Bit 0 is the least significant bit (meaning that it produces the smallest variation in the output number)

#3

Added fibonacci, fibonacci a*b and fibonacci factorial sequencers.
Added encode 8 and encode 16.

#4

Added horizontal knee shapes

#5

chorder.axo

Stores 8 chords in memory. Maximum chord size: 8 notes (lower notes have higher priority).

Inlets:
pitch -> the base pitch on which the selected chord is constructed
sel -> chord selector (input must go from 0 to 7, otherwise nothing will be outputted.
enable -> acts like a master note on. If not enabled all output triggers are set to 0. If enabled, the triggers corresponding to active notes will output 1.

Outlets:
p1, p2, .. p8 -> output the pitch cv for the corresponding note. Only active notes will be changed, the others will remain to the previous state.
t1, t2, .. t8 -> output the trigger value for the corresponding note. If the note is active output=1, if inactive output=0

Parameters:

chord1, chord2, .... chord8 -> allow to edit individual notes per chord and chord parameters:
[1][2][3][4][5][6][7][8][9][10][11][12] correspond to semitones. If, for example you want to build a major chord on the root note, you'll have to check 1,4 and 7. If you want to build a sus2 chord 1,3 and 7. You can figure out the rest.
[13] shifts active odd outlets (1, 3, 5, 7) up by one octave
[14] shifts active even outlets (1, 3, 5, 7) up by one octave
[15] shifts odd notes (1, 3, 5, 7, 9, 11) up by one octave
[16] shifts even notes (2, 4, 6, 8, 10, 12) up by one octave

chorder.png719x486 21.6 KB

#6

Comparator Doepfer A167.axo

Compares two k-rate signals after multiplying them for a constant (gain1 and gain 2) and offsetting them by another constant (offset).
This comparator has hysteresis implemented (you can specify the amount with the relative knob)

There are two outputs (normal and inverted) and a disp/bool integrated in the object for visual reference.

Since philoop asked, i added a sum output like on the doepfer module (basically it outputs gain1*in1 - gain2*in2 + offset)

You can check the doepfer site for further information http://www.doepfer.de/A167.htm

#7

Thank you for your contributions! Do you have an example patch of the euclidean sequencer in use?

#8

doepfer 167 has a cv out .......maybe you could update ?

#9

I've just done it. Sorry if it's quite a mess, but i'm short on sleep :expressionless:

@philoop Done, check it out :smiley:

Also i added a few objects, mainly in math category, tomorrow i'll write something about them.

Say goodnight to Sput :slight_smile:

#10

Rectangular windows

rectangular window k.axo
rectangular window k m.axo
rectangular window s.axo
rectangular window s m.axo
rectangular window s fm.axo

This set of objects work sorta like a double comparator, they output 1 if the input falls inside some range and 0 otherwise.
With the center knob you can decide (guess what) the center position of the window, while with the width knob you can decide how big the window is (how much of the signal can pass inside it)+

See the picture for more information

There's an example of the window object (from which i took the picture), you can find it in the contrib patch folder

rectangiuar widnwo.png455x563 16.9 KB

#11

Effect

bitcrusher s m.axo A simple audio rate bitcrusher module with variable bit size and modulation input (it's a modded math/quantize by Johannes)
sample and hold.axo An audio rate sample and hold module, completely integrated in only one module. Sample time is adjustable via parameter and inlet, linear frequency scale. There's an additional parameter that modulates (both in a positive and negative way) the hold time based on the current sample amplitude.
Object based on disp/samplehold cheap and osc/sine lin by Johannes
sat ur hate.axo Saturator distortion based on dist/soft by Johannes, see below for more info

Split

Family of audio rate objects that split the incoming signals to different outputs, based on amplitude. With variable cutoff point (it's not frequency cutoff, it's amplitude cutoff)

split 2.axo : Splits the signal in two (1 cutoff parameter)
split 2 overlap.axo : Splits the signal in two, with an overlapping band (hard overlapping) (1 cutoff parameter, 1 overlap amount parameter)
split 3.axo : Splits the signal in three (2 cutoff parameters)
split 3 overlap.axo : Splits the signal in three, with an overlapping band (hard overlapping) (2 cutoff parameters, 1 overlapp amount parameter)
split 4 symm.axo : Splits the signal in four (1 cutoff parameter, that acts symmetricaly on both the upper and lower cutoff. Center cutoff is fixed at 0. No overlapping)

#12

mandelbrot.axo

Oscillator based on the Mandelbrot fractal iteration (z' = z^2 + c), where z is the variable of iteration (meaning that the output of each iteration is the input of the next one) and c a user defined complex number (in the form Re + Im*i)

This object does not model faithfully the actual function, which has an extreme dynamic range, but it tries to "tame the beast" and make it somewhat usable for sound generation purposes. Neither the parameters map exactly 1 to 1 the points of the complex plane, they're scaled differently.

Parameter list:
re : the real part of the complex number
im : the imaginary part of the complex number

pitch : the pitch of the oscillator. Notice that in some zones of the complex plane the function iterates at different multiples of the pitch. Use autoadjust to overcome this problem

limit : the size of the bailout window. Basically, any iteration that escapes from this window will reset the oscillator to 0. This parameter also adjusts the output gain of the osc. If a complex number does not produce any sound you might try changing this number.

3oct : pitch the oscillator down 3 octaves (might be useful)

autoadjust : try to pitch the oscillator correctly (this won't work properly if the current iteration does not diverge.

interp: interpolate between two consecutive values.

Inputs : Pitch, re and im (modulations of the respective parameters)
Outputs : Re, im (the current values for the complex number)
iterations: the number of iterations for this particular configuration

#13

slicer.axo
slicer i.axo

Sample slicer.
This object is to be used in conjunction with table/read objects.
It produces two ramp signals (phase can be fed inside a window object, pos can go into a conv/interp and then into table/read interp to enable playback), and is easily chainable.
The object is programmed to play the sample at the correct speed, based on the size of the sample (hence the size menu).
You can specify the start position and the (relative) length of the slice.
Speed allows to tune the sample playback speed (not chromatically, unfortunately), reverse enables reversed playback.
In case you want to chain several object, you can select the sample to play by feeding an integer (0, 1, 2 ...) inside sel inlet.

I've added the modified slicer i.axo object, which uses inlets instead of parameters.

Also, i have made some edits to my contrib folder (renamed what before was called /math Table 16bit into /table to make it more consistent with the factory library)
Hope this won't cause trouble (it should not)

#14

Added a few objects in the sequencer folder and help file

#15

effect/sat ur hate.axo:

A saturator distortion based on dist/soft and filter/lp1 - hp1 by Johannes Taelman.
A soft saturator is cascaded with a filter (lowpass or highpass).
You can feed the output of the filter back into the input with the feed knob and change the filter cutoff with the filter knob.
postfilter allows you to pick up the sound after filtering; highpass changes the filter from lowpass to highpass.

sequencer/maestro.axo:

First instance of a melody generator, based on euclidean rhytms.
This object requires a Ph.D in aerospace engineering for basic operation.

Input: 24ppq (connect to some 24ppq counter signal)
Outputs: pitch and velocity.
3 levels of velocity are outputted, corresponding to the 3 accent levels (strong, medium and weak). Velocity output can be used also as a gate/trigger output for envelopes.

Parameter list:
Cue: adds a constant number to the 24ppq signal before processing it, useful to fine-sync the object.
length: sets the length in quarters of the melody
strongDiv, mediumDiv, weakDiv: set the denominators for the velocity subdivisions
mediumBypass, weakBypass: bypass medium and weak beats (in case you don't need velocities)
oddBypass: skip all the odd beats during the euclidean subdivision.
strongStart: use in conjunction with oddBypass to force the first beat to be strong velocity
activenotes: set the number of notes for the melody (this will also change the rhythm, since it operates on the euclidean subdivision.
gateMode: sets the length of notes
rootNote: pretty straightworward
scale: select a scale between the modes of the diatonic scale
alteration: change some notes in the scale (see parameter)
seed: parameter for melody algorithms
algorithm: select an algorithm between a list
octaves: number of octaves excursion for the melody
harmony: in some algorithms you can decide to use particular harmonizations (triad, quartal, fifths, sixths and stuff like that). Algos that use this parameter are indicated by the usesHarmony led

This last part will be improved over time. You can write your own algorithm, just put it in local data in the calculatepitch function.

#16

yes a help file would help to fly it.....
maestro.axp (5.2 KB)

#17

edrum/kick drum.axo:

another 808-style kick drum. Independent control for amp and pitch envelope and initial phase (in order to add an initial click.

osc/4op FM.axo:

4 operator matrix based PM/ FM engine, that allows for DX-style sounds and multiple feedbacks. Operation is detailed in the help patch (also with a blank FM patch to copy and paste, since the object does not work stand-alone but requires setup)

#18

table/granular player 1

Reads a table in a fruity granulyzer fashion. Tip for quickstart: set playback knob to 64 and density to something different than 0 and you're good to go, everything else is in object description

#19

table/granular player 2

Very similar to granular player 1, but with a slightly cheaper internal envelope implementation. This allows for more grains to be played (max number now set to 64).
Density scaling and playback scaling are now different from the previous implementation (much denser playback is allowed now, play speeds> 1 are now available without using mod inlet)

Still mono, but it's starting to sound autechrian

table/granular player 2 stereo

Like the previous, but grains are hardpanned left/right . Slightly more cpu hungry than previous

Here's some audio demo for the stereo granular player

#20

table/granular player 4

table/granular player 4 stereo

Same mechanism as before, but with rectangular windows (player 1 and 2 have triangular a/d windows)