Minim .get() never gets two times the same result when you run again the analysis

Core Library Questions

stp404

Minim .get() never gets two times the same result when you run again the analysis

in Core Library Questions • 6 months ago

I don`t know exactly what track.left.get(i) and track.right.get(i) are doing, but what I'm sure is that they don't always get the same result when you run the application multiple times.

Actually, if you get a short sound clip (just a few seconds) and let it loop printing the values to the terminal it will show a sequence that you could easily recognize, but actually it's not the same thing every time; sometimes there is a visual pattern (if you make a quick graphic out of the values) although the values doesn't match exactly, but at some level is pseudo-random stuff.

I was trying to generate an image from a sound file, but if gathering the data is not accurate from the beginning (run two times the sketch an get the same output) it actually doesn't work as a visualization tool, is more kind of 'sound based generation'.

Somebody has some ideas how to solve this?

Not playing the file at the same time you are analysing it helps a bit (in terms of repeatability). I also was playing with the buffer size but it doesn't help much.

Finally the best approach I found, was to run the analysis a few times and make an average, so you clean out a bit the 'random noise'... but of course this is a workaround, nothing to build upon.

As I see it, you should be able to get the data from a sound file as well as you get it from a text file.

Would be nice to hear if somebody got better results with repeatability in audio analysis with this or other library for Processing.

Replies(4)

Chrisir

Re: Minim .get() never gets two times the same result when you run again the analysis

5 months ago

hi,

I am new to minim and this problem. But this is my idea.

get reads the current buffer.
This buffer is probably filled differently always since all computers and system situations are different (especially under Win).

I wouldn't suggest average.

I would more expect that the values are always the same, but in different places (for get and for i) because of the different filling of the buffer

Thus I would suggest to read out the whole song and store it in an array.

run the song again and compare it to the array. I bet the values are the same (but match get and i differently)

for your graphic then use the array.

Greetings, Chrisir

stp404

Re: Minim .get() never gets two times the same result when you run again the analysis

5 months ago

Hmmm yes I was thinking the same, since there is a pattern, but kind of an offset each time you run the sketch...

The smoother the sketch (the computer) is running the more accurate it is, so not sending the file to the speakers help a bit, but anyway the array will be filled a bit differently every time, so you just can average that.

The way should be actually not even playing it, just getting the array directly from an offline analysis... then you should get 100% the same thing every time, since you are no analyzing a streaming (no matter if is happening local and the file is in your HDD) but extracting the information directly from the file, so (analysis) time is not in the equation.

Chrisir

Re: Minim .get() never gets two times the same result when you run again the analysis

5 months ago

so you just can average that.

I disagree

Did you try to put it all in an array or ArrayLIst and save that and analyze that?

I should always look the same. (not tested)

void draw()
{
for(int i = 0; i < song.bufferSize() - 1; i++)
{
arrLeft [counter] = song.left.get(i) ;
arrRight [counter] = song.right.get(i) ;
counter ++;
}
}

[Edited]
because then the buffer size is not important anymore, so (analysis) time is not in the equation.
Since we add up all buffer states in one array.

stp404

Re: Minim .get() never gets two times the same result when you run again the analysis

5 months ago

should always look the same

I agree with you, it should, but it doesn't.

Check the code bellow.

It generates a 2D list with the values: first dimension is the buffer size and the second one is the time (there is a variable there to quick cut out and just get the start of the file for testing)

It will print to the terminal the values in blocks (of the buffer size).

Just copy/paste the terminal output to an TXT file (to keep it for comparaison) and run again the sketch.

Maybe, the last number is the same, so looks right.

Sometimes, even a few before the last are also the same, so it should be right...

But if you copy one string on numbers, go to your TXT file, and make a search for it, it won't be there.... so is not actually exactly the same every time.

import ddf.minim.analysis.*;
import ddf.minim.*;
FFT fftLin;
Minim minim;
AudioPlayer groove;
ArrayList<ArrayList> waveMap = new ArrayList<ArrayList>();
int lines = 1000; // How long you want to get values from the file
void setup() {
noLoop();
minim = new Minim(this);
groove = minim.loadFile("test_sound.mp3");
groove.mute();
groove.play();
// GET VALUES
while (lines>0) {
ArrayList<Float> waveVal = new ArrayList<Float>();
for (int i = 0; i < groove.bufferSize(); i++) {
waveVal.add(groove.mix.get(i));
}
waveMap.add(waveVal);
lines--;
}
// PRINT VALUES
for (int i=0; i<waveMap.size(); i++) {
for (int j=0; j<groove.bufferSize(); j++) {
print(waveMap.get(i).get(j) + " ");
}
println();
println();
}
exit();
}

For me the issue is in the 'playing' part.

Also the downside of this approach, is that to get the analysis of a one hour long sound file, you need to wait one hour... which is nonsense considering it's digital.

Thinking in an analog way, is like you are physically playing it and then digital recording it to your computer (so you get the values), instead of just reading it since it is actually digitalized from the beginning.

Think of DV cassetes, when you need to actually play the video in order to import it (because you are recording the stream) vs the drag and copy of and video file.

I will look deeper into Minim documentation, should be a way to just get everything at once instead of while it's playing.

Top Reply