import ddf.minim.*;

Minim minim;
AudioInput in;
color white;

void setup()
{
  size(512, 100, P2D);
  white = color(255);
  colorMode(HSB,100);
  minim = new Minim(this);
  minim.debugOn();

  in = minim.getLineIn(Minim.STEREO, 512);
  background(0);
}

void draw()
{
  background(0);
  // draw the waveforms
  for(int i = 0; i < in.bufferSize() - 1; i++)
  {
    stroke((1+in.left.get(i))*50,100,100);
    line(i, 50 + in.left.get(i)*50, i, 50 + in.left.get(i+1)*50);
  }
}


void stop()
{
  in.close();
  minim.stop();
  super.stop();
}

My question is, how do I make the waveform trigger/stabilize like an actual oscilloscope? I'm trying to figure that out so I can make the waveform stay at a certain spot so it doesn't jump around. Basically keep the waveform stable at all times.

Thanks for your help.

I will soon have to make interactive video. As I know a little bit of Processing language, think I should use it for my project.

I have been searching for inspiration and found one of ideas (that might not be as complex for me as a beginer).

So the main question is this:

Is it possible in Processing to code smth like this:

The main idea is to make some black&white background "come to life" with the sounds. The input sounds make random different blurry color splashes that stays for a while, but doesn't disappear very fast.

Would like to make it a bit complex by having those colorful flashes on top of some video.

Any tuts/videos on mind, where I could learn something similar?

I've been working on a script where in very simple terms I would like a random beep to sound (Audioplayer beep - working!) and after that beep, a sequence of audio tracks to play (currently arranged in the array audio) and eventually audio recordings to be made (not set up yet).

My current issue is that

audio[0].play(); 

is working perfectly but not then playing the second audio track. I've tried setting this up as a separate event (

void playrecord()

) and have found this thread very helpful to get the crux of the code from @GoToLoop: https://forum.processing.org/two/discussion/12966/how-to-play-an-audio-file-sequentially.

Ideally I would like to sequence it as audio 0 play, record audio input 0 through microphone, audio 1 play, record audio input 1 through microphone. All before the next "beep" sound is made.

Can anyone suggest what is going wrong?

import ddf.minim.*;
import ddf.minim.AudioPlayer;
import oscP5.*;
import netP5.*;

OscP5 oscP5;
NetAddress otherSketch;

Minim minim;
AudioPlayer beep;

static final int AUDIO = 2;
final AudioPlayer[] audio = new AudioPlayer [AUDIO];
AudioInput daydream;
AudioRecorder[] recorder = new AudioRecorder [1];

PFont f;
int [] beeps = new int [5];
int ms;
int start = -millis();
int totalBeeps;
int beeptime;
boolean pressEnter;

int current=-1;
int count=0;
 
void setup() {
  size (512, 200, P3D);
  f= createFont ("Georgia", 16);
 
  boolean pressEnter = false;
  totalBeeps = 0;
 
  oscP5 = new OscP5(this,8001); /* start oscP5, listening for incoming messages at port 8001 */
  otherSketch = new NetAddress("xxxxxx",8000); /* Start listening at (IP Address, Port Number) */
  
 
  int fac=1000;
  beeps [0] = int(random(10, 60))*fac;//these numbers aren't right but give an earlier beep!
  beeps [1] = int(random(1260, 1739))*fac;
  beeps [2] = int(random(1860, 2339))*fac;
  beeps [3] = int(random(2460, 2939))*fac;
  beeps [4] = int(random(3060, 3539))*fac;
 
  printArray (beeps);
  
  minim = new Minim(this);
  audio [0] = minim.loadFile ("Audio_01.mp3");
  audio [1] = minim.loadFile ("Audio_02.mp3");
  
  minim = new Minim(this);
  daydream = minim.getLineIn();
 // recorder [0] = minim.createRecorder(daydream, "audio01.mp3");
  
  minim = new Minim(this);
  beep = minim.loadFile ("ping.mp3");
}
 
void keyPressed() { //boolean controlling the start screen.
  if (keyCode == ENTER) { 
    start = millis();
    pressEnter = true;
  }
}
 
void draw () {
 
  background (255);
  textFont (f, 16);
  fill (0);
 
  int ms = millis()-start;
 
  println(ms, start);
  
  startScreen();

  for (int i=0; i beeps[i] && i>current) {
      current=i;
      beeptime=millis();
      beep.rewind();
      beep.play();
      totalBeeps =totalBeeps+1;
      OscMessage myMessage = new OscMessage("time in milliseconds");
      myMessage.add(ms); 
      myMessage.add(millis()); 
      myMessage.add(beeptime); 
      myMessage.add(start); 
      oscP5.send(myMessage, otherSketch);       
playrecord();
    }
  } 
}

void startScreen(){
  
  if (pressEnter)//this boolean controls the start screen and initiates the timer -resetting millis to 0 when ENTER is pressed.
  {
    text("The experiment has begun and these are the random beep times:", 10, 40);
    text(beeps[0], 10, 70);
    text("milliseconds", 80, 70);
    text(beeps[1], 10, 90);
    text("milliseconds", 80, 90);
    text(beeps[2], 10, 110);
    text("milliseconds", 80, 110);
    text(beeps[3], 10, 130);
    text("milliseconds", 80, 130);
    text(beeps[4], 10, 150);
    text("milliseconds", 80, 150);
  } else {
    text("Press Enter to begin", 10, 100);
  }
 
  if (!pressEnter)
    return;
}

void playrecord(){
     audio[0].play();
     if (!audio[count].isPlaying()) audio[count=(count+1)% AUDIO].play(); 
}

import ddf.minim.*;

Minim minim;
AudioInput in;

void setup()
{
  size(800, 600, P3D);

  minim = new Minim(this);

  // use the getLineIn method of the Minim object to get an AudioInput
  in = minim.getLineIn();
  println (in.bufferSize());
  // uncomment this line to *hear* what is being monitored, in addition to seeing it
  //in.enableMonitoring();
  background(0);
}

void draw()
{
  //background(0);
  fill (0, 32, 0, 32);
  rect (0, 0, width, height);
  stroke (32);
  for (int i = 0; i < 11 ; i++){
    line (0, i*75, width, i*75);
    line (i*75+25, 0, i*75+25, height);
  }
  stroke (0);
  line (width/2, 0, width/2, height);
  line (0, height/2, width, height/2);
  stroke (128,255,128);
  int crossing=0;
  // draw the waveforms so we can see what we are monitoring
  for(int i = 0; i < in.bufferSize() - 1 && i<width+crossing; i++)
  {
    if (crossing==0&&in.left.get(i)<0&&in.left.get(i+1)>0) crossing=i;
    if (crossing!=0){
      line( i-crossing, height/2 + in.left.get(i)*300, i+1-crossing, height/2 + in.left.get(i+1)*300 );
    }
  }
}

Is there a way to get the audio input from the stereo mix without making it the default device?

Minim minim;

AudioInput in;

PImage[] img = new PImage[4];

PImage[] blue = new PImage[31];

PVector player;

PVector velocity;

PVector leftHand;

float gravity = 0.1;

float r=100;

float force;

PImage body;

PImage zuo;

PImage zuoshou;

PImage you;

PImage youshou;

int n = 15;

PVector enemy[] = new PVector[n];

boolean show[] = new boolean[n];

boolean blink[] = new boolean[n];

int times[] = new int[n];

int count[] = new int[n];

boolean start = false;

boolean change = true;

boolean judge(int k) {

//int i=0;

for (int i=0; i<k; i++) {

if (dist(enemy[k].x, enemy[k].y, enemy[i].x, enemy[i].y) < 100) {

  return true;
}

} return false; }

