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 赫兹，即使我演奏恒定音调也会发生变化。其次，我只能分析高达 4000 Hz 的音频。有没有一种方法可以更准确地 and/or 分析高达 22 kHz 的音频？也许通过将块大小编辑为 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

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

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

 binWidthInHz = sampleRate / numBins;

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

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

Answer 2

为了增加您可以分析的最大频率，您需要将采样频率增加到您希望分析的最高频率（奈奎斯特频率）的两倍。

为了提高频率分辨率，您可以通过长时间观察信号来增加时域样本的数量 time.Instead 增加分辨率，您可以选择在频率仓之间进行插值在执行 FFT 之前填充输入信号，或者在 FFT 之后在频率区间之间执行某种插值。（有关零填充和频率分辨率的更多信息，请参见 this post。

Android: 通过fft得到更精确的频率

Android: Get more precise frequencies through fft

java

audio

android

fft

frequency-analysis