humanoid sounds, uncanny valley

Here's one babbling. It sounds a bit irritated to me...

# ported from the original sporth code september 2020
patchwerk nodes

100 8 metro 0.3 0 maygate 200 mul 0.1 port add

29 40 1 10 0.5 randi randi add

0 1 3 randi
0 1 3 20 1 randi randi
0.7
0
voc

1 metro 0.7 0 maygate 0.03 port mul

"rant.wav" wavout bdrop

sr 30 * _compute rep

humanoid sounds, uncanny valley

Revisiting some voice physical model demos I did a few years ago. Mostly it's just porting code from Sporth to Runt.

Here's a cyber monk:

patchwerk nodes

36 -0.1 0.1 1 4 0.2 randi randi add mtof
0.1 1 sine 0 1 biscale
0.9
0.9
0.3 1 sine 0 1 biscale
voc dcblock

36 mtof 70 5 eqfil

bdup bdup 0.97 10000 revsc bdrop -14 ampdb mul dcblock add

"chant.wav" wavout bdrop

sr 30 * _compute rep

Getting back to my fbm experiments, based on the code found in the book of shaders: thebookofshaders.com/13/

Instead of shader code, my version runs on the CPU using ANSI C, with some hobbled together vector functions. The frames get encoded into h264 video via the x264 interface, then wrapped into an mp4 container via ffmpeg.

Syncing this with sound comes next.

Just finished up my initial implementation of f-table lists in , which are essentially arrays of soundpipe tables. It's a simple and long overdue means to have ftables change over time. Think chord progressions and stuff like that.

Here's the wiki stub on it with a sample runt program (with a link to the woven ftlist program at the bottom):

pbat.ch/proj/monolith/wiki/ftl

The relevant code itself in monolith:

git.sr.ht/~pbatch/monolith/tre

And, oh heck, I've also uploaded some bloops that bleep using ftlists and ftlist accessories.

Been playing around with a modified version of the chaos noise algorithm found in SuperCollider's "Crackle". Next thing you know, I find myself channeling my inner Dean Hurley. The morale of the story is: add a "rate" parameter to your noise generators!

Here's the code used to generate the sound. "chaosnoise" is the generator itself.

patchwerk nodes

0.9 1.3 0.512 randi
40 45 0.5 randi
10.1 metro 0.1 0 maygate 9000 mul add
chaosnoise
60 60 3 eqfil
bdup
bdup bdup 0.93 8000 revsc bdrop -10 ampdb mul
dcblock
4000 2000 2 eqfil

"test.wav" wavout bdrop

30 sr * _compute rep

Stumbled upon a crayola color palette in JSON. It has the name, hex, and RGB values.

gist.github.com/jjdelc/1868136

Wrote a quick program to parse the JSON and generate a small preview.

This is bc10.tairyzesh.

This etude encapsulates some things that have interested me in the past 3 months (it took *way* too long to make this):

rainbows (okay not a rainbow here, but still)

vintage apple color palette (see: rainbows)

feedback FM (via fmpair) pbat.ch/sndkit/fmpair/

my trig rhythm computer (drums were sequenced with this): pbat.ch/proj/monolith/wiki/tri

samples @unfa beatboxing! freesound.org/people/unfa/soun

valp1 is a VA one-pole lowpass filter implemented in ANSI C: pbat.ch/sndkit/valp1/ using

It's based on the implementation found in the The Art of VA Filter design by Vadim Zavalishin, a engineer of native instruments and creator of Reaktor.

I've uploaded a sample of what it sounds like when you use it to filter noise. Because it's only 1-pole, it sounds an awful lot like gain control.

I've also ported it to a node in . Here's the code used to generate the sound:

patchwerk nodes

0.5 noise
1 1 sine 100 1000 biscale
valp1

"valp1.wav" wavout bdrop

sr 20 * _compute rep

FM synthesis noodling

Added feedback to my FM operator pair in , and added a new "fmpair" word in to mark the occasion.

Here's a quick patch written in :

patchwerk nodes

4096 ftnew gen_sine 0 regset

36 mtof 1 1.01
3
0.1 1 0 0 regget osc 0 0.9 biscale
0 regget fmpair

36 12 - mtof 1 0.997
3
0 0.9 0.4 randi
0 regget fmpair

0.4 mul

"fmpair_test.wav" wavout bdrop

sr 20 * _compute rep

Working on a linear feedback shift register noise generator based on the NES APU specs found here: wiki.nesdev.com/w/index.php/AP

I've wrapped it into a node called bitnoise, and made a little patch to test it out (audio attached).

Here is the code that generated it:

patchwerk nodes
60 300 1 randi 5000
2 dmetro 0.5 0 maygate 0.1 port 1 20 scale
randi
1 dmetro 0.5 0 maygate bitnoise
0.1 mul
8000 butlp
"test.wav" wavout bdrop
sr 20 * _compute rep

gameboy mods, part 2

@320x200 it works! I think the issue ended up being a the ground cable. Forgot to trim the end before soldering, and I found the unsleeved bits touching other connections.

Thanks again for the test program :)

Boston

There was some bulldozing happening today in the Boston Garden this morning on my bike ride today.

How to render one TeX equation to an image using plain TeX and dvipng

First, put this in a new TeX file. It has the equation, and does some sneaky things:

\hsize 0pt
\vsize 0pt
\nopagenumbers
\overfullrule 0pt
\noindent
$$X(\omega_k) = \sum_{n=0}^{N-1} x(t_n)e^{-j\omega_k t_n}$$
\bye

Then, run TeX to generate the DVI.

Run dvipng to convert the DVI file to PNG. Using the "-o" flag will set the output file to be name of your choosing.

With any luck, the resulting image should look like the one attached.

Managed to get a full bike ride in for the first time in 6 weeks since I injured myself. I am fortunate enough to live near some pretty nature junk and stuff. Here's a photo I took. This area always reminded me of a Monet painting.

Wet cotton candy, anybody?

f(p) = fbm(p + fbm(p + fbm(p)))

Did some scaling adjustments (also done in shader code) to make it more proportional.

In the process of porting fractal brownian motion shader code from the book of shaders[0] to ANSI C code. I just got the first example ported. The generated output is posted.

FBM Domain warping [1] comes next, followed closely by some animation over time. At that point... I'll try to hook it up to some sound in .

A little reference card I made a while back for trig, a rhythmic toy computer and sequencer for . The card itself was generated using my 1-bit graphics library . This card features classic macintosh bitmap fonts using a font renderer I wrote.

Thinking up rhythmic structures to program on my rhythm computer for my next audiovisual etude. Learning how to count bits so I can actually implement it!

baking

Tried my hand at mini Boston cream pie cupcakes. Quarter for scale.

Every cupcake has been hand filled with a dollop of homemade vanilla pudding. It was also my first time making a chocolate glaze, which is the icing you see on top. Dark chocolate, of course.

Despite it a bit being labor intensive, I can see myself trying to make these again!