android/WALT/app/src/main/java/org/chromium/latency/walt/MidiTest.java - platform/external/walt - Git at Google

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.chromium.latency.walt;

 import android.annotation.TargetApi;
 import android.content.Context;
 import android.media.midi.MidiDevice;
 import android.media.midi.MidiDeviceInfo;
 import android.media.midi.MidiInputPort;
 import android.media.midi.MidiManager;
 import android.media.midi.MidiOutputPort;
 import android.media.midi.MidiReceiver;
 import android.os.Handler;

 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Locale;

 import static org.chromium.latency.walt.Utils.getIntPreference;

 @TargetApi(23)
 class MidiTest extends BaseTest {

     private Handler handler = new Handler();

     private static final String TEENSY_MIDI_NAME = "Teensyduino Teensy MIDI";
     private static final byte[] noteMsg = {(byte) 0x90, (byte) 99, (byte) 0};

     private MidiManager midiManager;
     private MidiDevice midiDevice;
     // Output and Input here are with respect to the MIDI device, not the Android device.
     private MidiOutputPort midiOutputPort;
     private MidiInputPort midiInputPort;
     private boolean isConnecting = false;
     private long last_tWalt = 0;
     private long last_tSys = 0;
     private long last_tJava = 0;
     private int inputSyncAfterRepetitions = 100;
     private int outputSyncAfterRepetitions = 20; // TODO: implement periodic clock sync for output
     private int inputRepetitions;
     private int outputRepetitions;
     private int repetitionsDone;
     private ArrayList<Double> deltasToSys = new ArrayList<>();
     ArrayList<Double> deltasInputTotal = new ArrayList<>();
     ArrayList<Double> deltasOutputTotal = new ArrayList<>();

     private static final int noteDelay = 300;
     private static final int timeout = 1000;

     MidiTest(Context context) {
         super(context);
         inputRepetitions = getIntPreference(context, R.string.preference_midi_in_reps, 100);
         outputRepetitions = getIntPreference(context, R.string.preference_midi_out_reps, 10);
         midiManager = (MidiManager) context.getSystemService(Context.MIDI_SERVICE);
         findMidiDevice();
     }

     MidiTest(Context context, AutoRunFragment.ResultHandler resultHandler) {
         this(context);
         this.resultHandler = resultHandler;
     }

     void setInputRepetitions(int repetitions) {
         inputRepetitions = repetitions;
     }

     void setOutputRepetitions(int repetitions) {
         outputRepetitions = repetitions;
     }

     void testMidiOut() {
         if (midiDevice == null) {
             if (isConnecting) {
                 logger.log("Still connecting...");
                 handler.post(new Runnable() {
                     @Override
                     public void run() {
                         testMidiOut();
                     }
                 });
             } else {
                 logger.log("MIDI device is not open!");
                 if (testStateListener != null) testStateListener.onTestStoppedWithError();
             }
             return;
         }
         try {
             setupMidiOut();
         } catch (IOException e) {
             logger.log("Error setting up test: " + e.getMessage());
             if (testStateListener != null) testStateListener.onTestStoppedWithError();
             return;
         }
         handler.postDelayed(cancelMidiOutRunnable, noteDelay * inputRepetitions + timeout);
     }

     void testMidiIn() {
         if (midiDevice == null) {
             if (isConnecting) {
                 logger.log("Still connecting...");
                 handler.post(new Runnable() {
                     @Override
                     public void run() {
                         testMidiIn();
                     }
                 });
             } else {
                 logger.log("MIDI device is not open!");
                 if (testStateListener != null) testStateListener.onTestStoppedWithError();
             }
             return;
         }
         try {
             setupMidiIn();
         } catch (IOException e) {
             logger.log("Error setting up test: " + e.getMessage());
             if (testStateListener != null) testStateListener.onTestStoppedWithError();
             return;
         }
         handler.postDelayed(requestNoteRunnable, noteDelay);
     }

     private void setupMidiOut() throws IOException {
         repetitionsDone = 0;
         deltasInputTotal.clear();
         deltasOutputTotal.clear();

         midiInputPort = midiDevice.openInputPort(0);

         waltDevice.syncClock();
         waltDevice.command(WaltDevice.CMD_MIDI);
         waltDevice.startListener();
         waltDevice.setTriggerHandler(triggerHandler);

         scheduleNotes();
     }

     private void findMidiDevice() {
         MidiDeviceInfo[] infos = midiManager.getDevices();
         for(MidiDeviceInfo info : infos) {
             String name = info.getProperties().getString(MidiDeviceInfo.PROPERTY_NAME);
             logger.log("Found MIDI device named " + name);
             if(TEENSY_MIDI_NAME.equals(name)) {
                 logger.log("^^^ using this device ^^^");
                 isConnecting = true;
                 midiManager.openDevice(info, new MidiManager.OnDeviceOpenedListener() {
                     @Override
                     public void onDeviceOpened(MidiDevice device) {
                         if (device == null) {
                             logger.log("Error, unable to open MIDI device");
                         } else {
                             logger.log("Opened MIDI device successfully!");
                             midiDevice = device;
                         }
                         isConnecting = false;
                     }
                 }, null);
                 break;
             }
         }
     }

     private WaltDevice.TriggerHandler triggerHandler = new WaltDevice.TriggerHandler() {
         @Override
         public void onReceive(WaltDevice.TriggerMessage tmsg) {
             last_tWalt = tmsg.t + waltDevice.clock.baseTime;
             double dt = (last_tWalt - last_tSys) / 1000.;

             deltasOutputTotal.add(dt);
             logger.log(String.format(Locale.US, "Note detected: latency of %.3f ms", dt));
             if (testStateListener != null) testStateListener.onTestPartialResult(dt);
             if (traceLogger != null) {
                 traceLogger.log(last_tSys, last_tWalt, "MIDI Output",
                         "Bar starts when system sends audio and ends when WALT receives note");
             }

             last_tSys += noteDelay * 1000;
             repetitionsDone++;

             if (repetitionsDone < outputRepetitions) {
                 try {
                     waltDevice.command(WaltDevice.CMD_MIDI);
                 } catch (IOException e) {
                     logger.log("Failed to send command CMD_MIDI: " + e.getMessage());
                 }
             } else {
                 finishMidiOut();
             }
         }
     };

     private void scheduleNotes() {
         if(midiInputPort == null) {
             logger.log("midiInputPort is not open");
             return;
         }
         long t = System.nanoTime() + ((long) noteDelay) * 1000000L;
         try {
             // TODO: only schedule some, then sync clock
             for (int i = 0; i < outputRepetitions; i++) {
                 midiInputPort.send(noteMsg, 0, noteMsg.length, t + ((long) noteDelay) * 1000000L * i);
             }
         } catch(IOException e) {
             logger.log("Unable to schedule note: " + e.getMessage());
             return;
         }
         last_tSys = t / 1000;
     }

     private void finishMidiOut() {
         logger.log("All notes detected");
         logger.log(String.format(
                 Locale.US, "Median total output latency %.1f ms", Utils.median(deltasOutputTotal)));

         handler.removeCallbacks(cancelMidiOutRunnable);

         if (resultHandler != null) {
             resultHandler.onResult(deltasOutputTotal);
         }
         if (testStateListener != null) testStateListener.onTestStopped();
         if (traceLogger != null) traceLogger.flush(context);
         teardownMidiOut();
     }

     private Runnable cancelMidiOutRunnable = new Runnable() {
         @Override
         public void run() {
             logger.log("Timed out waiting for notes to be detected by WALT");
             if (testStateListener != null) testStateListener.onTestStoppedWithError();
             teardownMidiOut();
         }
     };

     private void teardownMidiOut() {
         try {
             midiInputPort.close();
         } catch(IOException e) {
             logger.log("Error, failed to close input port: " + e.getMessage());
         }

         waltDevice.stopListener();
         waltDevice.clearTriggerHandler();
         waltDevice.checkDrift();
     }

     private Runnable requestNoteRunnable = new Runnable() {
         @Override
         public void run() {
             logger.log("Requesting note from WALT...");
             String s;
             try {
                 s = waltDevice.command(WaltDevice.CMD_NOTE);
             } catch (IOException e) {
                 logger.log("Error sending NOTE command: " + e.getMessage());
                 if (testStateListener != null) testStateListener.onTestStoppedWithError();
                 return;
             }
             last_tWalt = Integer.parseInt(s);
             handler.postDelayed(finishMidiInRunnable, timeout);
         }
     };

     private Runnable finishMidiInRunnable = new Runnable() {
         @Override
         public void run() {
             waltDevice.checkDrift();

             logger.log("deltas: " + deltasToSys.toString());
             logger.log("MIDI Input Test Results:");
             logger.log(String.format(Locale.US,
                     "Median MIDI subsystem latency %.1f ms\nMedian total latency %.1f ms",
                     Utils.median(deltasToSys), Utils.median(deltasInputTotal)
             ));

             if (resultHandler != null) {
                 resultHandler.onResult(deltasToSys, deltasInputTotal);
             }
             if (testStateListener != null) testStateListener.onTestStopped();
             if (traceLogger != null) traceLogger.flush(context);
             teardownMidiIn();
         }
     };

     private class WaltReceiver extends MidiReceiver {
         public void onSend(byte[] data, int offset,
                            int count, long timestamp) throws IOException {
             if(count > 0 && data[offset] == (byte) 0x90) { // NoteOn message on channel 1
                 handler.removeCallbacks(finishMidiInRunnable);
                 last_tJava = waltDevice.clock.micros();
                 last_tSys = timestamp / 1000 - waltDevice.clock.baseTime;

                 final double d1 = (last_tSys - last_tWalt) / 1000.;
                 final double d2 = (last_tJava - last_tSys) / 1000.;
                 final double dt = (last_tJava - last_tWalt) / 1000.;
                 logger.log(String.format(Locale.US,
                         "Result: Time to MIDI subsystem = %.3f ms, Time to Java = %.3f ms, " +
                                 "Total = %.3f ms",
                         d1, d2, dt));
                 deltasToSys.add(d1);
                 deltasInputTotal.add(dt);
                 if (testStateListener != null) {
                     handler.post(new Runnable() {
                         @Override
                         public void run() {
                             testStateListener.onTestPartialResult(dt);
                         }
                     });
                 }
                 if (traceLogger != null) {
                     traceLogger.log(last_tWalt + waltDevice.clock.baseTime,
                             last_tSys + waltDevice.clock.baseTime, "MIDI Input Subsystem",
                             "Bar starts when WALT sends note and ends when received by MIDI subsystem");
                     traceLogger.log(last_tSys + waltDevice.clock.baseTime,
                             last_tJava + waltDevice.clock.baseTime, "MIDI Input Java",
                             "Bar starts when note received by MIDI subsystem and ends when received by app");
                 }

                 repetitionsDone++;
                 if (repetitionsDone % inputSyncAfterRepetitions == 0) {
                     try {
                         waltDevice.syncClock();
                     } catch (IOException e) {
                         logger.log("Error syncing clocks: " + e.getMessage());
                         handler.post(finishMidiInRunnable);
                         return;
                     }
                 }
                 if (repetitionsDone < inputRepetitions) {
                     handler.post(requestNoteRunnable);
                 } else {
                     handler.post(finishMidiInRunnable);
                 }
             } else {
                 logger.log(String.format(Locale.US, "Expected 0x90, got 0x%x and count was %d",
                         data[offset], count));
             }
         }
     }

     private void setupMidiIn() throws IOException {
         repetitionsDone = 0;
         deltasInputTotal.clear();
         deltasOutputTotal.clear();
         midiOutputPort = midiDevice.openOutputPort(0);
         midiOutputPort.connect(new WaltReceiver());
         waltDevice.syncClock();
     }

     private void teardownMidiIn() {
         handler.removeCallbacks(requestNoteRunnable);
         handler.removeCallbacks(finishMidiInRunnable);
         try {
             midiOutputPort.close();
         } catch (IOException e) {
             logger.log("Error, failed to close output port: " + e.getMessage());
         }
     }
 }
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.chromium.latency.walt;

	import android.annotation.TargetApi;
	import android.content.Context;
	import android.media.midi.MidiDevice;
	import android.media.midi.MidiDeviceInfo;
	import android.media.midi.MidiInputPort;
	import android.media.midi.MidiManager;
	import android.media.midi.MidiOutputPort;
	import android.media.midi.MidiReceiver;
	import android.os.Handler;

	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.Locale;

	import static org.chromium.latency.walt.Utils.getIntPreference;

	@TargetApi(23)
	class MidiTest extends BaseTest {

	private Handler handler = new Handler();

	private static final String TEENSY_MIDI_NAME = "Teensyduino Teensy MIDI";
	private static final byte[] noteMsg = {(byte) 0x90, (byte) 99, (byte) 0};

	private MidiManager midiManager;
	private MidiDevice midiDevice;
	// Output and Input here are with respect to the MIDI device, not the Android device.
	private MidiOutputPort midiOutputPort;
	private MidiInputPort midiInputPort;
	private boolean isConnecting = false;
	private long last_tWalt = 0;
	private long last_tSys = 0;
	private long last_tJava = 0;
	private int inputSyncAfterRepetitions = 100;
	private int outputSyncAfterRepetitions = 20; // TODO: implement periodic clock sync for output
	private int inputRepetitions;
	private int outputRepetitions;
	private int repetitionsDone;
	private ArrayList<Double> deltasToSys = new ArrayList<>();
	ArrayList<Double> deltasInputTotal = new ArrayList<>();
	ArrayList<Double> deltasOutputTotal = new ArrayList<>();

	private static final int noteDelay = 300;
	private static final int timeout = 1000;

	MidiTest(Context context) {
	super(context);
	inputRepetitions = getIntPreference(context, R.string.preference_midi_in_reps, 100);
	outputRepetitions = getIntPreference(context, R.string.preference_midi_out_reps, 10);
	midiManager = (MidiManager) context.getSystemService(Context.MIDI_SERVICE);
	findMidiDevice();
	}

	MidiTest(Context context, AutoRunFragment.ResultHandler resultHandler) {
	this(context);
	this.resultHandler = resultHandler;
	}

	void setInputRepetitions(int repetitions) {
	inputRepetitions = repetitions;
	}

	void setOutputRepetitions(int repetitions) {
	outputRepetitions = repetitions;
	}

	void testMidiOut() {
	if (midiDevice == null) {
	if (isConnecting) {
	logger.log("Still connecting...");
	handler.post(new Runnable() {
	@Override
	public void run() {
	testMidiOut();
	}
	});
	} else {
	logger.log("MIDI device is not open!");
	if (testStateListener != null) testStateListener.onTestStoppedWithError();
	}
	return;
	}
	try {
	setupMidiOut();
	} catch (IOException e) {
	logger.log("Error setting up test: " + e.getMessage());
	if (testStateListener != null) testStateListener.onTestStoppedWithError();
	return;
	}
	handler.postDelayed(cancelMidiOutRunnable, noteDelay * inputRepetitions + timeout);
	}

	void testMidiIn() {
	if (midiDevice == null) {
	if (isConnecting) {
	logger.log("Still connecting...");
	handler.post(new Runnable() {
	@Override
	public void run() {
	testMidiIn();
	}
	});
	} else {
	logger.log("MIDI device is not open!");
	if (testStateListener != null) testStateListener.onTestStoppedWithError();
	}
	return;
	}
	try {
	setupMidiIn();
	} catch (IOException e) {
	logger.log("Error setting up test: " + e.getMessage());
	if (testStateListener != null) testStateListener.onTestStoppedWithError();
	return;
	}
	handler.postDelayed(requestNoteRunnable, noteDelay);
	}

	private void setupMidiOut() throws IOException {
	repetitionsDone = 0;
	deltasInputTotal.clear();
	deltasOutputTotal.clear();

	midiInputPort = midiDevice.openInputPort(0);

	waltDevice.syncClock();
	waltDevice.command(WaltDevice.CMD_MIDI);
	waltDevice.startListener();
	waltDevice.setTriggerHandler(triggerHandler);

	scheduleNotes();
	}

	private void findMidiDevice() {
	MidiDeviceInfo[] infos = midiManager.getDevices();
	for(MidiDeviceInfo info : infos) {
	String name = info.getProperties().getString(MidiDeviceInfo.PROPERTY_NAME);
	logger.log("Found MIDI device named " + name);
	if(TEENSY_MIDI_NAME.equals(name)) {
	logger.log("^^^ using this device ^^^");
	isConnecting = true;
	midiManager.openDevice(info, new MidiManager.OnDeviceOpenedListener() {
	@Override
	public void onDeviceOpened(MidiDevice device) {
	if (device == null) {
	logger.log("Error, unable to open MIDI device");
	} else {
	logger.log("Opened MIDI device successfully!");
	midiDevice = device;
	}
	isConnecting = false;
	}
	}, null);
	break;
	}
	}
	}

	private WaltDevice.TriggerHandler triggerHandler = new WaltDevice.TriggerHandler() {
	@Override
	public void onReceive(WaltDevice.TriggerMessage tmsg) {
	last_tWalt = tmsg.t + waltDevice.clock.baseTime;
	double dt = (last_tWalt - last_tSys) / 1000.;

	deltasOutputTotal.add(dt);
	logger.log(String.format(Locale.US, "Note detected: latency of %.3f ms", dt));
	if (testStateListener != null) testStateListener.onTestPartialResult(dt);
	if (traceLogger != null) {
	traceLogger.log(last_tSys, last_tWalt, "MIDI Output",
	"Bar starts when system sends audio and ends when WALT receives note");
	}

	last_tSys += noteDelay * 1000;
	repetitionsDone++;

	if (repetitionsDone < outputRepetitions) {
	try {
	waltDevice.command(WaltDevice.CMD_MIDI);
	} catch (IOException e) {
	logger.log("Failed to send command CMD_MIDI: " + e.getMessage());
	}
	} else {
	finishMidiOut();
	}
	}
	};

	private void scheduleNotes() {
	if(midiInputPort == null) {
	logger.log("midiInputPort is not open");
	return;
	}
	long t = System.nanoTime() + ((long) noteDelay) * 1000000L;
	try {
	// TODO: only schedule some, then sync clock
	for (int i = 0; i < outputRepetitions; i++) {
	midiInputPort.send(noteMsg, 0, noteMsg.length, t + ((long) noteDelay) * 1000000L * i);
	}
	} catch(IOException e) {
	logger.log("Unable to schedule note: " + e.getMessage());
	return;
	}
	last_tSys = t / 1000;
	}

	private void finishMidiOut() {
	logger.log("All notes detected");
	logger.log(String.format(
	Locale.US, "Median total output latency %.1f ms", Utils.median(deltasOutputTotal)));

	handler.removeCallbacks(cancelMidiOutRunnable);

	if (resultHandler != null) {
	resultHandler.onResult(deltasOutputTotal);
	}
	if (testStateListener != null) testStateListener.onTestStopped();
	if (traceLogger != null) traceLogger.flush(context);
	teardownMidiOut();
	}

	private Runnable cancelMidiOutRunnable = new Runnable() {
	@Override
	public void run() {
	logger.log("Timed out waiting for notes to be detected by WALT");
	if (testStateListener != null) testStateListener.onTestStoppedWithError();
	teardownMidiOut();
	}
	};

	private void teardownMidiOut() {
	try {
	midiInputPort.close();
	} catch(IOException e) {
	logger.log("Error, failed to close input port: " + e.getMessage());
	}

	waltDevice.stopListener();
	waltDevice.clearTriggerHandler();
	waltDevice.checkDrift();
	}

	private Runnable requestNoteRunnable = new Runnable() {
	@Override
	public void run() {
	logger.log("Requesting note from WALT...");
	String s;
	try {
	s = waltDevice.command(WaltDevice.CMD_NOTE);
	} catch (IOException e) {
	logger.log("Error sending NOTE command: " + e.getMessage());
	if (testStateListener != null) testStateListener.onTestStoppedWithError();
	return;
	}
	last_tWalt = Integer.parseInt(s);
	handler.postDelayed(finishMidiInRunnable, timeout);
	}
	};

	private Runnable finishMidiInRunnable = new Runnable() {
	@Override
	public void run() {
	waltDevice.checkDrift();

	logger.log("deltas: " + deltasToSys.toString());
	logger.log("MIDI Input Test Results:");
	logger.log(String.format(Locale.US,
	"Median MIDI subsystem latency %.1f ms\nMedian total latency %.1f ms",
	Utils.median(deltasToSys), Utils.median(deltasInputTotal)
	));

	if (resultHandler != null) {
	resultHandler.onResult(deltasToSys, deltasInputTotal);
	}
	if (testStateListener != null) testStateListener.onTestStopped();
	if (traceLogger != null) traceLogger.flush(context);
	teardownMidiIn();
	}
	};

	private class WaltReceiver extends MidiReceiver {
	public void onSend(byte[] data, int offset,
	int count, long timestamp) throws IOException {
	if(count > 0 && data[offset] == (byte) 0x90) { // NoteOn message on channel 1
	handler.removeCallbacks(finishMidiInRunnable);
	last_tJava = waltDevice.clock.micros();
	last_tSys = timestamp / 1000 - waltDevice.clock.baseTime;

	final double d1 = (last_tSys - last_tWalt) / 1000.;
	final double d2 = (last_tJava - last_tSys) / 1000.;
	final double dt = (last_tJava - last_tWalt) / 1000.;
	logger.log(String.format(Locale.US,
	"Result: Time to MIDI subsystem = %.3f ms, Time to Java = %.3f ms, " +
	"Total = %.3f ms",
	d1, d2, dt));
	deltasToSys.add(d1);
	deltasInputTotal.add(dt);
	if (testStateListener != null) {
	handler.post(new Runnable() {
	@Override
	public void run() {
	testStateListener.onTestPartialResult(dt);
	}
	});
	}
	if (traceLogger != null) {
	traceLogger.log(last_tWalt + waltDevice.clock.baseTime,
	last_tSys + waltDevice.clock.baseTime, "MIDI Input Subsystem",
	"Bar starts when WALT sends note and ends when received by MIDI subsystem");
	traceLogger.log(last_tSys + waltDevice.clock.baseTime,
	last_tJava + waltDevice.clock.baseTime, "MIDI Input Java",
	"Bar starts when note received by MIDI subsystem and ends when received by app");
	}

	repetitionsDone++;
	if (repetitionsDone % inputSyncAfterRepetitions == 0) {
	try {
	waltDevice.syncClock();
	} catch (IOException e) {
	logger.log("Error syncing clocks: " + e.getMessage());
	handler.post(finishMidiInRunnable);
	return;
	}
	}
	if (repetitionsDone < inputRepetitions) {
	handler.post(requestNoteRunnable);
	} else {
	handler.post(finishMidiInRunnable);
	}
	} else {
	logger.log(String.format(Locale.US, "Expected 0x90, got 0x%x and count was %d",
	data[offset], count));
	}
	}
	}

	private void setupMidiIn() throws IOException {
	repetitionsDone = 0;
	deltasInputTotal.clear();
	deltasOutputTotal.clear();
	midiOutputPort = midiDevice.openOutputPort(0);
	midiOutputPort.connect(new WaltReceiver());
	waltDevice.syncClock();
	}

	private void teardownMidiIn() {
	handler.removeCallbacks(requestNoteRunnable);
	handler.removeCallbacks(finishMidiInRunnable);
	try {
	midiOutputPort.close();
	} catch (IOException e) {
	logger.log("Error, failed to close output port: " + e.getMessage());
	}
	}
	}