Java实时处理MIDI输入流详解

从现在开始，努力学习吧！本文《Java实时处理MIDI输入流教程》主要讲解了等等相关知识点，我会在golang学习网中持续更新相关的系列文章，欢迎大家关注并积极留言建议。下面就先一起来看一下本篇正文内容吧，希望能帮到你！

本教程详细介绍了如何在Java应用程序中从实时MIDI乐器获取并处理MIDI输入流。通过实现自定义的`Receiver`接口，可以实时捕获和响应MIDI消息，如音符开启事件。文章还涵盖了如何同时进行MIDI事件监听与录制，并提供了完整的代码示例和最佳实践，帮助开发者构建实时MIDI处理应用。

实时MIDI输入流处理概述

在开发需要与实时MIDI乐器交互的Java应用程序时，一个常见的需求是能够即时捕获并响应从乐器发出的MIDI消息。例如，在构建一个自动乐谱显示器或MIDI分析工具时，我们需要实时获取按键事件（如音符开启/关闭）。Java Sound API提供了强大的功能来处理MIDI数据，但初学者可能会在如何实现实时回调方面遇到挑战。本文将重点介绍如何利用javax.sound.midi包中的Receiver接口来高效、实时地处理MIDI输入。

核心概念：MIDI设备、发送器与接收器

在Java Sound API中，MIDI数据的流动主要通过以下几个核心组件实现：

• MidiDevice: 代表一个MIDI设备，可以是硬件（如数字钢琴）或软件（如合成器）。它提供了MIDI数据的输入和输出端口。
• Transmitter (发送器): 负责从MidiDevice中发送MIDI消息。一个MidiDevice可以有多个Transmitter。
• Receiver (接收器): 负责接收Transmitter发送的MIDI消息。当Transmitter将MIDI消息发送给Receiver时，Receiver的send()方法会被调用，从而实现实时回调。

要实现实时MIDI输入，关键在于创建一个自定义的Receiver，并将其连接到MIDI输入设备的Transmitter。

实现自定义MIDI接收器

Receiver接口定义了一个send(MidiMessage message, long timeStamp)方法。当MIDI消息到达时，系统会调用此方法。通过实现这个接口，我们可以在send方法中编写逻辑来处理接收到的MIDI事件。

步骤1：选择MIDI输入设备

首先，我们需要识别并选择正确的MIDI输入设备。MidiSystem.getMidiDeviceInfo()方法可以获取所有可用MIDI设备的Info对象列表，通过这些信息可以找到目标设备。

import javax.sound.midi.*;
import java.io.File;
import java.io.IOException;
import javax.swing.Timer; // 用于演示定时停止录制

public class MidiInputProcessor {

    // 自定义MIDI接收器类
    private static class MyReceiver implements Receiver {
        @Override
        public void send(MidiMessage message, long timeStamp) {
            // 实时处理MIDI消息
            if (message instanceof ShortMessage) {
                ShortMessage sm = (ShortMessage) message;
                // 仅处理NOTE_ON消息作为示例
                if (sm.getCommand() == ShortMessage.NOTE_ON) {
                    int key = sm.getData1(); // 音符的键值 (0-127)
                    int velocity = sm.getData2(); // 按键力度 (0-127)
                    System.out.println("实时接收到 NOTE_ON 事件: Key=" + key + ", Velocity=" + velocity + ", TimeStamp=" + timeStamp);
                    // 在此处添加您的实时处理逻辑，例如更新UI、触发声音等
                    // 建议将耗时操作放到单独的线程中，以避免阻塞MIDI事件流
                } else if (sm.getCommand() == ShortMessage.NOTE_OFF) {
                    int key = sm.getData1();
                    System.out.println("实时接收到 NOTE_OFF 事件: Key=" + key + ", TimeStamp=" + timeStamp);
                }
                // 可以处理其他类型的ShortMessage，如Control Change (sm.getCommand() == ShortMessage.CONTROL_CHANGE)
            } else if (message instanceof SysexMessage) {
                // 处理系统独占消息
                System.out.println("接收到 SysexMessage");
            } else if (message instanceof MetaMessage) {
                // 处理Meta消息 (通常只在MIDI文件中出现，实时流中较少)
                System.out.println("接收到 MetaMessage");
            }
        }

