Cellular Automata Streams

Download CSD Project Here

Implementation of 1-dimensional (Elementary) Cellular Automata as a
stream using feedback and circular buffer delay line. Stream
generates 1 (Live) and 0 (Dead) values, according to initial state
and rule.

Initial state may be any length array. Different array lengths
affects the rate of mutation, comparable to classical cellular
automata implementations that use a fixed array as value between CA
processing steps.

Rule numbers are implemented using Wolfram-style encoding where
number is interpreted as bits. This allows user to use Wolfram rule
numbers. For example, Rule 30 gives bit value of 00011110.

For this project, the CA stream values are used to turn and off a
held note of a specific frequency and amplitude. Actions occur only
when the stream values has transitioned from 0 to 1 or vice versa. The project runs indefinitely but was capped off at ten minutes here.

Using a feedback+delay-based approach could be interesting to allow for user input. The ca_stream user-defined opcode here could be modified to take in input and use bitwise-or with a generated value before writing it back into the stream. This could allow users to “play” the stream, and could make the Class 1 rules that evolve to 0’s be interesting for generating a limited amount of output in time to the user input. (I am curious to know if this could be useful, and will plan to investigate shortly by implementing an interactive web application.)

Shimmer Reverb

Download Csound CSD Project here

Exploration of Shimmer Reverb effect, inspired by Brian Eno’s feedback reverb with pitch-shifter effect. This example uses the following Csound opcodes:

References

Resonant Impulses 2

Download Csound CSD Project here

Further explorations into resonant impulses.  This version is modified in two primary ways:

  1. Additional band-pass filters used to add resonance to the impulses
  2. Gesture generator parameters further randomized to get larger range of textures to listen to.

The zdf_2pole bandpass filter is once again used here, but using mode=3 (Unity-Gain band pass) is used for the second two filters in the series.

Resonant Impulses

Download Csound CSD project file

A study of class synthesis technique of using an impulse generator with resonant filter.  Implemented using Csound with:

  1. gbuzz opcode for bandlimited impulses
  2. zdf_2pole for band-pass filter with high Q setting; filter center frequency swept with exponential envelope
  3. Additional declicking and exponential envelope use to shape gesture
  4. reverbsc opcode used as always-on reverb effect
  5. Temporal Recursion Player instrument used to randomly initiate gesture playback with various, slightly randomized parameters

Special thanks to Eugenio Giordani and Alessandro Petrolati for discussion of VCS3 implementation in this paper, which inspired me to use gbuzz as the impulse generator for this example.

Live Code – Modular-esque

Live code session using csound-live-code and https://live.csound.com.

Initial code happens for about 2m40s, then sound begins.

For those interested in the code, the session uses:

1. start UDO for working with the different always-on instruments
2. vco2 square wave for enveloping (has a nicer quality to it than
using lfo with type 3, IMO)
3. portk for frequency glide
4. chnset for immediate setting of a channel value as part of performance
5. chnset within an always-on instrument (“Mod”) together with k-rate
randh to show how to approach using continuous values with channels

Algorave: Algosix

This past weekend I was happy to participate in the Algosix celebration of Algorave with a live code performance. (The first few minutes of the test sound were me trying to check sound on the stream and failing to realize it was working…).

The video shows a little bit of vim, csound, and csound-live-code. In particular, it demonstrates the hex beats work in the live code project, as well as using phasors and non-interpolating oscillator functions for pitch values.   Drum sounds are from Iain McCurdy’s TR808 code and synth sounds were ones I have been working on in the live code project.

The event was a lot of fun with lots of different approaches, aesthetics, tools, etc. Lots of appreciation for the community and organizers of the event! (And many thanks for the opportunity to perform!)

Pink 0.4.0, Score 0.4.0

Hi All,

I’d like to announce the release of Pink 0.4.0 and Score 0.4.0:

[kunstmusik/pink “0.4.0”]
[kunstmusik/score “0.4.0”]

Pink is an audio engine library, and Score is a library for higher-level music representations (e.g. notes, phrases, parts, scores).

Change logs are available at:

