将FFT应用于java中的音频录制

Question

我在这个网站上看到过类似的问题，但我的问题有点不同。我用来捕获音频的代码是这样的。我想简单地获取捕获的音频，并对其应用256点的FFT。

我意识到这个行数= 行读（缓冲区，0，缓冲区长度）; 将音频分解为“块”。

我使用的FFT也可以在这里找到。

我的问题是：

1. 我想知道是否有一种方法可以将FFT应用于整个音频记录，而不仅仅是缓冲量。
2. 我看到FFT的代码需要实部和虚部，如何从带有音频文件的代码中获取实部和虚部。

Answer 1

javax.sound.采样包所做的就是从文件中读取原始字节并将其写入输出。因此，您必须执行一个“介于两者之间”的步骤，即自己转换样本。

下面显示了如何为PCM这样做(带有注释),摘自我的代码示例WaveformDemo:

public static float[] unpack(
    byte[] bytes,
    long[] transfer,
    float[] samples,
    int bvalid,
    AudioFormat fmt
) {
    if(fmt.getEncoding() != AudioFormat.Encoding.PCM_SIGNED
            && fmt.getEncoding() != AudioFormat.Encoding.PCM_UNSIGNED) {

        return samples;
    }

    final int bitsPerSample = fmt.getSampleSizeInBits();
    final int bytesPerSample = bitsPerSample / 8;
    final int normalBytes = normalBytesFromBits(bitsPerSample);

    /*
     * not the most DRY way to do this but it's a bit more efficient.
     * otherwise there would either have to be 4 separate methods for
     * each combination of endianness/signedness or do it all in one
     * loop and check the format for each sample.
     * 
     * a helper array (transfer) allows the logic to be split up
     * but without being too repetetive.
     * 
     * here there are two loops converting bytes to raw long samples.
     * integral primitives in Java get sign extended when they are
     * promoted to a larger type so the & 0xffL mask keeps them intact.
     * 
     */

    if(fmt.isBigEndian()) {
        for(int i = 0, k = 0, b; i < bvalid; i += normalBytes, k++) {
            transfer[k] = 0L;

            int least = i + normalBytes - 1;
            for(b = 0; b < normalBytes; b++) {
                transfer[k] |= (bytes[least - b] & 0xffL) << (8 * b);
            }
        }
    } else {
        for(int i = 0, k = 0, b; i < bvalid; i += normalBytes, k++) {
            transfer[k] = 0L;

            for(b = 0; b < normalBytes; b++) {
                transfer[k] |= (bytes[i + b] & 0xffL) << (8 * b);
            }
        }
    }

    final long fullScale = (long)Math.pow(2.0, bitsPerSample - 1);

    /*
     * the OR is not quite enough to convert,
     * the signage needs to be corrected.
     * 
     */

    if(fmt.getEncoding() == AudioFormat.Encoding.PCM_SIGNED) {

        /*
         * if the samples were signed, they must be
         * extended to the 64-bit long.
         * 
         * so first check if the sign bit was set
         * and if so, extend it.
         * 
         * as an example, imagining these were 4-bit samples originally
         * and the destination is 8-bit, a mask can be constructed
         * with -1 (all bits 1) and a left shift:
         * 
         *     11111111
         *  <<  (4 - 1)
         *  ===========
         *     11111000
         * 
         * (except the destination is 64-bit and the original
         * bit depth from the file could be anything.)
         * 
         * then supposing we have a hypothetical sample -5
         * that ought to be negative, an AND can be used to check it:
         * 
         *    00001011
         *  & 11111000
         *  ==========
         *    00001000
         * 
         * and an OR can be used to extend it:
         * 
         *    00001011
         *  | 11111000
         *  ==========
         *    11111011
         * 
         */

        final long signMask = -1L << bitsPerSample - 1L;

        for(int i = 0; i < transfer.length; i++) {
            if((transfer[i] & signMask) != 0L) {
                transfer[i] |= signMask;
            }
        }
    } else {

        /*
         * unsigned samples are easier since they
         * will be read correctly in to the long.
         * 
         * so just sign them:
         * subtract 2^(bits - 1) so the center is 0.
         * 
         */

        for(int i = 0; i < transfer.length; i++) {
            transfer[i] -= fullScale;
        }
    }

    /* finally normalize to range of -1.0f to 1.0f */

    for(int i = 0; i < transfer.length; i++) {
        samples[i] = (float)transfer[i] / (float)fullScale;
    }

    return samples;
}

public static int normalBytesFromBits(int bitsPerSample) {

    /*
     * some formats allow for bit depths in non-multiples of 8.
     * they will, however, typically pad so the samples are stored
     * that way. AIFF is one of these formats.
     * 
     * so the expression:
     * 
     *  bitsPerSample + 7 >> 3
     * 
     * computes a division of 8 rounding up (for positive numbers).
     * 
     * this is basically equivalent to:
     * 
     *  (int)Math.ceil(bitsPerSample / 8.0)
     * 
     */

    return bitsPerSample + 7 >> 3;
}

这段代码假定< code>float[]，而您的FFT需要< code>double[]，但这是一个相当简单的更改。< code>transfer和< code>samples是长度等于< code > bytes . length * normal bytes 的数组，而< code>bvalid是< code>read的返回值。我的代码示例假设AudioInputStream，但是相同的转换应该适用于TargetDataLine。我不确定你能复制粘贴它，但这是一个例子。

关于你的两个问题：

1. 您可以对整个记录进行很长的FFT，也可以对每个缓冲区的FFT求平均值。
2. 您链接到的 FFT 计算已就地。因此，真实部分是音频样本，虚部是长度等于真实部分的空数组（填充零）。

但是当FFT完成时，仍然有一些事情需要做，我看不到链接类在做：

< li >转换为极坐标。 < li >通常丢弃负频率(频谱的整个上半部分，它是下半部分的镜像)。 < li >通过将结果幅度(实数部分)除以变换的长度，可以对其进行缩放。

编辑，相关:

• 如何使用Java声音的音频采样数据