        @Override
        public void close() {
            System.out.println("MyReceiver 已关闭。");
        }
    }

    public static void main(String[] args) throws MidiUnavailableException, InvalidMidiDataException, IOException {
        // 1. 列出所有MIDI设备并选择输入设备
        MidiDevice inputDevice = null;
        Info[] infos = MidiSystem.getMidiDeviceInfo();
        System.out.println("可用MIDI设备列表:");
        for (int i = 0; i < infos.length; i++) {
            System.out.println(i + ": " + infos[i].getName() + " - " + infos[i].getDescription());
            try {
                MidiDevice device = MidiSystem.getMidiDevice(infos[i]);
                // 尝试打开设备，检查是否有Transmitter（即是否为输入设备）
                if (device.getMaxTransmitters() != 0) {
                    System.out.println("   (这是一个输入设备)");
                    // 假设选择第一个找到的输入设备，实际应用中可能需要用户选择
                    if (inputDevice == null) {
                        inputDevice = device;
                    }
                }
                device.close(); // 立即关闭，避免占用
            } catch (MidiUnavailableException e) {
                System.out.println("   (无法打开此设备: " + e.getMessage() + ")");
            }
        }

        if (inputDevice == null) {
            System.err.println("未找到任何MIDI输入设备。请确保您的MIDI设备已连接并正确安装驱动。");
            return;
        }

        System.out.println("\n选择的输入设备: " + inputDevice.getDeviceInfo().getName());
        inputDevice.open(); // 打开输入设备

        // 2. 创建自定义接收器并连接到设备的发送器
        Transmitter transmitter = inputDevice.getTransmitter();
        MyReceiver myReceiver = new MyReceiver();
        transmitter.setReceiver(myReceiver);

        System.out.println("开始实时监听MIDI输入...");
        System.out.println("按任意键停止。");

        // 保持程序运行，直到用户输入
        try {
            System.in.read();
        } finally {
            // 3. 关闭资源
            if (transmitter != null) {
                transmitter.close();
            }
            if (myReceiver != null) {
                myReceiver.close();
            }
            if (inputDevice != null && inputDevice.isOpen()) {
                inputDevice.close();
            }
            System.out.println("程序已停止，资源已释放。");
        }
    }
}

在上述代码中，MyReceiver类的send方法是核心。它接收MidiMessage对象，我们可以通过instanceof操作符判断消息类型（如ShortMessage、SysexMessage、MetaMessage），然后进一步解析消息内容。对于音符事件，ShortMessage的getCommand()方法会返回ShortMessage.NOTE_ON或ShortMessage.NOTE_OFF，getData1()是音符键值，getData2()是力度。

注意事项：

• 线程安全: send方法会在MIDI事件线程中被调用。如果您的处理逻辑耗时，可能会阻塞后续MIDI事件的处理，导致延迟。建议将复杂的或耗时的处理（如UI更新、文件写入等）放在单独的线程或使用执行器服务中异步执行。
• 资源管理: 务必在程序退出时关闭所有打开的MIDI设备、发送器和接收器，以释放系统资源。

同时进行MIDI事件监听与录制

在某些场景下，您可能不仅需要实时处理MIDI事件，还需要将这些事件录制成MIDI文件。Sequencer接口可以实现MIDI序列的录制和播放。要同时实现实时监听和录制，我们可以为输入设备配置两个Transmitter：一个连接到自定义的Receiver进行实时处理，另一个连接到Sequencer的Receiver进行录制。

import javax.sound.midi.*;
import java.io.File;
import java.io.IOException;
import javax.swing.Timer; // 用于演示定时停止录制

public class MidiInputRecorder {

    private static class MyReceiver implements Receiver {
        private String name;
        public MyReceiver(String name) { this.name = name; }

        @Override
        public void send(MidiMessage message, long timeStamp) {
            if (message instanceof ShortMessage) {
                ShortMessage sm = (ShortMessage) message;
                if (sm.getCommand() == ShortMessage.NOTE_ON) {
                    System.out.println(name + " 实时接收到 NOTE_ON: Key=" + sm.getData1() + ", Velocity=" + sm.getData2());
                }
            }
        }

