title: Fourier transforming a byte array
body: <p>I am not so proficient in Java, so please keep it quite simple. I will, though, try to understand everything you post. Here's my problem.</p>
  
  <p>I have written code to record audio from an external microphone and store that in a .wav. Storing this file is relevant for archiving purposes. What I need to do is a FFT of the stored audio. </p>
  
  <p>My approach to this was loading the wav file as a byte array and transforming that, with the problem that 1. There's a header in the way I need to get rid of, but I should be able to do that and 2. I got a byte array, but most if not all FFT algorithms I found online and tried to patch into my project work with complex / two double arrays.</p>
  
  <p>I tried to work around both these problems and finally was able to plot my FFT array as a graph, when I found out it was just giving me back "0"s. The .wav file is fine though, I can play it back without problems. I thought maybe converting the bytes into doubles was the problem for me, so here's my approach to that (I know it's not pretty)</p>
  
  <pre><code>byte ByteArray[] = Files.readAllBytes(wav_path);
  String s = new String(ByteArray);
  double[] DoubleArray = toDouble(ByteArray);
  // build 2^n array, fill up with zeroes
  boolean exp = false;
  int i = 0;
  int pow = 0;
  while (!exp) {
      pow = (int) Math.pow(2, i);
      if (pow &gt; ByteArray.length) {
          exp = true;
      } else {
          i++;
      }
  }
  System.out.println(pow);
  double[] Filledup = new double[pow];
  for (int j = 0; j &lt; DoubleArray.length; j++) {
      Filledup[j] = DoubleArray[j];
      System.out.println(DoubleArray[j]);
  }
  for (int k = DoubleArray.length; k &lt; Filledup.length; k++) {
      Filledup[k] = 0;
  }
  </code></pre>
  
  <p>This is the function I'm using to convert the byte array into a double array:</p>
  
  <pre><code>public static double[] toDouble(byte[] byteArray) {
      ByteBuffer byteBuffer = ByteBuffer.wrap(byteArray);
      double[] doubles = new double[byteArray.length / 8];
      for (int i = 0; i &lt; doubles.length; i++) {
          doubles[i] = byteBuffer.getDouble(i * 8);
      }
      return doubles;
  }
  </code></pre>
  
  <p>The header still is in there, I know that, but that should be the smallest problem right now. I transformed my byte array to a double array, then filled up that array to the next power of 2 with zeroes, so that the FFT can actually work (it needs an array of 2^n values). The FFT algorithm I'm using gets two double arrays as input, one being the real, the other being the imaginary part. I read, that for this to work, I'd have to keep the imaginary array empty (but its length being the same as the real array).</p>
  
  <p>Worth to mention: I'm recording with 44100 kHz, 16 bit and mono.</p>
  
  <p>If necessary, I'll post the FFT I'm using.</p>
  
  <p>If I try to print the values of the double array, I get kind of weird results:</p>
  
  <pre><code>...
  -2.0311904060823147E236
  -1.3309975624948503E241
  1.630738286366793E-260
  1.0682002560745842E-255
  -5.961832069690704E197
  -1.1476447092561027E164
  -1.1008407401197794E217
  -8.109566204271759E298
  -1.6104556241572942E265
  -2.2081172620352248E130
  NaN
  3.643749694745671E-217
  -3.9085815506127892E202
  -4.0747557114875874E149
  ...
  </code></pre>
  
  <p>I know that somewhere the problem lies with me overlooking something very simple I should be aware of, but I can't seem to find the problem. My question finally is: How can I get this to work?</p>