void setup() {

size(1000, 1000);

frameRate(24);

velocity = new PVector(0, 0);

player = new PVector(width/2, height/2);

for (int i = 0; i < n; i ++) {

enemy[i] = new PVector(random(0, width), random(200, height/2));

while ((dist(width/2, height/2, enemy[i].x, enemy[i].y) < 300)||judge(i)) {

  enemy[i] = new PVector(random(0, width), random(200, height/2));

}

show[i] = true;

blink[i] = false;

times[i] = 0;

count[i] = 0;

}

minim = new Minim(this);

in = minim.getLineIn();

imageMode(CENTER);

body=loadImage("main.png");

//left arm

zuo=loadImage("zuo.png");

zuoshou=loadImage("zuoshou.png");

//right arm

you=loadImage("you.png");

youshou=loadImage("youshou.png");

//MY IMAGE ARRAY

for(int i=0;i<blue.length;i++){

String imageName = nf(i,3)+".png";

blue[i] = loadImage(imageName);

}

for (int i=0; i<4; i++) {

img[i] = loadImage(i%4+".png");

}

}

void draw() {

background(255);

if (getLevel() > 0.01) {

start = true;

}

force = map(getLevel(), 0, 0.1, 0, 0.2);

force = constrain(force, 0, 0.2);

println(force, player.x, player.y, velocity.x, velocity.y);

r = map(getLevel(), 0, 0.1, 0.3, 0.5);

r = constrain(r, 0.3, 0.5);

for (int i = 0; i < n; i ++) {

if (blink[i]) {

  if (frameCount % 30 < 15)

    fill(255, 209, 238);

  else fill(255);

  if (frameCount%30 == 29) {

    times[i] ++;

  }

  if (times[i]>20) {

    blink[i] = false;

    times[i]=0;

  }

} else {

  fill(255, 209, 238);

}

if (show[i]) {

  image(img[i%4], enemy[i].x, enemy[i].y, height/20, height/20);

  println(i%4+".png"+i);

}else{

  pushMatrix();

  fill(0);

  //MY IMAGE ARRAY HERE> 

  count[i]++;

  if(count[i] >= blue.length)

    count[i]--;

  image(blue[count[i]],enemy[i].x, enemy[i].y,100,150);

  popMatrix();

}

}

drawPlayer();

}

void drawPlayer() {

if (abs(gravity)<0.0005) {

velocity.y = 0;

} //wald check edges

if (player.y <= r*body.height/2) {

velocity.y *= -1;

}

if (player.y>=height-body.height*r) {

if (force < 0.01) {

  velocity.y *=-1;

}

if (change) {

  velocity.x = random(-8, 8);

  change = false;

}

}

if (player.x >= width-rbody.width/2 || player.x <= rbody.width/2) {

velocity.x *= -1;

}

player.add(velocity);

if (start) {

velocity.y += (gravity-force);

velocity.y -= 0.03*velocity.y/abs(velocity.y);

}

player.y = constrain(player.y, rbody.height/2, height-body.heightr);

player.x = constrain(player.x, rbody.width/2, width-rbody.width/2);

//pictures image(body, player.x, player.y, 369r, 721r);

float angle0 = atan2(mouseY-player.x, mouseX-player.y);

float leftHandx=0;

float leftHandy=90;

pushMatrix();

translate(player.x-40, player.y-50);

rotate(angle0);

image(zuo, 0, 50, 85r, 306r);

image(zuoshou, 0, 90, 180r, 180r);

leftHand = new PVector (leftHandx, leftHandy);

leftHand.x=leftHandx;

leftHand.y=leftHandy;

for (int i = 0; i < n; i ++) {

if ((dist(player.x, player.y-50, enemy[i].x, enemy[i].y) < r*body.width/2) && show[i]) {

  velocity.x *= -1;

  velocity.y *= -1;

  blink[i] = true;

  times[i] = 0;

  println(i);

}

}

for (int i = 0; i < n; i ++) {

if ((dist(player.x-40+90*sin(-angle0), player.y+40+90*cos(-angle0), enemy[i].x, enemy[i].y) < 100) && show[i]) {

  velocity.x *= -1;

  velocity.y *= -1;

  show[i] = false;  

  println("get"+i);

}

}

ellipse(leftHand.x, leftHand.y, 180r, 180r);

popMatrix();

float angle1 = atan2(mouseY-player.x, mouseY-player.y);

pushMatrix();

translate(player.x+40, player.y-50);

rotate(angle1);

image(you, 0, 50, 85r, 306r);

image(youshou, 0, 90, 180r, 180r);

popMatrix(); }

float getLevel() {

float t = 0;

for (int i = 0; i < in.bufferSize() - 1; i++) {

t += abs(in.mix.get(i));

}

t /= in.bufferSize();

return t;

}

Hi,everyone,above are my coding part.Im kinda new with processing.I suppose it is because I loaded images in draw(),so it would load an image 60 times every second.But i don't know how to tackle that . I would be really appreciate it if any of you guys help me out of it.Thanks!;)

The original code was using mp3 files to draw.
However I want to get the sound and fft from Audio Input.

I'm trying to get the sound from audio but I think the original code using minim library so I can't get the sound right.

How can I get the sound from mic like I get the sound from mp3?

import ddf.minim.*;
import ddf.minim.analysis.*;
import processing.sound.*;

FFT fft;
AudioIn song;

// Variables that define the "zones" of the spectrum
// For example, for bass, we take only the first 4% of the total spectrum
float specLow = 0.03; // 3%
float specMid = 0.125;  // 12.5%
float specHi = 0.20;   // 20%

// This leaves 64% of the possible spectrum that will not be used.
// These values are usually too high for the human ear anyway.

// Scoring values for each zone
float scoreLow = 0;
float scoreMid = 0;
float scoreHi = 0;

// Previous value, to soften the reduction
float oldScoreLow = scoreLow;
float oldScoreMid = scoreMid;
float oldScoreHi = scoreHi;

// Softening value
float scoreDecreaseRate = 25;

// Cubes appearing in space
int nbCubes;
Cube[] cubes;

//Lines that appear on the sides
int nbWalls = 500;
Wall[] murs;

void setup()
{
  //Display in 3D on the entire screen
  fullScreen(P3D);

  //Create the FFT object to analyze the song
  //fft = new FFT(song.bufferSize(), song.sampleRate());
  fft = new FFT(this, song.sampleRate());


  //Get Audio In
  song = new AudioIn(this, 0);
  song.start();
  fft.input(song);

  //One cube per frequency bandOne cube per frequency band
  nbCubes = (int)(fft.specSize()*specHi);
  cubes = new Cube[nbCubes];

  //As many walls as we want
  walls = new Wall[nbWalls];

  //Create all objects
  //Create cubic objects
  for (int i = 0; i < nbCubes; i++) {
   cubes[i] = new Cube(); 
  }

  //Create wall objects
  //walls LEFT
  for (int i = 0; i < nbWalls; i+=4) {
   walls[i] = new Wall(0, height/2, 10, height); 
  }

  //walls RIGHT
  for (int i = 1; i < nbWalls; i+=4) {
   walls[i] = new Wall(width, height/2, 10, height); 
  }

  //walls DOWN
  for (int i = 2; i < nbWalls; i+=4) {
   walls[i] = new Wall(width/2, height, width, 10); 
  }

  //walls UP
  for (int i = 3; i < nbWalls; i+=4) {
   walls[i] = new Wall(width/2, 0, width, 10); 
  }

  //Black background
  background(0);

  //Start the song
  song.play(0);
}



