Java - 使用 PPQ 节拍进行计时的自定义 MIDI 音序器的声音滞后
Java - Audible Lag with Custom MIDI Sequencer using PPQ Ticks for Timing
我一直在尝试在 Java 中实现我自己的 异步 MIDI 音序器，它通过处理 MidiEvent 的列表将 ShortMessage 发送到 VST。我需要性能达到最佳，以便在收听音频输出时不会有声音延迟。
问题是，由于滴答不准确地增加（有时增加太快或太慢，这会打乱所有 MidiEvent 的计时），肯定会有声音滞后。
下面是音序器的代码：
package com.dranithix.spectrum.vst;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import javax.sound.midi.MidiEvent;
import javax.sound.midi.ShortMessage;
import com.synthbot.audioplugin.vst.vst2.JVstHost2;
/**
*
* @author Kenta Iwasaki
*
*/
public class VstSequencer implements Runnable {
public static long BPM = 128L, PPQ = 4L;
private long oneTick = (60000L / (BPM * PPQ)) * 1000000;
private Map<MidiEvent, Long> currentEvents = new ConcurrentHashMap<MidiEvent, Long>();
private long startTime = System.nanoTime(), elapsedTicks = 0;
private JVstHost2 vst;
public VstSequencer(JVstHost2 vst) {
this.vst = vst;
}
@Override
public void run() {
while (true) {
if (System.nanoTime() - startTime >= oneTick) {
elapsedTicks++;
startTime = System.nanoTime();
}
Iterator<MidiEvent> it = currentEvents.keySet().iterator();
while (it.hasNext()) {
MidiEvent currentEvent = it.next();
long eventTime = currentEvent.getTick() - elapsedTicks;
if (eventTime <= 0) {
vst.queueMidiMessage((ShortMessage) currentEvent
.getMessage());
it.remove();
}
}
}
}
public void queueEvents(List<MidiEvent> events) {
Map<MidiEvent, Long> add = new HashMap<MidiEvent, Long>();
for (MidiEvent event : events) {
event.setTick(event.getTick() + elapsedTicks);
add.put(event, event.getTick());
}
currentEvents.putAll(add);
}
public void queueEvent(MidiEvent event) {
event.setTick(event.getTick() + elapsedTicks);
currentEvents.put(event, event.getTick());
}
}
我们怎样才能提高这个系统的性能？我们能否确保这种系统不会有可闻延迟（例如：固定时间步长）？
提前致谢。
编辑： 只是为了找出声音延迟的原因，我可以确认 VST 本身或框架将 MIDI 消息发送到 VST 没有延迟。它与目前在音序器中使用的基于滴答的计时系统有关。
已解决： 我通过在同一线程中包含 VST 事件处理代码（它们最初是在单独的线程）。对于那些读到这篇文章并一直在寻找将 MIDI 事件排序到 JVstHost2 或任何类似 Java VST 主机库的人，请随意将部分固定代码用于您自己的项目，因为这对我来说非常困难在网上找到合适的 VST 音序，因为 VST 是一种商业格式，很少有人接触 Java。
解决代码：
package com.dranithix.spectrum.vst;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import javax.sound.midi.MidiEvent;
import javax.sound.midi.ShortMessage;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import com.synthbot.audioplugin.vst.vst2.JVstHost2;
/**
*
* @author Kenta Iwasaki
*
*/
public class VstSequencer implements Runnable {
private static final float ShortMaxValueAsFloat = (float) Short.MAX_VALUE;
public static float BPM = 120f, PPQ = 2f;
private static float oneTick = 60000f / (BPM * PPQ);
private List<MidiEvent> currentEvents = new ArrayList<MidiEvent>();
private long startTime = System.currentTimeMillis(), elapsedTicks = 0;
private JVstHost2 vst;
private final float[][] fInputs;
private final float[][] fOutputs;
private final byte[] bOutput;
private int blockSize;
private int numOutputs;
private int numAudioOutputs;
private AudioFormat audioFormat;
private SourceDataLine sourceDataLine;
public VstSequencer(JVstHost2 vst) {
this.vst = vst;
numOutputs = vst.numOutputs();
numAudioOutputs = Math.min(2, numOutputs);
blockSize = vst.getBlockSize();
fInputs = new float[vst.numInputs()][blockSize];
fOutputs = new float[numOutputs][blockSize];
bOutput = new byte[numAudioOutputs * blockSize * 2];
audioFormat = new AudioFormat((int) vst.getSampleRate(), 16,
numAudioOutputs, true, false);
DataLine.Info dataLineInfo = new DataLine.Info(SourceDataLine.class,
audioFormat);
sourceDataLine = null;
try {
sourceDataLine = (SourceDataLine) AudioSystem.getLine(dataLineInfo);
sourceDataLine.open(audioFormat, bOutput.length);
sourceDataLine.start();
} catch (LineUnavailableException lue) {
lue.printStackTrace(System.err);
System.exit(1);
}
}
@Override
protected void finalize() throws Throwable {
try {
sourceDataLine.drain();
sourceDataLine.close();
} finally {
super.finalize();
}
}
private byte[] floatsToBytes(float[][] fData, byte[] bData) {
int index = 0;
for (int i = 0; i < blockSize; i++) {
for (int j = 0; j < numAudioOutputs; j++) {
short sval = (short) (fData[j][i] * ShortMaxValueAsFloat);
bData[index++] = (byte) (sval & 0x00FF);
bData[index++] = (byte) ((sval & 0xFF00) >> 8);
}
}
return bData;
}
@Override
public void run() {
while (true) {
if (Thread.interrupted()) {
break;
}
if (System.currentTimeMillis() - startTime >= oneTick) {
elapsedTicks++;
startTime = System.currentTimeMillis();
}
vst.processReplacing(fInputs, fOutputs, blockSize);
sourceDataLine.write(floatsToBytes(fOutputs, bOutput), 0,
bOutput.length);
Iterator<MidiEvent> it = currentEvents.iterator();
while (it.hasNext()) {
MidiEvent currentEvent = it.next();
long eventTime = currentEvent.getTick() - elapsedTicks;
if (eventTime <= 0) {
vst.queueMidiMessage((ShortMessage) currentEvent
.getMessage());
it.remove();
}
}
}
}
public void queueEvents(List<MidiEvent> events) {
for (MidiEvent event : events) {
event.setTick(event.getTick() + elapsedTicks);
}
currentEvents.addAll(events);
}
public void queueEvent(MidiEvent event) {
event.setTick(event.getTick() + elapsedTicks);
currentEvents.add(event);
}
}
我怀疑问题是：
event.setTick(event.getTick() + elapsedTicks);
add.put(event, event.getTick());
事件流可能已经有时间戳，所以不需要添加 elapsedTicks。这只是意味着他们会随着时间的推移变得越来越晚。
有几种非常明显的方法可以提高上面代码的性能。很难说它们是否是您问题的原因：
1：不要忙等待：上面的代码在有事可做之前无法阻塞（ConcurrentHashMap 不提供阻塞行为）。相反，它循环不断燃烧 CPU 个循环，即使无事可做。这种行为通常会受到操作系统调度程序的惩罚。当它不是 运行 时，您的线程无法安排事件，并且它当前的设计鼓励这样做。
2：为 currentEvents 使用以 MIDIEvent 为键的 HashMap 是一个糟糕的选择，而且效率低下。您需要迭代整个容器以找到需要传送到 VST 的事件。此外，由于没有顺序保证，您可能会无序地交付落在当前报价中的事件。考虑使用 SortedMap，其中关键是交货时间。事件现在是有序的，最快的在结构的开头。提供活动很便宜。
这条线还有一个潜在的问题——它不会导致不规律的计时，但我的意思可能是 oneTick 是错误的：
private long oneTick = (60000L / (BPM * PPQ)) * 1000000;
除以 BPM * PPQ 导致截断。先做乘法。
我一直在尝试在 Java 中实现我自己的 异步 MIDI 音序器，它通过处理 MidiEvent 的列表将 ShortMessage 发送到 VST。我需要性能达到最佳，以便在收听音频输出时不会有声音延迟。
问题是，由于滴答不准确地增加（有时增加太快或太慢，这会打乱所有 MidiEvent 的计时），肯定会有声音滞后。
下面是音序器的代码：
package com.dranithix.spectrum.vst;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import javax.sound.midi.MidiEvent;
import javax.sound.midi.ShortMessage;
import com.synthbot.audioplugin.vst.vst2.JVstHost2;
/**
*
* @author Kenta Iwasaki
*
*/
public class VstSequencer implements Runnable {
public static long BPM = 128L, PPQ = 4L;
private long oneTick = (60000L / (BPM * PPQ)) * 1000000;
private Map<MidiEvent, Long> currentEvents = new ConcurrentHashMap<MidiEvent, Long>();
private long startTime = System.nanoTime(), elapsedTicks = 0;
private JVstHost2 vst;
public VstSequencer(JVstHost2 vst) {
this.vst = vst;
}
@Override
public void run() {
while (true) {
if (System.nanoTime() - startTime >= oneTick) {
elapsedTicks++;
startTime = System.nanoTime();
}
Iterator<MidiEvent> it = currentEvents.keySet().iterator();
while (it.hasNext()) {
MidiEvent currentEvent = it.next();
long eventTime = currentEvent.getTick() - elapsedTicks;
if (eventTime <= 0) {
vst.queueMidiMessage((ShortMessage) currentEvent
.getMessage());
it.remove();
}
}
}
}
public void queueEvents(List<MidiEvent> events) {
Map<MidiEvent, Long> add = new HashMap<MidiEvent, Long>();
for (MidiEvent event : events) {
event.setTick(event.getTick() + elapsedTicks);
add.put(event, event.getTick());
}
currentEvents.putAll(add);
}
public void queueEvent(MidiEvent event) {
event.setTick(event.getTick() + elapsedTicks);
currentEvents.put(event, event.getTick());
}
}
我们怎样才能提高这个系统的性能？我们能否确保这种系统不会有可闻延迟（例如：固定时间步长）？
提前致谢。
编辑： 只是为了找出声音延迟的原因，我可以确认 VST 本身或框架将 MIDI 消息发送到 VST 没有延迟。它与目前在音序器中使用的基于滴答的计时系统有关。
已解决： 我通过在同一线程中包含 VST 事件处理代码（它们最初是在单独的线程）。对于那些读到这篇文章并一直在寻找将 MIDI 事件排序到 JVstHost2 或任何类似 Java VST 主机库的人，请随意将部分固定代码用于您自己的项目，因为这对我来说非常困难在网上找到合适的 VST 音序，因为 VST 是一种商业格式，很少有人接触 Java。
解决代码：
package com.dranithix.spectrum.vst;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import javax.sound.midi.MidiEvent;
import javax.sound.midi.ShortMessage;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.SourceDataLine;
import com.synthbot.audioplugin.vst.vst2.JVstHost2;
/**
*
* @author Kenta Iwasaki
*
*/
public class VstSequencer implements Runnable {
private static final float ShortMaxValueAsFloat = (float) Short.MAX_VALUE;
public static float BPM = 120f, PPQ = 2f;
private static float oneTick = 60000f / (BPM * PPQ);
private List<MidiEvent> currentEvents = new ArrayList<MidiEvent>();
private long startTime = System.currentTimeMillis(), elapsedTicks = 0;
private JVstHost2 vst;
private final float[][] fInputs;
private final float[][] fOutputs;
private final byte[] bOutput;
private int blockSize;
private int numOutputs;
private int numAudioOutputs;
private AudioFormat audioFormat;
private SourceDataLine sourceDataLine;
public VstSequencer(JVstHost2 vst) {
this.vst = vst;
numOutputs = vst.numOutputs();
numAudioOutputs = Math.min(2, numOutputs);
blockSize = vst.getBlockSize();
fInputs = new float[vst.numInputs()][blockSize];
fOutputs = new float[numOutputs][blockSize];
bOutput = new byte[numAudioOutputs * blockSize * 2];
audioFormat = new AudioFormat((int) vst.getSampleRate(), 16,
numAudioOutputs, true, false);
DataLine.Info dataLineInfo = new DataLine.Info(SourceDataLine.class,
audioFormat);
sourceDataLine = null;
try {
sourceDataLine = (SourceDataLine) AudioSystem.getLine(dataLineInfo);
sourceDataLine.open(audioFormat, bOutput.length);
sourceDataLine.start();
} catch (LineUnavailableException lue) {
lue.printStackTrace(System.err);
System.exit(1);
}
}
@Override
protected void finalize() throws Throwable {
try {
sourceDataLine.drain();
sourceDataLine.close();
} finally {
super.finalize();
}
}
private byte[] floatsToBytes(float[][] fData, byte[] bData) {
int index = 0;
for (int i = 0; i < blockSize; i++) {
for (int j = 0; j < numAudioOutputs; j++) {
short sval = (short) (fData[j][i] * ShortMaxValueAsFloat);
bData[index++] = (byte) (sval & 0x00FF);
bData[index++] = (byte) ((sval & 0xFF00) >> 8);
}
}
return bData;
}
@Override
public void run() {
while (true) {
if (Thread.interrupted()) {
break;
}
if (System.currentTimeMillis() - startTime >= oneTick) {
elapsedTicks++;
startTime = System.currentTimeMillis();
}
vst.processReplacing(fInputs, fOutputs, blockSize);
sourceDataLine.write(floatsToBytes(fOutputs, bOutput), 0,
bOutput.length);
Iterator<MidiEvent> it = currentEvents.iterator();
while (it.hasNext()) {
MidiEvent currentEvent = it.next();
long eventTime = currentEvent.getTick() - elapsedTicks;
if (eventTime <= 0) {
vst.queueMidiMessage((ShortMessage) currentEvent
.getMessage());
it.remove();
}
}
}
}
public void queueEvents(List<MidiEvent> events) {
for (MidiEvent event : events) {
event.setTick(event.getTick() + elapsedTicks);
}
currentEvents.addAll(events);
}
public void queueEvent(MidiEvent event) {
event.setTick(event.getTick() + elapsedTicks);
currentEvents.add(event);
}
}
我怀疑问题是：
event.setTick(event.getTick() + elapsedTicks);
add.put(event, event.getTick());
事件流可能已经有时间戳，所以不需要添加 elapsedTicks。这只是意味着他们会随着时间的推移变得越来越晚。
有几种非常明显的方法可以提高上面代码的性能。很难说它们是否是您问题的原因：
1：不要忙等待：上面的代码在有事可做之前无法阻塞（ConcurrentHashMap 不提供阻塞行为）。相反，它循环不断燃烧 CPU 个循环，即使无事可做。这种行为通常会受到操作系统调度程序的惩罚。当它不是 运行 时，您的线程无法安排事件，并且它当前的设计鼓励这样做。
2：为 currentEvents 使用以 MIDIEvent 为键的 HashMap 是一个糟糕的选择，而且效率低下。您需要迭代整个容器以找到需要传送到 VST 的事件。此外，由于没有顺序保证，您可能会无序地交付落在当前报价中的事件。考虑使用 SortedMap，其中关键是交货时间。事件现在是有序的，最快的在结构的开头。提供活动很便宜。
这条线还有一个潜在的问题——它不会导致不规律的计时，但我的意思可能是 oneTick 是错误的：
private long oneTick = (60000L / (BPM * PPQ)) * 1000000;
除以 BPM * PPQ 导致截断。先做乘法。