Quelle  IOLoop.java

/*
 * Copyright (c) 2002, 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

import java.io.ByteArrayOutputStream;

import javax.sound.midi.MidiDevice;
import javax.sound.midi.MidiMessage;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.Receiver;
import javax.sound.midi.ShortMessage;
import javax.sound.midi.SysexMessage;
import javax.sound.midi.Transmitter;

/**
 * @test
 * @bug 4782924
 * @bug 4812168
 * @bug 4356787
 * @summary MIDI i/o. This is an interactive test! Start it and follow the
 *          instructions.
 * @run main/manual IOLoop
 */
public class IOLoop {
    private static final int LONG_SYSEX_LENGTH = 2000;

    private static Receiver receiver;
    private static Transmitter transmitter;
    private static MidiMessage receivedMessage;
    private static ByteArrayOutputStream baos;
    private static int expectedBytes;
    private static int receivedBytes;
    private static Object lock = new Object();
    private static long lastTimestamp;

    public static void main(String[] args) throws Exception {
        ShortMessage sMsg = new ShortMessage();
        SysexMessage syMsg = new SysexMessage();
        boolean isTestPassed = true;
        boolean sysExTestPassed = true;
        boolean isTestExecuted = true;

        out("To run this test successfully, you need to have attached");
        out("  your MIDI out port with the MIDI in port.");

        MidiDevice inDev = null;
        MidiDevice outDev = null;

        // setup
        try {
            MidiDevice.Info[] infos = MidiSystem.getMidiDeviceInfo();

            int devNum = Integer.decode(args[0]).intValue();
            out("-> opening Transmitter from "+infos[devNum]);
            inDev = MidiSystem.getMidiDevice(infos[devNum]);
            inDev.open();
            transmitter = inDev.getTransmitter();
            Receiver testReceiver = new TestReceiver();
            transmitter.setReceiver(testReceiver);

            devNum = Integer.decode(args[1]).intValue();
            out("-> opening Receiver from "+infos[devNum]);
            outDev = MidiSystem.getMidiDevice(infos[devNum]);
            outDev.open();
            receiver = outDev.getReceiver();

        } catch (Exception e) {
            System.out.println(e);
            System.out.println("Cannot test!");
            return;
        }

        // test
        sMsg.setMessage(ShortMessage.NOTE_OFF | 0, 27, 100);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.NOTE_OFF | 0, 0, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.NOTE_OFF | 15, 127, 127);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.NOTE_ON | 4, 27, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.NOTE_ON | 0, 0, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.NOTE_ON | 15, 127, 127);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.POLY_PRESSURE | 11, 98, 99);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.POLY_PRESSURE | 0, 0, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.POLY_PRESSURE | 15, 127, 127);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.CONTROL_CHANGE | 13, 1, 63);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.CONTROL_CHANGE | 0, 0, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.CONTROL_CHANGE | 15, 127, 127);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.PROGRAM_CHANGE | 2, 120, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.PROGRAM_CHANGE | 0, 0, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.PROGRAM_CHANGE | 15, 127, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.CHANNEL_PRESSURE | 6, 30, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.CHANNEL_PRESSURE | 0, 0, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.CHANNEL_PRESSURE | 15, 127, 0);
        isTestPassed &= testMessage(sMsg);

        sMsg.setMessage(ShortMessage.PITCH_BEND | 6, 56, 4);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.PITCH_BEND | 0, 0, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.PITCH_BEND | 15, 127, 127);
        isTestPassed &= testMessage(sMsg);

        sMsg.setMessage(ShortMessage.MIDI_TIME_CODE, 0, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.MIDI_TIME_CODE, 127, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.SONG_POSITION_POINTER, 1, 77);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.SONG_POSITION_POINTER, 0, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.SONG_POSITION_POINTER, 127, 127);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.SONG_SELECT, 51, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.SONG_SELECT, 0, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.SONG_SELECT, 127, 0);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.TUNE_REQUEST);
        isTestPassed &= testMessage(sMsg);

        sMsg.setMessage(ShortMessage.TIMING_CLOCK);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.START);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.CONTINUE);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.STOP);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.ACTIVE_SENSING);
        isTestPassed &= testMessage(sMsg);
        sMsg.setMessage(ShortMessage.SYSTEM_RESET);
        isTestPassed &= testMessage(sMsg);

        syMsg.setMessage(new byte[]{(byte) 0xF0, (byte) 0xF7}, 2);
        isTestPassed &= testMessage(syMsg);
        syMsg.setMessage(new byte[]{(byte) 0xF0, 0x01, (byte) 0xF7}, 3);
        isTestPassed &= testMessage(syMsg);
        syMsg.setMessage(new byte[]{(byte) 0xF0, 0x02, 0x03, (byte) 0xF7}, 4);
        isTestPassed &= testMessage(syMsg);
        syMsg.setMessage(new byte[]{(byte) 0xF0, 0x04, 0x05, 0x06, (byte) 0xF7}, 5);
        isTestPassed &= testMessage(syMsg);

        if (isTestPassed) {
            byte[] sysexArray = new byte[LONG_SYSEX_LENGTH];
            sysexArray[0] = (byte) 0xF0;
            for (int i = 1; i < sysexArray.length; i++) {
                sysexArray[i] = (byte) (i % 0x80);
            }
//          syMsg.setMessage(new byte[]{(byte) 0xF7, (byte) ShortMessage.START}, 2);
//          sMsg.setMessage(ShortMessage.START);
//          isTestPassed &= testMessage(syMsg, sMsg, DEFAULT_SLEEP_INTERVALL);
            for (int trial = sysexArray.length; trial > 4; trial -= 1234) {
                sleep(500);
                sysexArray[trial - 1] = (byte) 0xF7;
                syMsg.setMessage(sysexArray, trial);
                sysExTestPassed &= testMessage(syMsg);
                break;
            }
        }

        // cleanup
        receiver.close();
        transmitter.close();
        inDev.close();
        outDev.close();

        if (isTestExecuted) {
            if (isTestPassed && sysExTestPassed) {

                out("Test PASSED.");
            } else {
                if (isTestPassed
                    && !sysExTestPassed
                    && (System.getProperty("os.name").startsWith("Windows"))) {
                    out("Some Windows MIDI i/o drivers have a problem with larger ");
                    out("sys ex messages. The failing sys ex cases are OK, therefore.");
                    out("Test PASSED.");
                } else {
                    throw new Exception("Test FAILED.");
                }
            }
        } else {
            out("Test NOT FAILED");
        }
    }

    private static boolean testMessage(MidiMessage message) {
        receivedMessage = null;
        baos = new ByteArrayOutputStream();
        expectedBytes = message.getLength();
        receivedBytes = 0;
        System.out.print("Sending message " + getMessageString(message.getMessage())+"...");
        receiver.send(message, -1);
        /* sending 3 bytes can roughly be done in 1 millisecond,
         * so this estimate waits at max 3 times longer than the message takes,
         * plus a little offset to allow the MIDI subsystem some processing time
         */
        int offset = 300; // standard offset 100 millis
        if (message instanceof SysexMessage) {
            // add a little processing time to sysex messages
            offset += 1000;
        }
        if (receivedBytes < expectedBytes) {
            sleep(expectedBytes + offset);
        }
        boolean equal;
        byte[] data = baos.toByteArray();
        if (data.length > 0) {
            equal = messagesEqual(message.getMessage(), data);
        } else {
            equal = messagesEqual(message, receivedMessage);
            if (receivedMessage != null) {
                data = receivedMessage.getMessage();
            } else {
                data = null;
            }
        }
        if (!equal) {
            if ((message.getStatus() & 0xF0) == ShortMessage.PITCH_BEND) {
                out("NOT failed (may expose a bug in ALSA)");
                equal = true;
                sleep(100);
            }
            if ((message.getStatus() == 0xF6) && (message.getLength() == 1)) {
                out("NOT failed (may expose an issue on Solaris)");
                equal = true;
                sleep(100);
            }
            else if ((message.getStatus()) == 0xF0 && message.getLength() < 4) {
                out("NOT failed (not a correct sys ex message)");
                equal = true;
                sleep(200);
            } else {
                out("FAILED:");
                out("  received as " + getMessageString(data));
            }
        } else {
            System.out.println("OK");
        }
        return equal;
    }

    private static void sleep(int milliseconds) {
        synchronized(lock) {
            try {
                lock.wait(milliseconds);
            } catch (InterruptedException e) {
            }
        }
    }

    private static String getMessageString(byte[] data) {
        String s;
        if (data == null) {
            s = "<null>";
        } else if (data.length == 0) {
            s = "0-sized array";
        } else {
            int status = data[0] & 0xFF;
            if (data.length <= 3) {
                if (status < 240) {
                    s = "command 0x" + Integer.toHexString(status & 0xF0) + " channel " + (status & 0x0F);
                } else {
                    s = "status 0x" + Integer.toHexString(status);
                }
                if (data.length > 1) {
                    s += " data 0x" + Integer.toHexString(data[1] & 0xFF);
                    if (data.length > 2) {
                        s += " 0x" + Integer.toHexString(data[2] & 0xFF);
                    }
                }
            } else {
                s = "status " + Integer.toHexString(status)+" and length "+data.length+" bytes";
            }
        }
        return s;
    }

    private static boolean messagesEqual(MidiMessage m1, MidiMessage m2) {
        if (m1 == null || m2 == null) {
            return false;
        }
        if (m1.getLength() != m2.getLength()) {
            return false;
        }
        byte[] array1 = m1.getMessage();
        byte[] array2 = m2.getMessage();
        return messagesEqual(array1, array2);
    }

    private static boolean messagesEqual(byte[] a1, byte[] a2) {
        if (a1.length != a2.length) return false;
        for (int i = 0; i < a1.length; i++) {
            if (a1[i] != a2[i]) {
                return false;
            }
        }
        return true;
    }

    private static void out(String s) {
        System.out.println(s);
        System.out.flush();
    }

    private static String canIn(MidiDevice dev) {
        if (dev.getMaxTransmitters() != 0) {
            return "IN ";
        }
        return "   ";
    }

    private static String canOut(MidiDevice dev) {
        if (dev.getMaxReceivers() != 0) {
            return "OUT ";
        }
        return "   ";
    }


    private static void checkTimestamp(long timestamp) {
        // out("checking timestamp...");
        if (timestamp < 1) {
            out("timestamp 0 or negative!");
        }
        if (timestamp < lastTimestamp) {
            out("timestamp not progressive!");
        }
        lastTimestamp = timestamp;
    }

    private static class TestReceiver implements Receiver {
        public void send(MidiMessage message, long timestamp) {
            //System.out.print(""+message.getLength()+"..");
            checkTimestamp(timestamp);
            try {
                receivedMessage = message;
                if (message.getStatus() == 0xF0
                    || (message.getLength() > 3 && message.getStatus() != 0xF7)) {
                    // sys ex message
                    byte[] data = message.getMessage();
                    baos.write(data);
                    receivedBytes += data.length;
                }
                else if (message.getStatus() == 0xF7) {
                    // sys ex cont'd message
                    byte[] data = message.getMessage();
                    // ignore the prepended 0xF7
                    baos.write(data, 1, data.length-1);
                    receivedBytes += (data.length - 1);
                } else {
                    receivedBytes += message.getLength();
                }
                if (receivedBytes >= expectedBytes) {
                    synchronized(lock) {
                        lock.notify();
                    }
                }
                System.out.print(""+receivedBytes+"..");

            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        public void close() {
        }
    }
}