From CCRMA Wiki
Jump to: navigation, search

Music 220B ~ Compositional Algorithms, Psychoacoustics, and Spatial Processing - Winter '08

Final Project ~


See Homework #2 page for details on Cellular Automata rules, and communication between C++ and ChucK. This project uses code in C++ to get information about the Cellular Automata, and ChucK code to seed and update the CA, map readings from the CA onto sound parameters, and analyse sound input to be manipulated by the sound parameters.

~ Program Notes: Seeds (2008), by Michael Berger (4m20s) for Bass Guitar, Disklavier, and Laptops with ChucK

  • Based upon software by Prof. Ge Wang that renders a visual representation of Cellular Automata ("CAlories" ©2008 Ge Wang), and using rules inspired by John Conway's "Game of Life" (1970), Seeds is a live computer mediated improvisation performance construct, more than it is a composed piece of music. The Bassist attempts to accompany / be accompanied by the Disklavier; while the latter is being controlled by automated C.A. software on one laptop, and the former's sound output is manipulating and being manipulated by similar software on a second computer. The Disklavier's controlling computer is to be either completely automated, given 'seeds' by a human performer, or will receive 'seeds' over a network connection from the Bassist's computer. 'Seeds' in this case are inputs that initiate or change the automated rule-based simulation as it is rendered by the software; they inject life into lifelessness, or push the existing life in a new direction. The Bassist's automated simulation receives 'seeds' from the Bass Guitar itself: the greater the volume of the input the more dense the 'seeding' of the cellular automation. This way in which this automation grows and recedes then directly controls the sound-output of the Bass Guitar.
    The complex chain of dependancies that link the performative agents of Seeds together raises several questions about the relationship between these agents, and blurs the lines between live, computer-mediated, and non-live-media performance types. Who are the performers? Whose decisions govern the manifestation of the performance? of the piece?

~ Code:
alternate version without FMsynth:

What each does:

  • -
    • listens to the bass-guitar (input 1)
    • sends seed values to CAlories depending on the attack volume
    • tracks the pitch of note, finds the 8 most prominent partials and sends them to the synth. which is sent through a low pass filter before it outputs to dac.
    • listens to CAlories (via OSC)
    • depending on the density of 'live' cells in each of the 8 octants (see Homework #2 page) it controls an FM synth (that is patched to the 8 outputs).
    • sporks four functions:
      • ramp_stuff_synth — slews values for the FM synth
      • thresholder — listens for bass attacks, sends info to CAlories
      • PitchTracking — gets the top 8 spectral components and passes them to the synth
      • updater — sends update messages to CAlories at a set rate
  • (runs on separate computer)-
    • sends midi data to the disklavier based on the density in eighty sectors of the 20x20x20 Cellular Automata
    • counts the duration of the piece (4m20s), in the last 2 minutes the density of disklavier notes slows.
    • sends seeds at random times to CAlories maybe
    • sends random single live cells to CAlories at a set rate
    • sends update messages to CAlories
    • sporks three functions:
      • add — sends random live cells to CAlories
      • seed — sometimes maybe sends random seed values to CAlories
      • updater — sends update messages to CAlories at a set rate

The Journey:

Originally I had planned to use multiple computers and send CAlories messages from one or two central PCs to "play" the computers with a very spactial result. This dissolved quickly due to lack of multiple computers. Then the idea of playing the computer playing the piano began to appeal to me. This idea stuck around for a while (it is still stuck as far as I can tell). I soon arrived at the idea to have the bass guitar control the CAlories program. Originally I was going to have the bass not only control its own CA but also that of the piano. I quickly became too lazy to do this (the disklavier CA is random and automated). The idea to combine this with the piano was a relatively recent addition, but it fits well with things.
The bass sound was a tricky matter. Initially I wanted to granulate the bass sound and have the grains shift as the CA evolved. As alien as this sound was, it was still too similar to the bass' inherent sound. I decided to track the bass frequencies and feed them into a synthesizer.
This is how Seeds remains today. A player playing digital sounds, a computer playing analogue sounds.