Java extract amplitude array from recorded wave

转载自：http://ganeshtiwaridotcomdotnp.blogspot.com/2011/12/java-extract-amplitude-array-from.html

Extract amplitude array from recorded/saved wav : From File , AudioInputStream , ByteArray of File or ByteArrayInputStream - working java source code example

import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import javax.sound.sampled.AudioFileFormat;
 import javax.sound.sampled.AudioFormat;
 import javax.sound.sampled.AudioInputStream;
 import javax.sound.sampled.AudioSystem;
 import javax.sound.sampled.UnsupportedAudioFileException;
 /**
  * saving and extracting amplitude data from wavefile byteArray
  *
  * @author Ganesh Tiwari
  */
 public class WaveData {
      private byte[] arrFile;
      private byte[] audioBytes;
      private int[] audioData;
      private ByteArrayInputStream bis;
      private AudioInputStream audioInputStream;
      private AudioFormat format;
      private double durationSec;
      private double durationMSec;
      public WaveData() {
      }
      public int[] extractAmplitudeFromFile(File wavFile) {
           try {
                // create file input stream  
                FileInputStream fis = new FileInputStream(wavFile);
                // create bytearray from file  
                arrFile = new byte[(int) wavFile.length()];
                fis.read(arrFile);
           } catch (Exception e) {
                System.out.println("SomeException : " + e.toString());
           }
           return extractAmplitudeFromFileByteArray(arrFile);
      }
      public int[] extractAmplitudeFromFileByteArray(byte[] arrFile) {
           // System.out.println("File : "+wavFile+""+arrFile.length);  
           bis = new ByteArrayInputStream(arrFile);
           return extractAmplitudeFromFileByteArrayInputStream(bis);
      }
      /**
       * for extracting amplitude array the format we are using :16bit, 22khz, 1
       * channel, littleEndian,
       *
       * @return PCM audioData
       * @throws Exception
       */
      public int[] extractAmplitudeFromFileByteArrayInputStream(ByteArrayInputStream bis) {
           try {
                audioInputStream = AudioSystem.getAudioInputStream(bis);
           } catch (UnsupportedAudioFileException e) {
                System.out.println("unsupported file type, during extract amplitude");
                e.printStackTrace();
           } catch (IOException e) {
                System.out.println("IOException during extracting amplitude");
                e.printStackTrace();
           }
           // float milliseconds = (long) ((audioInputStream.getFrameLength() *
           // 1000) / audioInputStream.getFormat().getFrameRate());
           // durationSec = milliseconds / 1000.0;  
           return extractAmplitudeDataFromAudioInputStream(audioInputStream);
      }
      public int[] extractAmplitudeDataFromAudioInputStream(AudioInputStream audioInputStream) {
           format = audioInputStream.getFormat();
           audioBytes = new byte[(int) (audioInputStream.getFrameLength() * format.getFrameSize())];
           // calculate durations  
           durationMSec = (long) ((audioInputStream.getFrameLength() * 1000) / audioInputStream.getFormat().getFrameRate());
           durationSec = durationMSec / 1000.0;
           // System.out.println("The current signal has duration "+durationSec+" Sec");  
           try {
                audioInputStream.read(audioBytes);
           } catch (IOException e) {
                System.out.println("IOException during reading audioBytes");
                e.printStackTrace();
           }
           return extractAmplitudeDataFromAmplitudeByteArray(format, audioBytes);
      }
      public int[] extractAmplitudeDataFromAmplitudeByteArray(AudioFormat format, byte[] audioBytes) {
           // convert
           // TODO: calculate duration here  
           audioData = null;
           if (format.getSampleSizeInBits() == 16) {
                int nlengthInSamples = audioBytes.length / 2;
                audioData = new int[nlengthInSamples];
                if (format.isBigEndian()) {
                     for (int i = 0; i < nlengthInSamples; i++) {
                          /* First byte is MSB (high order) */
                          int MSB = audioBytes[2 * i];
                          /* Second byte is LSB (low order) */
                          int LSB = audioBytes[2 * i + 1];
                          audioData[i] = MSB << 8 | (255 & LSB);
                     }
                } else {
                     for (int i = 0; i < nlengthInSamples; i++) {
                          /* First byte is LSB (low order) */
                          int LSB = audioBytes[2 * i];
                          /* Second byte is MSB (high order) */
                          int MSB = audioBytes[2 * i + 1];
                          audioData[i] = MSB << 8 | (255 & LSB);
                     }
                }
           } else if (format.getSampleSizeInBits() == 8) {
                int nlengthInSamples = audioBytes.length;
                audioData = new int[nlengthInSamples];
                if (format.getEncoding().toString().startsWith("PCM_SIGN")) {
                     // PCM_SIGNED  
                     for (int i = 0; i < audioBytes.length; i++) {
                          audioData[i] = audioBytes[i];
                     }
                } else {
                     // PCM_UNSIGNED  
                     for (int i = 0; i < audioBytes.length; i++) {
                          audioData[i] = audioBytes[i] - 128;
                     }
                }
           }// end of if..else
                // System.out.println("PCM Returned===============" +
                // audioData.length);  
           return audioData;
      }
      public byte[] getAudioBytes() {
           return audioBytes;
      }
      public double getDurationSec() {
           return durationSec;
      }
      public double getDurationMiliSec() {
           return durationMSec;
      }
      public int[] getAudioData() {
           return audioData;
      }
      public AudioFormat getFormat() {
           return format;
      }
 }  

留言：

Think I found a bug for 8 bit unsigned samples in the code above.

Java regards a byte-variable as a signed variable, so we can't just subtract 128 for all sample-values. For "negative" values we must instead add 128, I think.

E.g. the sampled unsigned value 10000000 (128 unsigned) should mean that we are in the middle of the value-range. It should actually mean 0, but java sees it as -128, and if we subtract 128 we'll get -256, which isn't what we want at all.

And the "highest" sample-value possible with 8 bits, 11111111, means -1 to java if it's in a byte-variable. We'd get the value -129 here with the old method, but we would expect 127.

For all "positive" values 00000000 - 01111111 it works fine to subtract 128 as before, so something like this would work better:

// PCM_UNSIGNED
for (int i = 0; i < audioBytes.length; i++)
{
if (audioBytes[i] >= 0)
_audioData[i] = audioBytes[i] - 128;
else
_audioData[i] = audioBytes[i] + 128;
}

(Or e.g. you could "shift" the byte-value into an int-variable before subtracting 128.)