2 * DOUBLE BLACK DIAMOND DOUBLE BLACK DIAMOND
5 * ///\\\ ///\\\ ///\\\ ///\\\
6 * \\\/// \\\/// \\\/// \\\///
9 * EXPERTS ONLY!! EXPERTS ONLY!!
11 * This file defines the MIDI mapping interfaces. This shouldn't
12 * need editing unless you're adding top level support for a
13 * specific MIDI device of some sort. Generally, all MIDI devices
14 * will just work with the default configuration, and you can
15 * set your SCPattern class to respond to the controllers that you
19 interface MidiEngineListener {
20 public void onFocusedDeck(int deckIndex);
25 public final GridController grid;
26 private final List<MidiEngineListener> listeners = new ArrayList<MidiEngineListener>();
27 private final List<SCMidiInput> midiControllers = new ArrayList<SCMidiInput>();
29 public MidiEngine addListener(MidiEngineListener l) {
34 public MidiEngine removeListener(MidiEngineListener l) {
39 private SCMidiInput midiQwertyKeys;
40 private SCMidiInput midiQwertyAPC;
42 private int activeDeckIndex = 0;
45 grid = new GridController(this);
46 midiControllers.add(midiQwertyKeys = new VirtualKeyMidiInput(this, VirtualKeyMidiInput.KEYS));
47 midiControllers.add(midiQwertyAPC = new VirtualKeyMidiInput(this, VirtualKeyMidiInput.APC));
49 for (MidiInputDevice device : RWMidi.getInputDevices()) {
50 if (device.getName().contains("APC")) {
56 for (MidiInputDevice device : RWMidi.getInputDevices()) {
57 if (device.getName().contains("APC")) {
59 if (apcCount > 1 && apcIndex < 2) {
62 midiControllers.add(new APC40MidiInput(this, device, apcDeck).setEnabled(true));
63 } else if (device.getName().contains("SLIDER/KNOB KORG")) {
64 midiControllers.add(new KorgNanoKontrolMidiInput(this, device).setEnabled(true));
65 } else if (device.getName().contains("Arturia MINILAB")) {
66 midiControllers.add(new ArturiaMinilabMidiInput(this, device).setEnabled(true));
69 device.getName().contains("KEYBOARD KORG") ||
70 device.getName().contains("Bus 1 Apple");
71 midiControllers.add(new GenericDeviceMidiInput(this, device).setEnabled(enabled));
76 for (MidiOutputDevice device : RWMidi.getOutputDevices()) {
77 if (device.getName().contains("APC")) {
79 if (apcCount > 1 && apcIndex < 2) {
82 new APC40MidiOutput(this, device, apcDeck);
87 public List<SCMidiInput> getControllers() {
88 return this.midiControllers;
91 public LXDeck getFocusedDeck() {
92 return lx.engine.getDeck(activeDeckIndex);
95 public SCPattern getFocusedPattern() {
96 return (SCPattern) getFocusedDeck().getActivePattern();
99 public MidiEngine setFocusedDeck(int deckIndex) {
100 if (this.activeDeckIndex != deckIndex) {
101 this.activeDeckIndex = deckIndex;
102 for (MidiEngineListener listener : listeners) {
103 listener.onFocusedDeck(deckIndex);
109 public boolean isQwertyEnabled() {
110 return midiQwertyKeys.isEnabled() || midiQwertyAPC.isEnabled();
114 public interface SCMidiInputListener {
115 public void onEnabled(SCMidiInput controller, boolean enabled);
118 public abstract class SCMidiInput extends AbstractScrollItem {
120 protected boolean enabled = false;
121 private final String name;
123 protected final MidiEngine midiEngine;
125 final List<SCMidiInputListener> listeners = new ArrayList<SCMidiInputListener>();
127 protected SCMidiInput(MidiEngine midiEngine, String name) {
128 this.midiEngine = midiEngine;
132 public SCMidiInput addListener(SCMidiInputListener l) {
137 public SCMidiInput removeListener(SCMidiInputListener l) {
142 public String getLabel() {
146 public boolean isEnabled() {
150 public boolean isSelected() {
154 public void onMousePressed() {
155 setEnabled(!enabled);
158 public SCMidiInput setEnabled(boolean enabled) {
159 if (enabled != this.enabled) {
160 this.enabled = enabled;
161 for (SCMidiInputListener l : listeners) {
162 l.onEnabled(this, enabled);
168 private boolean logMidi() {
169 return (uiMidi != null) && uiMidi.logMidi();
172 protected SCPattern getTargetPattern() {
173 return midiEngine.getFocusedPattern();
176 final void programChangeReceived(ProgramChange pc) {
181 println(getLabel() + " :: Program Change :: " + pc.getNumber());
183 handleProgramChange(pc);
186 final void controllerChangeReceived(rwmidi.Controller cc) {
191 println(getLabel() + " :: Controller :: " + cc.getChannel() + " :: " + cc.getCC() + ":" + cc.getValue());
193 if (!handleControllerChange(cc)) {
194 getTargetPattern().controllerChange(cc);
198 final void noteOnReceived(Note note) {
203 println(getLabel() + " :: Note On :: " + note.getChannel() + ":" + note.getPitch() + ":" + note.getVelocity());
205 if (!handleNoteOn(note)) {
206 getTargetPattern().noteOn(note);
210 final void noteOffReceived(Note note) {
215 println(getLabel() + " :: Note Off :: " + note.getChannel() + ":" + note.getPitch() + ":" + note.getVelocity());
217 if (!handleNoteOff(note)) {
218 getTargetPattern().noteOff(note);
222 // Subclasses may implement these to map top-level functionality
223 protected boolean handleProgramChange(ProgramChange pc) { return false; }
224 protected boolean handleControllerChange(rwmidi.Controller cc) { return false; }
225 protected boolean handleNoteOn(Note note) { return false; }
226 protected boolean handleNoteOff(Note note) { return false; }
229 public class VirtualKeyMidiInput extends SCMidiInput {
231 public static final int KEYS = 1;
232 public static final int APC = 2;
234 private final int mode;
236 private int octaveShift = 0;
241 NoteMeta(int channel, int number) {
242 this.channel = channel;
243 this.number = number;
247 final Map<Character, NoteMeta> keyToNote = new HashMap<Character, NoteMeta>();
249 VirtualKeyMidiInput(MidiEngine midiEngine, int mode) {
250 super(midiEngine, "QWERTY (" + (mode == APC ? "APC" : "Key") + " Mode)");
257 registerKeyEvent(this);
260 private void mapAPC() {
287 private void mapKeys() {
289 mapNote('a', 1, note++);
290 mapNote('w', 1, note++);
291 mapNote('s', 1, note++);
292 mapNote('e', 1, note++);
293 mapNote('d', 1, note++);
294 mapNote('f', 1, note++);
295 mapNote('t', 1, note++);
296 mapNote('g', 1, note++);
297 mapNote('y', 1, note++);
298 mapNote('h', 1, note++);
299 mapNote('u', 1, note++);
300 mapNote('j', 1, note++);
301 mapNote('k', 1, note++);
302 mapNote('o', 1, note++);
303 mapNote('l', 1, note++);
306 void mapNote(char ch, int channel, int number) {
307 keyToNote.put(ch, new NoteMeta(channel, number));
310 public void keyEvent(KeyEvent e) {
314 char c = Character.toLowerCase(e.getKeyChar());
315 NoteMeta nm = keyToNote.get(c);
318 case KeyEvent.KEY_PRESSED:
319 noteOnReceived(new Note(Note.NOTE_ON, nm.channel, nm.number + octaveShift*12, 127));
321 case KeyEvent.KEY_RELEASED:
322 noteOffReceived(new Note(Note.NOTE_OFF, nm.channel, nm.number + octaveShift*12, 0));
326 if ((mode == KEYS) && (e.getID() == KeyEvent.KEY_PRESSED)) {
329 octaveShift = constrain(octaveShift-1, -4, 4);
332 octaveShift = constrain(octaveShift+1, -4, 4);
339 public class GenericDeviceMidiInput extends SCMidiInput {
340 GenericDeviceMidiInput(MidiEngine midiEngine, MidiInputDevice d) {
341 super(midiEngine, d.getName().replace("Unknown vendor",""));
346 public class APC40MidiInput extends GenericDeviceMidiInput {
348 private boolean shiftOn = false;
349 private LXEffect releaseEffect = null;
350 final private LXDeck targetDeck;
352 APC40MidiInput(MidiEngine midiEngine, MidiInputDevice d) {
353 this(midiEngine, d, -1);
356 APC40MidiInput(MidiEngine midiEngine, MidiInputDevice d, int deckIndex) {
357 super(midiEngine, d);
358 targetDeck = (deckIndex < 0) ? null : lx.engine.getDecks().get(deckIndex);
361 protected LXDeck getTargetDeck() {
362 return (targetDeck != null) ? targetDeck : midiEngine.getFocusedDeck();
365 protected SCPattern getTargetPattern() {
366 if (targetDeck != null) {
367 return (SCPattern) (targetDeck.getActivePattern());
369 return super.getTargetPattern();
372 private class GridPosition {
373 public final int row, col;
374 GridPosition(int r, int c) {
380 private GridPosition getGridPosition(Note note) {
381 int channel = note.getChannel();
382 int pitch = note.getPitch();
384 if (pitch >= 53 && pitch <=57) return new GridPosition(pitch-53, channel);
389 private boolean handleGridNoteOn(Note note) {
390 GridPosition p = getGridPosition(note);
392 return midiEngine.grid.gridPressed(p.row, p.col);
397 private boolean handleGridNoteOff(Note note) {
398 GridPosition p = getGridPosition(note);
400 return midiEngine.grid.gridReleased(p.row, p.col);
405 protected boolean handleControllerChange(rwmidi.Controller cc) {
406 int channel = cc.getChannel();
407 int number = cc.getCC();
408 float value = cc.getValue() / 127.;
414 // effects.colorFucker.hueShift.setValue(value);
417 effects.colorFucker.desat.setValue(value);
420 effects.colorFucker.sharp.setValue(value);
423 effects.blur.amount.setValue(value);
426 effects.quantize.amount.setValue(value);
433 effects.colorFucker.level.setValue(value);
438 lx.engine.getDeck(GLucose.RIGHT_DECK).getFader().setValue(value);
443 float val = effects.colorFucker.hueShift.getValuef();
444 int cv = cc.getValue();
450 val += (cv - 64) / 300.;
451 effects.colorFucker.hueShift.setValue((val+1) % 1);
455 int parameterIndex = -1;
456 if (number >= 48 && number <= 55) {
457 parameterIndex = number - 48;
458 } else if (number >= 16 && number <= 19) {
459 parameterIndex = 8 + (number-16);
461 if (parameterIndex >= 0) {
462 List<LXParameter> parameters = getTargetPattern().getParameters();
463 if (parameterIndex < parameters.size()) {
464 parameters.get(parameterIndex).setValue(value);
469 if (number >= 20 && number <= 23) {
470 int effectIndex = number - 20;
471 List<LXParameter> parameters = glucose.getSelectedEffect().getParameters();
472 if (effectIndex < parameters.size()) {
473 parameters.get(effectIndex).setValue(value);
481 private long tap1 = 0;
483 private boolean lbtwn(long a, long b, long c) {
484 return a >= b && a <= c;
487 protected boolean handleNoteOn(Note note) {
488 if (handleGridNoteOn(note)) {
492 int nPitch = note.getPitch();
493 int nChan = note.getChannel();
499 effects.colorFucker.mono.setValue(1);
502 effects.colorFucker.invert.setValue(1);
505 lx.cycleBaseHue(60000);
511 effects.boom.trigger();
515 effects.flash.trigger();
519 getTargetPattern().reset();
523 // dan's dirty tapping mechanism
530 midiEngine.setFocusedDeck(GLucose.LEFT_DECK);
532 uiCrossfader.setDisplayMode("A");
537 uiCrossfader.setDisplayMode("COMP");
542 midiEngine.setFocusedDeck(GLucose.RIGHT_DECK);
544 uiCrossfader.setDisplayMode("B");
550 glucose.incrementSelectedEffectBy(-1);
552 getTargetDeck().goPrev();
556 case 95: // down bank
558 glucose.incrementSelectedEffectBy(1);
560 getTargetDeck().goNext();
568 case 99: // tap tempo
573 lx.tempo.setBpm(lx.tempo.bpm() + (shiftOn ? 1 : .1));
577 lx.tempo.setBpm(lx.tempo.bpm() - (shiftOn ? 1 : .1));
580 case 62: // Detail View / red 5
581 releaseEffect = glucose.getSelectedEffect();
582 if (releaseEffect.isMomentary()) {
583 releaseEffect.enable();
585 releaseEffect.toggle();
589 case 63: // rec quantize / red 6
590 glucose.getSelectedEffect().disable();
597 protected boolean handleNoteOff(Note note) {
598 if (handleGridNoteOff(note)) {
602 int nPitch = note.getPitch();
603 int nChan = note.getChannel();
610 effects.colorFucker.mono.setValue(0);
613 effects.colorFucker.invert.setValue(0);
616 lx.setBaseHue(lx.getBaseHue());
621 case 52: // CLIP STOP
622 if (nChan < PresetManager.NUM_PRESETS) {
624 presetManager.store(getTargetDeck(), nChan);
626 presetManager.select(getTargetDeck(), nChan);
632 long tapDelta = millis() - tap1;
633 if (lbtwn(tapDelta,5000,300*1000)) { // hackish tapping mechanism
634 double bpm = 32.*60000./(tapDelta);
635 while (bpm < 20) bpm*=2;
636 while (bpm > 40) bpm/=2;
637 lx.tempo.setBpm(bpm);
640 println("Tap Set - " + bpm + " bpm");
644 case 63: // rec quantize / RED 6
645 if (releaseEffect != null) {
646 if (releaseEffect.isMomentary()) {
647 releaseEffect.disable();
661 class KorgNanoKontrolMidiInput extends GenericDeviceMidiInput {
663 KorgNanoKontrolMidiInput(MidiEngine midiEngine, MidiInputDevice d) {
664 super(midiEngine, d);
667 protected boolean handleControllerChange(rwmidi.Controller cc) {
668 int number = cc.getCC();
669 if (number >= 16 && number <= 23) {
670 int parameterIndex = number - 16;
671 List<LXParameter> parameters = midiEngine.getFocusedPattern().getParameters();
672 if (parameterIndex < parameters.size()) {
673 parameters.get(parameterIndex).setValue(cc.getValue() / 127.);
678 if (cc.getValue() == 127) {
681 case 58: // Left track
682 midiEngine.setFocusedDeck(GLucose.LEFT_DECK);
685 case 59: // Right track
686 midiEngine.setFocusedDeck(GLucose.RIGHT_DECK);
689 case 43: // Left chevron
690 midiEngine.getFocusedDeck().goPrev();
693 case 44: // Right chevron
694 midiEngine.getFocusedDeck().goNext();
703 class APC40MidiOutput implements LXParameter.Listener, GridOutput {
705 private final MidiEngine midiEngine;
706 private final MidiOutput output;
707 private LXPattern focusedPattern = null;
708 private LXEffect focusedEffect = null;
709 private final LXDeck targetDeck;
711 APC40MidiOutput(MidiEngine midiEngine, MidiOutputDevice device) {
712 this(midiEngine, device, -1);
715 APC40MidiOutput(MidiEngine midiEngine, MidiOutputDevice device, int deckIndex) {
716 this.midiEngine = midiEngine;
717 output = device.createOutput();
718 targetDeck = (deckIndex < 0) ? null : lx.engine.getDecks().get(deckIndex);
719 setDPatternOutputs();
720 if (targetDeck != null) {
721 midiEngine.addListener(new MidiEngineListener() {
722 public void onFocusedDeck(int deckIndex) {
723 resetPatternParameters();
724 for (int i = 0; i < 8; ++i) {
725 output.sendNoteOn(i, 52, 0);
730 glucose.addEffectListener(new GLucose.EffectListener() {
731 public void effectSelected(LXEffect effect) {
732 resetEffectParameters();
735 LXDeck.Listener deckListener = new LXDeck.AbstractListener() {
736 public void patternDidChange(LXDeck deck, LXPattern pattern) {
737 if (deck == getTargetDeck()) {
738 resetPatternParameters();
742 for (LXDeck d : lx.engine.getDecks()) {
743 if (targetDeck == null || d == targetDeck) {
744 d.addListener(deckListener);
747 presetManager.addListener(new PresetListener() {
748 public void onPresetSelected(LXDeck deck, Preset preset) {
749 if (deck == getTargetDeck()) {
750 for (int i = 0; i < 8; ++i) {
751 output.sendNoteOn(i, 52, (preset.index == i) ? 1 : 0);
755 public void onPresetDirty(LXDeck deck, Preset preset) {
756 if (deck == getTargetDeck()) {
757 output.sendNoteOn(preset.index, 52, 2);
760 public void onPresetStored(LXDeck deck, Preset preset) {
761 onPresetSelected(deck, preset);
765 midiEngine.grid.addOutput(this);
767 lx.cycleBaseHue(60000);
768 output.sendNoteOn(6, 49, 127);
770 // Turn off the track selection lights and preset selectors
771 for (int i = 0; i < 8; ++i) {
772 output.sendNoteOn(i, 51, 0);
773 output.sendNoteOn(i, 52, 0);
776 // Turn off the MASTER selector
777 output.sendNoteOn(0, 80, 0);
780 private void setDPatternOutputs() {
781 for (LXDeck deck : lx.engine.getDecks()) {
782 if (targetDeck == null || deck == targetDeck) {
783 for (LXPattern pattern : deck.getPatterns()) {
784 if (pattern instanceof DPat) {
785 ((DPat)pattern).setAPCOutput(output);
792 protected LXDeck getTargetDeck() {
793 return (targetDeck != null) ? targetDeck : midiEngine.getFocusedDeck();
796 private void resetParameters() {
797 resetPatternParameters();
798 resetEffectParameters();
801 private void resetPatternParameters() {
802 LXPattern newPattern = getTargetDeck().getActivePattern();
803 if (newPattern == focusedPattern) {
806 if (focusedPattern != null) {
807 for (LXParameter p : focusedPattern.getParameters()) {
808 ((LXListenableParameter) p).removeListener(this);
811 focusedPattern = newPattern;
813 for (LXParameter p : focusedPattern.getParameters()) {
814 ((LXListenableParameter) p).addListener(this);
820 if (focusedPattern instanceof DPat) {
821 ((DPat)focusedPattern).updateLights();
823 for (int j = 0; j < 8; ++j) {
824 output.sendNoteOn(j, 48, 0);
826 for (int row = 0; row < 7; ++row) {
827 for (int col = 0; col < 8; ++col) {
828 setGridState(row, col, 0);
834 private void resetEffectParameters() {
835 LXEffect newEffect = glucose.getSelectedEffect();
836 if (newEffect == focusedEffect) {
839 if (focusedEffect != null) {
840 for (LXParameter p : focusedPattern.getParameters()) {
841 ((LXListenableParameter) p).removeListener(this);
844 focusedEffect = newEffect;
846 for (LXParameter p : focusedEffect.getParameters()) {
847 ((LXListenableParameter) p).addListener(this);
848 sendKnob(12 + i++, p);
851 sendKnob(12 + i++, 0);
855 private void sendKnob(int i, LXParameter p) {
856 sendKnob(i, (int) (p.getValuef() * 127.));
859 private void sendKnob(int i, int value) {
861 output.sendController(0, 48+i, value);
863 output.sendController(0, 8+i, value);
867 public void onParameterChanged(LXParameter parameter) {
869 for (LXParameter p : focusedPattern.getParameters()) {
870 if (p == parameter) {
877 for (LXParameter p : focusedEffect.getParameters()) {
878 if (p == parameter) {
886 public void setGridState(int row, int col, int state) {
887 if (col < 8 && row < 5) {
888 output.sendNoteOn(col, 53+row, state);
893 class ArturiaMinilabMidiInput extends GenericDeviceMidiInput {
894 ArturiaMinilabMidiInput(MidiEngine midiEngine, MidiInputDevice d) {
895 super(midiEngine, d);
898 protected boolean handleControllerChange(rwmidi.Controller cc) {
899 int parameterIndex = -1;
900 switch (cc.getCC()) {
901 case 7: parameterIndex = 0; break;
902 case 74: parameterIndex = 1; break;
903 case 71: parameterIndex = 2; break;
904 case 76: parameterIndex = 3; break;
905 case 114: parameterIndex = 4; break;
906 case 18: parameterIndex = 5; break;
907 case 19: parameterIndex = 6; break;
908 case 16: parameterIndex = 7; break;
911 float val = effects.colorFucker.hueShift.getValuef();
912 val += (cc.getValue() - 64) / 256.;
913 effects.colorFucker.hueShift.setValue((val+1) % 1);
916 if (parameterIndex >= 0) {
917 List<LXParameter> parameters = midiEngine.getFocusedPattern().getParameters();
918 if (parameterIndex < parameters.size()) {
919 LXParameter p = parameters.get(parameterIndex);
920 float curVal = p.getValuef();
921 curVal += (cc.getValue() - 64) / 127.;
922 p.setValue(constrain(curVal, 0, 1));
929 interface GridOutput {
930 public static final int OFF = 0;
931 public static final int GREEN = 1;
932 public static final int GREEN_BLINK = 2;
933 public static final int RED = 3;
934 public static final int RED_BLINK = 4;
935 public static final int YELLOW = 5;
936 public static final int YELLOW_BLINK = 6;
937 public static final int ON = 127;
939 public void setGridState(int row, int col, int state);
942 class GridController {
943 private final List<GridOutput> outputs = new ArrayList<GridOutput>();
945 private final MidiEngine midiEngine;
947 GridController(MidiEngine midiEngine) {
948 this.midiEngine = midiEngine;
951 public void addOutput(GridOutput output) {
955 public boolean gridPressed(int row, int col) {
956 return midiEngine.getFocusedPattern().gridPressed(row, col);
959 public boolean gridReleased(int row, int col) {
960 return midiEngine.getFocusedPattern().gridReleased(row, col);
963 public void setState(int row, int col, int state) {
964 for (GridOutput g : outputs) {
965 g.setGridState(row, col, state);