使用FFT和Complex类获取频率wav音频

时间:2013-07-02 15:17:47

标签: android audio fft frequency

已经被问了很多,但我还是坚持在Android上实现FFT类 我需要使用FFT处理我的音频数据......

我已经在这里阅读了几乎相同的问题How can I get frequency data from PCM using FFT 在这里How to get frequency from fft result? 还有更多问题,但即使在我尝试了答案之后仍然没有找到答案......

FFT类I我正在使用: http://www.cs.princeton.edu/introcs/97data/FFT.java

要使用它的复杂类:http://introcs.cs.princeton.edu/java/97data/Complex.java.html

这是我的代码

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.media.AudioFormat;
import android.media.AudioRecord;
import android.media.MediaRecorder;
import android.os.Bundle;
import android.os.Environment;
import android.view.View;
import android.widget.Button;

public class Latihan extends Activity{
        private static final int RECORDER_BPP = 16;
        private static final String AUDIO_RECORDER_FILE_EXT_WAV = ".wav";
        private static final String AUDIO_RECORDER_FOLDER = "AudioRecorder";
        private static final String AUDIO_RECORDER_TEMP_FILE = "record_temp.raw";
        private static final int RECORDER_SAMPLERATE = 44100;
        private static final int RECORDER_CHANNELS = AudioFormat.CHANNEL_IN_STEREO;
        private static final int RECORDER_AUDIO_ENCODING = AudioFormat.ENCODING_PCM_16BIT;
        short[] audioData;

        private AudioRecord recorder = null;
        private int bufferSize = 0;
        private Thread recordingThread = null;
        private boolean isRecording = false;
        Complex[] fftTempArray;
        Complex[] fftArray;
        int[] bufferData;
        int bytesRecorded;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.p1);

        setButtonHandlers();
        enableButtons(false);

        bufferSize = AudioRecord.getMinBufferSize
                (RECORDER_SAMPLERATE,RECORDER_CHANNELS,RECORDER_AUDIO_ENCODING)*3;

        audioData = new short [bufferSize]; //short array that pcm data is put into.

        }


    private void setButtonHandlers() {
        ((Button)findViewById(R.id.btStart)).setOnClickListener(btnClick);
        ((Button)findViewById(R.id.btStop)).setOnClickListener(btnClick);
        }


        private void enableButton(int id,boolean isEnable){
                ((Button)findViewById(id)).setEnabled(isEnable);
        }

        private void enableButtons(boolean isRecording) {
                enableButton(R.id.btStart,!isRecording);
                enableButton(R.id.btStop,isRecording);
        }

        private String getFilename(){
                String filepath = Environment.getExternalStorageDirectory().getPath();
                File file = new File(filepath,AUDIO_RECORDER_FOLDER);

                if(!file.exists()){
                        file.mkdirs();
                }

                return (file.getAbsolutePath() + "/" + System.currentTimeMillis() + AUDIO_RECORDER_FILE_EXT_WAV);
        }


        public void convert(){



        }

        public void calculate(){
            Complex[] fftTempArray = new Complex[bufferSize];
            for (int i=0; i<bufferSize; i++)
            {
                fftTempArray[i] = new Complex(audioData[i], 0);
            }
            Complex[] fftArray = FFT.fft(fftTempArray);

            double[] micBufferData = new double[bufferSize];
            final int bytesPerSample = 2; 
            final double amplification = 100.0; 
            for (int index = 0, floatIndex = 0; index < bytesRecorded - bytesPerSample + 1; index += bytesPerSample, floatIndex++) {
                double sample = 0;
                for (int b = 0; b < bytesPerSample; b++) {
                    int v = bufferData[index + b];
                    if (b < bytesPerSample - 1 || bytesPerSample == 1) {
                        v &= 0xFF;
                    }
                    sample += v << (b * 8);
                }
                double sample32 = amplification * (sample / 32768.0);
                micBufferData[floatIndex] = sample32;
            }


     }


        private String getTempFilename(){
                String filepath = Environment.getExternalStorageDirectory().getPath();
                File file = new File(filepath,AUDIO_RECORDER_FOLDER);

                if(!file.exists()){
                        file.mkdirs();
                }

                File tempFile = new File(filepath,AUDIO_RECORDER_TEMP_FILE);

                if(tempFile.exists())
                        tempFile.delete();

                return (file.getAbsolutePath() + "/" + AUDIO_RECORDER_TEMP_FILE);
        }

        private void startRecording(){
            recorder = new AudioRecord(MediaRecorder.AudioSource.MIC,
                                                RECORDER_SAMPLERATE, RECORDER_CHANNELS,RECORDER_AUDIO_ENCODING, bufferSize);

                recorder.startRecording();

                isRecording = true;

                recordingThread = new Thread(new Runnable() {

                        public void run() {
                                writeAudioDataToFile();
                        }
                },"AudioRecorder Thread");

                recordingThread.start();
        }

        private void writeAudioDataToFile(){
                byte data[] = new byte[bufferSize];
                String filename = getTempFilename();
                FileOutputStream os = null;

                try {
                        os = new FileOutputStream(filename);
                } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }

                int read = 0;

                if(null != os){
                        while(isRecording){
                                read = recorder.read(data, 0, bufferSize);

                                if(AudioRecord.ERROR_INVALID_OPERATION != read){
                                        try {
                                                os.write(data);
                                        } catch (IOException e) {
                                                e.printStackTrace();
                                        }
                                }
                        }

                        try {
                                os.close();
                        } catch (IOException e) {
                                e.printStackTrace();
                        }
                }
        }

        private void stopRecording(){
                if(null != recorder){
                        isRecording = false;

                        recorder.stop();
                        recorder.release();

                        recorder = null;
                        recordingThread = null;
                }

                copyWaveFile(getTempFilename(),getFilename());
               // deleteTempFile();
        }

        private void deleteTempFile() {
                File file = new File(getTempFilename());
                file.delete();
        }

        private void copyWaveFile(String inFilename,String outFilename){
                FileInputStream in = null;
                FileOutputStream out = null;
                long totalAudioLen = 0;
                long totalDataLen = totalAudioLen + 36;
                long longSampleRate = RECORDER_SAMPLERATE;
                int channels = 2;
                long byteRate = RECORDER_BPP * RECORDER_SAMPLERATE * channels/8;

                byte[] data = new byte[bufferSize];

                try {
                        in = new FileInputStream(inFilename);
                        out = new FileOutputStream(outFilename);
                        totalAudioLen = in.getChannel().size();
                        totalDataLen = totalAudioLen + 36;

                        AppLog.logString("File size: " + totalDataLen);

                        WriteWaveFileHeader(out, totalAudioLen, totalDataLen,
                                        longSampleRate, channels, byteRate);

                        while(in.read(data) != -1){
                                out.write(data);
                        }

                        in.close();
                        out.close();
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }

        private void WriteWaveFileHeader(
                        FileOutputStream out, long totalAudioLen,
                        long totalDataLen, long longSampleRate, int channels,
                        long byteRate) throws IOException {
            //another code    

        }

        private View.OnClickListener btnClick = new View.OnClickListener() {
                public void onClick(View v) {
                     switch(v.getId()){
                              case R.id.btStart:{
                                        AppLog.logString("Start Recording");
                                        enableButtons(true);
                                        startRecording();
                                        break;
                                }
                                case R.id.btStop:{
                                    AppLog.logString("Stop Recording");
                                        enableButtons(false);
                                        stopRecording();
                                        calculate();
                                        break;

                                }
                        }
                }
        }; 
}

