Kassen

As mentioned, it’s not so much that I slacked on practice/creation in the #hackpact week (though that happened too), it’s that i was terrible at documentation. In this episode; analogue synthesis and turntablism.

(more…)

Overview of the direction my practice took in the past month, noting areas that need work and the direction I was moving in.

(more…)

Today is Acid-Day!

I thought I’d look into the Moog UGen for basslines. Then, before I knew it my toying around had gotten me a pritty interesting acid bassline so while I was at it I thought I’d add some drums, I again used the standard ChucK drums so people will be able to reproduce the piece. With some more playing and tweaking a hour had passed already and I resolved to turn this in rather than do something new for hackpact as I quite like this. For editing during the recording I would’ve had to split it up over several files and use my clock (so editing drums wouldn’t reset the bass). I decided not to do that and just leave it be as it is because I kinda like hearing it evolve on it’s own. I think sitting still and listening must sometimes count as “public thought” as well

I’m inserting the code as a file because wordpress doesn’t like indentation.

hackpact-day4 code

Kassen_hackpact-day4 (audio)

Today I played with bitwise operations and had a lot more fun than last night. I picked bitwise operations as I hadn’t really gotten into those before but clearly this was a mistake. They now seem more interesting to me than combinations modulo operations as a quick&dirty way of generating interesting patterns. They seem to allow for quite compact yet effective code as well, probably as techno is quite “bitwise” in structure too. You can also get large musical changes from a single edited character yet it all seems to stay coherent, at least when you keep it as simple as I did here. Time will tell what happens when I get into complexity.

I played with very simple edits, then gradually build up to the code below, automating the changes. Finally I started recording and while recording made some impulsive edits, trying to recompile on the beat. The samples used were those that come with ChucK (see /examples/data/ so they should be available to anyone who can run this code.

["hihat.wav", "hihat-open.wav", "kick.wav", "snare.wav", "snare-hop.wav", "snare-chili.wav" ] @=> string samples[];

SndBuf b[samples.cap()];

for(int n; n<b.cap(); n++)
{
samples[n] => b[n].read;
b[n].samples() => b[n].pos;
b[n] => dac;
}

int count;
int foo;
int bar;

while(1)
{
count++;
if (!(count % 8))
{
foo++;
if (!(foo % 4)) bar++;
}

if (bar%4 < 2)
{
for (int n; n < b.cap(); n++)
{
if (!(count % 8 ^ (n + foo)% 8))    0 => b[n].pos;
}
}
else if ((bar%4) ==2 )
{
for (int n; n < b.cap(); n++)
{
if (!(count % 8 & (n + foo)% 8))    0 => b[n].pos;
}
}
else if ((bar%4) == 3)
{
for (int n; n < b.cap(); n++)
{
if (!(count % 8 | (n + foo)% 8))    0 => b[n].pos;
}
}

.125::second => now;
}

Kassen_hackpact-day3

Not as challenging as “re-seeding” but I do regret not getting into these sooner as they make for some good fun and code edits at the speed of phrases become very viable.

Some force of will was involved in practising today as I was busy arranging things in the afternoon, then had to help a friend move in the evening. However, I practiced and tried to study the rapid resetting of the RNG seed some more. The factors that are involved are fairly delicate. There is only one RNG yet multiple processes may be writing different numbers to it at various rates, leading to a sort of chord. Furthermore, the sound of any given UGens that makes use of it will be affected by the total number of such UGens being currently processed.

The issue as I experienced it tonight in this setup is that for patterns to remain interesting the sub-patterns should be prime in length, relative to each other, however numbers that are prime relative to each other tend not to make good chords. I struggled with this for a while before deciding sleep would be a better plan now with hopefully fresh perspectives later.

Below is the code, first my clock;

==================

public class clk
{
//beats per minute
static float BPM;
//beats per bar
static int bpb;
static dur period;

//what beat we are at
static int beatnr;
//what bar we are at
static int barnr;

//broadcasts every bar
static Event @ bar;
//broadcasts every beat
static Event @ beat;

//sets the bpm
fun static void bpm(float value)
{
if (value > 0)
{
value => BPM;
minute / BPM => period;
}
else <<<”BPM should be greater than 0″>>>;

}
}

//bget around instantiation issue
new Event @=> clk.beat;
new Event @=> clk.bar;

//set defaults
130 => clk.bpm;
8    => clk.bpb;

while(1)
{
if(!clk.beatnr)
{
clk.barnr++;
clk.bar.broadcast();
}
clk.beat.broadcast();
clk.period => now;
clk.beatnr++;
clk.bpb %=> clk.beatnr;
}

=================

Here is the first sound;

==============

SubNoise s;

10::ms => dur period;
2::ms => dur fund;

fun void mod()
{
while(1)
{
period => now;
1 => Std.srand;
}
}

spork ~ mod();

while (clk.beat => now)
{
(1+ ((clk.beatnr + clk.barnr) % 5)) * 4 => s.rate;
(2+ (clk.beatnr % 4))::fund => period;
if (clk.beatnr % 2) s =< dac;
else s => dac;
}

============

Which I contrasted against this variation (note these interact and aren’t really independant at all for the above reasons)

============

SubNoise s;

10::ms => dur period;
3::ms => dur fund;

fun void mod()
{
while(1)
{
period => now;
0 => Std.srand;
}
}

spork ~ mod();

while (clk.beat => now)
{
(1+ ((clk.beatnr + clk.barnr) % 13)) * 5 => s.rate;
(2+ (clk.barnr % 4))::fund => period;
if (clk.beatnr % 3) s =< dac;
else s => dac;
}

================

The result isn’t all that spectacular, but I’m not yet ready to give up on this principle. It’s clearly hard to use effectively but the challenge is interesting; so many factors interact in texture and perceived pitch. I’ll let the idea stew for a while and try something different tomorrow, I think.

Kassen_hackpact-day2

It’s a challenging listen, I suppose, but then it’s a rather conceptual study trying to challenge myself.

Kassen_hackpact-day1

Sadly just a recording; i lost the code trying to quite the vm, which ran into some sort of bug. Should save first in the future.

This is a recording of the final results of about a hour of experimenting with tuning noise by rapidly (yet at a variable rate) resetting the RNG seed in ChucK. It was also my first real session using the clock ob ject I wrote to use in livecoding as I was tired of re-implementing a central clock every time. The technique seems quite viable, especially with using SubNoise which can have it’s own rate that can be used melodically. Filtering that, with the filter frequency set in plain Hz as opposed to multiples of the sample rate is something I’ll need to get a feel for. I should also get a better feel for the interactions between different patterns generated by different modulo’s of the beat number and the bar count.

Not the most satisfactory of sessions due to some snafus and the lost code but I suppose it’s good to feel like you need more practice on day one and I did get into it when I ended up with something that reminded me of a jazz preset on a very cheap toykeyboard. In recent years I seem to end up with toykeyboard jazz quite often, apparently regardless of what instrument I’m playing or trying to create.

I’d like to return to this trechnique and setup (both the technical one and leaning back on the big bean-bag) tomorrow. I’m fairly sure it should be possible to create basslines in the style of that newer French elektro stuff this way and I like how it blurs the line between sequencing and DSP code. I’ll try to document it in more depth then as well.