Добавлено тестирование из файлов

.classpath

@@ -9,5 +9,6 @@
 	<classpathentry exported="true" kind="lib" path="lib/jcommon-1.0.23.jar"/>
 	<classpathentry exported="true" kind="lib" path="lib/jfreechart-1.0.19.jar"/>
 	<classpathentry exported="true" kind="lib" path="lib/JTransforms-3.1-with-dependencies.jar"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.USER_LIBRARY/jflac-1.3"/>
 	<classpathentry kind="output" path="out/production/test_google_speach_api"/>
 </classpath>

src/com/company/Main.java

@@ -12,6 +12,8 @@
 public class Main {
 
     public static void main (String[] args) throws LineUnavailableException, IOException, UnsupportedAudioFileException {
+        //RecordingThread recordingThread = new RecordingThread();
+        //File AudioStream = new File("/Users/user/IdeaProjects/test_google_speach_api/all_records/Converted/4.wav");
         RecordingThread recordingThread = new RecordingThread();
         CommandsRecognizer commandsRecognizer = new CommandsRecognizer();
 

src/com/company/RecordingThread/RecordingThread.java

@@ -33,6 +33,8 @@ public class RecordingThread extends Thread {
 
     private List<ResponseListener> listeners;
 
+    private File AudioFileStream;
+
     public RecordingThread() {
 
         microphone = new MicrophoneAnalyzer(FLACFileWriter.FLAC);
@@ -47,6 +49,17 @@ public RecordingThread() {
 
     }
 
+    public RecordingThread(File AudioFile) {
+
+        microphone = new MicrophoneAnalyzer(FLACFileWriter.FLAC);
+
+        recognizer = new Recognizer(Recognizer.Languages.RUSSIAN, apiKey);
+        listeners = new ArrayList<ResponseListener>();
+
+        this.AudioFileStream = AudioFile;
+
+    }
+
     private double CalculateNoiseLevel(int TimeInMsToCalculateNoiseLevel) {
 
         tempAudioFile = new File("DisplayAllReponce.flac");
@@ -94,56 +107,111 @@ public void addResponceListener(ResponseListener listener) {
     public void run() {
 
         int curSample = 0;
+        if(this.AudioFileStream == null) {
 
-        while (true) {
-            microphone.open();
+            while (true) {
+                microphone.open();
+
+                try {
+                    tempAudioFile = new File("DisplayAllReponce.flac");
+                    microphone.setAudioFile(tempAudioFile);
+                    microphone.captureAudioToFile(microphone.getAudioFile());
 
-            try {
-                tempAudioFile = new File("DisplayAllReponce.flac");
-                microphone.setAudioFile(tempAudioFile);
-                microphone.captureAudioToFile(microphone.getAudioFile());
 
-                Thread.sleep(checkVolumeSampleTime * 3);
+                    Thread.sleep(checkVolumeSampleTime * 3);
 
-                double magnitude =  microphone.magnitude(120, 122);
+                    double magnitude = microphone.magnitude(120, 122);
 
-                //int magnitude = microphone.getAudioVolume(checkVolumeSampleTime);
-                System.out.println(magnitude);
-                //boolean isSpeaking = (volume > minimumVolumeToStartrecording);
-                boolean isSpeaking = (magnitude > 200);
+                    //int magnitude = microphone.getAudioVolume(checkVolumeSampleTime);
+                    System.out.println(magnitude);
+                    //boolean isSpeaking = (volume > minimumVolumeToStartrecording);
+                    boolean isSpeaking = (magnitude > 200);
 
-                if (isSpeaking) {
+                    if (isSpeaking) {
 
-                    DebugLog("Start RECORDING...");
+                        DebugLog("Start RECORDING...");
 
-                    do {
-                        DebugLog("RECORDING proc...");
-                        Thread.sleep(sampleTime);//Updates every second
-                    } while (microphone.magnitude(120, 122) > 100);
+                        do {
+                            DebugLog("RECORDING proc...");
+                            Thread.sleep(sampleTime);//Updates every second
+                        } while (microphone.magnitude(120, 122) > 100);
 
 
-                    DebugLog("Recording Complete!");
-                    microphone.close();
+                        DebugLog("Recording Complete!");
+                        microphone.close();
 
-                    DebugLog("Recognizing...");
+                        DebugLog("Recognizing...");
 
-                    GoogleResponse response = recognizer.getRecognizedDataForFlac(microphone.getAudioFile(), 1);
-                    notifyListeners(response);
+                        GoogleResponse response = recognizer.getRecognizedDataForFlac(microphone.getAudioFile(), 1);
+                        notifyListeners(response);
 
-                    DebugLog("Looping back");//Restarts loops
+                        DebugLog("Looping back");//Restarts loops
 
 
+                    }
+                    microphone.getAudioFile().delete();
+
+
+                } catch (Exception e) {
+                    // TODO Auto-generated catch block
+                    e.printStackTrace();
+                    System.out.println("Error Occured");
+                } finally {
+                    microphone.close();//Makes sure microphone closes on exit.
                 }
-                microphone.getAudioFile().delete();
+            }
+        } else {
 
+            while (true) {
+                microphone.open();
 
-            } catch (Exception e) {
-                // TODO Auto-generated catch block
-                e.printStackTrace();
-                System.out.println("Error Occured");
-            } finally {
-                microphone.close();//Makes sure microphone closes on exit.
+                try {
+                    tempAudioFile = new File("DisplayAllReponce.flac");
+                    microphone.setAudioFile(tempAudioFile);
+                    microphone.captureAudioFromFileToFile(microphone.getAudioFile(), AudioFileStream);
+
+                    Thread.sleep(checkVolumeSampleTime * 3);
+
+                    double magnitude = microphone.magnitudeInFile(120, 122);
+
+                    //int magnitude = microphone.getAudioVolume(checkVolumeSampleTime);
+                    System.out.println(magnitude);
+                    //boolean isSpeaking = (volume > minimumVolumeToStartrecording);
+                    boolean isSpeaking = (magnitude > 200);
+
+                    if (isSpeaking) {
+
+                        DebugLog("Start RECORDING...");
+
+                        do {
+                            DebugLog("RECORDING proc...");
+                            Thread.sleep(sampleTime);//Updates every second
+                        } while (microphone.magnitude(120, 122) > 100);
+
+                        DebugLog("Recording Complete!");
+                        microphone.close();
+
+                        DebugLog("Recognizing...");
+
+                        GoogleResponse response = recognizer.getRecognizedDataForFlac(microphone.getAudioFile(), 1);
+                        notifyListeners(response);
+
+                        DebugLog("Looping back");//Restarts loops
+
+
+                    }
+                    microphone.getAudioFile().delete();
+
+
+                } catch (Exception e) {
+                    // TODO Auto-generated catch block
+                    e.printStackTrace();
+                    System.out.println("Error Occured");
+                } finally {
+                    microphone.close();//Makes sure microphone closes on exit.
+                }
             }
+
         }
 
     }

src/com/company/microphone/Microphone.java

@@ -1,5 +1,7 @@
 package com.company.microphone;
 
+import org.kc7bfi.jflac.sound.spi.FlacAudioFileReader;
+
 import javax.sound.sampled.*;
 
 import java.io.Closeable;
@@ -132,6 +134,29 @@ public void captureAudioToFile(File audioFile) throws LineUnavailableException {
         new Thread(new CaptureThread()).start();
 
 
+    }
+
+    protected File audioFileStream;
+    /**
+     * Captures audio from the microphone and saves it a file
+     *
+     * @param audioFile The File to save the audio to
+     * @throws LineUnavailableException
+     */
+    public void captureAudioFromFileToFile(File audioFile, File audioFileStream) throws LineUnavailableException {
+
+        setState(CaptureState.STARTING_CAPTURE);
+        setAudioFile(audioFile);
+        this.audioFileStream = audioFileStream;
+
+        if(getTargetDataLine() == null){
+            initTargetDataLine();
+        }
+
+        //Get Audio
+        new Thread(new CaptureFromFileThread()).start();
+
+
     }
 
     /**
@@ -209,6 +234,7 @@ private class CaptureThread implements Runnable {
          * Run method for thread
          */
         public void run() {
+
             try {
                 AudioFileFormat.Type fileType = getFileType();
                 File audioFile = getAudioFile();
@@ -221,4 +247,29 @@ public void run() {
         }
     }
 
+    /**
+     * Thread to capture the audio from the microphone and save it to a file
+     */
+    private class CaptureFromFileThread implements Runnable {
+
+        /**
+         * Run method for thread
+         */
+        public void run() {
+
+            try {
+                AudioFileFormat.Type fileType = getFileType();
+                File audioFile = getAudioFile();
+                File audioStream = audioFileStream;
+                open();
+
+                AudioInputStream inputStream  = AudioSystem.getAudioInputStream(audioFileStream);
+                AudioSystem.write(inputStream, fileType, audioFile);
+                //Will write to File until it's closed.
+            } catch (Exception ex) {
+                ex.printStackTrace();
+            }
+        }
+    }
+
 }

src/com/company/microphone/MicrophoneAnalyzer.java

@@ -2,11 +2,14 @@
 
 import com.darkprograms.speech.util.Complex;
 import com.darkprograms.speech.util.FFT;
+import org.kc7bfi.jflac.sound.spi.FlacAudioFileReader;
 
 import java.io.IOException;
 
 import javax.sound.sampled.AudioFileFormat;
 import javax.sound.sampled.AudioInputStream;
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.UnsupportedAudioFileException;
 
 
 /********************************************************************************************
@@ -208,6 +211,62 @@ public double magnitude (int minFreq, int maxFreq) {
 
     }
 
+    static int numOfBytesTotalOffset = 0;
+
+    public double magnitudeInFile (int minFreq, int maxFreq) throws IOException, UnsupportedAudioFileException {
+
+        int numOfBytes = 2048;
+
+        numOfBytesTotalOffset += numOfBytes;
+        FlacAudioFileReader flacAudioFileReader = new FlacAudioFileReader();
+        AudioInputStream stream  = flacAudioFileReader.getAudioInputStream(this.getAudioFile());
+
+        byte[] data = new byte[numOfBytes+1];//One byte is lost during conversion
+        try {
+            stream.read(data, 0, numOfBytes);
+        } catch (IOException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+
+
+        double[] audioData = this.bytesToDoubleArray(data);
+        audioData = applyHanningWindow(audioData);
+        Complex[] complex = new Complex[audioData.length];
+        for(int i = 0; i<complex.length; i++){
+            complex[i] = new Complex(audioData[i], 0);
+        }
+        Complex[] fftData = FFT.fft(complex);
+
+
+        int N = 3;
+
+        if(N<=0 || fftData == null){ return -1; } //error case
+
+        final int LENGTH = fftData.length;//Used to calculate bin size
+        fftData = removeNegativeFrequencies(fftData);
+
+        Complex[][] comdata = new Complex[N][fftData.length/N];
+        for(int i = 0; i<N; i++){
+            for(int j = 0; j<comdata[0].length; j++){
+                comdata[i][j] = fftData[j*(i+1)];
+            }
+        }
+
+        Complex[] result = new Complex[fftData.length/N];//Combines the arrays
+        for(int i = 0; i<result.length; i++){
+            Complex tmp = new Complex(1,0);
+            for(int j = 0; j<N; j++){
+                tmp = tmp.times(comdata[j][i]);
+            }
+            result[i] = tmp;
+        }
+
+
+        return findMeanBetween(minFreq, maxFreq, fftData);
+
+    }
+
     private double findMeanBetween(int minFreq, int maxFreq, Complex[] result) {
 
         float sampleRate = getAudioFormat().getSampleRate();

test_google_speach_api.eml

@@ -26,4 +26,7 @@
 	<lib name="JTransforms-3.1-with-dependencies.jar" scope="COMPILE">
 		<relative-module-cls project-related="jar://$PROJECT_DIR$/lib/JTransforms-3.1-with-dependencies.jar!/"/>
 	</lib>
+	<levels>
+		<level name="jflac-1.3" value="project"/>
+	</levels>
 </component>