OSC string concatenation bug

7 Jul 2011

      I'm writing a program that talks with Wekinator, but I'm having a problem
with sending the feature names over OSC that I'm fairly certain is a problem
with chuck.

At the bottom of the code (see bottom of email) is the relevant method,
sendOscFeatureNames().  When I run wekinator and get to the training screen,
I run this code.  The instant it sends the feature names to Wekinator (i.e.,
the instant it is run), an exception gets raised:

"
Exception in thread "Thread-4" java.lang.ArrayIndexOutOfBoundsException:
1536
        at
com.illposed.osc.utility.OSCByteArrayToJavaConverter.lengthOfCurrentS
tring(Unknown Source)
        at
com.illposed.osc.utility.OSCByteArrayToJavaConverter.readString(Unkno
wn Source)
        at
com.illposed.osc.utility.OSCByteArrayToJavaConverter.readArgument(Unk
nown Source)
        at
com.illposed.osc.utility.OSCByteArrayToJavaConverter.convertMessage(U
nknown Source)
        at
com.illposed.osc.utility.OSCByteArrayToJavaConverter.convert(Unknown
Source)
        at com.illposed.osc.OSCPortIn.run(Unknown Source)
        at java.lang.Thread.run(Unknown Source)
"

This exception is not thrown when I replace numDataPoints[i] with a constant
(like 5).

Here is the entire .ck file.  You can use it just like you would any OSC
feature extractor with Wekinator.

//Extracts the following for different numDataPoints
//0 - centroidAvg
//1 - centroidStdDev
//2 - centroidMin
//3 - centroidMax
//4 - rmsAvg
//5 - rmsStdDev
//6 - rmsMin
//7 - rmsMax
//8 - fft bin with highest fval (highest over all windows)
//...
//whenever an amplitude > threshold is detected from input, computed over
//numDataPoints 128-sample ffts that overlap by 64-samples
//
"127.0.0.1" => string hostname;
OscSend xmit;
xmit.setHost( hostname, 6448 );
OscSend xmit2;
xmit2.setHost( hostname, 6448 );

//Custom objects
adc => FFT f =^ RMS rms => blackhole;
f =^ Centroid centroid => blackhole;
f =^ Flux flux => blackhole;
f =^ RollOff rolloff => blackhole;
UAnaBlob b;

//for storing the results from each window
float rmsArr[50];
float cent[50];
float highestFFTBin[50]; //bin with highest fft fval
float highestFFTVal[50]; //the actual value of the bin

//Set up bin stuff
128 => int FFT_SIZE;
FFT_SIZE => f.size;
Windowing.hamming(64) => f.window;

1::second / 1::samp => float SR;
SR/FFT_SIZE => float bin_width;

//constants
.5 => float threshold;
0 => int peakDetected; //flag if peak has been detected
now => time lastPeakTime;
100::samp => dur peakWindow;
10::samp => dur peakPollRate;
[1,5,10,15,20,25,30,35,40,45,50] @=> int numDataPoints[]; //list of
numDataPoints values to try
1 => float rmsMultiplier; //so it isn't out of wek's range (this actually
doesn't matter, leave it at 1)

0 => int currentlyAnalyzing; //flag if currently analyzing i.e. don't detect
peak

//Run the peak detector in parallel to set the peakDetected flag
spork ~peakDetector();
spork ~sendOscFeatureNames();

//Extract features and send via osc when peak detected.
while (true) {
    if (peakDetected) {
        <<<"Peak detected! Analyzing">>>;
        analyzeAndSend();
    }
    .1::second => now;
}

