java - Android:通过fft获得更精确的频率

Question

我正在使用this FFTBasedSpectrumAnalyzer分析麦克风收集的声音。然而，FFTBasedSpectrumAnalyzer 创建了一个图表，而我想要一个可以放在标签中的单个频率，因此我尝试通过以下公式获取峰值的频率: mFreq = (((1.0 * frequency) / (1.0 * blockSize)) * mPeakPos)/2 。我还通过以下公式获得幅度(以及峰值和峰值频率):

int mPeakPos = 0;
                double mMaxFFTSample = 150.0;
                for (int i = 0; i < progress[0].length; i++) {
                    int x = i;
                    int downy = (int) (150 - (progress[0][i] * 10));
                    int upy = 150;
                    //Log.i("SETTT", "X: " + i + " downy: " + downy + " upy: " + upy);

                    if(downy < mMaxFFTSample)
                    {
                        mMaxFFTSample = downy;
                        //mMag = mMaxFFTSample;
                        mPeakPos = i;
                    }
                }

但是，我有两个问题。首先，最大频率偏离了 10-40 Hz，并且即使我播放恒定音调也会发生变化。其次，我只能分析高达 4000 Hz 的音频。有没有办法使其更准确和/或分析高达 22 kHz 的音频？也许可以通过将 block 大小编辑为 256 以外的值或将频率编辑为 8000 以外的值(即使当我尝试这样做时，mFreq 会下降到 0，mMaxFFTSample 通常会变为 -2)。 谢谢。

完整代码如下:

public class FrequencyListener extends AppCompatActivity {
    private double mFreq;
    private double mMag;
    private boolean mDidHitTargetFreq;
    private View mBackgroundView;

    int frequency = 8000;
    int channelConfiguration = AudioFormat.CHANNEL_IN_MONO;
    int audioEncoding = AudioFormat.ENCODING_PCM_16BIT;

    AudioRecord audioRecord;
    private RealDoubleFFT transformer;
    int blockSize;
    boolean started = false;
    boolean CANCELLED_FLAG = false;


    RecordAudio recordTask;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        blockSize = 256;
        transformer = new RealDoubleFFT(blockSize);

        started = true;
        CANCELLED_FLAG = false;
        recordTask = new RecordAudio();
        recordTask.execute();
    }

    private class RecordAudio extends AsyncTask<Void, double[], Boolean> {

        @Override
        protected Boolean doInBackground(Void... params) {

            int bufferSize = AudioRecord.getMinBufferSize(frequency,
                    channelConfiguration, audioEncoding);
            audioRecord = new AudioRecord(
                    MediaRecorder.AudioSource.DEFAULT, frequency,
                    channelConfiguration, audioEncoding, bufferSize);
            int bufferReadResult;
            short[] buffer = new short[blockSize];
            double[] toTransform = new double[blockSize];
            try {
                audioRecord.startRecording();
            } catch (IllegalStateException e) {
                Log.e("Recording failed", e.toString());

            }
            while (started) {
                if (isCancelled() || (CANCELLED_FLAG == true)) {

                    started = false;
                    //publishProgress(cancelledResult);
                    Log.d("doInBackground", "Cancelling the RecordTask");
                    break;
                } else {
                    bufferReadResult = audioRecord.read(buffer, 0, blockSize);

                    for (int i = 0; i < blockSize && i < bufferReadResult; i++) {
                        toTransform[i] = (double) buffer[i] / 32768.0; // signed 16 bit
                    }

                    transformer.ft(toTransform);

                    publishProgress(toTransform);

                }

            }
            return true;
        }
        @Override
        protected void onProgressUpdate(double[]...progress) {

            int mPeakPos = 0;
            double mMaxFFTSample = 150.0;
            for (int i = 0; i < progress[0].length; i++) {
                int x = i;
                int downy = (int) (150 - (progress[0][i] * 10));
                int upy = 150;
                //Log.i("SETTT", "X: " + i + " downy: " + downy + " upy: " + upy);

                if(downy < mMaxFFTSample)
                {
                    mMaxFFTSample = downy;
                    //mMag = mMaxFFTSample;
                    mPeakPos = i;
                }
            }

            mFreq = (((1.0 * frequency) / (1.0 * blockSize)) * mPeakPos)/2;
            Log.i("SETTT", "FREQ: " + mFreq + " MAG: " + mMaxFFTSample);

        }
        @Override
        protected void onPostExecute(Boolean result) {
            super.onPostExecute(result);
            try{
                audioRecord.stop();
            }
            catch(IllegalStateException e){
                Log.e("Stop failed", e.toString());

            }
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        started = false;
    }

    @Override
    protected void onResume() {
        super.onResume();
        started = true;
    }
}

Answer 1

数字信号可以表示的最大频率始终是采样率/2。这被称为 Nyquist frequency 。如果您需要测量超过 4kHz 的信号，那么唯一可能的解决方案是提高采样率。

下一个问题是 FFT 的频率分辨率，它是 FFT 大小和采样率的函数。

 binWidthInHz = sampleRate / numBins;

在您的情况下，您的采样率为 8000 和 256 个 bin，因此每个 bin 的宽度为 31.25 Hz。提高分辨率的唯一方法是 a) 降低采样率或 b) 增加 fft 大小。

最后一点。您似乎没有对信号应用任何窗口。结果是您的峰值将由于spectral leakage而被抹掉。 。应用窗口函数，例如 Hann function您的时域信号将抵消此作用。本质上，FFT 算法通过将信号的副本连接在一起，将信号视为无限长。除非您的信号满足某些条件，否则缓冲区的最后一个样本和第一个样本之间很可能会有很大的跳跃。窗口函数在缓冲区的开始和结束处应用锥度以使其平滑。