https://github.com/kunstmusik/pink/blob/master/CHANGELOG.md
https://github.com/kunstmusik/score/blob/master/CHANGELOG.md

Short version is that Pink has a number of new filters and effects, updates to minimize object allocations (e.g., Distruptor-style message ring buffers), and utility code for building streaming disk-based caches for pre-rendered (“frozen”) parts. Score has new functions geared towards live coding (e.g., euclidean and hexadecimal beats), a new mini-language for notating musical lines, and number of other updates.

Codox-generated documentation/site is now published at:

http://kunstmusik.github.com/pink
http://kunstmusik.github.com/score

For any questions, please feel free to email me or post on the pink-users list. For issues and PR’s, please use the facilities on Github for each of the projects.

Thanks!
Steven

reface DX style FM Feedback (Saw, Square)

I have long avoided FM (Frequency Modulation) synthesis in my own musical practice as I never felt connected with the results I was able to get myself. However, I recently had the great pleasure to attend a talk about the 50th anniversary of FM synthesis, given by its creator, John Chowning, and I was very inspired to explore FM once again. In so doing, I came across the Yamaha reface DX synthesizer and became fascinated with reproducing its feedback system to morph an operator’s output from a Sine to either Saw or Square waveform.

Now, I do not own a reface DX, so most of my research into it was through looking at manuals and watching video demonstrations on YouTube to try to get an idea of how it might be done. I knew from going through literature on FM and PM (Phase Modulation) that using PM with feedback could get an operator’s signal to move from a Sine to Sawtooth wave, depending upon the amount of feedback. I was quickly able to setup a PM instrument in Csound and test this out and it sounded much like what I had heard for the reface DX.

;; feedback PM - feedback moves towards saw
instr PMFBSaw
ifreq = p4
iamp = p5

kfb = linseg(0, p3 * .5, 0.3, p3 * .5, 0)

aphs = phasor(ifreq)

; init for feedback
acar init 0
acar = tablei(aphs+(acar*kfb), 1, 1, 0, 1)
acar *= linen:a(1, 0.1, p3, 0.1) * iamp

outc(acar, acar)
endin

In the code above, one can see that the acar output from tablei is also used as input into the opcode. The code above runs in a single-sample context (in Csound parlance, with ksmps=1).

Now, the part I could not find anywhere in literature or discussion online was how to use operator feedback to morph from Sine to Square. (This is done by using 0 to -127 range for feedback on the reface DX.) After a couple days of research and exploration, I stumbled upon a calculation that sounded to my ears very much like what I had heard on the reface DX videos.

The code below shows the entire instrument:

;; feedback PM - feedback moves towards square
instr PMFBSquare 
  ifreq = p4 
  iamp = p5

  kfb = linseg(0, p3 * .5, 0.3, p3 * .5, 0)
  
  aphs = phasor(ifreq)

  ; init for feedback
  acar init 0 
  acar = tablei(aphs+(acar*acar*kfb), 1, 1, 0, 1)
  acar *= linen:a(1, 0.1, p3, 0.1) * iamp

  outc(acar, acar)
endin

This instrument is virtually the same as the first instrument with the exception of one additional calculation: the multiplication of the acar feedback by itself. (This is seen in the acar*acar calculation.) Adding this one additional multiplication made the signal move from Sine to Square.

I posted this to the Csound User list and Iain McCurdy gave great feedback that the waveform could be morphed between Saw and Square by interpolating between acar and 1. This made a lot of sense as when one of the acar‘s becomes 1, it reduces back down to the normal feedback addition to produce a Saw sound. After some further emails, I did some experiments to use a cosine-based mapping for the interpolation that resulted in a nice transition.