//When peak detected, compute min, max, avg, and std. dev for centroid and
rms
//and send
fun void analyzeAndSend() {
    1 => currentlyAnalyzing;
    xmit.startMsg( "/oscCustomFeatures",
"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
    //Get all float and rms values for the maximum numDataPoints
    getRmsCentroidAndFFT();

    for (0 => int i; i < 11; i++) {
        analyzeNumDataPoints(numDataPoints[i]) @=> float result[];
        for (0 => int j; j < 9; j++) {
            result[j] => xmit.addFloat;
        }
    }
    <<<"done">>>;
    0 => currentlyAnalyzing;
}

//populates rms, cent, and fft arrays
fun void getRmsCentroidAndFFT() {
    50 => int maxDataPoints;

    128::samp => now;
    rms.upchuck();

    for (0 => int i; i < maxDataPoints; 1 +=> i) {
        rms.fval(0) => rmsArr[i];
        centroid.upchuck();
        centroid.fval(0) => cent[i];

        0 => float highestBinMagnitude;
        0 => int highestBin;
        f.upchuck();
         //find highest bin
        for (1 => int j; j < FFT_SIZE; j++) {
            if (f.fval(j) > highestBinMagnitude) {
                f.fval(j) => highestBinMagnitude;
                j => highestBin;
            }
        }
        highestBin => highestFFTBin[i];
        highestBinMagnitude => highestFFTVal[i];

    }
}

//Analyze data using the specified number of data points, return the float
array corresponding to
//the osc message format described at top
//requires that the arrays have been populated
fun float[] analyzeNumDataPoints(int numDataPoints) {
    float centroidTotal;
    float centroidMin;
    float centroidMax;
    float centroidStdDev;
    float rmsTotal;
    float rmsMin;
    float rmsMax;
    float rmsStdDev;
    float highestBin;
    float highestBinMagnitude;
    new float[numDataPoints] @=> float centroidData[];
    new float[numDataPoints] @=> float rmsData[];

    //get 1st centroid and rms

    rmsArr[0] +=> rmsTotal;
    rmsArr[0] => rmsMin => rmsMax => rmsData[0];
    cent[0] +=> centroidTotal;
    cent[0] => centroidMin => centroidMax => centroidData[0];
    //do rest
    for (1 => int i; i < numDataPoints; i++) {
        rmsArr[i] +=> rmsTotal;
        Math.max( rmsArr[i], rmsMax ) => rmsMax;
        Math.min( rmsArr[i], rmsMin ) => rmsMin;
        rmsArr[i] => rmsData[i];
        cent[i] +=> centroidTotal;
        Math.max( cent[i], centroidMax ) => centroidMax;
        Math.min( cent[i], centroidMin ) => centroidMin;
        cent[i] => centroidData[i];

        //compute current highestBin
        if (highestFFTVal[i] > highestBinMagnitude) {
            highestFFTVal[i] => highestBinMagnitude;
            highestFFTBin[i] => highestBin;
        }
    }
    //calculate
    rmsTotal / numDataPoints => float rmsAvg;
    centroidTotal / numDataPoints => float centroidAvg;
    //get std dev
    float rmsDevSquaredTotal;
    float centroidDevSquaredTotal;
    for (0 => int i; i < numDataPoints; i++) {
        (rmsData[i] - rmsAvg)*(rmsData[i] - rmsAvg) +=> rmsDevSquaredTotal;
        (centroidData[i] - centroidAvg)*(centroidData[i] - centroidAvg) +=>
centroidDevSquaredTotal;
    }
    Math.sqrt(rmsDevSquaredTotal / numDataPoints) => rmsStdDev;
    Math.sqrt(centroidDevSquaredTotal / numDataPoints) => centroidStdDev;

    float result[9];

centroidAvg => result[0];
    centroidStdDev => result[1];
    centroidMin => result[2];
    centroidMax => result[3];
    rmsAvg * rmsMultiplier => result[4];
    rmsStdDev * rmsMultiplier => result[5];
    rmsMin * rmsMultiplier => result[6];
    rmsMax * rmsMultiplier => result[7];
    highestBin => result[8];

    return result;
}

//Pretty inefficient but does the trick
//Looks for a peak in the last peakWindow
fun void peakDetector() {
while (true){
if (adc.last() > threshold || adc.last() < -1 * threshold) {
1 => peakDetected; // analyze
now => lastPeakTime;
 } else if (now > lastPeakTime + peakWindow) {
0 => peakDetected;
}

        peakPollRate => now; //This is silly; would be better do do a
low-pass filter envelope and look for peaks there. But don't worry about it
right now.

}

}

//run in parallel to send osc feature names
fun void sendOscFeatureNames() {
    while (true) {
        xmit2.startMsg( "/oscCustomFeaturesNames
sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss");
        for (0 => int i; i < 11; i++) {
            numDataPoints[i] => int n;
            xmit2.addString(n + "centroidAvg");
            xmit2.addString(n + "centroidStdDev");
            xmit2.addString(n + "centroidMin");
            xmit2.addString(n + "centroidMax");
            xmit2.addString(n + "rmsAvg");
            xmit2.addString(n + "rmsStdDev");
            xmit2.addString(n + "rmsMin");
            xmit2.addString(n + "rmsMax");
            xmit2.addString(n + "highestFFT");
        }
        .1::second => now;
    }
}

Kyle Hipke

tags

participants (1)