Question

我正在尝试将音频输入的低音增强设置为12 dB。这是代码

public class BassBoost {
    double xn1, xn2, yn1, yn2;
    double omega, sn, cs, a, shape, beta, b0, b1, b2, a0, a1, a2;

    public BassBoost(int frequency, int dB_boost, int sampleRate) {
        xn1 = 0;
        xn2 = 0;
        yn1 = 0;
        yn2 = 0;

        omega = 2 * Utils.pi * frequency / sampleRate;
        sn = Math.sin(omega);
        cs = Math.cos(omega);
        a = Math.exp(Math.log(10.0) * dB_boost / 40);
        shape = 1.0;
        beta = Math.sqrt((a * a + 1) / shape - (Math.pow((a - 1), 2)));
        /* Coefficients */
        b0 = a * ((a + 1) - (a - 1) * cs + beta * sn);
        b1 = 2 * a * ((a - 1) - (a + 1) * cs);
        b2 = a * ((a + 1) - (a - 1) * cs - beta * sn);
        a0 = ((a + 1) + (a - 1) * cs + beta * sn);
        a1 = -2 * ((a - 1) + (a + 1) * cs);
        a2 = (a + 1) + (a - 1) * cs - beta * sn;
    }

    public void process(double[] buffer, int length) {
        double out, in = 0;

        for (int i = 0; i < length; i++) {
            in = buffer[i];
            out = (b0 * in + b1 * xn1 + b2 * xn2 - a1 * yn1 - a2 * yn2) / a0;
            xn2 = xn1;
            xn1 = in;
            yn2 = yn1;
            yn1 = out;

            if (out < -1.0)
                out = -1.0;
            else if (out > 1.0)
                out = 1.0; // Prevents clipping

            buffer[i] = out;
        }
    }
}

这是调用进程的伪代码

录制音频并存储在短缓冲区中。 Buffer分为小数组并复制到double数组进行过滤处理。如果我不分开，我正在使用OutofMemory，因为我在Android手机上尝试这个。应用过滤（LPF，HPF）在写入Byte数组之前，使用以下代码放大输出双缓冲区。

void doOutput(int outlen, boolean maxGain) {
    int qi;
    int i, i2;

    while (true) {
        int max = 0;
        i = outbp;
        for (i2 = 0; i2 < outlen; i2 += 4) {
            qi = (int) (leftBuffer[i] * outputGain);
            if (qi > max)
                max = qi;
            if (qi < -max)
                max = -qi;
            ob[i2 + 1] = (byte) (qi >> 8);
            ob[i2] = (byte) qi;
            i = (i + 1) & fbufmask;
        }
        i = outbp;
        for (i2 = 2; i2 < outlen; i2 += 4) {
            qi = (int) (rightBuffer[i] * outputGain);
            if (qi > max)
                max = qi;
            if (qi < -max)
                max = -qi;
            ob[i2 + 1] = (byte) (qi >> 8);
            ob[i2] = (byte) qi;
            i = (i + 1) & fbufmask;
        }
        // if we're getting overflow, adjust the gain
        if (max > 32767) {
            outputGain *= 30000. / max;
            if (outputGain < 1e-8 || Double.isInfinite(outputGain)) {
                unstable = true;
                break;
            }
            continue;
        } else if (maxGain && max < 24000) {
            if (max == 0) {
                if (outputGain == 1)
                    break;
                outputGain = 1;
            } else
                outputGain *= 30000. / max;
            continue;
        }
        break;
    }
    if (unstable)
        return;
    outbp = i;

out.write(ob, 0, outlen);
}

此代码适用于android，因此它必须具有内存效率。我尝试过使用Arraylist，但那也是不合时宜的。

问题是要将一致的outputGain应用到缓冲区之外，我目前正在应用过滤两次并写入byteOutputStream一次。在尝试使用单个outputGain之前，我尝试使用Arraylist存储输出缓冲区，但这样做是为了存储整个Double缓冲区（1分钟录制）。另外对于BassBoost，我想将它一次应用到整个输出。有记忆效率的方法来做到这一点。使用ArrayList是不可能的。为了获得一致的outputGain，我必须遍历整个输出缓冲区并将其应用于单个outputGain。

想要使上面的示例代码高效，这样我就不必经历两次缓冲区了。如果我把它应用到块中，Bass Boost也能让我在连续声音中休息。

由于

Answer 1

一分钟的44.1kHz立体声声音的short[]需要44100 * 2 * 2 * 60 = 10584000或大约10MB的内存。

对于普通的短缓冲区，只是。

由于您使用ArrayList<Double>，根据您的评论，它会变得更大。 Java为每个Object增加了一些开销，这个arraylist将拥有大约5 百万个对象。我很确定VM的开销量会有所不同。

但我相信，每Object的开销为at least 8 bytes。使用您的500万Shorts，(8 + 8) * 5M = 80MB 最小。

看看这是怎么回事？

我认为您不想创建500万个对象。我给出的数字仅仅是样本本身。如果你在处理阶段使用额外的内存，情况会更糟。这就是为什么基本上每个音频应用都会以块的形式进行处理。那里有大量的数据，即使对于相对“短”的剪辑也是如此。

Java中的低音增强

1 个答案: