[sdiy] Oscillator sampler with sorting capabilities concept

[cheater00 .]

Hi guys,
I was wondering what you guys thought of this synthesis technique. Has
anyone tried this? Could it sound good?

Here's a chat log between me and a fellow synthesis fan.

have you ever tried running a waveform through a sorting algorithm?
That is, take each cycle and sort that. If you sort the waveform fully
you should get something like a saw. But you could limit the amount of
work the sorting algo can perform before the waveform cycle is
released. If you put this parameter on a knob then you could perhaps
have a somewhat-smooth transition from your current waveform to a saw
waveform.

I think it could even work for analogue synths, you'd just need
somewhat of a buffer


you could have a sampler which works like this: it has a sync input
and a wave input from a VCO. when the vco outputs sync, it starts
sampling the waveform until the next sync. Once that's done, this is
called "a wave". Now for the output. Every time a wave is sampled, it
is placed on a queue (fifo). When a vco sync happens, the output
module takes the next wave from the fifo and starts outputting it. As
long as the wave is being output, syncs can be ignored (or instead, it
could jump to the next waveform at index 0, or to the next waveform at
the same index as it currently is). If there is only one wave left in
the queue, and the device is getting sync pulses over and over, then
it could either start outputting silence, or start outputting the last
wave it had in the queue.


this way it could work even delay-less (but would mangle the output in
a fun way)


Snd of course, while this happens the currently output waveform could
be mangled by: sorting, randomizing, sorting or shaping according to
the current waveform shape in a second sampler, etc.


could be fun when run on FM oscillators which change pitch.


So what "slaving to another sampler" would mean is that, in the master
sampler you have the sorting algorithm, and it moves sample 4 to
position 1. Then the slave sampler doesn't sort its own samples,
instead it just moves sample 4 to position 1, just like the master
sampler. I think this might only work if the wave are "normalized" to
some length, or alternatively if the waves in the slave get resampled
to the length of the master, or alternatively if the waves in the
master get resampled to the length of the slave. Resampling slave to
length of master would mean we either get a nice low-pass effect (if
the resampling is band-limited) or we get frequency-dependent aliasing
(if the resampling is not band-limited). The aliasing would not change
position in an inharmonic way like it usually happens when you alias
against a static sample rate (like when recording to a low sample rate
interface); instead aliasing would add a timbral quality which would
be constant across the keyboard, and work in a musical fashion.
Because both the master and slave waveforms are sampled at the same
clock rate, this aliasing process is immune to the clock rate of the
samplers.

You could laso have the master send the current wave to the slave and
you could have the slave use it to wave-shape its wave with that. So
if the master has a rising saw, nothing happens, and if master has a
sine wave, then you get a sine shaper.

If the master sends a wave, where the voltage level of the nth sample
is instead replaced by the index it has after being sorted, then
"slave sorting" could work simply by wave-shaping the slave wave by
that master "sorting index" wave.


Of course you could have the slave have its own sampling input and
sampling sync input, but then have its *output* sync to the master's
sync input or a dedicated output-module sync input. Then if the sample
memory is really long, and the sync happens every now and then, you
could have a stutter effect.


You could even have "markers" in the wave, which happen when a third
input is triggered. Then, once the output module get sync, rather than
jump to the beginning of the current wave it could jump back to the
latest marker or skip forward.


And if you have a long sample memory then you can just trigger the
input sync once and have a loop play forever.


I wonder what everyone thinks of this?


This is fairly similar to some of the stuff I did in Pure Data at some
point, but I've only now figured out how this could fit into the
context of a modular synth.


Cheers,
D.