void draw()
{  
  //Forward the song. One draw () for each "frame" of the song ...
  fft.forward(song.mix);

  //Calculation of "scores" (power) for three categories of sound
  //First, save old values
  oldScoreLow = scoreLow;
  oldScoreMid = scoreMid;
  oldScoreHi = scoreHi;

  //Reset values
  scoreLow = 0;
  scoreMid = 0;
  scoreHi = 0;

  //Calculate the new "scores"
  for(int i = 0; i < fft.specSize()*specLow; i++)
  {
    scoreLow += fft.getBand(i);
  }

  for(int i = (int)(fft.specSize()*specLow); i < fft.specSize()*specMid; i++)
  {
    scoreMid += fft.getBand(i);
  }

  for(int i = (int)(fft.specSize()*specMid); i < fft.specSize()*specHi; i++)
  {
    scoreHi += fft.getBand(i);
  }

  //To slow down the descent.
  if (oldScoreLow > scoreLow) {
    scoreLow = oldScoreLow - scoreDecreaseRate;
  }

  if (oldScoreMid > scoreMid) {
    scoreMid = oldScoreMid - scoreDecreaseRate;
  }

  if (oldScoreHi > scoreHi) {
    scoreHi = oldScoreHi - scoreDecreaseRate;
  }

  //Volume for all frequencies at this time, with the highest sounds higher.
  //This allows the animation to go faster for the higher pitched sounds, which is more noticeable
  float scoreGlobal = 0.66*scoreLow + 0.8*scoreMid + 1*scoreHi;

  //Subtle color of background
  background(scoreLow/100, scoreMid/100, scoreHi/100);

  //Cube for each frequency band
  for(int i = 0; i < nbCubes; i++)
  {
    //Value of the frequency band
    float bandValue = fft.getBand(i);

    //The color is represented as: red for bass, green for medium sounds and blue for high.
    //The opacity is determined by the volume of the tape and the overall volume.
    cubes[i].display(scoreLow, scoreMid, scoreHi, bandValue, scoreGlobal);
  }

  //Walls lines, here we must keep the value of the previous tape and the next to connect them together
  float previousBandValue = fft.getBand(0);

  //Distance between each line point, negative because on the z dimension
  float dist = -25;

  //Multiply the height by this constant
  float heightMult = 2;

  //For each band
  for(int i = 1; i < fft.specSize(); i++)
  {
    //Value of the frequency band, we multiply the bands farther to make them more visible.
    float bandValue = fft.getBand(i)*(1 + (i/50));

    //Selection of the color according to the forces of the different types of sounds
    stroke(100+scoreLow, 100+scoreMid, 100+scoreHi, 255-i);
    strokeWeight(1 + (scoreGlobal/100));

    //lower left line
    line(0, height-(previousBandValue*heightMult), dist*(i-1), 0, height-(bandValue*heightMult), dist*i);
    line((previousBandValue*heightMult), height, dist*(i-1), (bandValue*heightMult), height, dist*i);
    line(0, height-(previousBandValue*heightMult), dist*(i-1), (bandValue*heightMult), height, dist*i);

    //upper left line
    line(0, (previousBandValue*heightMult), dist*(i-1), 0, (bandValue*heightMult), dist*i);
    line((previousBandValue*heightMult), 0, dist*(i-1), (bandValue*heightMult), 0, dist*i);
    line(0, (previousBandValue*heightMult), dist*(i-1), (bandValue*heightMult), 0, dist*i);

    //ligne inferieure droite
    line(width, height-(previousBandValue*heightMult), dist*(i-1), width, height-(bandValue*heightMult), dist*i);
    line(width-(previousBandValue*heightMult), height, dist*(i-1), width-(bandValue*heightMult), height, dist*i);
    line(width, height-(previousBandValue*heightMult), dist*(i-1), width-(bandValue*heightMult), height, dist*i);

    //lower right line
    line(width, (previousBandValue*heightMult), dist*(i-1), width, (bandValue*heightMult), dist*i);
    line(width-(previousBandValue*heightMult), 0, dist*(i-1), width-(bandValue*heightMult), 0, dist*i);
    line(width, (previousBandValue*heightMult), dist*(i-1), width-(bandValue*heightMult), 0, dist*i);

    //Save the value for the next loop round
    previousBandValue = bandValue;
  }

  //Rectangular walls
  for(int i = 0; i < nbWalls; i++)
  {
    //Each wall is assigned a band, and its strength is sent to it.
    float intensity = fft.getBand(i%((int)(fft.specSize()*specHi)));
    walls[i].display(scoreLow, scoreMid, scoreHi, intensity, scoreGlobal);
  }
}

//Class for cubes floating in space
class Cube {
  //Z position of spawn and maximum Z position
  float startingZ = -10000;
  float maxZ = 1000;

  //Position values
  float x, y, z;
  float rotX, rotY, rotZ;
  float sumRotX, sumRotY, sumRotZ;

  //--------------------------builder--------------------------
  //--------------------------builder--------------------------
  //--------------------------builder--------------------------

  Cube() {
    //Make the cube appear in a random place
    x = random(0, width);
    y = random(0, height);
    z = random(startingZ, maxZ);

    //Give the cube a random rotation
    rotX = random(0, 1);
    rotY = random(0, 1);
    rotZ = random(0, 1);
  }

  void display(float scoreLow, float scoreMid, float scoreHi, float intensity, float scoreGlobal) {
    //Selection of the color, opacity determined by the intensity (volume of the band)
    color displayColor = color(scoreLow*0.67, scoreMid*0.67, scoreHi*0.67, intensity*5);
    fill(displayColor, 255);

    //Color lines, they disappear with the individual intensity of the cube
    color strokeColor = color(255, 150-(20*intensity));
    stroke(strokeColor);
    strokeWeight(1 + (scoreGlobal/300));

    //Creating a transformation matrix to perform rotations, enlargements
    pushMatrix();

    //Shifting
    translate(x, y, z);

    //Calculation of the rotation according to the intensity for the cube
    sumRotX += intensity*(rotX/1000);
    sumRotY += intensity*(rotY/1000);
    sumRotZ += intensity*(rotZ/1000);

    //Application of the rotation
    rotateX(sumRotX);
    rotateY(sumRotY);
    rotateZ(sumRotZ);

    //Creation of the box, variable size according to the intensity for the cube
    box(100+(intensity/2));

    //Application of the matrix
    popMatrix();

    //Z displacement
    z+= (1+(intensity/5)+(pow((scoreGlobal/150), 2)));

    //Replace the box at the back when it is no longer visible
    if (z >= maxZ) {
      x = random(0, width);
      y = random(0, height);
      z = startingZ;
    }
  }
}

//Class to display the lines on the sides
class Wall {
  //Minimum and maximum position Z
  float startingZ = -10000;
  float maxZ = 50;

  //Position values
  float x, y, z;
  float sizeX, sizeY;

  //--------------------------builder--------------------------
  //--------------------------builder--------------------------
  //--------------------------builder--------------------------

  Wall(float x, float y, float sizeX, float sizeY) {
    //Make the line appear at the specified place
    this.x = x;
    this.y = y;
    //Random depth
    this.z = random(startingZ, maxZ);  

    //We determine the size because the walls on the floors have a different size than those on the sides
    this.sizeX = sizeX;
    this.sizeY = sizeY;
  }