        @Override
        public void close() {
            System.out.println(name + " Receiver 已关闭。");
        }
    }

    public static void main(String[] args) throws MidiUnavailableException, InvalidMidiDataException, IOException {
        MidiDevice inputDevice = null;
        Sequencer sequencer = null;
        Transmitter customReceiverTransmitter = null;
        Transmitter sequencerTransmitter = null;
        MyReceiver myReceiver = null;

        try {
            // 1. 选择MIDI输入设备
            Info[] infos = MidiSystem.getMidiDeviceInfo();
            for (int i = 0; i < infos.length; i++) {
                try {
                    MidiDevice device = MidiSystem.getMidiDevice(infos[i]);
                    if (device.getMaxTransmitters() != 0) {
                        inputDevice = device;
                        break; // 找到第一个输入设备
                    }
                } catch (MidiUnavailableException e) {
                    // 忽略无法打开的设备
                }
            }

            if (inputDevice == null) {
                System.err.println("未找到任何MIDI输入设备。");
                return;
            }

            inputDevice.open();
            System.out.println("已打开输入设备: " + inputDevice.getDeviceInfo().getName());

            // 2. 初始化 Sequencer 用于录制
            sequencer = MidiSystem.getSequencer();
            sequencer.open();
            Sequence sequence = new Sequence(Sequence.PPQ, 24); // 创建一个空的MIDI序列
            Track currentTrack = sequence.createTrack();
            sequencer.setSequence(sequence);

            // 3. 连接第一个Transmitter到自定义Receiver进行实时监听
            customReceiverTransmitter = inputDevice.getTransmitter();
            myReceiver = new MyReceiver("MyCustomReceiver");
            customReceiverTransmitter.setReceiver(myReceiver);
            System.out.println("自定义Receiver已连接，开始实时监听。");

            // 4. 连接第二个Transmitter到Sequencer的Receiver进行录制
            sequencerTransmitter = inputDevice.getTransmitter(); // 注意：每个MidiDevice可以有多个Transmitter
            sequencerTransmitter.setReceiver(sequencer.getReceiver());
            sequencer.recordEnable(currentTrack, -1); // 启用录制到指定Track
            sequencer.startRecording(); // 开始录制
            System.out.println("Sequencer已连接，开始录制MIDI数据。");

            System.out.println("\n程序将运行10秒，同时进行实时监听和录制。");

            // 5. 设置定时器，10秒后停止录制并保存文件
            new Timer(10000, e -> {
                sequencer.stopRecording();
                System.out.println("\n10秒已到，停止录制。");
                try {
                    File outputFile = new File("recorded_midi.mid");
                    MidiSystem.write(sequence, 0, outputFile); // 将录制的Sequence写入文件
                    System.out.println("MIDI数据已保存到: " + outputFile.getAbsolutePath());
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
                // 停止定时器并退出程序
                ((Timer) e.getSource()).stop();
                System.exit(0);
            }).start();

            // 保持主线程活跃，等待定时器触发退出
            Thread.currentThread().join();

        } finally {
            // 6. 确保所有资源都被关闭
            if (customReceiverTransmitter != null) customReceiverTransmitter.close();
            if (sequencerTransmitter != null) sequencerTransmitter.close();
            if (myReceiver != null) myReceiver.close();
            if (sequencer != null && sequencer.isOpen()) sequencer.close();
            if (inputDevice != null && inputDevice.isOpen()) inputDevice.close();
            System.out.println("所有MIDI资源已关闭。");
        }
    }
}

在这个示例中，我们通过inputDevice.getTransmitter()两次获取了两个独立的Transmitter实例。一个用于连接到我们的MyReceiver进行实时打印，另一个连接到sequencer.getReceiver()进行录制。这样，来自MIDI输入设备的事件会同时发送到两个不同的接收器，实现并行处理。

总结

通过实现javax.sound.midi.Receiver接口，Java开发者可以轻松地从实时MIDI乐器获取并处理MIDI输入流。这种方法提供了灵活的回调机制，允许应用程序对每个MIDI消息进行即时响应。结合Sequencer，我们还可以实现同时的实时监听和MIDI数据录制。在实际开发中，请务必注意线程安全和资源管理，以确保应用程序的稳定性和性能。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。