�ݺ�ߣ

• Audio Processing/Synthesis

• Statistics

• Medical Data

• Image/Video Processing

• ETC
DIGITAL SIGNAL
PROCESSING

How do you create
sound, digitally?

• The number of samples (data points) of audio per second

• The granularity/resolution of your signal

• 44.1kHz / 44100Hz = 44100 samples per second
Sample Rate

• The number of samples for sound card to process at one
time

• Buffer === too small, computer can’t fill the buffers fast
enough, get glitching

• Buffer === too big, can experience latency in real time
performance (i.e: pressing a key on a MIDI keyboard)
Buffer Size

[ ]
Sample Rate: 44100
Buﬀer Size: 1024

Sample Rate: 44100
Buﬀer Size: 1024

Sample Rate: 44100
Buﬀer Size: 1024
43.06 per second

Playing native audio with
ReasonML

open Portaudio;
open Bigarray;
Portaudio.init();
let deviceId = Portaudio.get_default_output_device();
let device = Portaudio.get_device_info(deviceId);
let outparam =
    Some({
      channels: 2,
      device: deviceId,
      sample_format: format_float32,
      latency: device.d_default_low_output_latency,
    });
let stream = open_stream(None, outparam, sampleRate, bufferSize, []);
let dims = [|2 * bufferSize|];
let ba = Genarray.create(float32, c_layout, dims);
while (playing^ === true) {
  fill_ba(ba, dispatch, appStateRef^);
  Portaudio.write_stream_ba(stream, ba, 0, bufferSize);
};

let mtime = ref(0.0);
let mdelta = 1. /. sampleRate;
let fill_ba = (ba) => {
/* Reset mtime if it gets too big */
  if (mtime^ > Float.max_float) {
    mtime := 0.;
  };
/* Get Audio Data */
  let data = getData(mtime);
/* Increment time by sample */
  mtime := mtime^ +. mdelta;
/* Get stereo channel array indexes */
  let left = [|2 * i|];
  let right = [|2 * i + 1|];
  /* Set the data at the index */
  Genarray.set(ba, left, data);
  Genarray.set(ba, right, data);
};

Oscillators emit waveform
values over time

Frequency (pitch) determines
how fast it oscillates

Time determines where in
the cycle (period) you are
(phase)

Period: One full oscillation cycle

let getSine = (frequency, gain, phase, mtime)
=>
sin(
Float.pi *. 2. *. frequency *. mtime +. phase
) *. gain;

Gain: multiplier that makes
the signal louder or softer
(volume)

let getSquare = (frequency, gain, mtime) =>
  let fpt = 1. /. freq;
  let hpt = fpt /. 2.;
  let lt = mod_float(mtime, fpt);
  (lt < hpt ? 1.0 : (-1.0)) *. gain

let getSaw = (frequency, gain, mtime) =>
  let fpt = 1. /. freq;
  let hpt = fpt /. 2.;
  let lt = mod_float(mtime, fpt);
  (lt /. fpt *. 2. -. 1.0) *. gain

How can we combine two
waves to make a new
sound?

You literally add them
together.

let dataPoint = sineWaveDataPoint
+ sawWaveDataPoint;

Envelopes change amplitude
over time to shape a signal

Attack - Initial ramp up of amplitude after Note On
Decay - Initial step down of amplitude
Sustain - Holds amplitude steady
Release - How long it takes for the amplitude to fade
out after Note Oﬀ

We can make an envelope
with a state machine

type envelope = {
  minimumLevel: float,
  mutable currentStage: stage,
  mutable currentLevel: float,
  mutable multiplier: float,
  mutable currentSampleIndex: int,
  mutable nextStageSampleIndex: int,
};

let create = () => {
  minimumLevel: 0.0001,
  currentStage: Off,
  currentLevel: 0.0001,
  multiplier: 0.1,
  currentSampleIndex: 0,
  nextStageSampleIndex: 0,
};

