我正在尝试实时生成一组同步音。但是程序产生的所有声音都是＆＃34;模糊＆＃34;，或者有＆＃34;静态＆＃34;，甚至听起来像'＃34;尖叫＆＃34;在后台。这在低音调声中尤其明显。 这是代码：
static final long bufferLength = 44100;
static final AudioFormat af = new AudioFormat(bufferLength, 8, 1, true, false);
static boolean go = true; //to be changed somewhere else
static void startSound(double[] hertz) {
if (hertz.length == 0) {return;}
try {
SourceDataLine sdl = AudioSystem.getSourceDataLine(af);
sdl.open();
sdl.start();
int i = 0;
//iterate as long as the sound must play
do {
//create a new buffer
double[] buf = new double[128]; //arbitrary number
final int startI = i;
//iterate through each of the tones
for (int k = 0; k < hertz.length; k++) {
i = startI;
//iterate through each of the samples for this buffer
for (int j = 0; j < buf.length; j++) {
double x = (double)i/bufferLength*hertz[k]*2*Math.PI;
double wave1 = Math.sin(x);
//decrease volume with increasing pitch
double volume = Math.min(Math.max(300 - hertz[k], 50d), 126d);
buf[j] += wave1*volume;
i++;
if (i == 9999999) { //prevent i from getting too big
i = 0;
}
}
}
final byte[] finalBuffer = new byte[buf.length];
//copy the double buffer into byte buffer
for (int j = 0; j < buf.length; j++) {
//divide by hertz.length to prevent simultaneous sounds
// from becoming too loud
finalBuffer[j] = (byte)(buf[j]/hertz.length);
}
//play the sound
sdl.write(finalBuffer, 0, finalBuffer.length);
} while (go);
sdl.flush();
sdl.stop();
} catch (LineUnavailableException e) {
e.printStackTrace();
}
}
//play some deep example tones
startSound(new double[]{65.4064, 58.2705, 48.9995});
我已经尝试录制从该程序输出的声音，波浪看起来有点锯齿状。但是当我直接从程序中打印出生成的波形时，它们看起来非常流畅。我产生的声音似乎与扬声器发出的声音不匹配。任何人都可以抓住我做错的事吗？
答案 0 :(得分：1)
根据我的评论，我认为你听到quantization error因为8位音频，你应该切换到16位。量化误差有时被称为噪声，但是是一种方波谐波失真，是你听到的微妙泛音的来源。
8位有时可以接受像语音这样的东西，它听起来更像是噪音。纯音会使失真更明显。
我将您的代码转换为粗略的MCVE以证明其差异。
class SoundTest {
static final int bufferLength = 44100;
static final AudioFormat af8 = new AudioFormat(bufferLength, 8, 1, true, false);
static final AudioFormat af16 = new AudioFormat(bufferLength, 16, 1, true, false);
static volatile boolean go = true; //to be changed somewhere else
static void startSound8(double[] hertz) {
if (hertz.length == 0) {return;}
try {
SourceDataLine sdl = AudioSystem.getSourceDataLine(af8);
sdl.open();
sdl.start();
int i = 0;
//iterate as long as the sound must play
do {
//create a new buffer
double[] buf = new double[128]; //arbitrary number
final int startI = i;
//iterate through each of the tones
for (int k = 0; k < hertz.length; k++) {
i = startI;
//iterate through each of the samples for this buffer
for (int j = 0; j < buf.length; j++) {
double x = (double)i/bufferLength*hertz[k]*2*Math.PI;
double wave1 = Math.sin(x);
//decrease volume with increasing pitch
// double volume = Math.min(Math.max(300 - hertz[k], 50d), 126d);
double volume = 64;
buf[j] += wave1*volume;
i++;
if (i == 9999999) { //prevent i from getting too big
i = 0;
}
}
}
final byte[] finalBuffer = new byte[buf.length];
//copy the double buffer into byte buffer
for (int j = 0; j < buf.length; j++) {
//divide by hertz.length to prevent simultaneous sounds
// from becoming too loud
finalBuffer[j] = (byte)(buf[j]/hertz.length);
}
//play the sound
sdl.write(finalBuffer, 0, finalBuffer.length);
} while (go);
sdl.flush();
sdl.stop();
synchronized (SoundTest.class) {
SoundTest.class.notifyAll();
}
} catch (LineUnavailableException e) {
e.printStackTrace();
}
}
static void startSound16(double[] hertz) {
if (hertz.length == 0) {return;}
try {
SourceDataLine sdl = AudioSystem.getSourceDataLine(af16);
sdl.open();
sdl.start();
int i = 0;
//iterate as long as the sound must play
do {
//create a new buffer
double[] buf = new double[128]; //arbitrary number
final int startI = i;
//iterate through each of the tones
for (int k = 0; k < hertz.length; k++) {
i = startI;
//iterate through each of the samples for this buffer
for (int j = 0; j < buf.length; j++) {
double x = (double)i/bufferLength*hertz[k]*2*Math.PI;
double wave1 = Math.sin(x);
//decrease volume with increasing pitch
// double volume = Math.min(Math.max(300 - hertz[k], 50d), 126d);
double volume = 16384;
buf[j] += wave1*volume;
i++;
if (i == 9999999) { //prevent i from getting too big
i = 0;
}
}
}
final byte[] finalBuffer = new byte[buf.length * 2];
//copy the double buffer into byte buffer
for (int j = 0; j < buf.length; j++) {
//divide by hertz.length to prevent simultaneous sounds
// from becoming too loud
int a = (int) (buf[j] / hertz.length);
finalBuffer[j * 2] = (byte) a;
finalBuffer[(j * 2) + 1] = (byte) (a >>> 8);
}
//play the sound
sdl.write(finalBuffer, 0, finalBuffer.length);
} while (go);
sdl.flush();
sdl.stop();
synchronized (SoundTest.class) {
SoundTest.class.notifyAll();
}
} catch (LineUnavailableException e) {
e.printStackTrace();
}
}
static void playTone(final double hz, final boolean fewBits) {
go = true;
new Thread() {
@Override
public void run() {
if (fewBits) {
startSound8(new double[] {hz});
} else {
startSound16(new double[] {hz});
}
}
}.start();
try {
Thread.sleep(5000);
} catch (InterruptedException x) {
x.printStackTrace();
} finally {
go = false;
synchronized (SoundTest.class) {
try {
SoundTest.class.wait();
} catch (InterruptedException x) {
x.printStackTrace();
}
}
}
}
public static void main(String[] args) {
playTone(220, true);
playTone(220, false);
}
}
我讨论了用于打包16位字节数组here的位操作的概念以及那里的示例代码。
另外值得一提的是，如果专业应用程序由于某种原因需要使用8位，那么在量化之前它可能会添加dither，这听起来比纯量化误差更好。 （对于16位，同样的事情，但16位的量化误差是听不见的，除非它已被累积。）