I wrote up some notes on two projects inspired by #FAuSt #dsp block diagram algebra progamming language.

One from 2009 (typesafe #Haskell embedding of FAuSt semantics) that I abandoned shortly afterwards.

One vague idea (FAuSt + #GridFlow + #OpenCL = some kind of video processing thing) that I haven't started work on implementing (and might never), just in the what if thinking stage.

https://mathr.co.uk/web/faust.html

I spent the evening porting the #audiovisual piece "Scanned" I made in 2006 (the original was earlier, 2004 or 2005, but the version I found was for the Openlab 3 Exhibition Catalogue DVD) from #Pd + #GridFlow to #C99 (around 135 lines of code with libsndfile for audio output and PPM output for video).

The generated material is pathologically incompressible (exceedingly noisy), but 1MByte/second (maximum allowed bitrate) PAL DVD resolution just about looks okish.

I thought I'd be clever and fix a small inconsistency (the image is 788x576 with square pixels, which gets squashed to 720x576 with image display aspect ratio 4:3 in the video encoding process), wherein I centered the rotation on 360,288, but moving it to (788/2),288 made it look much less interesting and not as I remembered, so I changed it back.

The video part would probably a 1-liner in something like Hydra...

Project idea: mashup of #FAuSt (signal processing block diagram algebra) and #GridFlow (multidimensional array processing for #PureData inspired by #APL etc) compiled via #OpenCL to run on #GPU.

https://gridflow.ca/
https://faust.grame.fr/

Worked a bit on #Barry, in particular the Barrington interpreter. Made it work on a blockwise basis, with compiled inner loops for each supported type/operation combination - this reduces the tremendous overheads of type-based dispatching that were previously done every sample for every operation. The type dispatch is now done only once per operation each time the code changes.

It is implemented via a #DSP chain similar to #PureData's: the main loop is now roughly `while (w = w->f(w)) ;` with function pointers and data in a flat array. I tried and failed to reuse signal vectors, the subtleties of nested scopes and local variables broke it. It does free the old chains eventually, so no huge leaks (hopefully).

I implemented multidimensional signal vectors, in case it will be useful for video. Inspired by #GridFlow, except that it promotes dimensions to the largest size, instead of requiring the LHS to be bigger. This is for sanity when livecoding audio: if `t 2 *` works and `2 t *` doesn't then it's frustrating.

Still lots of debugging printouts to remove/fix up into a better UI.

https://code.mathr.co.uk/barry

I published my work in progress patch set for #gridflow for #puredata . It's a library for multidimensional array processing and more, but was abandoned some years ago.

I mainly hacked on it to get my old Mandelbrot set periodic attractor music patch to work again, so that I can figure out how it works and reimplement it with the enhanced knowledge that the years bring.

patchset against gridflow git svn clone
https://mathr.co.uk/gridflow/patches/

EP released on GOSUB10 in 2010
https://archive.bleu255.com/gosub10/GOSUB10-003.html

updated version of the EP's source code
https://code.mathr.co.uk/zzc

gridflow home page
https://gridflow.ca/