  //Display function
  void display(float scoreLow, float scoreMid, float scoreHi, float intensity, float scoreGlobal) {
    //Color determined by low, medium and high sounds
    //Opacity determined by the overall volume
    color displayColor = color(scoreLow*0.67, scoreMid*0.67, scoreHi*0.67, scoreGlobal);

    //Make lines disappear in the distance to give an illusion of fog
    fill(displayColor, ((scoreGlobal-5)/1000)*(255+(z/25)));
    noStroke();

    //First band, the one that moves according to the force
    //Transformation Matrix
    pushMatrix();

    //Shifting
    translate(x, y, z);

    //extension
    if (intensity > 100) intensity = 100;
    scale(sizeX*(intensity/100), sizeY*(intensity/100), 20);

    //Creation of the "box"
    box(1);
    popMatrix();

    //Second band, the one that is still the same size
    displayColor = color(scoreLow*0.5, scoreMid*0.5, scoreHi*0.5, scoreGlobal);
    fill(displayColor, (scoreGlobal/5000)*(255+(z/25)));
    //Transformation Matrix
    pushMatrix();

    //Shifting
    translate(x, y, z);

    //extension
    scale(sizeX, sizeY, 10);

    //Creation of the "box"
    box(1);
    popMatrix();

    //Z displacement
    z+= (pow((scoreGlobal/150), 2));
    if (z >= maxZ) {
      z = startingZ;  
    }
  }
}

Can I use an audio source other than my PC, connect it via LineIn to the processing sketch and play it back from there, so that the visualization and the playback have the same delay?

I tried achieving this using Beads, this solution using Minim as well as its LiveInput class, but had issues with very glitchy audio playback in all cases.

The processing.sound library seems to handle that better, this bit of code seems to do exactly what I want:

import processing.sound.*;

AudioIn input;

void setup() {
input = new AudioIn(this, 0); input.play(); }

void draw() { background(0); }

However, I have experienced it to be very prone to crashing on Windows as soon as the code becomes slightly more complex than that (Target VM fails to initialize, reproducable with some of the included examples, the one most closely related to what I am trying to achieve would be FFTSpectrum), and it does not seem to be in active development anymore.

Is there any way to accomplish this only using Minim or is there a way to combine both libraries - using minim for the analysis and processing.sound for the playback?

l watch Daniel Shiffman's video "17.9: Sound Visualization: Graphing Amplitude - p5.js", https://youtube.com/watch?v=jEwAMgcCgOA&t=370s, but what I use is processing and pure data, I have a question about how to put those microphone value into an array in Processing, like the tutorial in the video, (the way of receive sound from microphone I use is Pure data, and I'm successfully connect pd and Processing), but I just don't know how to put those value into an array in processing, and I guess the value also need to greater than a certain value because microphone will also receive value when is not saying.Thank you for your help!

My Pure data and Processing sketch is here https://github.com/nancyjou/Sound-Visualization

and here is only my Processing sketch.

float global1;
float global2;
float adc;
float fiddle;
float colorY;
float alphaX;

import netP5.*;
import oscP5.*;


OscP5 oscP5;
NetAddress myRemoteLocation;

void setup() {
  size(800, 800);
  background(255);
  frameRate(25);
  colorMode(HSB, 360, 100, 100);
  noStroke();
  /* start oscP5, listening for incoming messages at port 12000 */
  oscP5 = new OscP5(this, 12001);

  myRemoteLocation = new NetAddress("127.0.0.1", 12000);
}

void draw() {

  fiddle = global2;
  colorY= map(global2, 25, 150, 0, 360);
  alphaX= map(global1, 40, 250, 20, 255);
  fill(colorY, 100, 100);
  fill(colorY, 100, fiddle+50, alphaX);
  for (int y=200; y<(height/4)+1; y+=10) {
    ellipse(width/2, random(0, 400), global1, global1);
    println(y);
  }
  adc = global1 + 10;
}


void mousePressed() {
  OscMessage myMessage = new OscMessage("/first");


  myMessage.add(123);
  myMessage.add(12.34);
  myMessage.add("some text");

  oscP5.send(myMessage, myRemoteLocation);
}  

void oscEvent(OscMessage theOscMessage) {

  if (theOscMessage.checkAddrPattern("/first")==true) {



    float firstValue = theOscMessage.get(0).floatValue();
    global1 = firstValue;
  }

  if (theOscMessage.checkAddrPattern("/second")==true) {



    float secondValue = theOscMessage.get(0).floatValue();
    global2 = secondValue;
  }
  println("### received an osc message. with address pattern "+theOscMessage.addrPattern());
}

Now I'm very rusty with processing so I'm 100% sure I'm making some dumb mistakes here.

I'm trying to make the ellipses in this sketch change colour as they become older but I can't figure it out for the life of me!

Thanks in advance for any help/suggestions :)

See code here:

import ddf.minim.*;

Minim minim;
AudioInput in;
 float volume = 0;
float volumeF = 0;

   int maxParticles=1000; // max number of particles. real particles count depends on ppf and its lifetime
int addPPF=2;         // number of particles per frame added
ArrayList particles;

void setup(){
  size(900,900, P3D);
  frameRate(30);
  smooth();
  background(0);
  noStroke();
     minim = new Minim(this);
  minim.debugOn();

  // get a line in from Minim, default bit depth is 16
  in = minim.getLineIn(Minim.MONO, 512);


  particles = new ArrayList();
}

void draw(){
  background(0); // overpaint circles the frame before
  //  for(int i = 0; i < 1; i++)
  //{
     volumeF = in.right.level()*1000;
  volume = 0.8*volume + 0.2*volumeF;
  if(particles.size()<maxParticles){
    // add particle(s)
    for(int k=1; k<= volume; k++){
      particles.add(new Particles());
    }
  }
  //}

  // run trought all Balls and make some action
  for(int j=0; j<particles.size(); j++){
    Particles particle = (Particles)particles.get(j);
    // if particle still alive
    if( particle.alive() ){
      // update x/y positions
      particle.position();
      // now draw as cirle
      if( particle.lt < 200 ) fill(20, 20, 20, particle.lt);
      else if(particle.lt >= 200) fill(50, 50, 50, particle.lt);
      else if(particle.lt >= 300) fill(100, 100, 100, particle.lt);
      else if(particle.lt >= 400) fill(150, 150, 150, particle.lt);
      else if(particle.lt >= 500) fill(200, 200, 200, particle.lt);
      else if(particle.lt >= 600) fill(250, 250, 250, particle.lt);
      //stroke(random(100));
      ellipse(particle.x, particle.y, particle.r, particle.r);

  }else{
      // if lifetime is running out, delete
      particles.remove(j);
    }
  }
}


  void stop()
{
  // always close Minim audio classes when you are done with them
  in.close();
  minim.stop();

  super.stop();
}

public class Particles {
  float r, x, y, _x, _y, dx=0, dy=0, lt;

  // init start-values
  public Particles() {
    // start position center
    x=width/2;
    y=height/2;
    // now random values to make it non-linear
    lt=random(5,2000);       // lifetime in frames
    r=random(1, 4);        // circle Radius
    _x=random(-0.001, 0.001);    // stepwidth in x-pos (left, right)
    _y=random(-0.001, 0.001);    // stepwidth in y-pos (up, down)
  }

  public void position() {
    // stepwidth increases, circlespeed is exponential
    dx+=_x;
    dy+=_y;
    x+=dx;
    y+=dy;
  }

  public boolean alive(){
     if(lt<=0){ return false; }else{ lt--; return true; }
  }
}

I am doing an project where I am displaying information on a snare drum only (not a all drum kit!). My goal is to give simple feedbacks to the user using a microphone as detection tool. My projection look like a clock and when the main hand reach a point, the player should hit the drum. I would like to detect if he hits the drum on time or not and if he hits the drum or not. My projection is in yellow on a black background, it will highlight in blue if he didn't hit on time and in red if he didn't hit the drum (or if he hits anything which is not the drum).

I tried with minim and beatdetect but unfortunatelly the "isSnare" doesn't work as it should be ... It returns true even if I am whistling or hitting my desk...

