为什么使用java Audiosystem时，英语发音频率会过高

Question

我试图创建一个从开始音符到结束音符的glissando(平滑音高上升((下面的java代码(。我像这个一样从开始音符频率线性上升到停止音符频率

for (i = 0; i < b1.length; i++) {
instantFrequency = startFrequency + (i * deltaFreq / nrOfSamples);
b1[i] = (byte) (127 * Math.sin(2 * Math.PI * instantFrequency * i / sampleRate));
}

在产生的音频片段中，滑音的结尾显然比停止音的音高更高。我的数学有问题吗？或者这个上升的正弦似乎过冲是有听力学原因吗？任何想法都将不胜感激！

public static void main(String[] args) throws IOException {
int sampleRate = 44100;
int sampleSizeInBits = 8;
int nrOfChannels = 1;
byte[] sine220 = createTimedSine(220, sampleRate, 0.5);
byte[] gliss220to440 = createTimedGlissando(220, 440, sampleRate, 4);
byte[] sine440 = createTimedSine(440, sampleRate, 2);
byte[] fullWave = concatenate(sine220, gliss220to440, sine440);
AudioInputStream stream = new AudioInputStream(new ByteArrayInputStream(fullWave),
new AudioFormat(sampleRate, sampleSizeInBits, nrOfChannels, true, false), fullWave.length);
File fileOut = new File(path, filename);
Type wavType = AudioFileFormat.Type.WAVE;
try {
AudioSystem.write(stream, wavType, fileOut);
} catch (IOException e) {
System.out.println("Error writing output file '" + filename + "': " + e.getMessage());
}
}
public static byte[] createTimedSine(float frequency, int samplingRate, double duration) {
int nrOfSamples = (int) Math.round(duration * samplingRate);
return (createSampledSine(nrOfSamples, frequency, samplingRate));
}
public static byte[] createSampledSine(int nrOfSamples, float frequency, int sampleRate) {
byte[] b1 = new byte[nrOfSamples];
int i;
for (i = 0; i < b1.length; i++) {
b1[i] = (byte) (127 * Math.sin(2 * Math.PI * frequency * i / sampleRate));
}
System.out.println("Freq of sine: " + frequency);
return b1;
}
public static byte[] createTimedGlissando(float startFrequency, float stopFrequency, int samplingRate,
double duration) {
int nrOfSamples = (int) Math.round(duration * samplingRate);
return (createGlissando(nrOfSamples, startFrequency, stopFrequency, samplingRate));
}
public static byte[] createGlissando(int nrOfSamples, float startFrequency, float stopFrequency, int sampleRate) {
byte[] b1 = new byte[nrOfSamples];
float deltaFreq = (stopFrequency - startFrequency);
float instantFrequency = 0;
int i;
for (i = 0; i < b1.length; i++) {
instantFrequency = startFrequency + (i * deltaFreq / nrOfSamples);
b1[i] = (byte) (127 * Math.sin(2 * Math.PI * instantFrequency * i / sampleRate));
}
System.out.println("Start freq glissando :" + startFrequency);
System.out.println("Stop freq glissando :" + instantFrequency);
return b1;
}
static byte[] concatenate(byte[] a, byte[] b, byte[] c) throws IOException {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
outputStream.write(a);
outputStream.write(b);
outputStream.write(c);
byte d[] = outputStream.toByteArray();
return d;
}

控制台输出：

Freq of sine: 220.0
Start freq glissando :220.0
Stop freq glissando :439.9975
Freq of sine: 440.0

Answer 1

问题的出现是因为每帧的相邻间距太宽。instantFrequency的计算是好的，但通过将其乘以i得出一个值是可疑的。当您从i到i+1时，前进的距离如下：

distance = ((n+1) * instantFrequency[n+1]) - (n * instantFrequency[n]) 

这大于所需的delta值，该值应等于新的instantFrequency值，例如：

distance = ((n+1) * instantFrequency[n]) - (n * instantFrequency[n]) 

下面的代码帮助我解决了这个问题，这个问题让我困惑了好几个小时。直到睡了一觉，我才能够得到上面简洁的解释(在编辑中添加(。

这里有一个更简单的例子来说明这个问题。由于这个问题发生在sin函数计算之前，我排除了它们以及trig计算之后的所有操作。

public class CuriousSeries {
public static void main(String[] args) {
double aa = 1;  // analogous to your 220
double bb = 2;  // analogous to your 440

double delta = bb - aa;

int steps = 10;
double[] travelVals = new double[steps + 1]; 

// trip aa
for (int i = 0; i <= 10; i++) {
travelVals[i] = aa * i;
System.out.println("aa trip. travelVals[" + i + "] = " + travelVals[i]);
}

// trip ab
for (int i = 0; i <= 10; i++) {
double instantFreq = aa + (i / 10.0) * delta;
travelVals[i] = instantFreq * i;
System.out.println("ab trip. travelVals[" + i + "] = " + travelVals[i]);
}

// trip bb
for (int i = 0; i <= 10; i++) {
travelVals[i] = bb * i;
System.out.println("bb trip. travelVals[" + i + "] = " + travelVals[i]);
}

// trip cc
travelVals[0] = 0;
for (int i = 1; i <= 10; i++) {
double travelIncrement = aa + (i / 10.0) * delta;
travelVals[i] = travelVals[i-1] + travelIncrement;
System.out.println("cc trip. travelVals[" + i + "] = " + travelVals[i]);
}
}
}

让我们把aa看作类似于220Hz，把bb看作类似于440Hz。在每一节中，我们从0开始，然后转到位置10。我们前进的金额与您的计算类似。对于"；"固定速率"；，我们简单地将阶跃的值乘以CCD_ 6(tripsaa和bb(。在tripab中，我使用了与您类似的计算方法。问题是最后的步骤太大了。如果你检查输出行，你可以看到这一点：

ab trip. travelSum[9] = 17.099999999999998
ab trip. travelSum[10] = 20.0

"；步骤"；接近3，而不是理想的2！

在最后一个例子中，tripcc，travelIncrement的计算与instantFrequency的计算相同。但在这种情况下，增量只是添加到先前的位置。

事实上，出于音频合成的目的(当通过计算创建波形时(，使用加法来最小化cpu成本是有意义的。按照这些思路，我通常会做一些更像以下的事情，从内部循环中删除尽可能多的计算：

double cursor = 0;
double prevCursor = 0;
double pitchIncrement = 2 * Math.PI * frequency / sampleRate;
for (int i = 0; i < n; i++) {
cursor = prevCursor + pitchIncrement;
audioVal[i] = Math.sin(cursor);
prevCursor = cursor;
}