Recent Examples (audio)

Frequenz Gruppen ermitteln (audio)

Jonas Loh (@ranzen) — Mon, 06 Feb 2012 21:55:21 +0000

Die minim Bibliothek bietet neben dem Laden/Abspielen von Dokumenten, dem Nutzen von Audiohardware ein Paket von Werkzeugen um Klange zu erzeugen bzw. bestehendes Material auszuwerten. Eine bekannte Mehthode ist die sog. FFT (Fast Fourier Transform), bei der das Frequenzspektrum in eine feste Anzahl von FrequnzbÃ¤ndern unterteilt wird. Durch das Auslesen dieser BÃ¤nder erhÃ¤lt man Aufschluss Ã¼ber die Verteilung von HÃ¶hen, Mitten und Tiefen in der Audiodatei.

Da es bei hohen AuflÃ¶sungen in den Bereichen von 1024, 512 oder 256 BÃ¤ndern (wie in diesem Fall) nicht zu einer Abfrage jedes Frequenzbandes kommen muss, werden diese in den meisten FÃ¤llen zu Gruppen zusammengefasst. Im folgenden Beispiel liefert die Funktion getGroup() diese verkÃ¼rzte Fassung mit einer AuflÃ¶sung von 16 Bereichen, welche als Parameter angegeben wird. Die Anzahl der Bereich muss dabei immer ein Vielfaches von 2 sein (2, 4, 8, 16, 32, 64, 128, â€¦). Innerhalb der Funktion wird ein Array angelegt und der Mittelwert einer jeden Frequenzgruppe berechnet, final in einem der Arrayfelder abgelegt. Nach dem Aufruf im draw(), kommt es zu einer simplen Abbildung der Audiodaten um die Funktionsweise zu verdeutlichen.

Example code

import ddf.minim.*;
import ddf.minim.analysis.*;
 
Minim minim;
AudioInput input;
FFT fft;

float maxSpec = 0;

void setup () {
  size(320, 240);
  noStroke ();
  
  // Audiotool-Box und Mikrofoneingang erstellen 
  // und einrichten. Die '256' bestimmen dabei die 
  // spÃ¤tere AuflÃ¶sung des Spektrums.
  minim = new Minim (this);
  input = minim.getLineIn (Minim.STEREO, 256);
  // FFT-Instanz fÃ¼r die Spektrumsanalyse
  fft = new FFT (input.bufferSize (), 
                 input.sampleRate ());
}
 
void draw () {
  background (0);
  
  float g = 0;    // GrÃ¼nwert der FÃ¼llfarbe
  float h = 0;    // HÃ¶he von Rechteck und Linie
  float specStep; // Breite einer horiz. Linie
  float specScale = (float) width / (fft.specSize () - 1);
  
  // Erzeugen der 'Frequenz-Gruppen' (16 Bereich)
  // mÃ¶gliche Schritte: 2-4-8-16-32-64-128
  float[] group = getGroup (16);
  
  // Zeichnen des detailierten Frequenzspektrums
  noStroke ();
  for (int i = 0; i < fft.specSize (); i++) {
    g = map (fft.getBand (i), 0, maxSpec, 50, 255);
    h = map (fft.getBand (i), 0, maxSpec, 2, height);
    fill (0, g, 0);
    rect (i * specScale, height - h, specScale, h);
  }
  
  // Zeichnen der Gruppen (Linien)
  stroke (255, 255, 0, 200);
  specStep = width / group.length;
  for (int i=0; i < group.length; i++) {
    h = height - map (group[i], 0, maxSpec, 0, height);
    line (i * specStep, h, (i+1) * specStep, h);
  }
}

/** 
 * Funktion fasst das vorliegende FFT-Spektrum
 * in eine durch den Parameter 'theGroupNum' 
 * festgelegte Anzahl von gleichgroÃŸen Bereichen
 * zusammen â€“ und gibt deren Mittelwert zurÃ¼ck.
 */
float[] getGroup (int theGroupNum) {
  fft.forward (input.mix);
  
  // Leeres Array fÃ¼r die Gruppen erstellen
  float[] group  = new float[theGroupNum];
  // Das FFT-Spekturm hat eine Stelle mehr 
  // als beim Input definiert. (256->257).
  // Diese wird ignoriert.
  int specLimit  = fft.specSize () - 1;
  // Anzahl der FrequenzbÃ¤nder pro Gruppe
  int groupSize = specLimit / theGroupNum;
  
  // Alle Gruppen mit einem Startwert fÃ¼llen
  for (int i=0; i < group.length; i++) {
    group[i] = 0;
  }
  
  // FÃ¼r jedes FFT-Frequenz-Band
  for (int i=0; i < specLimit; i++) {
    // Maximum?
    if (fft.getBand (i) > maxSpec) {
      maxSpec = fft.getBand (i);
    }
    // Jedes Band einer Gruppe zuweisen
    int index = (int) Math.floor (i / groupSize);
    group[index] += fft.getBand (i);
  }
  
  // Der Wert jeder Gruppe durch die Anzahl
  // der enthaltenen BÃ¤nder Teilen - >Mittelwert
  for (int i=0; i < group.length; i++) {
    group[i] /= groupSize;
  }
  // Gruppe zurÃ¼ck geben.
  return group;
}

Simples Spektrum (Wellenform) (audio)

Jonas Loh (@ranzen) — Mon, 06 Feb 2012 21:55:17 +0000