;; feedback PM - feedback moves from square to saw 
;; Based on Iain McCurdy's comments on Csound User List
instr PMFBSquareSaw 
  ifreq = p4 
  iamp = p5

  kfb = 0.25 
  ;;kfb = linseg(0, p3 * .5, 0.5, p3 * .5, 0)
  kwaveshape = linseg(0, p3 * .5, 1, p3 * .5, 0) ;; range 0-1 for saw->square
  kwaveshape *= kwaveshape ;; adjust curve
  kwaveshape = $M_PI * (kwaveshape + 1) ;; adjust from PI->2PI
  kwaveshape = (cos(kwaveshape) * 0.5) + 0.5  ;; adjust to 0-1
  
  aphs = phasor(ifreq)

  ; init for feedback
  acar init 0 
  acar = tablei(aphs+(ntrpol(acar, a(1), kwaveshape)*acar*kfb), 1, 1, 0, 1)
  acar *= linen:a(1, 0.1, p3, 0.1) * iamp

  outc(acar, acar)
endin

I do not know if these calculations are what are used in the reface DX, but regardless, the sine->square sounded good to my ear and I felt it was usable for the kind of sound work I was interested in doing. For now, I have posted the Csound CSD project file here. The audio example at the top of this post is an MP3 version of the output rendered from this project.

Cheers!
Steven

Hex Beats

Hexadecimal (base 16) has been used in various forms of computer music for a very long time, generally as a condensed way to notate values within a power-of-two range.  For example, rather than write out “15” as a decimal value (base 10), one can use “F”, and rather than write out “255”, one can use “FF”. The notation of hexadecimal numbers, in general, take up less horizontal space on the screen than its base 10 counterpart.

The differences in screen real estate is even more pronounced when comparing the binary value (base 2) to the decimal and hex values.  Let’s compare some values here:

Binary:  1101
Decimal: 14
Hex:     E

Binary:  11001111
Decimal: 207
Hex:     CF

A chart showing the binary, decimal, and hex values for number 0-255 are available here.

Now, one of the interesting challenges in live coding pattern-oriented music for me has been trying to have a very condensed notation for expressing beats (onsets).  One way I’ve seen used is to notate values in a binary form within a string, such as “1000100010101000” which would mean “play notes where there are 1’s, but don’t play notes where there are 0’s”. In this case, on beat 1, 5, 9, 11, and 13.

Binary values in a string, on the one hand, quite clearly notates when an instrument should play. On the other hand, I’ve found it visually takes up quite some space and can be a bit slow to parse mentally.

One thing I’ve found rather useful is to notate onset patterns using hexadecimal strings.  I first explored this in my Clojure systems Pink and Score, but recently translated the function I was using to Csound code.  The Csound code turned out to be quite simple:

opcode hexbeat, i, Si
  Spat, ibeat xin

  ;; 4 bits/beats per hex value
  ipatlen = strlen(Spat) * 4
  ;; get beat within pattern length
  ibeat = ibeat % ipatlen
  ;; figure which hex value to use from string
  ipatidx = int(ibeat / 4)
  ;; figure out which bit from hex to use
  ibitidx = ibeat % 4 
  
  ;; convert individual hex from string to decimal/binary
  ibeatPat = strtol(strcat("0x", strsub(Spat, ipatidx, ipatidx + 1))) 

  ;; bit shift/mask to check onset from hex's bits
  xout (ibeatPat >> (3 - ibitidx)) & 1 

endop

And an example of its use is shown here:

  if(hexbeat("f0d0d0f0", ibeat % 32) == 1) then
    schedule("Synth1", 0, p3, inScale(48, 0) )
  endif

The above is saying: “within the hexadecimal beat string of f0d0d0f0, and given the current beat value between 0 and 32, check if the onset is a 1 and, if so, perform Synth 1”.

The code above may be a little tricky to grok at first glance. I’ve started a Github repository for this code and made an online web app for live coding with Csound and this library. The live web site is available at:

https://kunstmusik.github.io/csound-live-code/

and the source code is available at:

https://github.com/kunstmusik/csound-live-code

In working with the hex beat patterns, I found it took a little practice but the meaning of various hex values started to become intuitive over time.  Hexadecimal works really well, in my opinion, for notating pattern onsets as each hex value maps to 4 bits, which works perfectly for 4 16th-notes.  With this, 4 hex values can be used to notate a single measure of 16 16th-notes, 8 hex for 2 measures, and so on.