Fun With Perl. Blips and Beeps. DC Perl ... - The Lack Thereof

NoiseGen
Fun With Perl. Blips and Beeps.
DC Perl Mongers, March 2012
Brock Wilcox
awwaiid@thelackthereof.org

Let's build a software synthesizer
in about 20 minutes.

What is sound?

Let's reverse-engineer!

Exercises for reader:
Speakers → Ears → Consciousness

Let's start with speakers

I like it better sideways...

Alternating Current

Sound = Speaker movement = Electrical input

Waves

What is digital sound?

What is digital sound?

Divide into samples

A sample is number from -1 .. 1

(y-axis)

Evenly spaced over time

(x-axis)

Samples per second
↳ "Sample Rate"

Common sample rates:
DVD: 48,000
CD: 44,100
VOIP: 16,000
Telephone: 8,000

Representation of each sample
↳ "Bit Depth"

8 bit: 0..255 (old video games)
16 bit: 0..65535 (CD)
24 bit: 0..16777215 (DVD-Audio)

Human Ear: 21 bit @ 40k

What does it matter?

Amplitude and Frequency

Amplitude is easy!

amplitude = volume

Frequency not so easy

frequency = wiggle speed = pitch

Low bit depth
causes volume-aliasing

Low sample rate
causes frequency-aliasing

So!

We just gotta generate samples!

48000 of them per second!

No problem.

Audio::PortAudio

Alternatives: /dev/dsp, aplay, ...

# smallbeep.pl
my $stream =
Audio::PortAudio::default_host_api()
->default_output_device
->open_write_stream(
{ channel_count => 1 },
48000,
100
);

# smallbeep.pl
my $time = 0;
my $time_step = 1 / 48000;
while(1) {
my $raw = '';
for(1..100) { # Build up 100 samples
my $sample = sin( 2 * 3.1415 * $time * 440 );
$time += $time_step;
$raw .= pack "f*", $sample;
}
$stream->write($raw);
exit if $time > 1; # don't beep forever!
}

Woo... beeping!

# smallbeep.pl
my $sample = sin( 2 * 3.1415 * $time * 440 );

# smallnoise.pl
my $sample = rand(2) - 1;

Two beeps at once?

Turns out you just add waves together

# smallbeep2.pl
my $sample = sin( 2 * 3.1415 * $time * 440 );
$sample += sin( 2 * 3.1415 * $time * 349.23 );
$sample /= 2; # Avoid clipping!

Let's generalize

my $sample = get_next_sample();

Call get_next_sample() over and over

Get a new sample each time

sub sine {
return sin( 2 * 3.1415 * $time * 440 );
}

That was easy.

Not very configurable or dynamic though.

# What I want:
my $sample_gen = sine(440);
# ...
my $sample = $sample_gen->();

This is called a 'generator'

We can make this using a 'closure'!

(aka subref with bound variables)

sub sine {
my $freq = shift;
return sub {
return sin( 2 * 3.1415 * $time * $freq );
}
}

# So now we have it:
my $sample_gen = sine(440);
# ... in 'play'
my $sample = $sample_gen->();

# Create a 440 Hz sine generator
my $gen = sine(440);
# Play it!
play( $gen );

play( sine( 440 ) );

One more generator tweak

Parameterize generators with generators,
and use named params

# Audio::NoiseGen
sub sine {
my %params = generalize( freq => 440, @_ );
return sub {
return sin( 2 * 3.1415 * $time * $params{freq}->() );
}
}

# Audio::NoiseGen
# Turn constants into generators
sub generalize {
my %params = @_;
foreach my $name (keys %params) {
unless(ref $params{$name} eq 'CODE') {
my $val = $params{$name};
$params{$name} = sub { $val };
}
}
return %params;
}

I've put these and others
into Audio::NoiseGen

use Audio::NoiseGen qw(:all :init);
play( gen => sine( freq => 440 ) );

Why would we use generators
as parameters?

Now we're cooking with FIRE!

What's with this '440' stuff?

That's an 'A' note.

I got a whole list of them from the internets.

Stuck 'em in a hash.
$note_freq{'A4'} == 440

Why 440, you say?

Remember,
ear → consciousness
is your problem :)

use Audio::NoiseGen qw(:all :init);
play( gen => sine( freq => 440 ) );

Now plays forever

Scale the volume

Amplify Generator

Envelope Generator

Attack, [Decay], Sustain, Release

envelope(
attack => 0.5,
sustain => 1,
release => 0.5,
gen => sine( freq => 440 )
)

eturns undef when done

Sequence Generator

sequence( gens => [
envelope( sustain => 1, gen => sine( freq => 440 ) ),
envelope( sustain => 1, gen => sine( freq => 349.23 ) ),
])

Combine Generator

combine( gens => [
envelope( sustain => 1, gen => sine( freq => 440 ) ),
envelope( sustain => 1, gen => sine( freq => 349.23 ) ),
])

Note / Song Generators

note( note => 'A4' )

segment( notes => 'A4 F3' ),

combine( gens => [
segment( notes => 'A4' ),
segment( notes => 'F3' ),
])

Input Control

Let's build something we can PLAY

With my touch-screen

$ xmousepos
838 574 221 170

my ($x, $y) = split(' ', `xmousepos`);

# Generate frequency based on mouse-x
sub mousefreq {
my $c = 0;
my ($x, $y) = (0, 0);
return sub {
# Don't update too often
unless($c++ % 1000) {
($x, $y) = split(' ', `xmousepos`);
print "pos: $x, $yn";
}
return $x;
}
}

play( gen =>
amp(
amount => mousevol(),
gen => sine(
freq => mousefreq()
)
)
);

And now we have a synth :)

THE END

References
* http://people.xiph.org/~xiphmont/demo/neil-young.html