我假设audioData数组包含原始音频数据,但我的代码捕获异常并返回“N不是2的幂”

我的代码有什么问题吗? 如何将其传递给FFT.java类并获取fftResult ??

或者还有其他方法可以将时域数据转换为频率数据更容易吗?

自从我遇到这个问题已经有几个月......我的项目太过比较了* .wav文件的2个音频, 任何帮助将不胜感激...... :)

2 个答案:

答案 0 :(得分:7)

我已经找到了答案......:)

我创建了从音频计算数组值的方法......

public double[] calculateFFT(byte[] signal)
    {           
        final int mNumberOfFFTPoints =1024;
        double mMaxFFTSample;

        double temp;
        Complex[] y;
        Complex[] complexSignal = new Complex[mNumberOfFFTPoints];
        double[] absSignal = new double[mNumberOfFFTPoints/2];

        for(int i = 0; i < mNumberOfFFTPoints; i++){
            temp = (double)((signal[2*i] & 0xFF) | (signal[2*i+1] << 8)) / 32768.0F;
            complexSignal[i] = new Complex(temp,0.0);
        }

        y = FFT.fft(complexSignal); // --> Here I use FFT class

        mMaxFFTSample = 0.0;
        mPeakPos = 0;
        for(int i = 0; i < (mNumberOfFFTPoints/2); i++)
        {
             absSignal[i] = Math.sqrt(Math.pow(y[i].re(), 2) + Math.pow(y[i].im(), 2));
             if(absSignal[i] > mMaxFFTSample)
             {
                 mMaxFFTSample = absSignal[i];
                 mPeakPos = i;
             } 
        }

        return absSignal;

    }

然后我在课堂上写了一下Write Audio ..

private void writeAudioDataToFile(){

        byte data[] = new byte[bufferSize];
        String filename = getTempFilename();
       FileOutputStream os = null;

        try {
                os = new FileOutputStream(filename);
        } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
        }

        int read = 0;                
        if(null != os){
                while(isRecording){
                        read = recorder.read(data, 0, bufferSize);
                        if(read > 0){
                            absNormalizedSignal = calculateFFT(data); // --> HERE ^__^
                        }

                        if(AudioRecord.ERROR_INVALID_OPERATION != read){
                                try {
                                        os.write(data);
                                } catch (IOException e) {
                                        e.printStackTrace();
                                }
                        }
                }

                try {
                        os.close();
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }
}

答案 1 :(得分:0)

听起来你的直接问题是“N不是2的力量”。在这种情况下,N可能指的是您放入FFT的数据大小。大多数FFT算法仅适用于大小为2的数据块。

您是否尝试将整个文件同时置于FFT中?如果是这样,您可能需要阅读更多背景材料以了解您在做什么。也许从这里开始:http://blog.bjornroche.com/2012/07/frequency-detection-using-fft-aka-pitch.html