Should I go in an FFT analysis ? I am up for any advices .. I don't really know where to start.. Should I record the drum sound and then test in real-time if the hit is equal to the recorded sound?

Here is my code for now:

import ddf.minim.*;
import ddf.minim.analysis.*;

Minim minim;
BeatDetect beat;
AudioInput in;


float eRadius;

void setup()
{
  size(200, 200, P3D);
  minim = new Minim(this);

  in = minim.getLineIn(Minim.STEREO, 512);
  // a beat detection object SOUND_FREQUENCY based on my mic
  beat = new BeatDetect(in.bufferSize(), in.sampleRate());

}

void draw()
{
  background(0);
  beat.detect(in.mix);

  println("isSnare: "+ beat.isSnare());
  //println("isHat: "+ beat.isHat());
  //println("isKick: " + beat.isKick());
  //println("isOnset: "+ beat.isOnset());

}

At the moment I have a word that reacts to sound input from an external mic. The title really explains what I'm looking to do. I've been looking at 'delay()' as a a possible way to change the word every 10 seconds, but I honestly don't know where to start. I've looked at tutorials and other threads to no avail.

I'm thinking I create a string of words I want the sketch to cycle through, but as to how I link that to time I don't know. Or is it a case of creating separate classes?

Thanks for any help or pointers to tutorials that could help me!

Here's what I've done so far:

import ddf.minim.*;
import ddf.minim.analysis.*;

Minim minim; 
BeatDetect beat;
AudioInput in;
FFT fft;

float angle = 0;

PFont font1;
PFont font2;
PFont font3;


void setup()
{


  noCursor();
  fullScreen();
  smooth();
  minim = new Minim(this);
  in = minim.getLineIn();
  fft = new FFT(in.bufferSize(), in.sampleRate());

  frameRate(60);

  beat = new BeatDetect();
   beat.setSensitivity(100);


  font1=loadFont("Simplon.vlw");
  font2=loadFont("Simplon 50.vlw");
  font3=loadFont("Simplon 80.vlw");


}

void draw()
{
  noFill();
  background(255);
  fft.forward(in.mix);
  for (int i = 0; i < in.mix.size() - 1; i++) {
    angle = radians(i);
     textFont(font3);
    textSize(80);
    textAlign(CENTER, CENTER);
    fill(0);
    text("John", 
    width/2 +1000 *cos(angle)*(10*in.mix.get(i)), 
    height/2 -1000 *sin(angle)*(10*in.mix.get(i)));
  }


}

void keyPressed() {

  if (key == 's') {
    saveFrame("wallpapers/wallpaper-####.tif");
  }

}

import ddf.minim.analysis.*;
import ddf.minim.*;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.List;


Minim minim;
AudioInput in;
FFT fft;
AudioPlayer song;
String str="X coordinate= || Y cordinate=";
ArrayList<String> times = new ArrayList();



// Configuration: spectrogram size (pixels)
int colmax = 500;
int rowmax = 250;
// Sample rate
float sampleRate = 22050;
// buffer size (= FFT size, must be power of 2)
int bufferSize = 1024;

// Variables
int[][] sgram = new int[rowmax][colmax];
int col;
int row;
int leftedge;
int topedge;
int window_len = bufferSize;
String timeHoover="";

PFont mono;


void setup()
{
  size(580, 250, P3D);
  textMode(SCREEN);
  textFont(createFont("SanSerif", 12));

  minim = new Minim(this);
  song = minim.loadFile("theMez.mp3", bufferSize);
  song.loop();
  // setup audio input
  //in = minim.getLineIn(Minim.MONO, bufferSize, sampleRate);

  fft = new FFT(song.bufferSize(), song.sampleRate());

  // suppress windowing inside FFT - we'll do it ourselves
  fft.window(FFT.NONE);
  times.add("");
}

void draw()
{
  background(0);
  stroke(255);
  strokeWeight(3);
  line(70, 0, 70, height);

  //song.play();
  // grab the input samples
  float[] samples = song.mix.toArray();
  // apply windowing
  for (int i = 0; i < samples.length/2; ++i) {
    // Calculate & apply window symmetrically around center point
    // Hanning (raised cosine) window
    float winval = (float)(0.5+0.5*Math.cos(Math.PI*(float)i/(float)(window_len/2)));
    if (i > window_len/2)  winval = 0;
    samples[samples.length/2 - i] *= winval;
    samples[samples.length/2 + i] *= winval;
  }
  // zero out first point (not touched by odd-length window)
  samples[0] = 0; 

  // perform a forward FFT on the samples in the input buffer
  fft.forward(samples);

  // fill in the new column of spectral values
  for (int i = 0; i < colmax /* fft.specSize() */; i++) {
    sgram[row][i] = (int)Math.round(Math.max(0, 2*20*Math.log10(1000*fft.getBand(i))));

  }

  // next time will be the next column
  row = row+1;
  // wrap back to the first column when we get to the end
  if (row == rowmax) { 
    row = 0;
  }

  // Draw points.
  // leftedge is the column in the ring-filled array that is drawn at the extreme left
  // start from there, and draw to the end of the array


  for (int i= 0; i<colmax; i++)
  {
    for (int j=0; j<row; j++)
    {
      stroke(sgram[j][i]);
      point(100+i,j);
     // l.add(sdf.format(cal.getTime()));

    }
  }



  //==============timePrinting
  mono = createFont("Verdana", 12);
  textFont(mono);
   if ( !times.get(0).equals("" + hour() + ":" + minute() + ":" + second())) {
    times.add(0, "" + hour() + ":" + minute() + ":" + second());
  }
 // println(times.size());
  while (times.size() > 15) { 
    times.remove(15);
  }
  for ( int i = 0; i < times.size(); i++) {
    text(times.get(i), 5,  20* i);

    if (times.get(i).length()>0)
    {
      //timeHoover= times.get(i);
    stroke(255);
    strokeWeight(2);
    line(5,20*i+5,35,20*i+5);
    }

  }


  text(timeHoover,480,40);
  // Report window size
  //text(str, 8, 10);
}


void mousePressed()
{
  str="X cordinate = ";
  str += String.valueOf(mouseX);
  str+=" || Y cordinate = ";
  str+=String.valueOf(mouseY);
}

void mouseDragged() {
  // map mouse position within window to -1..1
  float proportion = map(mouseX, 0, colmax, -1, 0);
  // convert to window length, log scale, 2^8 range
  window_len = (int)Math.round(Math.pow(2.0, 4.0*proportion)*(float)bufferSize);
  text("asdffs",50,50);
}

void mouseMoved()
{

  int y = mouseY;
  int pos= mouseY/20;
  if (pos<times.size())
  {
    timeHoover = times.get(pos);
    text(timeHoover,480,40);
  }
}


void stop()
{
  // always close Minim audio classes when you finish with them
  in.close();
  minim.stop();
  super.stop();
}

And this is the representation:

    AudioInput in=minim.getLineIn();
    soundIn.add(in.mix);

    AudioOutput out=minim.getLineOut();
            //something like out.mix=soundIn.get(i);

This code only returns the value -64. What am i doing wrong?

import ddf.minim.*;

Minim minim;
AudioInput in;

void setup()
{
  minim = new Minim(this);
  minim.debugOn();


  in = minim.getLineIn(Minim.STEREO, 512);
}

void draw()
{
 println(in.getGain());  
}

void stop()
{

  in.close();
  minim.stop();

  super.stop();
}

I have tried combining them but of course it's not easy at it seem for a beginner like me, they either won't work at all or they don't work like the should.

This is not the only code that I am having trouble doing this with so I feel like I might be missing something. Any help with the code or just pointing me to the right direction would be greatly appreciated!