Eine der bekanntesten Darstellungen von Ton und Klang ist das klassische Spekturm. In minim als AudioBuffer bezeichnet, beinhaltet es ein float Array mit einem Wert pro Kanal. Die Anzal der KanÃ¤le wird bei dem Erzeugen des AudioInputs festgelegt. In diesem Fall unterteilen wir das Spektrum zu Beginn im setup-Blocks in 96 Bereiche.
Mit jedem Einzelbild wird eine Kopie des Buffers (toArray()) erzeugt um beim Durchlaufen des Arrays alle EintrÃ¤ge im Spektrum abzubilden. In der dafÃ¼r benutzen for-Schleife verbindet die Oberseite eines Rechtecks jeweils zwei Teile des Spektrums. Neben der y-Position gibt der Mittelwert beider KanÃ¤le die HSB-FÃ¼llfarbe an.

Example code

import ddf.minim.*;

Minim minim;
AudioInput input;

float yStart = 100;
float yScale = 140;

void setup () {
  // Sketch einstellen
  size (320, 240);
  smooth();
  noStroke ();
  colorMode (HSB);
  
  // Audiotoolkit anlegen
  minim = new Minim (this);
  input = minim.getLineIn (Minim.STEREO, 96);
}

void draw () {
  background (0);
  
  // Auslesen und speichern des Spektrums
  float[] buffer = input.mix.toArray ();
  // Breite der Rechtecke berechnen
  float step = ceil ((float) width / buffer.length);
  
  // FÃ¼r jeden einzelnen Eintrag im Buffer wird ein 
  // Rechteck gezeichnet. Es entsteht durch das verbinden
  // zweier Buffer-EintrÃ¤ge. Die Schleife beginnt bei 1, 
  // jeder Eintrag wird mit seinem VorgÃ¤nger verbunden.
  for (int i=1; i < buffer.length; i++) {
    
    // Positionen fÃ¼r alle 4 Punkt bestimmen
    float x1 = (i-1) * step;
    float x2 = i * step;
    float y1 = yStart + buffer[i-1] * yScale;
    float y2 = yStart + buffer[i] * yScale;
    
    // FÃ¼llfarbe definieren
    float h = (buffer[i-1] + buffer[i]) / 2;
    fill (h * 255, 255, 255);
    
    // Rechteck zeichnen
    beginShape (QUADS);
    vertex (x1, y1);
    vertex (x2, y2);
    vertex (x2, height);
    vertex (x1, height);
    endShape ();
  }
}

Mikrofoneingang nutzen (audio)

Jonas Loh (@ranzen) — Mon, 06 Feb 2012 21:55:12 +0000

Angewendet auf ein Mikrofon-Input visualisiert der folgende Sketch die chronologische Entwicklung der UmgebungsgerÃ¤usche. Je lauter, desto grÃ¶ÃŸer und separierter wird ein Kreis auf der ZeichenflÃ¤che abgebildet. Dabei verschiebt sich die Position auf der x-Achse von links nach rechts, bis es zu einem Umbruch in die nÃ¤chste Zeile kommt. Mittels der globalen Variablen x und y wird die aktuelle Position gespeichert und durch die if-Bedingung am Ende des draw()-Blocks kontrolliert.

Example code

import ddf.minim.*;

float x;
float y;
Minim minim;
AudioInput input;

void setup () {
  // Sketch einstellen
  size (320, 240);
  smooth();
  stroke (255, 25);
  noFill ();
  
  // Startposition festlegen
  x = 0;
  y = 20;
  
  // Audiotoolkit anlegen
  minim = new Minim (this);
  input = minim.getLineIn (Minim.STEREO, 512);
  background (0);
}

void draw () {
  // KreisgrÃ¶ÃŸe AbhÃ¤ngig von LautstÃ¤rke
  float dim = input.mix.level () * width;
  // Kreis x-Position verschieben
  x += input.mix.level () * 20;
  // Kreis zeichnen
  ellipse (x, y, dim, dim);
  
  if (x > width) {
    x = 0;
    y += 20;
  }
}

LautstÃ¤rke ermittlen (audio)

Jonas Loh (@ranzen) — Mon, 06 Feb 2012 21:55:08 +0000

Neben der Position im Audiodokument und dessen Steuerung, erlaubt die minim Bibliothek das Auslesen von Eigenschaften. Eine bezeichnendes Kriterium ist die wiedergegebene LautstrÃ¤ke zu einem bestimmten Zeitpunkt. WÃ¤hrend des Abspielens durch den play() Aufruf, kann im draw() das sogenannte 'level' fÃ¼r jedes Einzelbild erfragt werden. Die mix.level()-Funktion beschreibt die Auslastung dieses Merkmals in einem Wertebereich von 0 und 1.
Das Objekt mix reprÃ¤sentiert das Sterosignal, welches sich aus dem linken (left) und dem rechten (right) Kanal zusammen setzt.

Example code

import ddf.minim.*;

Minim minim;
AudioPlayer player;

void setup () {
  // Sketch einrichten
  size (320, 240);
  noStroke ();
  
  // Audiodatei laden und abspielen
  minim = new Minim (this);
  player = minim.loadFile ("track.aif");
  player.play ();
}

void draw () {
  // Schwarzes semitransparentes Recht 
  // Ã¼ber die gesamte BÃ¼hne zeichnen
  fill (0,30);
  rectMode (CORNER);
  rect (0, 0, width, height);
  
  // GrÃ¶ÃŸe des Quadrats in AbhÃ¤nigkeit von
  // der LautstÃ¤rke berechnen
  float dimension = player.mix.level () * 250;
  
  // Rechteck zeichnen
  fill (255);
  rectMode (CENTER);
  rect (width/2, height/2, dimension, dimension);
}