java - 将FFT应用于java中的录音

Question

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

我意识到这个 line count = line.read(buffer, 0, buffer.length); 将音频分解为“ block ”。

还可以找到我正在使用的 FFT here .

我的问题是:

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

Answer 1

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

下面显示了如何为 PCM 执行此操作(带有注释)，取 self 的代码示例 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;
}

那段代码假定 float[] 而您的 FFT 需要 double[] 但这是一个相当简单的更改。 transfer 和 samples 是长度等于 bytes.length * normalBytes 的数组，bvalid 是 阅读。我的代码示例采用 AudioInputStream，但相同的转换应该适用于 TargetDataLine。我不确定您是否可以从字面上复制和粘贴它，但这是一个示例。

关于你的两个问题:

1. 您可以对整个记录进行很长的 FFT，或者对每个缓冲区的 FFT 进行平均。
2. 您链接到的 FFT 计算就地。所以实部是音频样本，虚部是长度等于实部的空数组(用零填充)。

但是当 FFT 完成后，您仍然需要做一些我没有看到链接类在做的事情:

• 转换为极坐标。
• 通常丢弃负频率(频谱的整个上半部分是下半部分的镜像)。
• 可能通过将结果幅度(实部)除以变换的长度来缩放它们。

---

编辑，相关:

• How do I use audio sample data from Java Sound?