Code I want to stay in the back but still be interactive:

PShader sh;
String uid;

void setup() {
  PImage img = loadImage("test.jpg");

  size(img.width,img.height,P2D);
  background(0);

  // load and compile shader
  sh = loadShader("lens.glsl");
  // upload texture to graphics card
  sh.set("texture",img);
}

void draw() {
  // normalize mouse position
  float inpx = mouseX/(float)width;
  float inpy = mouseY/(float)height;

  // set shader variable
  sh.set("inp",inpx,inpy);

  // run shader
  shader(sh);

  // fill whole window
  rect(0,0,width,height);
}

And the text code:

import geomerative.*;
import ddf.minim.*;

Minim mySound; //CREATE A NEW SOUND OBJECT
AudioInput in;

RFont font;
String myText = "TEST";

void setup() {
  size(1500, 400);
  background(255);
  smooth();
  RG.init(this); 
  font = new RFont("FreeSans.ttf", 100, CENTER);

  mySound = new Minim(this);
  in = mySound.getLineIn(Minim.STEREO,512);
}

void draw() {
  background(255);
  strokeWeight(2);
  stroke(255, 0, 0);
  noFill();
  translate(width/2, height/1.5);

  float soundLevel = in.mix.level(); //GET OUR AUDIO IN LEVEL

  RCommand.setSegmentLength(soundLevel*9000);
  RCommand.setSegmentator(RCommand.UNIFORMLENGTH);

  RGroup myGoup = font.toGroup(myText); 
  RPoint[] myPoints = myGoup.getPoints();

  beginShape(QUAD_STRIP);
  for (int i=0; i<myPoints.length; i++) {

    vertex(myPoints[i].x, myPoints[i].y);
  }
  endShape();
}

Thanks a lot! Gianmaria

import ddf.minim.spi.*;
import ddf.minim.signals.*;
import ddf.minim.*;
import ddf.minim.analysis.*;
import ddf.minim.ugens.*;
import ddf.minim.effects.*;

Minim m;
AudioInput in;
AudioPlayer hera;
AudioPlayer time;
AudioPlayer hotlinebling;
AudioPlayer kemosabe;


boolean onOff = false;
boolean pOn = false;

void setup() {
  size(640, 360);
  background(255);

  m = new Minim(this);
  hera = m.loadFile("1.mp3");
  hera.loop();

  time = m.loadFile("2.mp3");
  time.loop();

  hotlinebling = m.loadFile("hbt.mp3");
  hotlinebling.loop();


  kemosabe = m.loadFile("4.mp3");
  kemosabe.loop();

  in = m.getLineIn(Minim.MONO, 2048);
}      

void draw() {

  if (onOff == false) {
    kemosabe.mute();
    time.mute();
    hera.nmute();
    hotlinebling.mute();

    //Mikrofon 
    if (keyPressed) {
      if (key == 'p' && !pOn) {
        if (random(0, 6) < 3) {
          in.enableMonitoring();
        } else {
          in.disableMonitoring();
        }
        println(in.isMonitoring());
        pOn = true;
      }
    } else {
      pOn = false;
      in.disableMonitoring();
    }
  } else {
    kemosabe.unmute();
    hera.unmute();
    hotlinebling.unmute();
    time.unmute();
  }

  //Hera koka hallatszik 
  if (keyPressed ) {
    if (key=='0') 
      time.mute();
  } else {
    time.unmute();
  }

  if (keyPressed ) {
    if (key=='0') 
      kemosabe.mute();
  } else {
    kemosabe.unmute();
  }

  if (keyPressed ) {
    if (key=='0') 
      hotlinebling.mute();
  } else {
    hotlinebling.unmute();
  }

  //I've had hallatszik 
  if (keyPressed ) {
    if (key=='2') 
      hera.mute();
  } else {
    hera.unmute();
  }

  if (keyPressed ) {
    if (key=='2') 
      kemosabe.mute();
  } else {
    kemosabe.unmute();
  }

  if (keyPressed ) {
    if (key=='2') 
      hotlinebling.mute();
  } else {
    hotlinebling.unmute();
  }

  //Hotline bling
  if (keyPressed ) {
    if (key=='5') 
      hera.mute();
  } else {
    hera.unmute();
  }

  if (keyPressed ) {
    if (key=='5') 
      kemosabe.mute();
  } else {
    kemosabe.unmute();
  }

  if (keyPressed ) {
    if (key=='5') 
      time.mute();
  } else {
    time.unmute();
  }

  //Kemosabe hallatszik 
  if (keyPressed ) {
    if (key=='8') 
      hera.mute();
  } else {
    hera.unmute();
  }

  if (keyPressed ) {
    if (key=='8') 
      time.mute();
  } else {
    time.unmute();
  }

  if (keyPressed ) {
    if (key=='8') 
      hotlinebling.mute();
  } else {
    hotlinebling.unmute();
  }
}

void keyPressed() {
  if (key == 'm') {
   onOff = !onOff;
  }
}

I want to use Processing to record sound from and Arduino with an Adafruit Electret Microphone Amplifier and have problem with the code. I haven't been able to find any tutorial so I looked in to the example Serial > Simple read and Minim > Basic > RecordAudioInput and tried to put them together.

What I am trying to do is to read the value from the serial and use it as the value for sound (was that clear?). Here is the code

I am using Processing 3.2.3 and latest Minim lib.

Am I on the right track? Thanks in advance. Daniel

import ddf.minim.*;
import processing.serial.*;

Serial myPort;  // Create object from Serial class
int val;      // Data received from the serial port

Minim minim;
AudioInput in;  // <---------This is the current input from the computer I need it from Serial (probably 'val')
AudioRecorder recorder;

void setup()
{
  size(512, 200, P3D);

  String portName = Serial.list()[1];
  myPort = new Serial(this, portName, 9600);

  minim = new Minim(this);

  in = minim.getLineIn();
  // create a recorder that will record from the input to the filename specified
  // the file will be located in the sketch's root folder.
  recorder = minim.createRecorder(in, "myrecording.wav");

  textFont(createFont("Arial", 12));
}

void draw()
{
  background(0); 
  stroke(255);
    if ( myPort.available() > 0) {  // If data is available,
    val = myPort.read();         // read it and store it in val
  }
  // draw the waveforms
  // the values returned by left.get() and right.get() will be between -1 and 1,
  // so we need to scale them up to see the waveform
  for(int i = 0; i < in.bufferSize() - 1; i++)
  {
    line(i, 50 + in.left.get(i)*50, i+1, 50 + in.left.get(i+1)*50);
    line(i, 150 + in.right.get(i)*50, i+1, 150 + in.right.get(i+1)*50);
  }

  if ( recorder.isRecording() )
  {
    text("Currently recording...", 5, 15);
  }
  else
  {
    text("Not recording.", 5, 15);
  }
}

void keyReleased()
{
  if ( key == 'r' ) 
  {
    // to indicate that you want to start or stop capturing audio data, you must call
    // beginRecord() and endRecord() on the AudioRecorder object. You can start and stop
    // as many times as you like, the audio data will be appended to the end of the buffer 
    // (in the case of buffered recording) or to the end of the file (in the case of streamed recording). 
    if ( recorder.isRecording() ) 
    {
      recorder.endRecord();
    }
    else 
    {
      recorder.beginRecord();
    }
  }
  if ( key == 's' )
  {
    // we've filled the file out buffer, 
    // now write it to the file we specified in createRecorder
    // in the case of buffered recording, if the buffer is large, 
    // this will appear to freeze the sketch for sometime
    // in the case of streamed recording, 
    // it will not freeze as the data is already in the file and all that is being done
    // is closing the file.
    // the method returns the recorded audio as an AudioRecording, 
    // see the example  AudioRecorder >> RecordAndPlayback for more about that
    recorder.save();
    println("Done saving.");
  }
}

