Android应用程序实时记录声音并识别频率

Question

我需要开发一个应用程序，使用手机的麦克风实时记录频率，然后显示它们(在文本中)。我在这里张贴我的代码。FFT和复杂的类已经从http://introcs.cs.princeton.edu/java/97data/FFT.java.html和http://introcs.cs.princeton.edu/java/97data/Complex.java.html使用。问题是，当我在模拟器上运行这个频率从一些随机值开始，并不断增加，直到7996。然后重复整个过程。有人能帮我一下吗?

public class Main extends Activity {
TextView disp;
private static int[] sampleRate = new int[] { 44100, 22050, 11025, 8000 };
short audioData[];
double finalData[];
int bufferSize,srate;
String TAG;
public boolean recording;
AudioRecord recorder;
Complex[] fftArray;
float freq;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    disp = (TextView) findViewById(R.id.display);
    Thread t1 = new Thread(new Runnable(){
        public void run() {
            Log.i(TAG,"Setting up recording");
            for (int rate : sampleRate) {
                try{
                    Log.d(TAG, "Attempting rate " + rate);
            bufferSize=AudioRecord.getMinBufferSize(rate,AudioFormat.CHANNEL_CONFIGURATION_MONO,
            AudioFormat.ENCODING_PCM_16BIT)*3; //get the buffer size to use with this audio record
            if (bufferSize != AudioRecord.ERROR_BAD_VALUE) {
            recorder = new AudioRecord (MediaRecorder.AudioSource.MIC,rate,AudioFormat.CHANNEL_CONFIGURATION_MONO,
            AudioFormat.ENCODING_PCM_16BIT,2048); //instantiate the AudioRecorder
            Log.d(TAG, "BufferSize " +bufferSize);
            srate = rate;
            }
            } catch (Exception e) {
                Log.e(TAG, rate + "Exception, keep trying.",e);
            }
        }
            bufferSize=2048;
            recording=true; //variable to use start or stop recording
            audioData = new short [bufferSize]; //short array that pcm data is put into.
            Log.i(TAG,"Got buffer size =" + bufferSize);                
            while (recording) {  //loop while recording is needed
                   Log.i(TAG,"in while 1");
            if (recorder.getState()==android.media.AudioRecord.STATE_INITIALIZED) // check to see if the recorder has initialized yet.
            if (recorder.getRecordingState()==android.media.AudioRecord.RECORDSTATE_STOPPED)
            recorder.startRecording();  //check to see if the Recorder has stopped or is not recording, and make it record.
            else {
                   Log.i(TAG,"in else");
                  // audiorecord();
                finalData=convert_to_double(audioData);
                Findfft();
                for(int k=0;k<fftArray.length;k++)
                {
                    freq = ((float)srate/(float) fftArray.length) *(float)k;
                    runOnUiThread(new Runnable(){
                     public void run()
                     {
                         disp.setText("The frequency is " + freq);
                         if(freq>=15000)
                             recording = false;
                     }
                 });

                }

             }//else recorder started
    } //while recording
    if (recorder.getState()==android.media.AudioRecord.RECORDSTATE_RECORDING) 
    recorder.stop(); //stop the recorder before ending the thread
    recorder.release(); //release the recorders resources
    recorder=null; //set the recorder to be garbage collected.
         }//run
    });
    t1.start();
}


private void Findfft() {
    // TODO Auto-generated method stub
    Complex[] fftTempArray = new Complex[bufferSize];
    for (int i=0; i<bufferSize; i++)
    {
        fftTempArray[i] = new Complex(finalData[i], 0);
    }
    fftArray = FFT.fft(fftTempArray);
}

private double[] convert_to_double(short data[]) {
    // TODO Auto-generated method stub
    double[] transformed = new double[data.length];
    for (int j=0;j<data.length;j++) {
    transformed[j] = (double)data[j];
    }
    return transformed;
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    // Inflate the menu; this adds items to the action bar if it is present.
    getMenuInflater().inflate(R.menu.main, menu);
    return true;
 }
 }       

