bon, ben j'y arrive toujours pas...


alors j'ai fait "à la barbare" :

import ddf.minim.*;
 
Minim minim;
AudioPlayer song;
 
// int compt =0;
//  float[] gauchedata = new float[4096];
//  float[] droitedata = new float[4096];
 
 
void setup()
{
  size(320, 200);
 
  minim = new Minim(this);
 
  // this loads mysong.wav from the data folder
  song = minim.loadFile("transition1.wav", 1024*4);
 
  song.play();
  
  
   
}
 
void draw()
{
  background(0);
  stroke(255);
  // we draw the waveform by connecting neighbor values with a line
  // we multiply each of the values by 50 
  // because the values in the buffers are normalized
  // this means that they have values between -1 and 1. 
  // If we don't scale them up our waveform 
  // will look more or less like a straight line.
 
  //println("songsize="+song.right.size());
  //println("song buffer size=" + song.bufferSize());
  //if ( song.isPlaying() )
 // {
  //println("son en cours");
  for(int i = 0; i < song.bufferSize() - 1; i++)
  {
  //  line(i, 50 + song.left.get(i)*50, i+1, 50 + song.left.get(i+1)*50);
   // line(i, 150 + song.right.get(i)*50, i+1, 150 + song.right.get(i+1)*50);
   // println(compt);
 // gauchedata[i]=song.left.get(i);
 // droitedata[i]=song.right.get(i);
  //println(song.bufferSize());
  //println(i);
  //println(gauchedata[i]);
point(width/2*(1+song.left.get(i)), height/2*(1+song.right.get(i)));
//println("i="+i+" D="+droitedata[i]+" G="+gauchedata[i]);
//compt++;
//song.pause();
} 
//song.pause();
 // }
  //else
 // {
  //println("fin son");
  
  //for (int k = 1; k<compt-1;k++)
 // {
 // for(int i = 0; i < song.bufferSize() - 1; i++)
  //{
    //line(i, 50 + song.left.get(i)*50, i+1, 50 + song.left.get(i+1)*50);
    //line(i, 150 + song.right.get(i)*50, i+1, 150 + song.right.get(i+1)*50);
  
//point(width/2*(1+gauchedata[i]), height/2*(1+droitedata[i]));
//float m=millis();
//if (millis()%33==0) { saveFrame("line-####.jpg"); }
saveFrame("line-####.jpg");
}
//saveFrame("line-####.jpg"); 
//song.play();
  //}
//}
 
//}
void stop()
{
  song.close();
  minim.stop();
 
  super.stop();
}

j'ai modifié le fichier wav dans Audacity pour supprimer le  blanc en début et fin, et avoir sa durée exacte.
Puis lancé ce script simpliste Processing. supprimé les images inutiles, compté les images restante, calculé le frame rate en fonction de la durée du wav (dans les 22-23 images/sec) .
Puis j'ai chargé les images et le wav dans virtualDub pour caler l'ensemble (modifier le framerate video , décaler le départ du wav).

ça donne ça :


http://vids.myspace.com/index.cfm?fusea … d=55966329

Donc je suis preneur d'astuces sous processing pour éviter tout ça...

A votre bon coeur...

Salut Minamata et bienvenue

J'ai eu le même problème pour une animation synchronisée sur du son, j'ai fait comme toi, pour la réalisation j'envoyais la musique et les images en même temps, par contre pour l'enregistrement, pas de son et images sauvées avec saveframe avec un framerate faible, l'animation finale est à 25 i/s et j'ai fait l'assemblage des images et du son avec ffmpeg. La différence, c'est que les images étaient calées sur le son mais pas *calculées* en fonction du son...

Peut-être que dans ton cas, le mieux est de faire 2 étapes, une première d'analyse du son qui enregistre les informations extraites du son dans des fichiers textes, une seconde ou les images sont fabriquées en lisant ces fichiers texte dans des tableaux et en calculant image par image. Pour calculer les images, il faut que tu aies 25 "données sonores" par seconde, ce qui correspond à 1764 frames sonores (à 44100 Hz), dans la méthode getSpectrum d'ESS il y a un paramètre offset pour démarrer l'analyse fft à partir d'une frame sonore donnée.

Les résultats bruts d'une fft traditionnelle ne sont pas toujours pertinents, un découpage par octave peut parfois être plus intéressant :
http://www.davebollinger.com/works/p5/fftoctana/
code : http://www.davebollinger.com/works/p5/f … er.pde.txt