So for this assignment I have to take either an audio file or live audio input and have it translate to a hue change on a photo! Overall it seems pretty simple but I'm stuck on how to put the information in to change the hue. I've inserted what I have so far below.

    import ddf.minim.*;
    import ddf.minim.signals.*;
    import ddf.minim.analysis.*;
    import ddf.minim.effects.*;
    PImage img;

    Minim minim;
    AudioInput in;

    void setup()
    {
        img = loadImage("Ash.jpg");
        size( 540, 687 );
        smooth();

        minim = new Minim( this );

        in = minim.getLineIn( Minim.STEREO, 512 );

        background(img);
    }

    void draw()
    {
    }
    void stop()
    {
        in.close();
        minim.stop();
        super.stop();
    }

thanks!

import ddf.minim.*;

Minim minim;
AudioInput in;

float x;
float y;
float px;
float py;
float vel; 
float dir; 

void setup(){
  size(400,400);
  stroke(0);
  background(255);
  smooth();
  frameRate(30);

  x=y=px=py=200;


  vel = random(5);  
  dir = random(360);  

  minim = new Minim(this);

  in = minim.getLineIn();
}

void draw(){
  px = x;
  py = y;

  x += cos(radians(dir)) * vel;
  y += sin(radians(dir)) * vel;

  stroke(0);
  line(px,py,x,y);

  float value = 0;

  for(int i = 0; i < in.bufferSize() - 1; i++) {
      value += in.mix.get(i);      
  }
  value /= in.bufferSize();
  dir += random(-30, 30) * value ;
}

void stop() {
  minim.stop();
  super.stop();
}

Minim minim; AudioInput in;

void setup() { size(512, 200, P3D);

minim = new Minim(this);

// use the getLineIn method of the Minim object to get an AudioInput in = minim.getLineIn(); } \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ Poor expression maybe. Thank you ：)

Is it possible, with the help of processing, to take INPUT from the microphone and play the data conversly in realtime.

Any help is much appreciated!

The line of code causing the problem is:

port = new Serial(this, Serial.list()[1],9600); //set baud rate

This is the error I'm receiving:

WARNING: RXTX Version mismatch Jar version = RXTX-2.2pre1 native lib Version = RXTX-2.2pre2 Exception in thread "Animation Thread" java.lang.ArrayIndexOutOfBoundsException: 1 at Audio_Spectrum_to_Arduino3216_doublebar_pde.setup(Audio_Spectrum_to_Arduino3216_doublebar_pde.java:68) at processing.core.PApplet.handleDraw(Unknown Source) at processing.core.PApplet.run(Unknown Source) at java.lang.Thread.run(Thread.java:662)

Here is the entire code:

                            import ddf.minim.analysis.*;
                            import ddf.minim.*;
                            import processing.serial.*; //library for serial communication

                            Serial port; //creates object "port" of serial class

                            Minim minim;
                            AudioInput in;
                            FFT fft;
                            float[] peaks;

                            int peak_hold_time = 1;  // how long before peak decays
                            int[] peak_age;  // tracks how long peak has been stable, before decaying

                            // how wide each 'peak' band is, in fft bins
                            int binsperband = 5;
                            int peaksize; // how many individual peak bands we have (dep. binsperband)
                            float gain = 40; // in dB
                            float dB_scale = 2.0;  // pixels per dB

                            int buffer_size = 1024;  // also sets FFT size (frequency resolution)
                            float sample_rate = 44100;

                            int spectrum_height = 176; // determines range of dB shown

                            int[] freq_array = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
                            int i,g;
                            float f;


                            float[] freq_height = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};  //avg amplitude of each freq band

                            void setup()
                            {
                              size(200, 200);

                              minim = new Minim(this);
                              port = new Serial(this, Serial.list()[1],9600); //set baud rate

                              in = minim.getLineIn(Minim.MONO,buffer_size,sample_rate);

                              // create an FFT object that has a time-domain buffer 
                              // the same size as line-in's sample buffer
                              fft = new FFT(in.bufferSize(), in.sampleRate());
                              // Tapered window important for log-domain display
                              fft.window(FFT.HAMMING);

                              // initialize peak-hold structures
                              peaksize = 1+Math.round(fft.specSize()/binsperband);
                              peaks = new float[peaksize];
                              peak_age = new int[peaksize];
                            }


                            void draw()
                            {
                            for(int k=0; k<16; k++){
                            freq_array[k] = 0;
                            }

                              // perform a forward FFT on the samples in input buffer
                              fft.forward(in.mix);

                            // Frequency Band Ranges      
                              freq_height[0] = fft.calcAvg((float) 0, (float) 50);
                              freq_height[1] = fft.calcAvg((float) 51, (float) 69);
                              freq_height[2] = fft.calcAvg((float) 70, (float) 94);
                              freq_height[3] = fft.calcAvg((float) 95, (float) 129);
                              freq_height[4] = fft.calcAvg((float) 130, (float) 176);
                              freq_height[5] = fft.calcAvg((float) 177, (float) 241);
                              freq_height[6] = fft.calcAvg((float) 242, (float) 331);
                              freq_height[7] = fft.calcAvg((float) 332, (float) 453);
                              freq_height[8] = fft.calcAvg((float) 454, (float) 620);
                              freq_height[9] = fft.calcAvg((float) 621, (float) 850);
                              freq_height[10] = fft.calcAvg((float) 851, (float) 1241);
                              freq_height[11] = fft.calcAvg((float) 1242, (float) 1600);
                              freq_height[12] = fft.calcAvg((float) 1601, (float) 2200);
                              freq_height[13] = fft.calcAvg((float) 2201, (float) 3000);
                              freq_height[14] = fft.calcAvg((float) 3001, (float) 4100);
                              freq_height[15] = fft.calcAvg((float) 4101, (float) 5600);


                            // Amplitude Ranges  if else tree
                              for(int j=0; j<16; j++){    
                                if (freq_height[j] < 200000 && freq_height[j] > 200){freq_array[j] = 16;}
                                else{ if (freq_height[j] <= 300 && freq_height[j] > 150){freq_array[j] = 15;}
                                else{ if (freq_height[j] <= 250 && freq_height[j] > 125){freq_array[j] = 14;}
                                else{ if (freq_height[j] <= 200 && freq_height[j] > 100){freq_array[j] = 13;}
                                else{ if (freq_height[j] <= 160 && freq_height[j] > 90){freq_array[j] = 12;}
                                else{ if (freq_height[j] <= 150 && freq_height[j] > 75){freq_array[j] = 11;}
                                else{ if (freq_height[j] <= 140 && freq_height[j] > 65){freq_array[j] = 10;}
                                else{ if (freq_height[j] <= 120 && freq_height[j] > 50){freq_array[j] = 9;}
                                else{ if (freq_height[j] <= 50 && freq_height[j] > 45){freq_array[j] = 8;}
                                else{ if (freq_height[j] <= 45 && freq_height[j] > 40){freq_array[j] = 7;}
                                else{ if (freq_height[j] <= 40 && freq_height[j] > 35){freq_array[j] = 6;}
                                else{ if (freq_height[j] <= 35 && freq_height[j] > 30){freq_array[j] = 5;}
                                else{ if (freq_height[j] <= 30 && freq_height[j] > 15){freq_array[j] = 4;}
                                else{ if (freq_height[j] <= 15 && freq_height[j] > 10){freq_array[j] = 3;}
                                else{ if (freq_height[j] <= 10 && freq_height[j] > 5){freq_array[j] = 2;}
                                else{ if (freq_height[j] <= 5 && freq_height[j] >= 1 ){freq_array[j] = 1;}
                                else{ if (freq_height[j] < 1 ){freq_array[j] = 0;}
                              }}}}}}}}}}}}}}}}}

                              //send to serial
                              port.write(0xff); //write marker (0xff) for synchronization

                              for(i=0; i<16; i++){
                                port.write((byte)(freq_array[i]));
                              }
                              //delay(2); //delay for safety
                            }


                            void stop()
                            {
                              // always close Minim audio classes when you finish with them
                              in.close();
                              minim.stop();

                              super.stop();
                            }