Answer 1

你的问题已经得到了简洁的回答，然而，为了进一步实现你的目标并完成循环…

是的，FFT在有限的cpu上对于基音/频率识别不是最佳的。更优的方法是这里描述的YIN。你可以在Tarsos找到一个实现。您将面临的问题是ADK中缺乏javax.sound. sampling，因此将AudioRecord中的short/bytes转换为参考实现所需的浮点数。

Answer 2

你的问题就在这里:

Findfft();
for(int k=0;k<fftArray.length;k++) {
    freq = ((float)srate/(float) fftArray.length) *(float)k;
    runOnUiThread(new Runnable() {
        public void run() {
            disp.setText("The frequency is " + freq);
            if(freq>=15000) recording = false;
        }
    });
}

所有这些for循环所做的就是遍历FFT值的数组，将数组索引转换为以Hz为单位的频率，并打印出来。

如果你想输出你记录的频率，你至少应该看看你的数组中的数据-最简单的方法是计算实际幅度的平方，并找到最大的频率bin。

除此之外，我不认为你正在使用的FFT算法做任何预计算-有其他的做，看到你正在开发一个移动设备，你可能要考虑到CPU使用和电力使用。

JTransforms是一个使用预计算来降低CPU负载的库，它的文档非常完整。

您还可以在维基百科上找到有关如何解释FFT返回的数据的有用信息-无意冒犯，但看起来您不太确定自己在做什么，所以我给出了指点。

最后，如果你想使用这个应用程序的音符，我似乎记得很多人说FFT不是最好的方法，但我不记得是什么。也许其他人能补充一下?

Answer 3

我发现这个解决方案几天后-最好的频率在赫兹:

下载Jtransforms和这个Jar也- Jtransforms需要它

那么我使用这个任务:

public class MyRecorder extends AsyncTask<Void, short[], Void> {
int blockSize = 2048;// = 256;
private static final int RECORDER_SAMPLERATE = 8000;
private static final int RECORDER_CHANNELS = AudioFormat.CHANNEL_IN_MONO;
private static final int RECORDER_AUDIO_ENCODING = AudioFormat.ENCODING_PCM_16BIT;
int BufferElements2Rec = 1024; // want to play 2048 (2K) since 2 bytes we use only 1024
int BytesPerElement = 2;

@Override
protected Void doInBackground(Void... params) {
    try {
        final AudioRecord audioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC,
                RECORDER_SAMPLERATE, RECORDER_CHANNELS,
                RECORDER_AUDIO_ENCODING, BufferElements2Rec * BytesPerElement);
        if (audioRecord == null) {
            return null;
        }
        final short[] buffer = new short[blockSize];
        final double[] toTransform = new double[blockSize];
        audioRecord.startRecording();
        while (started) {
            Thread.sleep(100);
            final int bufferReadResult = audioRecord.read(buffer, 0, blockSize);
            publishProgress(buffer);
        }
        audioRecord.stop();
        audioRecord.release();
    } catch (Throwable t) {
        Log.e("AudioRecord", "Recording Failed");
    }
    return null;
}

@Override
protected void onProgressUpdate(short[]... buffer) {
    super.onProgressUpdate(buffer);
    float freq = calculate(RECORDER_SAMPLERATE, buffer[0]);
    }

public static float calculate(int sampleRate, short [] audioData)
{
    int numSamples = audioData.length;
    int numCrossing = 0;
    for (int p = 0; p < numSamples-1; p++)
    {
        if ((audioData[p] > 0 && audioData[p + 1] <= 0) ||
                (audioData[p] < 0 && audioData[p + 1] >= 0))
        {
            numCrossing++;
        }
    }

    float numSecondsRecorded = (float)numSamples/(float)sampleRate;
    float numCycles = numCrossing/2;
    float frequency = numCycles/numSecondsRecorded;

    return frequency;
}