Реализация алгоритма shazam

[butuy]

Всем, кто может помочь, помогите пожалуйста.... Тема такая, не выходит посчитать амплитуду сигнала.. Не знаю в чем ошибка. Может ошибка в комплексных числах..

public static void freq() { // создание частотных характеристик

try { 

int chunkSize = 4; // размер скользящего окна 4 кб
byte audio [] = out.toByteArray();
int ts = audio.length; // длина аудиопотока
int ap= ts/chunkSize; // кол-во анализируемых блоков за одну секунду
Complex [][] results = new Complex[ap][]; // создаем массив 
FileWriter lg = new FileWriter("lenght",true); // сохр длину аудиопотока
lg.write("Длина аудиопотока"+ " "+ ts +"\n"); // добавление в файл
lg.close();
FileWriter qn = new FileWriter("quantity",true); // кол-во потоков за одну секнду
qn.write("Количество блоков"+ " "+ ap +"\n"); // добавление в файл
qn.close();



for (int times = 0;times< ap; times++) { // Во внешнем цикле проходим по всем блокам данных и для каждого из них запускаем БПФ-анализ
Complex[] x = new Complex[chunkSize];
for(int i = 0; i<chunkSize; i++) { // Во внутреннем цикле мы помещаем данные из временной области (образцы звука) в комплексные числа с мнимой частью равной 0.
x[i] = new Complex(audio[(times*chunkSize+i)], 0);
}

results[times] = FFT.fft(x); 


}
for (int i = 0; i<ap; i++) {
System.out.println(results[i] +"\n");
}

int [ ] s = new int [ap];
try {
for (int t = 0; t < results.length; t++) {
for (int j = 0; j < results.length; j++) {
double max = 0;
for (int freq = 100; freq < 2000 ; freq++) {
// Получим силу сигнала:
double mag = Math.log(results[t][freq].abs() );
if (max< mag) {
max = mag; 
}
}
s[j] = (int) max;
System.out.println(s[j]);
}
}

//Сохраним самое высокое значение силы сигнала и соответствующую частоту:

} catch(Exception e) {System.out.println("Ошибка в поиске максимальных амплитуд");}


} catch(Exception e) {System.out.println("Ошибка в получении частотных характеристик");}
}

Класс complex
public class Complex {
private final double re; // the real part
private final double im; // the imaginary part

public Complex(double real, double imag)
{
re = real;
im = imag;
}

public String toString()
{
if (im == 0) return re + "";
if (re == 0) return im + "i";
if (im < 0) return re + " - " + (-im) + "i";
return re + " + " + im + "i";
}

public double abs() 
{ return Math.hypot(re, im); } // Math.sqrt(re*re + im*im)
public double phase() 
{ return Math.atan2(im, re); } // between -pi and pi

public Complex sqrt()
{
Complex a = this; // invoking object
double r = Math.sqrt(this.abs());
double theta = this.phase()/2;
return new Complex(r*Math.cos(theta), r*Math.sin(theta));
}

public Complex log()
{
Complex a = this; // invoking object
double x = Math.log(this.abs());
double y = this.phase();
return new Complex(x, y);
}

public Complex plus(Complex b)
{
Complex a = this;
double real = a.re + b.re;
double imag = a.im + b.im;
return new Complex(real, imag);
}

public Complex minus(Complex b)
{
Complex a = this;
double real = a.re - b.re;
double imag = a.im - b.im;
return new Complex(real, imag);
}

public Complex times(Complex b)
{
Complex a = this;
double real = a.re * b.re - a.im * b.im;
double imag = a.re * b.im + a.im * b.re;
return new Complex(real, imag);
}

public Complex times(double alpha)
{ return new Complex(alpha * re, alpha * im); }

public Complex conjugate() { return new Complex(re, -im); }

public Complex reciprocal()
{
double scale = re*re + im*im;
return new Complex(re / scale, -im / scale);
}

public double re() { return re; }
public double im() { return im; }

public Complex divides(Complex b)
{
Complex a = this;
return a.times(b.reciprocal());
}

public Complex exp()
{ return new Complex(Math.exp(re) * Math.cos(im), 
Math.exp(re) * Math.sin(im)); }

public Complex sin()
{ return new Complex(Math.sin(re) * Math.cosh(im), 
Math.cos(re) * Math.sinh(im)); }

public Complex cos()
{ return new Complex(Math.cos(re) * Math.cosh(im), 
-Math.sin(re) * Math.sinh(im)); }

public Complex tan()
{ return sin().divides(cos()); }

public static Complex plus(Complex a, Complex b)
{
double real = a.re + b.re;
double imag = a.im + b.im;
Complex sum = new Complex(real, imag);
return sum;
}

public static Complex neg(Complex z)
{
return new Complex(-z.re(), -z.im());
}

}