import ddf.minim.*;
import ddf.minim.signals.*;
import ddf.minim.analysis.*;
import ddf.minim.effects.*;

Minim minim;
AudioPlayer track;
AudioInput in;


float bpm = 80;
float mspb = 54000/bpm;
float x = 0;
float y = 0;
float x1 =0;
float x2 =0;
float y2 =0;
float y1 =0;
float R_x =0;
float R_y =0;

float line_height = 1;
int time = 0;

void setup()
{
  fullScreen(P2D);
  background(255);
  strokeWeight(0);
  frameRate(20);
  smooth();
  minim = new Minim(this);
  track = minim.loadFile("alno.mp3", 2048);
  in = minim.getLineIn(Minim.STEREO, 1024);
  track.loop();

}


void draw() {
  int lapse = millis();
  for (int i = 0; i < track.left.size()-1; i++) {
    x1 = x;
    x2 = x;
    y1 = track.left.get(i);
    y2 = track.left.get(i+1);
    fill(0,abs(track.left.get(i))*255);
    noStroke();
    ellipse(x, y,lapse % abs(track.left.get(i))*10,lapse % abs(track.left.get(i))*10);
    x+=abs(track.left.get(i)+7);
  }



if (lapse > mspb || x > width ) {
    time = millis();
    y += 6;
    x = 0;
    if (y > height){
    y = 0;
  }  
  }

}

void stop(){

  track.close();
  minim.stop();
  super.stop();

}

My modified code is this (I am aware I haven't created an option for switching scenes yet):

// Tomash Ghz - tomashg.com
// Ableton synced visuals in Processing Tutorial

import ddf.minim.*; // Iport the Minim Library for sound input

Minim minim; // Create instances of Minim
AudioInput in;


int scene=1; // Keep track of the current scene
int shape=1; // and shape

color backgroundCol=0; // Store the background color
color strokeCol=255; // Store the shape outile color

float soundWeight; // Store the sound volume weight

void setup() { // Setup function runs only once when the sketch starts. Initialize everything here
  size(1280, 768); // Set the window size

  noFill(); // Will draw only outline of shapes
  rectMode(CENTER); // Set the rectangle origin to its center
  colorMode(HSB, 360, 100, 100); // Set the color values to Hue Saturation Brightness instead of Red Green Blue
  smooth(8); // Draw smooth shapes

  minim = new Minim(this); // Create a new Minim class for sound input
  in = minim.getLineIn(Minim.STEREO, 2048, 192000.0);  // Enable 
}

void draw() { // Draw function runs every frame. Update everything and draw on the screen
  soundWeight=in.mix.level()*20; // Read the audio input and scale the value
  drawScene(); // Draw the visuals
}


void drawScene(){ // A function we use to draw different things according to the current scene
  switch(scene){ // We only have 4 scenes here
    case 0:
      background(0); // set the background black
      break;
    case 1:
      background(backgroundCol); // just draw the background with its color
      break;
    case 2:
      drawShapes(0); //draw static shapes over the background
      break;
    case 3:
      drawShapes(soundWeight); //draw shapes that scale to the incoming volume levels. We pass the sound weight as the size value
      break;
  }
}

void randomColors(){ // A function we use to change randomly the colors
    backgroundCol=color(random(127,255),50,50); // Set a random color for the background with a hue from 127 to 255
    strokeCol=color(random(0,126),100,100);; // Set a random color for the outlines with a hue from 0 to 126
}

void drawShapes(float size){ // A function we use to draw a shape according to the current shape
  background(backgroundCol); // First draw the background
  stroke(strokeCol); // Set the outline color
  pushMatrix();
  translate(width/2,height/2); // Start drawing from the center of the screen

  switch(shape%3){ // We only have 3 shapes so lets sycle through them. We add the size value
    case 0: 
      rect(0,0,width/4+size*width/8,width/4+size*width/8); // Draw a square
      break;
    case 1:
      ellipse(0,0,width/4+size*width/8,width/4+size*width/8); // Draw a circle
      break;
    case 2:
      triangle(-width/8-size*width/16,width/8+size*width/16,0,-width/8-size*width/16,width/8+size*width/16,width/8+size*width/16); // Draw a triangle
      break;
  }
  popMatrix();
}

I've just downloaded Processing 2.2.1 and I'm trying to get the Minim library to work but with no success.

Even with this simple/ example code I get an error.

Code:

import ddf.minim.*;//minim

Minim minim;
AudioPlayer player;
AudioInput input;

void setup()
{
  size(100, 100);

  minim = new Minim(this);
  player = minim.loadFile("protection.mp3");
  input = minim.getLineIn();
}

void draw()
{
  // do what you do
}

Error:

==== JavaSound Minim Error ==== ==== Unable to return a TargetDataLine: unsupported format - PCM_SIGNED 44100.0 Hz, 16 bit, stereo, 4 bytes/frame, little-endian

=== Minim Error === === Minim.getLineIn: attempt failed, could not secure an AudioInput.

Any ideas?????

Thanks!

I'm on Windows 7 64bits and just updated to Java Version 8 Update 51. The file protection.mp3 is in a folder named data in the sketch folder.

here my first question in the forum, i´m trying to draw a audio reactive lines on screen using the minim library, and all works fine, but when i use the P2D or P3D in the size function that stop working.

using the 2.2.1 version of processing not work. using the 1.5.1 version of processing it works.

what can i do?

thnxs in advance, sorry for the bad english..

here´s the code:

  import ddf.minim.*;//minim

//Reactivo
Minim minim;
AudioInput in;
float eyey = 300;

void setup() {
  size (500, 500,P2D);// it does not work
  // size (500, 500,P2D);// is working

  //Minim entrada de audio
  minim = new Minim(this);
  in = minim.getLineIn();
  background(0);
}

void draw() {
  difumina(0, 10);

  llora(100);
  llora(200);
  llora(300);
}

void mousePressed() {
  background(0);
}

void llora( float _y){


 for (int i = 0; i < in.bufferSize () - 1; i++)
  {
    //Variables waveform
    float x1 = map(i, 0, in.bufferSize(), 0, width);

    stroke(255, 255);
    line(x1, _y+ in.right.get(i)*500, x1, _y+ in.right.get(i)*500);
  }



}

//Función fondo pantalla
void difumina(color c, float al) {

  fill(c, al);

  rect (-2, -2, width +10, height +10);
}

Here's my code so far:

PImage fade;

void setup(){

  size(1280, 720, P3D);
  smooth();


  fade = get(0, 0, width, height);


}

void draw(){  

  background(0);
  tint( 255, 255, 255, 254);
  translate(width/2, height/2);

  image(fade, -width/2, -height/2);
  noTint();


  colorMode(HSB, 100);


  filter.paintCircle(bassDominantFreq, 1);
  filter.paintCircle(midsDominantFreq, 2);
  filter.paintCircle(trebleDominantFreq, 3);

  fade = get(-width/2, -height/2, width/2, height/2);


}

Now, as far as I understand, the coordinates should be correct: top left corner would be -width/2, -height/2, and lower right corner would be width/2, height/2.

Any ideas?