Je viens de me rendre compte qu'Ess ne travaillait qu'en mono... peut-être que c'est contournable en créant 2 AudioChannel dans lesquels les canaux G et D sont chargés, (pour l'analyse dans une première phase)
Sinon, dans la classe FFT d'Ess il existe la méthode getLevel, qui récupère le niveau sonore, ça correspond à ce que tu cherches.
En remplaçant getSpectrum par getLevel, c'est dans la poche

salut,


bon, faute de comprendre les subtilités du offline dans ESS avec getLevel, je suis revenu à Minim en essayant de faire 1/ d'l'analyse du son et de stocker les valeurs dans un fichier texte puis 2/ de lire le fichier texte, réaliser l'animation et sauvegrader la video (saveframe) ou directement la video (mmoviemaker)

le premier script:

import ddf.minim.*;
import ddf.minim.analysis.*;
import processing.opengl.*;
Minim minim;
AudioPlayer song;
BeatDetect beat;
int r=2;
int t0=0;

int[] x = new int[0];








void setup() {
  //size(1024, 768, OPENGL); 
  frameRate(60);
 size(1024/r, 768/r, OPENGL);
  background(150); 
  noStroke();
 



  // Instantiate cubes, passing in random vals for size and postion
  
minim = new Minim(this);
 
  // this loads mysong.wav from the data folder
  song = minim.loadFile("noir2.wav", 1024*4);
 println(song.length());
 song.play();
 t0=millis();
 println(t0);
// t0=millis();

// t1=t0+song.length();
//println(t0+"   "+t1);
  beat = new BeatDetect();
beat.setSensitivity(400);  
//while (song.isPlaying()) {
//beat.detect(song.mix);
//if ( beat.isOnset() ) {
//  x=append(x, millis());
 //  println(millis());
  //}


//}
}


void draw() {
    beat.detect(song.mix);
  
  
  if (song.isPlaying()) {

if ( beat.isOnset() ) {
  x=append(x, millis()-t0);
 // println(millis()-t0);
 //  println(millis());
  }
  }
}


void keyPressed() { // Press a key to save the data
  String[] lines = new String[x.length];
  for (int i = 0; i < x.length; i++) {
    lines[i] = str(x[i]);
  //  println(x[i]);
  }
  saveStrings("lines.txt", lines);
  exit(); // Stop the program
}

le 2ème:

citation :

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

Minim minim;
AudioPlayer song;
//BeatDetect beat;

String[] lines;
int index = 0;

int t0=0;
int top=0;

Particle[] particles;
int numParticles = 4095;
boolean lignes = false;
int w = 320;
int h = 200;


float cX=w/2;
float cY=h/2;

void setup()
{
 
// frameRate(15);
  size(w, h);
  background(0);
  particles = new Particle[numParticles];
  for(int i=0;i<numParticles;i++)
  {
    particles[i] = new Particle();
    particles[i].x = random(w);
    particles[i].y = random(h);
    particles[i].vx = random(-1, 1);
    particles[i].vy = random(-1, 1);
  }
 
  lines = loadStrings("lines.txt");
  t0=millis();
  println("lines.length="+lines.length);
 
   minim = new Minim(this);

  // this loads mysong.wav from the data folder
// song = minim.loadFile("noir2.wav", 1024*4);

// song.play();
  //beat = new BeatDetect();
// beat.setSensitivity(200);
}

void draw()
{
//  beat.detect(song.mix);
  fill(0, 10);
  rect(0, 0, w, h);
// println(t0);
  // println(millis());
  for(int i=0;i<numParticles -1 ;i++)
  {

    if (  index < lines.length ) {
    if (int(lines[index]) <= (millis()-t0)) {

   cX= cX +random(w/4);
     cY=cY+ random(h/4);
     cX=cX%w;
     cY=cY%h;
     println(index+" "+lines[index]);
     index++;
   }
}
   particles[i].move(cX, cY);
    particles[i].render();
   }
   
   

//saveFrame("line-####.jpg");


   if ((index==lines.length)&&(top==0)) {
     top = millis();
     println("TOP="+top);
   }
   
   if ((top>0) && (millis()>=top+13547)) {
     println("EXIT"+millis());
    exit();
   }
   
   
   
}

void mousePressed()
{
  //
}
void stop()
{
  //song.close();
  //minim.stop();

// super.stop();
}

ben ça marche pas bien: le rendu enregistré est très en dessous de la qualité du temps réél.
Dans cet exemple, ce n'est donc pas tant l'analyse du son en temps réél qui perturbe l'enregistrement, mais bien l'enregistrement lui même des images..
http://vids.myspace.com/index.cfm?fusea … d=56558108

il faudrait animer image par image et sauvegarder image par images également.... j'imagine.

que de boulot pour garder une trace d'un script qui marche très bien en temps réel....