let enterStage = (env, nextStage, params) => {
  env.currentStage = nextStage;
  env.currentSampleIndex = 0;
  env.nextStageSampleIndex = (
    switch (nextStage) {
    | Off => 0
    | Sustain => 0
    | _ =>
      let idx = find(stageOrder, nextStage, ~i=0);
      int_of_float(params[idx] *. sampleRate);
    }
  );
  | Off =>
    env.currentLevel = 0.;
    env.multiplier = 1.0;
  | Attack =>
    env.currentLevel = env.minimumLevel;
    calculateMultiplier(env, env.currentLevel, 1.0, env.nextStageSample
Index);
  | Decay =>
    env.currentLevel = 1.0;
    calculateMultiplier(
      env,
      env.currentLevel,
      max(params[3], env.minimumLevel),
      env.nextStageSampleIndex,
    );
  | Sustain =>
    env.currentLevel = params[3];
  | Release =>

let idx = find(stageOrder, nextStage, ~i=0);
      int_of_float(params[idx] *. sampleRate);
    }
  );
  | Off =>
    env.currentLevel = 0.;
  | Attack =>
    env.currentLevel = env.minimumLevel;
    calculateMultiplier(env, env.currentLevel, 1.0, env.nextStageSample
Index);
  | Decay =>
    env.currentLevel = 1.0;
      env,
      env.currentLevel,
      max(params[3], env.minimumLevel),
    );
  | Sustain =>
    env.currentLevel = params[3];
  | Release =>
      env,
      env.currentLevel,
      env.minimumLevel,
    )
  };
  ();
};

Envelopes are typically
triggered by MIDI or a
sequencer

I don’t have PortMIDI bindings, so I
built a sequencer:

Step Sequencer
Tempo (Beats Per Minute)
Beat (1/4 Note)
Step (1/16th Note)

How can we sequence our
sounds?

• A bitcrusher is a combination of adjust bit depth and
downsampling

• Bit depth - resolution of our waves

• Downsampling - reducing the sample rate
Bitcrusher

let bitcrusher = Bitcrusher.create(16., 12);
let data = (getWaveData() *. gain)
|> Bitcrusher.process(bitcrusher);

type bitcrusher = {
  mutable bitDepth: float,
  mutable downSampling: int,
  mutable lastSample: float,
  mutable counter: int,
};
let create = (bitDepth, downSampling) => {
  bitDepth,
  downSampling,
  lastSample: 0.,
  counter: 0,
};

Delay
(It’s basically an echo)

let bitcrusher = Bitcrusher.create(16., 12);
let data = (getWaveData() *. gain)
|> Bitcrusher.process(bitcrusher)
|> Delay.process(delay);
Signal Chain

type delay = {
  mutable duration: float,
  mutable gain: float,
  delayBuffer: array(float),
  mutable currentSample: int,
};
let create = (duration, gain) => {
  duration,
  gain,
  delayBuffer: Array.make(int_of_float(sample
Rate *. 2.), 0.),
  currentSample: 0,
};

Delay Buffer
We use a circular buﬀer to schedule the
current signal to play at a later time

let process = (d: delay, input: float) => {
  /* Max buffer size */
  let max = int_of_float(sampleRate *. 2.) - 1;
  /* If we're at the end of the sample count, reset */
  if (d.currentSample > max) {
    d.currentSample = 0;
  };
  /* How many samples are we delaying */
  let delayIndex = int_of_float(sampleRate *. 2. *. d.duration);
  /* Get our insert index */
  let ii = d.currentSample + delayIndex;
  /
* If the index exceeds the buffer length, insert at beginning wi
th the difference */
  let insertIndex = ii < max + 1 ? ii : ii mod max;
  /* Fill our delay buffer */
  d.delayBuffer[insertIndex] = input;
  /* Mix delay buffer into input signal */
  let output = input +. d.delayBuffer[d.currentSample] *. d.gain
;
  /* Increment sample counter */
  d.currentSample = d.currentSample + 1;
  output;
};

�ݺ�ߣ

Audio DSP in ReasonML

More Related Content

Audio DSP in ReasonML