Java - 使用 PPQ 节拍进行计时的自定义 MIDI 音序器的可听滞后

Question

我一直在尝试用 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 本身或向 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);
    }
}

Answer 1

我怀疑问题是:

event.setTick(event.getTick() + elapsedTicks);
add.put(event, event.getTick());

事件流大概已经有时间戳，所以没有必要向它们添加 elapsedTicks。这只是意味着随着时间的推移，它们变得越来越晚。

有几种非常明显的方法可以提高上面代码的性能。很难说它们是否是您问题的原因:

1:不要忙等待:上面的代码没有阻塞的方法，直到有事情要做(ConcurrentHashMap 不提供阻塞行为)。相反，它循环不断地消耗 CPU 周期，即使在无事可做时也是如此。这种行为通常会受到操作系统调度程序的惩罚。您的线程在未运行时无法安排事件，其当前设计鼓励这样做。

2:为 currentEvents 使用以 MIDIEvent 为键的 HashMap 是一个糟糕的选择，而且效率低下。您需要迭代整个容器以找到需要传送到 VST 的事件。此外，由于没有顺序保证，您可能会无序地交付落在当前报价中的事件。考虑使用 SortedMap，其中键是交货时间。事件现在是有序的，最快的在结构的开头。提供 Activity 很便宜。

这条线还有一个潜在的问题——它不会导致不规律的计时，但我的意思可能是 oneTick 是错误的:

private long oneTick = (60000L / (BPM * PPQ)) * 1000000;

除以 BPM * PPQ 会导致截断。先做乘法。