diff --git a/res/controllers/Pioneer-DDJ-SR2-scripts.js b/res/controllers/Pioneer-DDJ-SR2-scripts.js new file mode 100755 index 00000000000..f415083cc26 --- /dev/null +++ b/res/controllers/Pioneer-DDJ-SR2-scripts.js @@ -0,0 +1,1311 @@ +/* +Author: Waylon Robertson + Version: 2, 24/01/2021 + Description: Pioneer DDJ-SR2 Controller Mapping for Mixxx + Source: https://github.com/WaylonR/mixxx/tree/feat_Pioneer_DDJ_SR2 + + Copyright (c) 2024 Waylon Robertson, licensed under GPL version 2 or later + Copyright (c) 2014-2015 various contributors, base for this mapping, licensed under MIT license + + Contributors: + - DJMaxergy: original DDJ-SX mapping for Mixxx + - Michael Stahl (DG3NEC): original DDJ-SB2 mapping for Mixxx 2.0 + .- Sophia Herzog: midiAutoDJ-scripts + - Joan Ardiaca Jové (joan.ardiaca@gmail.com): Pioneer DDJ-SB mapping for Mixxx 2.0 + - wingcom (wwingcomm@gmail.com): start of Pioneer DDJ-SB mapping + https://github.com/wingcom/Mixxx-Pioneer-DDJ-SB + - Hilton Rudham: Pioneer DDJ-SR mapping + https://github.com/hrudham/Mixxx-Pioneer-DDJ-SR + - Jan Holthuis: Roland DJ-505 mapping + original brief: https://mixxx.discourse.group/t/roland-dj-505/17916 but now part of main. + + This program is free software; you can redistribute it and/or modify it under the terms of the + GNU General Public License as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program 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 for more details. + + You should have received a copy of the GNU General Public License along with this program; if + not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + + +*/ +// eslint-disable-next-line no-var +var DDJSR2 = {}; + +/////////////////////////////////////////////////////////////// +// USER OPTIONS // +/////////////////////////////////////////////////////////////// + +// Sets the jogwheels sensitivity. 1 is default, 2 is twice as sensitive, 0.5 is half as sensitive. +DDJSR2.jogwheelSensitivity = 2; + +// Sets how much more sensitive the jogwheels get when holding shift. +// Set to 1 to disable jogwheel sensitivity increase when holding shift (default: 10). +DDJSR2.jogwheelShiftMultiplier = 10; + +DDJSR2.rateRanges = [0.08, 0.16, 0.32, 0.64, 0.90, 1.00]; + +DDJSR2.scratchSettings = { + alpha: 1.0 / 8, + beta: 1.0 / 8 / 32, + wheelResolution: 51000, + vinylSpeed: 33 + 1 / 3, +}; + +// The following variables controls the wheel ring colors. +// If set to OFF - no ring color. +// If set to a color that's in the wheelLedCircleColor list (has to be in caps), sets the deck color to that. +// If set to TRACK - sets the color to what the track column says. +// If set to POSITION - Changes color as playposition changes. +DDJSR2.wheelColor =[]; +DDJSR2.wheelColor[1] = "TRACK"; // Deck 1 +DDJSR2.wheelColor[2] = "TRACK"; // Deck 2 +DDJSR2.wheelColor[3] = "TRACK"; // Deck 3 +DDJSR2.wheelColor[4] = "TRACK"; // Deck 4 + +DDJSR2.wheelLedCircleColor = { + OFF: 20, + TRACK: 127, + POSITION: 128, + PURPLE: 1, + MAGENTA: 2, + RED: 3, + BROWN: 4, + ORANGE: 5, + YELLOW: 6, + LIMEGREEN: 7, + GREEN: 8, + BRIGHTGREEN: 9, + CELESTE: 10, + CYAN: 11, + TURQUOISE: 12, + BRIGHTBLUE: 13, + AZURE: 14, + DARKBLUE: 15, + VIOLET: 16, + ULTRAVIOLET: 17, + WHITE: 18, + DIMWHITE: 19 +}; + +// minVal is the minimum value of the color ring, maxVal is the value of the last color possible, before the ring goes blank. +DDJSR2.wheelLedCircle = Object.freeze({ + minVal: 0, + maxVal: 0x13, + blink: 0x3 +}); + +DDJSR2.wheelColorMap = new ColorMapper({ + 0xCC0000: DDJSR2.wheelLedCircleColor.RED, + 0x008000: DDJSR2.wheelLedCircleColor.GREEN, + 0x0000CC: DDJSR2.wheelLedCircleColor.BLUE, + 0xFFFF00: DDJSR2.wheelLedCircleColor.YELLOW, + 0x0088CC: DDJSR2.wheelLedCircleColor.CELESTE, + 0xFF8800: DDJSR2.wheelLedCircleColor.ORANGE, + 0x895129: DDJSR2.wheelLedCircleColor.BROWN, + 0xFF00FF: DDJSR2.wheelLedCircleColor.MAGENTA, + 0xEE82EE: DDJSR2.wheelLedCircleColor.VIOLET, + 0x8800CC: DDJSR2.wheelLedCircleColor.PURPLE, + 0xFFFFFF: DDJSR2.wheelLedCircleColor.WHITE, +}); + + +//////////// +// Code. // +////////// + +DDJSR2.seratoHeartbeat=[0xF0, 0x00, 0x20, 0x7F, 0x50, 0x01, 0xF7]; // Serato Heartbeat +DDJSR2.seratoControlsPoll=[0xF0, 0x00, 0x20, 0x7F, 0x03, 0x01, 0xF7]; // Serato first poll + +DDJSR2.init = function() { + // Browser section is part of Mixer container for now. + + DDJSR2.browser = new DDJSR2.BrowserContainer(); + + DDJSR2.deck = []; + for (let i = 0; i < 4; i++) { + DDJSR2.deck[i] = new DDJSR2.Deck(i); + DDJSR2.deck[i].setCurrentDeck(`[Channel${i+1}]`); + } + + DDJSR2.mixer = new DDJSR2.MixerContainer(); + + DDJSR2.createEffectUnits(); + + // Performance pads are part of the Deck specs, as are Illumination Controls + + DDJSR2.seratoHeartbeatTimer = engine.beginTimer(200, DDJSR2.doSeratoHeartbeatTimer, false); + + // After 500 ms have elapsed, after the serato heartbeat has occurred, then poll controls. Calling this before time results in an unsuccessful poll. + + engine.beginTimer(300, function() { + midi.sendSysexMsg(DDJSR2.seratoControlsPoll, DDJSR2.seratoControlsPoll.length); + }, true); + +}; + +DDJSR2.doSeratoHeartbeatTimer = function() { + midi.sendSysexMsg(DDJSR2.seratoHeartbeat, DDJSR2.seratoHeartbeat.length); +}; + + +// First, a function library. +//////////////// + + +DDJSR2.getRotaryDelta = function(value) { + return value > 0x40 ? value - 0x80: value; +}; + +DDJSR2.getJogWheelDelta = function(value) { + // The Wheel control centers on 0x40; find out how much it's moved by. + return value - 0x40; +}; + +DDJSR2.RingBufferView = class { + constructor(indexable, startIndex = 0) { + this.indexable = indexable; + this.index = startIndex; + } + advanceBy(n) { + this.index = script.posMod(this.index + n, this.indexable.length); + return this.current(); + } + next() { + return this.advanceBy(1); + } + previous() { + return this.advanceBy(-1); + } + current() { + return this.indexable[this.index]; + } +}; + +DDJSR2.BrowserContainer = function() { + const browserInstance = this; + this.browseKnob = new components.ComponentContainer({ + turn: new components.Encoder({ + group: "[Library]", + inKey: "MoveVertical", + inValueScale: DDJSR2.getRotaryDelta + }), + press: new components.Button({ + group: "[Library]", + key: "GoToItem" + }), + shiftPress: new components.Button({ + group: "[Library]", + input: function(channel, control, value, status, _group) { + browserInstance.browseKnob.isPressed = this.isPress(channel, control, value, status); + if (browserInstance.browseKnob.isPressed) { + return; + } + if (browserInstance.browseKnob.trackColorChangeHappened) { + browserInstance.browseKnob.trackColorChangeHappened = false; + return; + } + if (!engine.getValue("[PreviewDeck1]", "play")) { + engine.setValue("[PreviewDeck1]", "LoadSelectedTrackAndPlay", 1); + } else { + script.triggerControl("[PreviewDeck1]", "stop"); + } + } + }), + shiftTurn: new components.Encoder({ + beatJumpSize: 8, + inValueScale: DDJSR2.getRotaryDelta, + inSetParameter: function(rotateValue) { + if (browserInstance.browseKnob.isPressed) { + const direction = rotateValue > 0 ? "next" : "prev"; + script.toggleControl("[Library]", `track_color_${direction}`); + browserInstance.browseKnob.trackColorChangeHappened = true; + } else { + engine.setValue("[PreviewDeck1]", "beatjump", rotateValue*this.beatJumpSize); + } + } + }) + }); + this.loadButtons = [0, 1, 3, 4].map(channelOffset => new components.Button({ + group: `[Channel${channelOffset+1}]`, + key: "LoadSelectedTrack", + midi: [0x9B, channelOffset] + })); + + this.sortLibraryBpm = new components.Button({ + inKey: "sort_column", + group: "[Library]", + type: components.Button.prototype.types.toggle, + inToggle: function() { + this.inSetValue(script.LIBRARY_COLUMNS.BPM); + } + }); + this.sortLibraryArtist = new components.Button({ + inKey: "sort_column", + group: "[Library]", + type: components.Button.prototype.types.toggle, + inToggle: function() { + this.inSetValue(script.LIBRARY_COLUMNS.ARTIST); + } + }); + + this.backButton = new components.Button({ + group: "[Library]", + inKey: "MoveFocusBackward" + }); + + this.shiftBackButton = new components.Button({ + group: "[Master]", + inKey: "maximize_library" + }); + + this.loadPrepareButton = new components.Button({ + group: "[Library]", + inKey: "AutoDjAddBottom" + }); + + this.loadPrepareButtonShifted = new components.Button({ + group: "[Library]", + inKey: "AutoDjAddTop" + }); + + +}; +DDJSR2.BrowserContainer.prototype = new components.ComponentContainer(); + +DDJSR2.Deck = function(channelOffset) { + const deckNumber = channelOffset + 1; + this.deckNumber = deckNumber; + this.group = `[Channel${ deckNumber }]`; + const theDeck = this; + components.Deck.call(this, deckNumber); + // ============================= TRANSPORT ================================== + this.play = new components.PlayButton({ + midi: [0x90+channelOffset, 0x0B] + }); + this.stutter = new components.Button({ + midi: [0x90+channelOffset, 0x47], + key: "play_stutter" + }); + this.cue = new components.CueButton({ + midi: [0x90 + channelOffset, 0x0C] + }); + this.cuerewind = new components.Button({ + midi: [0x90 + channelOffset, 0x48], + key: "start_stop" + }); + this.jog = new components.JogWheelBasic({ // Jog Wheel is crap on the SR2, takes a big swing around to even get one midi tick. Use Platter instead. + deck: deckNumber, + wheelResolution: DDJSR2.scratchSettings.wheelResolution, + alpha: DDJSR2.scratchSettings.alpha, + beta: DDJSR2.scratchSettings.beta, + vinylMode: false, // Set the default to match the SR2's default. + inValueScale: function(value) { + if (!this.vinylMode) { + return (DDJSR2.getJogWheelDelta(value) / 5) * DDJSR2.jogwheelSensitivity; + } else { + return value < 0x40 ? value - (this.max + 1) : value; + } + } + }); + this.tempoFader = new components.Pot({ + invert: true, + inKey: "rate" + }); + const rates = new DDJSR2.RingBufferView(DDJSR2.rateRanges); + this.tempoRange = new components.Button({ + inKey: "rateRange", + type: components.Button.prototype.types.toggle, + inToggle: function() { + this.inSetValue(rates.next()); + } + }); + this.tempoReset = new components.Button({ + inKey: "rate", + type: components.Button.prototype.types.toggle, + inToggle: function() { + this.inSetValue(0); + } + }); + this.keyLock = new components.Button({ + midi: [0x90 + channelOffset, 0x1A], + key: "keylock", + type: components.Button.prototype.types.toggle + }); + this.needleSearchStripPositionShifted = new components.Pot({ + group: theDeck.group, + inKey: "playposition" + }); + this.needleSearchStripPosition = new components.Pot({ + inKey: "playposition", + group: theDeck.group, + input: function(channel, control, value, status, group) { + if (engine.getParameter(this.group, "play")) { + return; + } + components.Pot.prototype.input.call(this, channel, control, value, status, group); + } + }); + this.sync = new components.Button({ + midi: [0x90 + channelOffset, 0x58], + key: "sync_enabled", + type: components.Button.prototype.types.toggle + }); + this.syncOff = new components.Button({ + midi: [0x90 + channelOffset, 0x5C], + inKey: "sync_enabled", + inValueScale: () => false + }); + this.autoLoop = new components.Button({ + midi: [0x90 + channelOffset, 0x14], + outKey: "loop_enabled", + input: function(channel, control, value, status, group) { + if (this.isPress(channel, control, value, status, group)) { + if (engine.getValue(group, "loop_enabled")) { + script.triggerControl(group, "reloop_toggle"); + } else { + script.triggerControl(group, "beatloop_activate"); + } + } + } + }); + + this.loopActive = new components.Button({ + midi: [0x90 + channelOffset, 0x50], + key: "loop_enabled", + type: components.Button.prototype.types.toggle, + }); + + this.loopHalve = new components.Button({ + midi: [0x90 + channelOffset, 0x12], + key: "loop_halve", + }); + + this.loopDouble = new components.Button({ + midi: [0x90 + channelOffset, 0x13], + key: "loop_double", + }); + + this.loopShiftBackward = new components.Button({ + midi: [0x90 + channelOffset, 0x61], + key: "beatjump_backward", + }); + + this.loopShiftForward = new components.Button({ + midi: [0x90 + channelOffset, 0x62], + key: "beatjump_forward", + }); + + this.loopIn = new components.Button({ + midi: [0x90 + channelOffset, 0x10], + key: "loop_in", + }); + + this.loopOut = new components.Button({ + midi: [0x90 + channelOffset, 0x11], + key: "loop_out", + }); + + this.slotSelect = new components.Button({ + midi: [0x90 + channelOffset, 0x4C], + key: "quantize", + type: components.Button.prototype.types.toggle, + }); + + this.reloopExit = new components.Button({ + midi: [0x90 + channelOffset, 0x4D], + key: "reloop_toggle", + }); + + this.censor = new components.Button({ + midi: [0x90 + channelOffset, 0x15], + key: "reverseroll" + }); + + this.reverse = new components.Button({ + midi: [0x90 + channelOffset, 0x38], + key: "reverse", + type: components.Button.prototype.types.toggle + }); + + this.slipButton = new components.Button({ + midi: [0x90 + channelOffset, 0x40], + key: "slip_enabled", + type: components.Button.prototype.types.toggle + }); + + this.vinylButton = new components.Button({ + midi: [0x90 + channelOffset, 0x17], + type: components.Button.prototype.types.toggle, + trigger: function() { + this.output(theDeck.jog.vinylMode); + }, + input: function(channel, control, value, status, group) { + if (this.isPress(channel, control, value, status, group)) { + theDeck.jog.vinylMode = !theDeck.jog.vinylMode; + this.send(theDeck.jog.vinylMode); + } + } + }); + this.vinylButton.trigger(); + + this.brakeStopButton = new components.Button({ + midi: [0x90 + channelOffset, 0x79], + type: components.Button.prototype.types.toggle, + inToggle: function() { + // slow down the track + engine.brake(deckNumber, true); + } + }); + this.softStartButton = new components.Button({ + midi: [0x90 + channelOffset, 0x0A], + type: components.Button.prototype.types.toggle, + inToggle: function() { + engine.softStart(deckNumber, true); + } + }); + + this.gridSetButton = new components.Button({ + midi: [0x90 + channelOffset, 0x64], + inKey: "beats_translate_curpos" + }); + + this.keySync = new components.Button({ + midi: [0x90 + channelOffset, 0x70], + key: "sync_key" + }); + + this.keyShiftDown = new components.Button({ + midi: [0x90 + channelOffset, 0x72], + key: "pitch_down" + }); + + this.keyShiftUp = new components.Button({ + midi: [0x90 + channelOffset, 0x73], + key: "pitch_up" + }); + + this.keyReset = new components.Button({ + midi: [0x90 + channelOffset, 0x71], + inKey: "reset_key" + }); + + switch (DDJSR2.wheelColor[deckNumber]) { + case "TRACK": + this.wheelRing = new WheelRing({ + midi: [0xBB, 0x20 + channelOffset], + group: this.group, + outKey: "track_color", + output: function(colorRGB) { this.send(this.colorMapper.getValueForNearestColor(colorRGB)); } + }); + break; + case "POSITION": + this.wheelRing = new WheelRing({ + midi: [0xBB, 0x20 + channelOffset], + group: this.group, + outKey: "playposition", + revolutionsPerSecond: DDJSR2.scratchSettings.vinylSpeed / 60, + output: function(position) { + // Every time the playposition changes, update the wheel color. + // Timing calculation is handled in seconds!! + const elapsedTime = position * engine.getValue(this.group, "duration"); + const maxColorValue = DDJSR2.wheelLedCircle.maxVal; + // Determine the current position in the color cycle + // The modulo operation ensures the color value stays within the available range + // The multiplication by maxColorValue ensures that the position is spread over the entire range of indexed colors. + this.send(Math.round((this.revolutionsPerSecond * elapsedTime * maxColorValue) % maxColorValue)); + } + }); + break; + default: + this.wheelRing = new WheelRing({ + midi: [0xBB, 0x20 + channelOffset], + group: this.group, + outValueScale: () => DDJSR2.wheelColor[deckNumber] + }); + } + + // Attach the pads to the deck instance + this.padSection = new DDJSR2.PadSection(this, channelOffset); +}; + +DDJSR2.Deck.prototype = Object.create(components.Deck.prototype); + + +DDJSR2.MixerContainer = function() { + this.channels = [0, 1, 2, 3].map(channelIndex => new DDJSR2.Channel(channelIndex)); + this.crossfader = new components.Pot({ + group: "[Master]", + inKey: "crossfader", + }); + + const panelStates = new DDJSR2.RingBufferView([[false, false], [true, false], [true, true], [false, true]]); + + const makePanelSelectButton = method => function(channel, control, value, _status, _group) { + if (value) { + const [showSamplers, showFX] = method(); // Call method as a function + + engine.setValue("[Samplers]", "show_samplers", showSamplers); + engine.setValue("[EffectRack1]", "show", showFX); + } + }; + + // Pass the bound method reference + this.panelSelectButton = makePanelSelectButton(() => panelStates.next()); + this.shiftPanelSelectButton = makePanelSelectButton(() => panelStates.previous()); +}; + +DDJSR2.MixerContainer.prototype = new components.ComponentContainer(); + +DDJSR2.Channel = function(channelOffset) { + const deck = `[Channel${ channelOffset + 1 }]`; + this.pregain = new components.Pot({ + // midi: [0xB0 + offset, 0x16], + group: deck, + inKey: "pregain", + }); + + // EQ High, Mid and Low + this.eqKnob = [1, 2, 3].map(parameterIndex => new components.Pot({ + // midi: [0xB0 + channelOffset, 0x07+(parameterIndex-1)*4+(20 if LSB otherwise 0)] + group: `[EqualizerRack1_${deck}_Effect1]`, + inKey: `parameter${parameterIndex}`, + })); + + this.pfl = new components.Button({ + midi: [0x90 + channelOffset, 0x54], + group: deck, + type: components.Button.prototype.types.toggle, + key: "pfl", + }); + + this.tapBPM = new components.Button({ + midi: [0x90 + channelOffset, 0x68], + key: "bpm_tap" + }); + + this.filter = new components.Pot({ + group: `[QuickEffectRack1_${ deck }]`, + inKey: "super1", + }); + + + this.volume = new components.Pot({ + inKey: "volume", + group: deck + }); + + // Master level is handled at hardware level for the SR2, same with Booth Monitor Level, Headphones Mixing, and Sampler Volume + + this.vuMeter = new components.Component({ + outKey: "vu_meter", + group: deck, + midi: [0xB0 + channelOffset, 0x02], + send: function(value) { + if (this.value !== value) { + this.value = value; + components.Component.prototype.send.call(this, value); + } + }, + outValueScale: function(value) { + if (engine.getValue(this.group, "peak_indicator")) { + return 0x7F; + } + return value * 0x76; //full level indicator: 0x7F + } + }); +}; +DDJSR2.Channel.prototype = new components.ComponentContainer(); + +DDJSR2.createEffectUnits = function() { + DDJSR2.effectUnits = []; + const fxLeds = [0x4C, 0x50, 0x70, 0x54]; + for (let i = 1; i <= 2; i++) { + DDJSR2.effectUnits[i] = new components.EffectUnit(i); + DDJSR2.effectUnits[i].enableButtons[1].midi = [0x93 + i, 0x47]; + DDJSR2.effectUnits[i].enableButtons[2].midi = [0x93 + i, 0x48]; + DDJSR2.effectUnits[i].enableButtons[3].midi = [0x93 + i, 0x49]; + DDJSR2.effectUnits[i].dryWetKnob.input = function(channel, control, value, _status, _group) { + this.inSetParameter(this.inGetParameter() + DDJSR2.getRotaryDelta(value) / 30); + }; + for (let j = 1; j <= 4; j++) { + const channel = `Channel${j}`; + DDJSR2.effectUnits[i].enableOnChannelButtons.addButton(channel); + const midiout = fxLeds[j-1]+(i-1); + DDJSR2.effectUnits[i].enableOnChannelButtons[channel].midi = [0x96, midiout]; + } + + DDJSR2.effectUnits[i].init(); + } +}; + +// Performance Pad code +/////////////////////// + +DDJSR2.PadMode = { + HOTCUE: 0x1B, + ROLL: 0x1E, + SLICER: 0x20, + SAMPLER: 0x22, + SAMPLER2: 0x23, + CUELOOP: 0x69, + SAVEDLOOP: 0x6b, + SLICERLOOP: 0x6d, + PITCHPLAY: 0x6E, + TRANS: 0x6C, +}; + +DDJSR2.PadColor = { + OFF: 0x3F, + BLUE: 0x01, + CELESTE: 0xB, + GREEN: 0x15, + YELLOW: 0x1F, + ORANGE: 0X24, + RED: 0x2A, + PINK: 0x2F, + MAGENTA: 0x33, + PURPLE: 0x36, + VIOLET: 0x3c, + WHITE: 0x40, + DIM_MODIFIER: 0x40 +}; + +DDJSR2.PadColorMap = new ColorMapper({ + 0x000000: DDJSR2.PadColor.OFF, + 0xCC0000: DDJSR2.PadColor.RED, + 0x008000: DDJSR2.PadColor.GREEN, + 0x0000CC: DDJSR2.PadColor.BLUE, + 0xFFFF00: DDJSR2.PadColor.YELLOW, + 0x0088CC: DDJSR2.PadColor.CELESTE, + 0xFF8800: DDJSR2.PadColor.ORANGE, + 0xFF00FF: DDJSR2.PadColor.MAGENTA, + 0xEE82EE: DDJSR2.PadColor.VIOLET, + 0x8800CC: DDJSR2.PadColor.PURPLE, + 0xFFC0CB: DDJSR2.PadColor.PINK, + 0xFFFFFF: DDJSR2.PadColor.WHITE, +}); + + +DDJSR2.PadSection = function(deck, offset) { + // TODO: Add support for missing modes (flip, slicer, slicerloop) + /* + * The Performance Pad Section on the SR2 has two basic + * modes of operation that determines how the LEDs react to MIDI messages + * and button presses. + * + * 1. Standalone/MIDI mode + * + * The controller's performance pads allow setting various "modes" using + * the mode buttons and the shift modifier. Pressing the mode buttons will + * change their LED color (and makes the performance pads barely lit in + * that color, too). + * + * 2. Serato mode + * + * In this mode, pressing the pad mode buttons will not change their color. + * Instead, all LEDs have to be controlled by sending MIDI messages. Unlike + * in Standalone mode, it is also possible to illuminate the pad LEDs. + * + * The following table gives an overview over the different performance pad + * modes. The values in the "Serato LED" and "Serato Mode" columns have + * been taken from the Owner's Manual. + * + * Button MIDI control Standalone LED Serato LED Serato Mode + * ------------------------------ ------------ ---------------- ------------ ----------- + * [HOT CUE] 0x00 White White Hot Cue + * [HOT CUE] (press twice) 0x02 Blue Orange Saved Flip + * [SHIFT] + [HOT CUE] 0x03 Orange Blue Cue Loop + * [ROLL] 0x08 Turqoise Light Blue Roll + * [ROLL] (press twice) 0x0D Red Green Saved Loop + * [SHIFT] + [ROLL] 0x09 Blue Red Slicer + * [SHIFT] + [ROLL] (press twice) 0x0A Blue Blue Slicer Loop + * [TR] 0x04 Red Red TR + * [TR] (press twice) 0x06 Orange Orange TR Velocity + * [SHIFT] + [TR] 0x05 Green Green Pattern (Switches TR-S pattern) + * [SAMPLER] 0x0B Purple Magenta Sampler + * [SAMPLER] (press twice) 0x0F Aquamarine Green Pitch Play + * [SHIFT] + [SAMPLER] 0x0C Magenta Purple Velocity Sampler + * + * The Pad and Mode Buttons support 31 different LED states: + * + * MIDI value Color MIDI value Color + * ---------- ----- ---------- ----- + * 0x00 Off 0x10 Off + * 0x01 Red 0x11 Red (Dim) + * 0x02 Orange 0x12 Orange (Dim) + * 0x03 Blue 0x13 Blue (Dim) + * 0x04 Yellow 0x14 Yellow (Dim) + * 0x05 Applegreen 0x15 Applegreen (Dim) + * 0x06 Magenta 0x16 Magenta (Dim) + * 0x07 Celeste 0x17 Celeste (Dim) + * 0x08 Purple 0x18 Purple (Dim) + * 0x09 Apricot 0x19 Apricot (Dim) + * 0x0A Coral 0x1A Coral (Dim) + * 0x0B Azure 0x1B Azure (Dim) + * 0x0C Turquoise 0x1C Turquoise (Dim) + * 0x0D Aquamarine 0x1D Aquamarine (Dim) + * 0x0E Green 0x1E Green (Dim) + * 0x0F White 0x1F White (Dim) + * + * Serato DJ Pro maps its cue colors to MIDI values like this: + * + * Number Default Cue Serato Color MIDI value Color + * ------ ------------ ----------------- --------- ---------- + * 1 1 #CC0000 / #C02626 0x01 Red + * 2 #CC4400 / #DB4E27 0x0A Coral + * 3 2 #CC8800 / #F8821A 0x02 Orange + * 4 4 #CCCC00 / #FAC313 0x04 Yellow + * 5 #88CC00 / #4EB648 0x0E Green + * 6 #44CC00 / #006838 0x0E Green + * 7 5 #00CC00 / #1FAD26 0x05 Applegreen + * 8 #00CC44 / #8DC63F 0x0D Aquamarine + * 9 #00CC88 / #2B3673 0x0D Aquamarine + * 10 7 #00CCCC / #1DBEBD 0x0C Turquoise + * 11 #0088CC / #0F88CA 0x07 Celeste + * 12 #0044CC / #16308B 0x03 Blue + * 13 3 #0000CC / #173BA2 0x03 Blue + * 14 #4400CC / #5C3F97 0x0B Azure + * 15 8 #8800CC / #6823B6 0x08 Purple + * 16 6 #CC00CC / #CE359E 0x06 Magenta + * 17 #CC0088 / #DC1D49 0x06 Magenta + * 18 #CC0044 / #C71136 0x01 Red +*/ + components.ComponentContainer.call(this); + this.modes = { + // This need to be an object so that a recursive reconnectComponents + // call won't influence all modes at once + "hotcue": new DDJSR2.HotcueMode(deck, offset), + "sampler": new DDJSR2.SamplerMode(deck, offset), + "roll": new DDJSR2.RollMode(deck, offset), + "pitchplay": new DDJSR2.PitchPlayMode(deck, offset), + /* "slicer": new DDJSR2.SlicerMode(deck, offset), + "cueloop": new DDJSR2.CueLoopMode(deck, offset), + "savedloop": new DDJSR2.SavedLoop(deck, offset), + "slicerloop": new DDJSR2.SlicerLoop(deck, offset), + + "trans": new DDJSR2.TransMode(deck, offset) +*/ + }; + this.offset = offset; + + // Start in Hotcue Mode and disable other LEDs + this.setPadMode(DDJSR2.PadMode.HOTCUE); +// midi.sendShortMsg(0x94 + offset, this.modes.roll.ledControl, DDJSR2.PadColor.OFF); +// midi.sendShortMsg(0x94 + offset, this.modes.sampler.ledControl, DDJSR2.PadColor.OFF); +}; + +DDJSR2.PadSection.prototype = Object.create(components.ComponentContainer.prototype); +/* +DDJSR2.PadMode = { + HOTCUE: 0x1B, + ROLL: 0x1E, + SLICER: 0x20, + SAMPLER: 0x22, + CUELOOP: 0x69, + SAVEDLOOP: 0x6B, + SLICERLOOP: 0x6D, + PITCHPLAY: 0x6E, + TRANS: 0x6C, +}; +*/ + +DDJSR2.PadSection.prototype.controlToPadMode = function(control) { + switch (control) { + case DDJSR2.PadMode.HOTCUE: + return this.modes.hotcue; + case DDJSR2.PadMode.ROLL: + return this.modes.roll; + case DDJSR2.PadMode.SAMPLER: + return this.modes.sampler; + case DDJSR2.PadMode.SAMPLER2: + return this.modes.sampler; + case DDJSR2.PadMode.PITCHPLAY: + return this.modes.pitchplay; +/* + case DDJSR2.PadMode.SLICR: + return this.modes.slicer; + case DDJSR2.PadMode.CUELOOP: + case DDJSR2.PadMode.SAVEDLOOP: + case DDJSR2.PadMode.SLICERLOOP: + return null; + case DDJSR2.PadMode.TRANS: + return this.modes.trans; +*/ + } +}; + +DDJSR2.PadSection.prototype.padModeButtonPressed = function(channel, control, value, _status, _group) { + if (value) { + this.setPadMode(control); + } +}; + +DDJSR2.PadSection.prototype.setPadMode = function(control) { + const newMode = this.controlToPadMode(control); + + // Exit early if the requested mode is already active or not mapped + if (newMode === this.currentMode || newMode === undefined) { + return; + } + + // If we're switching away from or to a hardware-based mode (e.g. TR mode), + // the performance pad behaviour is hardcoded in the firmware and not + // controlled by Mixxx. These modes are represented by the value null. + // Hence, we only need to change LEDs and (dis-)connect components if + // this.currentMode or newMode is not null. + if (this.currentMode) { + // Disable the mode button LED of the currently active mode + midi.sendShortMsg(0x90 + this.offset, this.currentMode.ledControl, 0x00); + + this.currentMode.forEachComponent(function(component) { + component.disconnect(); + }); + } + + if (newMode) { + // Illuminate the mode button LED of the new mode + midi.sendShortMsg(0x90 + this.offset, newMode.ledControl, newMode.color); + + // Set the correct shift state for the new mode. For example, if the + // user is in HOT CUE mode and wants to switch to CUE LOOP mode, you + // need to press [SHIFT]+[HOT CUE]. Pressing [SHIFT] will make the HOT + // CUE mode pads become shifted. + // When you're in CUE LOOP mode and want to switch back to + // HOT CUE mode, the user need to press HOT CUE (without holding + // SHIFT). However, the HOT CUE mode pads are still shifted even though + // the user is not pressing [SHIFT] because they never got the unshift + // event (the [SHIFT] button was released in CUE LOOP mode, not in HOT + // CUE mode). + // Hence, it's necessary to set the correct shift state when switching + // modes. + if (this.isShifted) { + newMode.shift(); + } else { + newMode.unshift(); + } + + newMode.forEachComponent(function(component) { + component.connect(); + component.trigger(); + }); + } + this.currentMode = newMode; +}; + +DDJSR2.PadSection.prototype.padPressed = function(channel, control, value, status, group) { + if (this.currentMode) { + this.currentMode.pads[control].input(channel, control, value, status, group); + } +}; + +DDJSR2.HotcueMode = function(deck, offset) { + components.ComponentContainer.call(this); + this.ledControl = DDJSR2.PadMode.HOTCUE; + this.color = DDJSR2.PadColor.WHITE; + + this.pads = new components.ComponentContainer(); + for (let i = 0; i <= 7; i++) { + this.pads[i] = new components.HotcueButton({ + midi: [0x97 + offset, 0x0 + i], + sendShifted: true, + shiftControl: true, + shiftOffset: 8, + number: i + 1, + group: deck.currentDeck, + off: DDJSR2.PadColor.OFF, + colorMapper: DDJSR2.PadColorMap, + outConnect: false, + }); + } + this.clearHotcueButton = new components.Button({ + input: function(channel, control, value, status, group) { + const index = control - 0x08 + 1; + script.toggleControl(group, `hotcue_${ index }_clear`); + } + }); + + this.paramMinusButton = new components.Button({ + midi: [0x90 + offset, 0x24], + group: deck.currentDeck, + key: "hotcue_focus_color_prev", + }); + this.paramPlusButton = new components.Button({ + midi: [0x90 + offset, 0x2C], + group: deck.currentDeck, + key: "hotcue_focus_color_next", + }); + this.param2MinusButton = new components.Button({ + midi: [0x90 + offset, 0x01], + group: deck.currentDeck, + key: "beats_translate_earlier", + }); + this.param2PlusButton = new components.Button({ + midi: [0x90 + offset, 0x09], + group: deck.currentDeck, + key: "beats_translate_later", + }); +}; +DDJSR2.HotcueMode.prototype = Object.create(components.ComponentContainer.prototype); + +DDJSR2.RollMode = function(deck, offset) { + components.ComponentContainer.call(this); + this.ledControl = DDJSR2.PadMode.ROLL; + this.color = DDJSR2.PadColor.CELESTE; + this.pads = new components.ComponentContainer(); + this.loopSize = 0.03125; + this.minSize = 0.03125; // 1/32 + this.maxSize = 32; + + for (let i = 0; i <= 3; i++) { + const loopSize = (this.loopSize * Math.pow(2, i)); + this.pads[0x10+i] = new components.Button({ + midi: [0x97 + offset, 0x10 + i], + sendShifted: true, + shiftControl: true, + shiftOffset: 8, + group: deck.currentDeck, + outKey: `beatloop_${ loopSize }_enabled`, + inKey: `beatlooproll_${ loopSize }_activate`, + outConnect: false, + on: this.color, + off: (loopSize === 0.25) ? DDJSR2.PadColor.CELESTE : ((loopSize === 4) ? DDJSR2.PadColor.GREEN : (this.color + DDJSR2.PadColor.DIM_MODIFIER)), + }); + } + this.pads[0x10+4] = new components.Button({ + midi: [0x97 + offset, 0x14], + sendShifted: true, + shiftControl: true, + shiftOffset: 8, + group: deck.currentDeck, + key: "beatjump_backward", + outConnect: false, + off: DDJSR2.PadColor.RED, + on: DDJSR2.PadColor.RED + DDJSR2.PadColor.DIM_MODIFIER, + }); + this.pads[0x10+5] = new components.Button({ + midi: [0x97 + offset, 0x15], + sendShifted: true, + shiftControl: true, + shiftOffset: 8, + group: deck.currentDeck, + outKey: "beatjump_size", + outConnect: false, + on: DDJSR2.PadColor.ORANGE, + off: DDJSR2.PadColor.ORANGE + DDJSR2.PadColor.DIM_MODIFIER, + mode: this, + input: function(channel, control, value, _status, _group) { + if (value) { + const jumpSize = engine.getValue(this.group, "beatjump_size"); + if (jumpSize > this.mode.minSize) { + engine.setValue(this.group, "beatjump_size", jumpSize / 2); + } + } + }, + outValueScale: function(value) { + return value > this.mode.minSize ? this.on : this.off; + }, + }); + this.pads[0x10+6] = new components.Button({ + midi: [0x97 + offset, 0x16], + sendShifted: true, + shiftControl: true, + shiftOffset: 8, + group: deck.currentDeck, + outKey: "beatjump_size", + outConnect: false, + on: DDJSR2.PadColor.ORANGE, + off: DDJSR2.PadColor.ORANGE + DDJSR2.PadColor.DIM_MODIFIER, + mode: this, + input: function(channel, control, value, _status, _group) { + if (value) { + const jumpSize = engine.getValue(this.group, "beatjump_size"); + if (jumpSize < this.mode.maxSize) { + engine.setValue(this.group, "beatjump_size", jumpSize * 2); + } + } + }, + outValueScale: function(value) { + return value < this.mode.maxSize ? this.on : this.off; + }, + }); + this.pads[0x10+7] = new components.Button({ + midi: [0x97 + offset, 0x17], + sendShifted: true, + shiftControl: true, + shiftOffset: 8, + group: deck.currentDeck, + key: "beatjump_forward", + outConnect: false, + off: DDJSR2.PadColor.RED, + on: DDJSR2.PadColor.RED + DDJSR2.PadColor.DIM_MODIFIER, + }); + + + this.paramMinusButton = new components.Button({ + midi: [0x94 + offset, 0x28], + mode: this, + input: function(channel, control, value, _status, _group) { + if (value) { + if (this.mode.loopSize > this.mode.minSize) { + this.mode.setLoopSize(this.mode.loopSize / 2); + } + } + this.send(value); + }, + }); + this.paramPlusButton = new components.Button({ + midi: [0x94 + offset, 0x29], + mode: this, + input: function(channel, control, value, _status, _group) { + if (value) { + if (this.mode.loopSize * 8 < this.mode.maxSize) { + this.mode.setLoopSize(this.mode.loopSize * 2); + } + } + this.send(value); + }, + }); +}; +DDJSR2.RollMode.prototype = Object.create(components.ComponentContainer.prototype); +DDJSR2.RollMode.prototype.setLoopSize = function(loopSize) { + this.loopSize = loopSize; + let padLoopSize; + for (let i = 0; i <= 3; i++) { + padLoopSize = (this.loopSize * Math.pow(2, i)); + this.pads[0x10+i].inKey = `beatlooproll_${ padLoopSize }_activate`; + this.pads[0x10+i].outKey = `beatloop_${ padLoopSize }_enabled`; + this.pads[0x10+i].off = (padLoopSize === 0.25) ? DDJSR2.PadColor.CELESTE : ((padLoopSize === 4) ? DDJSR2.PadColor.GREEN : (this.color + DDJSR2.PadColor.DIM_MODIFIER)); + } + this.reconnectComponents(); +}; + +DDJSR2.SamplerMode = function(deck, offset) { + components.ComponentContainer.call(this); + this.ledControl = DDJSR2.PadMode.SAMPLER; + this.color = DDJSR2.PadColor.PURPLE; + this.pads = new components.ComponentContainer(); + for (let i = 0; i <= 7; i++) { + this.pads[0x30+i] = new components.SamplerButton({ + midi: [0x97 + offset, 0x30 + i], + number: i + 1, + outConnect: true, + playing: DDJSR2.PadColor.PURPLE, + on: this.color, + loaded: DDJSR2.PadColor.PURPLE+DDJSR2.PadColor.DIM_MODIFIER, + off: DDJSR2.PadColor.OFF, + }); + } + this.stopSamplerButton = new components.Button({ + input: function(channel, control, value, _status, _group) { + DDJSR2.selectedSamplerBank = 0; + const index = control - 0x38 + 1, + deckOffset = DDJSR2.selectedSamplerBank * 8, + sampleDeck = `[Sampler${ index + deckOffset }]`, + trackLoaded = engine.getValue(sampleDeck, "track_loaded"), + playing = engine.getValue(sampleDeck, "play"); + + if (trackLoaded && playing) { + script.toggleControl(sampleDeck, "stop"); + } else if (trackLoaded && !playing && value) { + script.toggleControl(sampleDeck, "eject"); + } + } + }); +}; +DDJSR2.SamplerMode.prototype = Object.create(components.ComponentContainer.prototype); + +DDJSR2.PitchPlayMode = function(deck, offset) { + components.ComponentContainer.call(this); + + const PitchPlayRange = { + DOWN: 0, + MID: 1, + UP: 2, + }; + + this.ledControl = DDJSR2.PadMode.PITCHPLAY; + this.color = DDJSR2.PadColor.GREEN; + this.cuepoint = 1; + this.range = new DDJSR2.RingBufferView(Object.values(PitchPlayRange), 1); + + this.PerformancePad = function(n) { + this.midi = [0x97 + offset, 0x70 + n]; + this.number = n + 1; + this.on = this.color + DDJSR2.PadColor.DIM_MODIFIER; + this.colorMapper = DDJSR2.PadColorMap; + this.colorKey = `hotcue_${ this.number }_color`; + components.Button.call(this); + }; + this.PerformancePad.prototype = new components.Button({ + group: deck.currentDeck, + mode: this, + outConnect: false, + off: DDJSR2.PadColor.OFF, + unshift: function() { + this.outKey = "pitch_adjust"; + this.output = function(_value, _group, _control) { + let color = this.mode.color + DDJSR2.PadColor.DIM_MODIFIER; + if ((this.mode.range.current() === PitchPlayRange.UP && this.number === 5) || + (this.mode.range.current() === PitchPlayRange.MID && this.number === 1) || + (this.mode.range.current() === PitchPlayRange.DOWN && this.number === 4)) { + color = DDJSR2.PadColor.WHITE; + } + this.send(color); + }; + this.input = function(channel, control, value, _status, _group) { + if (value > 0) { + let pitchAdjust; + switch (this.mode.range.current()) { + case PitchPlayRange.UP: + pitchAdjust = this.number + ((this.number <= 4) ? 4 : -5); + break; + case PitchPlayRange.MID: + pitchAdjust = this.number - ((this.number <= 4) ? 1 : 9); + break; + case PitchPlayRange.DOWN: + pitchAdjust = this.number - ((this.number <= 4) ? 4 : 12); + } + engine.setValue(this.group, "pitch_adjust", pitchAdjust); + engine.setValue(this.group, `hotcue_${ this.mode.cuepoint }_activate`, value); + } + }; + this.connect = function() { + components.Button.prototype.connect.call(this); // call parent connect + + if (this.connections[1] !== undefined) { + // Necessary, since trigger() apparently also triggers disconnected connections + this.connections.pop(); + } + }; + if (this.connections[0] !== undefined) { + this.disconnect(); + this.connect(); + this.trigger(); + } + } + }); + this.ShiftedPerformancePad = function(n) { + this.midi = [0x97 + offset, 0x78 + n]; + this.number = n + 1; + this.on = this.color + DDJSR2.PadColor.DIM_MODIFIER; + this.colorMapper = DDJSR2.PadColorMap; + this.colorKey = `hotcue_${ this.number }_color`; + components.Button.call(this); + }; + this.ShiftedPerformancePad.prototype = new components.Button({ + group: deck.currentDeck, + mode: this, + outConnect: false, + off: DDJSR2.PadColor.OFF, + outputColor: function(colorCode) { + // For colored hotcues (shifted only) + const midiColor = this.colorMapper.getValueForNearestColor(colorCode); + this.send((this.mode.cuepoint === this.number) ? midiColor : (midiColor + DDJSR2.PadColor.DIM_MODIFIER)); + }, + unshift: function() { + this.outKey = `hotcue_${ this.number }_enabled`; + this.output = function(value, _group, _control) { + const outval = this.outValueScale(value); + if (this.colorKey !== undefined && outval !== this.off) { + this.outputColor(engine.getValue(this.group, this.colorKey)); + } else { + this.send(DDJSR2.PadColor.OFF); + } + }; + this.input = function(channel, control, value, _status, _group) { + if (value > 0 && this.mode.cuepoint !== this.number && engine.getValue(this.group, `hotcue_${ this.number }_enabled`)) { + const previousCuepoint = this.mode.cuepoint; + this.mode.cuepoint = this.number; + this.mode.pads[0x78+previousCuepoint - 1].trigger(); + this.outputColor(engine.getValue(this.group, this.colorKey)); + } + }; + this.connect = function() { + components.Button.prototype.connect.call(this); // call parent connect + if (undefined !== this.group && this.colorKey !== undefined) { + this.connections[1] = engine.makeConnection(this.group, this.colorKey, function(id) { + if (engine.getValue(this.group, this.outKey)) { + this.outputColor(id); + } + }); + } + }; + if (this.connections[0] !== undefined) { + this.disconnect(); + this.connect(); + this.trigger(); + } + }, + }); + this.pads = new components.ComponentContainer(); + for (let n = 0; n <= 7; n++) { + this.pads[0x70+n] = new this.PerformancePad(n); + this.pads[0x78+n] = new this.ShiftedPerformancePad(n); + } + + this.paramMinusButton = new components.Button({ + midi: [0x90 + offset, 0x2B], + mode: this, + input: function(channel, control, value, status, group) { + this.send(value); + if (this.isPress(channel, control, value, status, group)) { + this.mode.range.previous(); + this.mode.forEachComponent(function(component) { + component.trigger(); + }); + } + }, + }); + this.paramPlusButton = new components.Button({ + midi: [0x90 + offset, 0x33], + mode: this, + input: function(channel, control, value, status, group) { + this.send(value); + if (this.isPress(channel, control, value, status, group)) { + this.mode.range.next(); + this.mode.forEachComponent(function(component) { + component.trigger(); + }); + } + }, + }); +}; +DDJSR2.PitchPlayMode.prototype = Object.create(components.ComponentContainer.prototype); + +const WheelRing = function(options) { + components.Component.call(this, options); +}; +WheelRing.prototype = new components.Component({ + colorMapper: DDJSR2.wheelColorMap, + send: function(value) { + if (this.value !== value) { + this.value = value; + components.Component.prototype.send.call(this, value); + } + }, + outputMaybe: function() { + if (engine.getValue(this.group, "end_of_track")) { + engine.getValue("[App]", "indicator_500ms") ? this.send(DDJSR2.wheelLedCircle.blink) : this.send(DDJSR2.wheelLedCircle.maxVal); + return; + } + this.output(this.outGetValue()); + }, + trigger: function() { + this.outputMaybe(); + }, + connect: function() { + if (typeof this.group !== "string") { + throw `invalid group: ${this.group}`; + } + const COs = [{}, {group: this.group, key: "end_of_track"}, {group: "[App]", key: "indicator_500ms"}]; + if (typeof this.outKey === "string") { + COs[0] = {group: this.group, key: this.outKey}; + } + this.connections = COs.map(co => engine.makeConnection(co.group, co.key, this.outputMaybe.bind(this))); + } +}); diff --git a/res/controllers/Pioneer-DDJ-SR2.midi.xml b/res/controllers/Pioneer-DDJ-SR2.midi.xml new file mode 100755 index 00000000000..37fa95ab423 --- /dev/null +++ b/res/controllers/Pioneer-DDJ-SR2.midi.xml @@ -0,0 +1,5953 @@ + + + + Pioneer DDJ-SR2 + Waylon Robertson + 4-deck mapping for Pioneer DDJ-SR2 controller + https://mixxx.zulipchat.com/#narrow/stream/113295-controller-mapping/topic/Pioneer.20DDJ-SR2 + roland_dj_505 for now + + + + + + + + + + + + + + + + + + + + + + + + + [Channel1] + DDJSR2.deck[0].play.input + DECK 1 PLAY/PAUSE + 0x90 + 0x0B + + + + + + [Channel1] + DDJSR2.deck[0].censor.input + DECK 1 CENSOR + 0x90 + 0x15 + + + + + + [Channel1] + DDJSR2.deck[0].reverse.input + DECK 1 REVERSE + 0x90 + 0x38 + + + + + + [Channel1] + DDJSR2.deck[0].stutter.input + DECK 1 STUTTER + 0x90 + 0x47 + + + + + + [Channel1] + DDJSR2.deck[0].cue.input + DECK 1 CUE + 0x90 + 0x0C + + + + + + [Channel1] + DDJSR2.deck[0].cuerewind.input + DECK 1 CUE REWIND + 0x90 + 0x48 + + + + + + [Channel1] + DDJSR2.deck[0].sync.input + DECK 1 SYNC + 0x90 + 0x58 + + + + + + [Channel1] + DDJSR2.deck[0].syncOff.input + DECK 1 SYNC OFF + 0x90 + 0x5C + + + + + + + + [Channel1] + DDJSR2.deck[0].tempoFader.inputMSB + DECK 1 TEMPO FADER (MSB) + 0xB0 + 0x00 + + + + + + [Channel1] + DDJSR2.deck[0].tempoFader.inputLSB + DECK 1 TEMPO FADER (LSB) + 0xB0 + 0x20 + + + + + + [Channel1] + DDJSR2.deck[0].tempoRange.input + DECK 1 TEMPO RANGE + 0x90 + 0x60 + + + + + + [Channel1] + DDJSR2.deck[0].tempoReset.input + DECK 1 TEMPO RESET + 0x90 + 0x1C + + + + + + [Channel1] + DDJSR2.deck[0].keyLock.input + DECK 1 KEY LOCK + 0x90 + 0x1A + + + + + + [Channel1] + DDJSR2.deck[0].keySync.input + DECK 1 KEY SYNC + 0x90 + 0x70 + + + + + + [Channel1] + DDJSR2.deck[0].keyShiftUp.input + DECK 1 KEY SHIFT UP + 0x90 + 0x73 + + + + + + [Channel1] + DDJSR2.deck[0].keyShiftDown.input + DECK 1 KEY SHIFT DOWN + 0x90 + 0x72 + + + + + + [Channel1] + DDJSR2.deck[0].keyReset.input + DECK 1 KEY RESET + 0x90 + 0x71 + + + + + + + [Channel1] + DDJSR2.deck[0].needleSearchStripPosition.input + DECK 1 NEEDLE SEARCH STRIP POSITION + 0xB0 + 0x03 + + + + + + [Channel1] + DDJSR2.deck[0].needleSearchStripPositionShifted.input + DECK 1 NEEDLE SEARCH STRIP POSITION Shift pressed + 0xB0 + 0x28 + + + + + + + [Channel1] + DDJSR2.deck[0].gridSetButton.input + 0x90 + 0x64 + + + + + + [Channel1] + DDJSR2.deck[0].brakeStopButton.input // Originally Grid Adjust, replaced due to poor functionality. + 0x90 + 0x79 + + + + + + [Channel1] + DDJSR2.deck[0].softStartButton.input // Originally Grid Slide, replaced due to poor functionality. + 0x90 + 0x0A + + + + + + + [Channel1] + DDJSR2.deck[0].jog.inputTouch + DECK 1 PLATTER TOUCH + 0x90 + 0x36 + + + + + + [Channel1] + DDJSR2.deck[0].jog.inputWheel + Jog Platter movement (Vinyl Mode) Deck 1, left JOGDIAL (Deck 1 active) + 0xB0 + 0x22 + + + + + + [Channel1] + DDJSR2.deck[0].jog.inputWheel + Jog Platter movement (CDJ Mode) Deck 1, left JOGDIAL (Deck 1 active) + 0xB0 + 0x23 + + + + + + + [Channel1] + DDJSR2.deck[0].vinylButton.input + DECK 1 VINYL MODE + 0x90 + 0x17 + + + + + + [Channel1] + DDJSR2.deck[0].slipButton.input + DECK 1 SLIP MODE + 0x90 + 0x40 + + + + + + + [Channel1] + DDJSR2.deck[0].autoLoop.input + DECK 1 AUTO LOOP + 0x90 + 0x14 + + + + + + [Channel1] + DDJSR2.deck[0].loopActive.input + DECK 1 LOOP ACTIVE + 0x90 + 0x50 + + + + + + [Channel1] + DDJSR2.deck[0].loopHalve.input + DECK 1 LOOP 1/2X + 0x90 + 0x12 + + + + + + + [Channel1] + DDJSR2.deck[0].loopDouble.input + DECK 1 LOOP 2X + 0x90 + 0x13 + + + + + + [Channel1] + DDJSR2.deck[0].loopShiftBackward.input + DECK 1 LOOP SHIFT 1/2X + 0x90 + 0x61 + + + + + + [Channel1] + DDJSR2.deck[0].loopShiftForward.input + DECK 1 LOOP SHIFT 2X + 0x90 + 0x62 + + + + + + [Channel1] + DDJSR2.deck[0].loopIn.input + DECK 1 LOOP IN + 0x90 + 0x10 + + + + + + [Channel1] + DDJSR2.deck[0].loopOut.input + DECK 1 LOOP OUT + 0x90 + 0x11 + + + + + + [Channel1] + DDJSR2.deck[0].slotSelect.input + DECK 1 SLOT SELECT + 0x90 + 0x4C + + + + + + [Channel1] + DDJSR2.deck[0].reloopExit.input + DECK 1 RELOOP/EXIT + 0x90 + 0x4D + + + + + + + + [Channel1] + DDJSR2.mixer.channels[0].pregain.inputMSB + DECK 1 TRIM (MSB) + 0xB0 + 0x04 + + + + + + [Channel1] + DDJSR2.mixer.channels[0].pregain.inputLSB + DECK 1 TRIM (LSB) + 0xB0 + 0x24 + + + + + + [EqualizerRack1_[Channel1]_Effect1] + DDJSR2.mixer.channels[0].eqKnob[2].inputMSB + DECK 1 EQ HI (MSB) + 0xB0 + 0x07 + + + + + + [EqualizerRack1_[Channel1]_Effect1] + DDJSR2.mixer.channels[0].eqKnob[2].inputLSB + DECK 1 EQ HI (LSB) + 0xB0 + 0x27 + + + + + + [EqualizerRack1_[Channel1]_Effect1] + DDJSR2.mixer.channels[0].eqKnob[1].inputMSB + DECK 1 EQ MID (MSB) + 0xB0 + 0x0B + + + + + + [EqualizerRack1_[Channel1]_Effect1] + DDJSR2.mixer.channels[0].eqKnob[1].inputLSB + DECK 1 EQ MID (LSB) + 0xB0 + 0x2B + + + + + + [EqualizerRack1_[Channel1]_Effect1] + DDJSR2.mixer.channels[0].eqKnob[0].inputMSB + DECK 1 EQ LOW (MSB) + 0xB0 + 0x0F + + + + + + [EqualizerRack1_[Channel1]_Effect1] + DDJSR2.mixer.channels[0].eqKnob[0].inputLSB + DECK 1 EQ LOW (LSB) + 0xB0 + 0x2F + + + + + + [QuickEffectRack1_[Channel1]] + DDJSR2.mixer.channels[0].filter.inputMSB + DECK 1 FILTER + 0xB6 + 0x17 + + + + + + [QuickEffectRack1_[Channel1]] + DDJSR2.mixer.channels[0].filter.inputLSB + DECK 1 FILTER + 0xB6 + 0x37 + + + + + + [Channel1] + DDJSR2.mixer.channels[0].pfl.input + DECK 1 CUE/PFL + 0x90 + 0x54 + + + + + [Channel1] + DDJSR2.mixer.channels[0].tapBPM.input + DECK 1 TAP + 0x90 + 0x68 + + + + + + [Channel1] + DDJSR2.mixer.channels[0].volume.inputMSB + DECK 1 VOLUME (MSB) + 0xB0 + 0x13 + + + + + + [Channel1] + DDJSR2.mixer.channels[0].volume.inputLSB + DECK 1 VOLUME (LSB) + 0xB0 + 0x33 + + + + + + + [Channel2] + DDJSR2.deck[1].autoLoop.input + DECK 2 AUTO LOOP + 0x91 + 0x14 + + + + + + [Channel2] + DDJSR2.deck[1].loopActive.input + DECK 2 LOOP ACTIVE + 0x91 + 0x50 + + + + + + [Channel2] + DDJSR2.deck[1].loopHalve.input + DECK 2 LOOP 1/2X + 0x91 + 0x12 + + + + + + + [Channel2] + DDJSR2.deck[1].loopDouble.input + DECK 2 LOOP 2X + 0x91 + 0x13 + + + + + + [Channel2] + DDJSR2.deck[1].loopShiftBackward.input + DECK 2 LOOP SHIFT 1/2X + 0x91 + 0x61 + + + + + + [Channel2] + DDJSR2.deck[1].loopShiftForward.input + DECK 2 LOOP SHIFT 2X + 0x91 + 0x62 + + + + + + [Channel2] + DDJSR2.deck[1].loopIn.input + DECK 2 LOOP IN + 0x91 + 0x10 + + + + + + [Channel2] + DDJSR2.deck[1].loopOut.input + DECK 2 LOOP OUT + 0x91 + 0x11 + + + + + + [Channel2] + DDJSR2.deck[1].slotSelect.input + DECK 2 SLOT SELECT + 0x91 + 0x4C + + + + + + [Channel2] + DDJSR2.deck[1].reloopExit.input + DECK 2 RELOOP/EXIT + 0x91 + 0x4D + + + + + + + + + [Channel2] + DDJSR2.deck[1].play.input + DECK 2 PLAY/PAUSE + 0x91 + 0x0B + + + + + + [Channel1] + DDJSR2.deck[1].censor.input + DECK 2 CENSOR + 0x91 + 0x15 + + + + + + [Channel2] + DDJSR2.deck[1].reverse.input + DECK 2 REVERSE + 0x91 + 0x38 + + + + + + [Channel2] + DDJSR2.deck[1].stutter.input + DECK 2 STUTTER + 0x91 + 0x47 + + + + + + [Channel2] + DDJSR2.deck[1].cue.input + DECK 2 CUE + 0x91 + 0x0C + + + + + + [Channel2] + DDJSR2.deck[1].cuerewind.input + DECK 2 CUE REWIND + 0x91 + 0x48 + + + + + + [Channel2] + DDJSR2.deck[1].sync.input + DECK 2 SYNC + 0x91 + 0x58 + + + + + + [Channel2] + DDJSR2.deck[1].syncOff.input + DECK 2 SYNC OFF + 0x91 + 0x5C + + + + + + + + [Channel2] + DDJSR2.deck[1].tempoFader.inputMSB + DECK 2 TEMPO FADER (MSB) + 0xB1 + 0x00 + + + + + + [Channel2] + DDJSR2.deck[1].tempoFader.inputLSB + DECK 2 TEMPO FADER (LSB) + 0xB1 + 0x20 + + + + + + [Channel2] + DDJSR2.deck[1].tempoRange.input + DECK 2 TEMPO RANGE + 0x91 + 0x60 + + + + + + [Channel2] + DDJSR2.deck[1].tempoReset.input + DECK 2 TEMPO RESET + 0x91 + 0x1C + + + + + + [Channel2] + DDJSR2.deck[1].keyLock.input + DECK 2 KEY LOCK + 0x91 + 0x1A + + + + + + [Channel2] + DDJSR2.deck[1].keySync.input + DECK 2 KEY SYNC + 0x91 + 0x70 + + + + + + [Channel2] + DDJSR2.deck[1].keyShiftUp.input + DECK 2 KEY SHIFT UP + 0x91 + 0x73 + + + + + + [Channel2] + DDJSR2.deck[1].keyShiftDown.input + DECK 2 KEY SHIFT DOWN + 0x91 + 0x72 + + + + + + [Channel2] + DDJSR2.deck[1].keyReset.input + DECK 2 KEY RESET + 0x91 + 0x71 + + + + + + + [Channel2] + DDJSR2.deck[1].needleSearchStripPosition.input + DECK 2 NEEDLE SEARCH STRIP POSITION + 0xB1 + 0x03 + + + + + + [Channel2] + DDJSR2.deck[1].needleSearchStripPositionShifted.input + DECK 2 NEEDLE SEARCH STRIP POSITION Shift pressed + 0xB1 + 0x28 + + + + + + + [Channel2] + DDJSR2.deck[1].gridSetButton.input + 0x91 + 0x64 + + + + + + [Channel2] + DDJSR2.deck[1].brakeStopButton // Originally Grid Adjust, replaced due to poor functionality. + 0x91 + 0x79 + + + + + + [Channel2] + DDJSR2.deck[1].softStartButton // Originally Grid Slide, replaced due to poor functionality. + 0x91 + 0x0A + + + + + + + [Channel2] + DDJSR2.deck[1].jog.inputTouch + DECK 2 PLATTER TOUCH + 0x91 + 0x36 + + + + + + [Channel2] + DDJSR2.deck[1].jog.inputWheel + Jog Platter movement (Vinyl Mode) Deck 2, right JOGDIAL (Deck 2 active) + 0xB1 + 0x22 + + + + + + [Channel2] + DDJSR2.deck[1].jog.inputWheel + Jog Platter movement (CDJ Mode) Deck 2, right JOGDIAL (Deck 2 active) + 0xB1 + 0x23 + + + + + + + [Channel2] + DDJSR2.deck[1].vinylButton.input + DECK 2 VINYL MODE + 0x91 + 0x17 + + + + + + [Channel2] + DDJSR2.deck[1].slipButton.input + DECK 2 SLIP MODE + 0x91 + 0x40 + + + + + + + [Channel2] + DDJSR2.mixer.channels[1].pregain.inputMSB + DECK 2 TRIM (MSB) + 0xB1 + 0x04 + + + + + + [Channel2] + DDJSR2.mixer.channels[1].pregain.inputLSB + DECK 2 TRIM (LSB) + 0xB1 + 0x24 + + + + + + [EqualizerRack1_[Channel2]_Effect1] + DDJSR2.mixer.channels[1].eqKnob[2].inputMSB + DECK 2 EQ HI (MSB) + 0xB1 + 0x07 + + + + + + [EqualizerRack1_[Channel2]_Effect1] + DDJSR2.mixer.channels[1].eqKnob[2].inputLSB + DECK 2 EQ HI (LSB) + 0xB1 + 0x27 + + + + + + [EqualizerRack1_[Channel2]_Effect1] + DDJSR2.mixer.channels[1].eqKnob[1].inputMSB + DECK 2 EQ MID (MSB) + 0xB1 + 0x0B + + + + + + [EqualizerRack1_[Channel2]_Effect1] + DDJSR2.mixer.channels[1].eqKnob[1].inputLSB + DECK 2 EQ MID (LSB) + 0xB1 + 0x2B + + + + + + [EqualizerRack1_[Channel2]_Effect1] + DDJSR2.mixer.channels[1].eqKnob[0].inputMSB + DECK 2 EQ LOW (MSB) + 0xB1 + 0x0F + + + + + + [EqualizerRack1_[Channel2]_Effect1] + DDJSR2.mixer.channels[1].eqKnob[0].inputLSB + DECK 2 EQ LOW (LSB) + 0xB1 + 0x2F + + + + + + [QuickEffectRack1_[Channel2]] + DDJSR2.mixer.channels[1].filter.inputMSB + DECK 2 FILTER + 0xB6 + 0x18 + + + + + + [QuickEffectRack1_[Channel2]] + DDJSR2.mixer.channels[1].filter.inputLSB + DECK 2 FILTER + 0xB6 + 0x38 + + + + + + [Channel2] + DDJSR2.mixer.channels[1].pfl.input + DECK 2 CUE/PFL + 0x91 + 0x54 + + + + + [Channel2] + DDJSR2.mixer.channels[1].tapBPM.input + DECK 2 TAP + 0x91 + 0x68 + + + + + + [Channel2] + DDJSR2.mixer.channels[1].volume.inputMSB + DECK 2 VOLUME (MSB) + 0xB1 + 0x13 + + + + + + [Channel2] + DDJSR2.mixer.channels[1].volume.inputLSB + DECK 2 VOLUME (LSB) + 0xB1 + 0x33 + + + + + + [Channel3] + DDJSR2.deck[2].play.input + DECK 3 PLAY/PAUSE + 0x92 + 0x0B + + + + + + [Channel3] + DDJSR2.deck[2].censor.input + DECK 3 CENSOR + 0x92 + 0x15 + + + + + + [Channel3] + DDJSR2.deck[2].reverse.input + DECK 3 REVERSE + 0x92 + 0x38 + + + + + + [Channel3] + DDJSR2.deck[2].stutter.input + DECK 3 STUTTER + 0x92 + 0x47 + + + + + + [Channel3] + DDJSR2.deck[2].cue.input + DECK 3 CUE + 0x92 + 0x0C + + + + + + [Channel3] + DDJSR2.deck[2].cuerewind.input + DECK 3 CUE REWIND + 0x92 + 0x48 + + + + + + [Channel3] + DDJSR2.deck[2].sync.input + DECK 3 SYNC + 0x92 + 0x58 + + + + + + [Channel3] + DDJSR2.deck[2].syncOff.input + DECK 3 SYNC OFF + 0x92 + 0x5C + + + + + + + + [Channel3] + DDJSR2.deck[2].tempoFader.inputMSB + DECK 3 TEMPO FADER (MSB) + 0xB2 + 0x00 + + + + + + [Channel3] + DDJSR2.deck[2].tempoFader.inputLSB + DECK 3 TEMPO FADER (LSB) + 0xB2 + 0x20 + + + + + + [Channel3] + DDJSR2.deck[2].tempoRange.input + DECK 3 TEMPO RANGE + 0x92 + 0x60 + + + + + + [Channel3] + DDJSR2.deck[2].tempoReset.input + DECK 3 TEMPO RESET + 0x92 + 0x1C + + + + + + [Channel3] + DDJSR2.deck[2].keyLock.input + DECK 3 KEY LOCK + 0x92 + 0x1A + + + + + + [Channel3] + DDJSR2.deck[2].keySync.input + DECK 3 KEY SYNC + 0x92 + 0x70 + + + + + + [Channel3] + DDJSR2.deck[2].keyShiftUp.input + DECK 3 KEY SHIFT UP + 0x92 + 0x73 + + + + + + [Channel3] + DDJSR2.deck[2].keyShiftDown.input + DECK 3 KEY SHIFT DOWN + 0x92 + 0x72 + + + + + + [Channel3] + DDJSR2.deck[2].keyReset.input + DECK 3 KEY RESET + 0x92 + 0x71 + + + + + + + [Channel3] + DDJSR2.deck[2].needleSearchStripPosition.input + DECK 3 NEEDLE SEARCH STRIP POSITION + 0xB2 + 0x03 + + + + + + [Channel3] + DDJSR2.deck[2].needleSearchStripPositionShifted.input + DECK 3 NEEDLE SEARCH STRIP POSITION Shift pressed + 0xB2 + 0x28 + + + + + + + [Channel3] + DDJSR2.deck[2].gridSetButton.input + 0x92 + 0x64 + + + + + + [Channel3] + DDJSR2.deck[2].brakeStopButton // Originally Grid Adjust, replaced due to poor functionality. + 0x92 + 0x79 + + + + + + [Channel3] + DDJSR2.deck[2].softStartButton // Originally Grid Slide, replaced due to poor functionality. + 0x92 + 0x0A + + + + + + + [Channel3] + DDJSR2.deck[2].jog.inputTouch + DECK 3 PLATTER TOUCH + 0x92 + 0x36 + + + + + + [Channel3] + DDJSR2.deck[2].jog.inputWheel + Jog Platter movement (Vinyl Mode) Deck 3, left JOGDIAL (Deck 3 active) + 0xB2 + 0x22 + + + + + + [Channel3] + DDJSR2.deck[2].jog.inputWheel + Jog Platter movement (CDJ Mode) Deck 3, left JOGDIAL (Deck 3 active) + 0xB2 + 0x23 + + + + + + + [Channel3] + DDJSR2.deck[2].vinylButton.input + DECK 3 VINYL MODE + 0x92 + 0x17 + + + + + + [Channel3] + DDJSR2.deck[2].slipButton.input + DECK 3 SLIP MODE + 0x92 + 0x40 + + + + + + + [Channel3] + DDJSR2.deck[2].autoLoop.input + DECK 3 AUTO LOOP + 0x92 + 0x14 + + + + + + [Channel3] + DDJSR2.deck[2].loopActive.input + DECK 3 LOOP ACTIVE + 0x92 + 0x50 + + + + + + [Channel3] + DDJSR2.deck[2].loopHalve.input + DECK 3 LOOP 1/2X + 0x92 + 0x12 + + + + + + + [Channel3] + DDJSR2.deck[2].loopDouble.input + DECK 3 LOOP 2X + 0x92 + 0x13 + + + + + + [Channel3] + DDJSR2.deck[2].loopShiftBackward.input + DECK 3 LOOP SHIFT 1/2X + 0x92 + 0x61 + + + + + + [Channel3] + DDJSR2.deck[2].loopShiftForward.input + DECK 3 LOOP SHIFT 2X + 0x92 + 0x62 + + + + + + [Channel3] + DDJSR2.deck[2].loopIn.input + DECK 3 LOOP IN + 0x92 + 0x10 + + + + + + [Channel3] + DDJSR2.deck[2].loopOut.input + DECK 3 LOOP OUT + 0x92 + 0x11 + + + + + + [Channel3] + DDJSR2.deck[2].slotSelect.input + DECK 3 SLOT SELECT + 0x92 + 0x4C + + + + + + [Channel3] + DDJSR2.deck[2].reloopExit.input + DECK 3 RELOOP/EXIT + 0x92 + 0x4D + + + + + + + + [Channel3] + DDJSR2.mixer.channels[2].pregain.inputMSB + DECK 3 TRIM (MSB) + 0xB2 + 0x04 + + + + + + [Channel3] + DDJSR2.mixer.channels[2].pregain.inputLSB + DECK 3 TRIM (LSB) + 0xB2 + 0x24 + + + + + + [EqualizerRack1_[Channel3]_Effect1] + DDJSR2.mixer.channels[2].eqKnob[2].inputMSB + DECK 3 EQ HI (MSB) + 0xB2 + 0x07 + + + + + + [EqualizerRack1_[Channel3]_Effect1] + DDJSR2.mixer.channels[2].eqKnob[2].inputLSB + DECK 3 EQ HI (LSB) + 0xB2 + 0x27 + + + + + + [EqualizerRack1_[Channel3]_Effect1] + DDJSR2.mixer.channels[2].eqKnob[1].inputMSB + DECK 3 EQ MID (MSB) + 0xB2 + 0x0B + + + + + + [EqualizerRack1_[Channel3]_Effect1] + DDJSR2.mixer.channels[2].eqKnob[1].inputLSB + DECK 3 EQ MID (LSB) + 0xB2 + 0x2B + + + + + + [EqualizerRack1_[Channel3]_Effect1] + DDJSR2.mixer.channels[2].eqKnob[0].inputMSB + DECK 3 EQ LOW (MSB) + 0xB2 + 0x0F + + + + + + [EqualizerRack1_[Channel3]_Effect1] + DDJSR2.mixer.channels[2].eqKnob[0].inputLSB + DECK 3 EQ LOW (LSB) + 0xB2 + 0x2F + + + + + + [QuickEffectRack1_[Channel3]] + DDJSR2.mixer.channels[2].filter.inputMSB + DECK 3 FILTER + 0xB6 + 0x19 + + + + + + [QuickEffectRack1_[Channel3]] + DDJSR2.mixer.channels[2].filter.inputLSB + DECK 3 FILTER + 0xB6 + 0x39 + + + + + + [Channel3] + DDJSR2.mixer.channels[2].pfl.input + DECK 3 CUE/PFL + 0x92 + 0x54 + + + + + [Channel3] + DDJSR2.mixer.channels[2].tapBPM.input + DECK 3 TAP + 0x92 + 0x68 + + + + + + [Channel3] + DDJSR2.mixer.channels[2].volume.inputMSB + DECK 3 VOLUME (MSB) + 0xB2 + 0x13 + + + + + + [Channel3] + DDJSR2.mixer.channels[2].volume.inputLSB + DECK 3 VOLUME (LSB) + 0xB2 + 0x33 + + + + + + + [Channel4] + DDJSR2.deck[3].autoLoop.input + DECK 4 AUTO LOOP + 0x93 + 0x14 + + + + + + [Channel4] + DDJSR2.deck[3].loopActive.input + DECK 4 LOOP ACTIVE + 0x93 + 0x50 + + + + + + [Channel4] + DDJSR2.deck[3].loopHalve.input + DECK 4 LOOP 1/2X + 0x93 + 0x12 + + + + + + + [Channel4] + DDJSR2.deck[3].loopDouble.input + DECK 4 LOOP 2X + 0x93 + 0x13 + + + + + + [Channel4] + DDJSR2.deck[3].loopShiftBackward.input + DECK 4 LOOP SHIFT 1/2X + 0x93 + 0x61 + + + + + + [Channel4] + DDJSR2.deck[3].loopShiftForward.input + DECK 4 LOOP SHIFT 2X + 0x93 + 0x62 + + + + + + [Channel4] + DDJSR2.deck[3].loopIn.input + DECK 4 LOOP IN + 0x93 + 0x10 + + + + + + [Channel4] + DDJSR2.deck[3].loopOut.input + DECK 4 LOOP OUT + 0x93 + 0x11 + + + + + + [Channel4] + DDJSR2.deck[3].slotSelect.input + DECK 4 SLOT SELECT + 0x93 + 0x4C + + + + + + [Channel4] + DDJSR2.deck[3].reloopExit.input + DECK 4 RELOOP/EXIT + 0x93 + 0x4D + + + + + + + + + [Channel4] + DDJSR2.deck[3].play.input + DECK 4 PLAY/PAUSE + 0x93 + 0x0B + + + + + + [Channel3] + DDJSR2.deck[3].censor.input + DECK 4 CENSOR + 0x93 + 0x15 + + + + + + [Channel4] + DDJSR2.deck[3].reverse.input + DECK 4 REVERSE + 0x93 + 0x38 + + + + + + [Channel4] + DDJSR2.deck[3].stutter.input + DECK 4 STUTTER + 0x93 + 0x47 + + + + + + [Channel4] + DDJSR2.deck[3].cue.input + DECK 4 CUE + 0x93 + 0x0C + + + + + + [Channel4] + DDJSR2.deck[3].cuerewind.input + DECK 4 CUE REWIND + 0x93 + 0x48 + + + + + + [Channel4] + DDJSR2.deck[3].sync.input + DECK 4 SYNC + 0x93 + 0x58 + + + + + + [Channel4] + DDJSR2.deck[3].syncOff.input + DECK 4 SYNC OFF + 0x93 + 0x5C + + + + + + + + [Channel4] + DDJSR2.deck[3].tempoFader.inputMSB + DECK 4 TEMPO FADER (MSB) + 0xB3 + 0x00 + + + + + + [Channel4] + DDJSR2.deck[3].tempoFader.inputLSB + DECK 4 TEMPO FADER (LSB) + 0xB3 + 0x20 + + + + + + [Channel4] + DDJSR2.deck[3].tempoRange.input + DECK 4 TEMPO RANGE + 0x93 + 0x60 + + + + + + [Channel4] + DDJSR2.deck[3].tempoReset.input + DECK 4 TEMPO RESET + 0x93 + 0x1C + + + + + + [Channel4] + DDJSR2.deck[3].keyLock.input + DECK 4 KEY LOCK + 0x93 + 0x1A + + + + + + [Channel4] + DDJSR2.deck[3].keySync.input + DECK 4 KEY SYNC + 0x93 + 0x70 + + + + + + [Channel4] + DDJSR2.deck[3].keyShiftUp.input + DECK 4 KEY SHIFT UP + 0x93 + 0x73 + + + + + + [Channel4] + DDJSR2.deck[3].keyShiftDown.input + DECK 4 KEY SHIFT DOWN + 0x93 + 0x72 + + + + + + [Channel4] + DDJSR2.deck[3].keyReset.input + DECK 4 KEY RESET + 0x93 + 0x71 + + + + + + + [Channel4] + DDJSR2.deck[3].needleSearchStripPosition.input + DECK 4 NEEDLE SEARCH STRIP POSITION + 0xB3 + 0x03 + + + + + + [Channel4] + DDJSR2.deck[3].needleSearchStripPositionShifted.input + DECK 4 NEEDLE SEARCH STRIP POSITION Shift pressed + 0xB3 + 0x28 + + + + + + + [Channel4] + DDJSR2.deck[3].gridSetButton.input + 0x93 + 0x64 + + + + + + [Channel4] + DDJSR2.deck[3].brakeStopButton // Originally Grid Adjust, replaced due to poor functionality. + 0x93 + 0x79 + + + + + + [Channel4] + DDJSR2.deck[3].softStartButton // Originally Grid Slide, replaced due to poor functionality. + 0x93 + 0x0A + + + + + + + [Channel4] + DDJSR2.deck[3].jog.inputTouch + DECK 4 PLATTER TOUCH + 0x93 + 0x36 + + + + + + [Channel4] + DDJSR2.deck[3].jog.inputWheel + Jog Platter movement (Vinyl Mode) Deck 4, right JOGDIAL (Deck 4 active) + 0xB3 + 0x22 + + + + + + [Channel4] + DDJSR2.deck[3].jog.inputWheel + Jog Platter movement (CDJ Mode) Deck 4, right JOGDIAL (Deck 4 active) + 0xB3 + 0x23 + + + + + + + [Channel4] + DDJSR2.deck[3].vinylButton.input + DECK 4 VINYL MODE + 0x93 + 0x17 + + + + + + [Channel4] + DDJSR2.deck[3].slipButton.input + DECK 4 SLIP MODE + 0x93 + 0x40 + + + + + + + [Channel4] + DDJSR2.mixer.channels[3].pregain.inputMSB + DECK 4 TRIM (MSB) + 0xB3 + 0x04 + + + + + + [Channel4] + DDJSR2.mixer.channels[3].pregain.inputLSB + DECK 4 TRIM (LSB) + 0xB3 + 0x24 + + + + + + [EqualizerRack1_[Channel4]_Effect1] + DDJSR2.mixer.channels[3].eqKnob[2].inputMSB + DECK 4 EQ HI (MSB) + 0xB3 + 0x07 + + + + + + [EqualizerRack1_[Channel4]_Effect1] + DDJSR2.mixer.channels[3].eqKnob[2].inputLSB + DECK 4 EQ HI (LSB) + 0xB3 + 0x27 + + + + + + [EqualizerRack1_[Channel4]_Effect1] + DDJSR2.mixer.channels[3].eqKnob[1].inputMSB + DECK 4 EQ MID (MSB) + 0xB3 + 0x0B + + + + + + [EqualizerRack1_[Channel4]_Effect1] + DDJSR2.mixer.channels[3].eqKnob[1].inputLSB + DECK 4 EQ MID (LSB) + 0xB3 + 0x2B + + + + + + [EqualizerRack1_[Channel4]_Effect1] + DDJSR2.mixer.channels[3].eqKnob[0].inputMSB + DECK 4 EQ LOW (MSB) + 0xB3 + 0x0F + + + + + + [EqualizerRack1_[Channel4]_Effect1] + DDJSR2.mixer.channels[3].eqKnob[0].inputLSB + DECK 4 EQ LOW (LSB) + 0xB3 + 0x2F + + + + + + [QuickEffectRack1_[Channel4]] + DDJSR2.mixer.channels[3].filter.inputMSB + DECK 4 FILTER + 0xB6 + 0x1A + + + + + + [QuickEffectRack1_[Channel4]] + DDJSR2.mixer.channels[3].filter.inputLSB + DECK 4 FILTER + 0xB6 + 0x3A + + + + + + [Channel4] + DDJSR2.mixer.channels[3].pfl.input + DECK 4 CUE/PFL + 0x93 + 0x54 + + + + + [Channel4] + DDJSR2.mixer.channels[3].tapBPM.input + DECK 4 TAP + 0x93 + 0x68 + + + + + + [Channel4] + DDJSR2.mixer.channels[3].volume.inputMSB + DECK 4 VOLUME (MSB) + 0xB3 + 0x13 + + + + + + [Channel4] + DDJSR2.mixer.channels[3].volume.inputLSB + DECK 4 VOLUME (LSB) + 0xB3 + 0x33 + + + + + + [Channel1] + DDJSR2.browser.loadButtons[0].input + DECK 1 LOAD + 0x96 + 0x46 + + + + + + [Channel2] + DDJSR2.browser.loadButtons[1].input + DECK 2 LOAD + 0x96 + 0x47 + + + + + + [Library] + DDJSR2.browser.sortLibraryBpm.input + BPM + 0x96 + 0x58 + + + + + + [Library] + DDJSR2.browser.sortLibraryArtist.input + ARTIST + 0x96 + 0x59 + + + + + + [Channel3] + DDJSR2.browser.loadButtons[2].input + DECK 3 LOAD + 0x96 + 0x48 + + + + + + + [Channel4] + DDJSR2.browser.loadButtons[3].input + DECK 4 LOAD + 0x96 + 0x49 + + + + + + + + + [Library] + DDJSR2.browser.browseKnob.turn.input + Knob: BROWSER + 0xB6 + 0x40 + + + + + + [Library] + DDJSR2.browser.browseKnob.press.input + Knob: BROWSER PRESS + 0x96 + 0x41 + + + + + + [Library] + DDJSR2.browser.browseKnob.shiftTurn.input + Knob: BROWSER SHIFT TURN + 0xB6 + 0x64 + + + + + + [Library] + DDJSR2.browser.browseKnob.shiftPress.input + Knob: BROWSER SHIFT PRESS + 0x96 + 0x42 + + + + + + [Library] + DDJSR2.browser.loadPrepareButton + AutoDJ Add to Bottom + 0x96 + 0x67 + + + + + + [Library] + DDJSR2.browser.loadPrepareButtonShifted + AutoDJ Add to top + 0x96 + 0x68 + + + + + + [Library] + DDJSR2.browser.backButton.input + Move focus backward in Library, Button: BACK + 0x96 + 0x65 + + + + + + [Library] + DDJSR2.browser.shiftBackButton.input + Toggle maximized view of Library, Button: SHIFT & BACK + 0x96 + 0x66 + + + + + + [Master] + DDJSR2.mixer.panelSelectButton + Show/hide EffectRack/Sampler, Button: left PANEL SELECT + 0x96 + 0x78 + + + + + + [Master] + DDJSR2.mixer.shiftPanelSelectButton + Show/hide EffectRack/Sampler reverse cycle, Button: left SHIFT + PANEL SELECT + 0x96 + 0x79 + + + + + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padModeButtonPressed + DECK 1 PADS - HOT CUE + 0x90 + 0x1B + + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padModeButtonPressed + DECK 1 PADS - ROLL + 0x90 + 0x1E + + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padModeButtonPressed + DECK 1 PADS - SAMPLER + 0x90 + 0x22 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padModeButtonPressed + DECK 1 PADS - SAMPLER + 0x90 + 0x23 + + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padModeButtonPressed + DECK 2 PADS - SAMPLER + 0x91 + 0x22 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padModeButtonPressed + DECK 1 PADS - PITCH PLAY + 0x90 + 0x6E + + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + Hot-Cue 1 Deck 1, Button: PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x97 + 0x00 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + Hot-Cue 2 Deck 1, Button: PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x97 + 0x01 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + Hot-Cue 3 Deck 1, Button: PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x97 + 0x02 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + Hot-Cue 4 Deck 1, Button: PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x97 + 0x03 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + Hot-Cue 5 Deck 1, Button: PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x97 + 0x04 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + Hot-Cue 6 Deck 1, Button: PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x97 + 0x05 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + Hot-Cue 7 Deck 1, Button: PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x97 + 0x06 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + Hot-Cue 8 Deck 1, Button: PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x97 + 0x07 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 1 Deck 1, Button: SHIFT & PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x97 + 0x08 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 2 Deck 1, Button: SHIFT & PAD2 (in HOT-CUE-Mode, Deck 1 active) + 0x97 + 0x09 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 3 Deck 1, Button: SHIFT & PAD3 (in HOT-CUE-Mode, Deck 1 active) + 0x97 + 0x0A + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 4 Deck 1, Button: SHIFT & PAD4 (in HOT-CUE-Mode, Deck 1 active) + 0x97 + 0x0B + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 5 Deck 1, Button: SHIFT & PAD5 (in HOT-CUE-Mode, Deck 1 active) + 0x97 + 0x0C + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 6 Deck 1, Button: SHIFT & PAD6 (in HOT-CUE-Mode, Deck 1 active) + 0x97 + 0x0D + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 7 Deck 1, Button: SHIFT & PAD7 (in HOT-CUE-Mode, Deck 1 active) + 0x97 + 0x0E + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 8 Deck 1, Button: SHIFT & PAD8 (in HOT-CUE-Mode, Deck 1 active) + 0x97 + 0x0F + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.paramMinusButton.input + Parameter1 Left Deck 1 (in HOT-CUE-Mode, Deck 1 active) + 0x90 + 0x24 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.paramPlusButton.input + Parameter1 Right Deck 1 (in HOT-CUE-Mode, Deck 1 active) + 0x90 + 0x2C + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.param2MinusButton.input + Parameter2 Left Deck 1 (in HOT-CUE-Mode, Deck 1 active) + 0x90 + 0x01 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.param2PlusButton.input + Paremeter2 Right Deck 1 (in HOT-CUE-Mode, Deck 1 active) + 0x90 + 0x09 + + + + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 ROLL 1 + 0x97 + 0x10 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 ROLL 2 + 0x97 + 0x11 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 ROLL 3 + 0x97 + 0x12 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 ROLL 4 + 0x97 + 0x13 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 ROLL 5 + 0x97 + 0x14 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 ROLL 6 + 0x97 + 0x15 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 ROLL 7 + 0x97 + 0x16 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 ROLL 8 + 0x97 + 0x17 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.paramMinusButton.input + DECK 1 ROLL PARAMETER 1 MINUS + 0x90 + 0x25 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.paramPlusButton.input + DECK 1 ROLL PARAMETER 1 PLUS + 0x90 + 0x2D + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.param2MinusButton.input + DECK 1 ROLL PARAMETER 2 MINUS + 0x90 + 0x02 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.param2PlusButton.input + DECK 1 ROLL PARAMETER 2 PLUS + 0x90 + 0x7A + + + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + Sampler 1 Deck 1, Button: PAD1 (in Sampler-Mode, Deck 1 active) + 0x97 + 0x30 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + Sampler 2 Deck 1, Button: PAD2 (in Sampler-Mode, Deck 1 active) + 0x97 + 0x31 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + Sampler 3 Deck 1, Button: PAD3 (in Sampler-Mode, Deck 1 active) + 0x97 + 0x32 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + Sampler 4 Deck 1, Button: PAD4 (in Sampler-Mode, Deck 1 active) + 0x97 + 0x33 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + Sampler 5 Deck 1, Button: PAD5 (in Sampler-Mode, Deck 1 active) + 0x97 + 0x34 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + Sampler 6 Deck 1, Button: PAD6 (in Sampler-Mode, Deck 1 active) + 0x97 + 0x35 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + Sampler 7 Deck 1, Button: PAD7 (in Sampler-Mode, Deck 1 active) + 0x97 + 0x36 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + Sampler 8 Deck 1, Button: PAD8 (in Sampler-Mode, Deck 1 active) + 0x97 + 0x37 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.stopSamplerButton.input + Clear Sampler 1 Deck 1, Button: SHIFT & PAD1 (in Sampler-Mode, Deck 1 active) + 0x97 + 0x38 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.stopSamplerButton.input + Clear Sampler 2 Deck 1, Button: SHIFT & PAD2 (in Sampler-Mode, Deck 1 active) + 0x97 + 0x39 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.stopSamplerButton.input + Clear Sampler 3 Deck 1, Button: SHIFT & PAD3 (in Sampler-Mode, Deck 1 active) + 0x97 + 0x3A + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.stopSamplerButton.input + Clear Sampler 4 Deck 1, Button: SHIFT & PAD4 (in Sampler-Mode, Deck 1 active) + 0x97 + 0x3B + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.stopSamplerButton.input + Clear Sampler 5 Deck 1, Button: SHIFT & PAD5 (in Sampler-Mode, Deck 1 active) + 0x97 + 0x3C + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.stopSamplerButton.input + Clear Sampler 6 Deck 1, Button: SHIFT & PAD6 (in Sampler-Mode, Deck 1 active) + 0x97 + 0x3D + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.stopSamplerButton.input + Clear Sampler 7 Deck 1, Button: SHIFT & PAD7 (in Sampler-Mode, Deck 1 active) + 0x97 + 0x3E + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.stopSamplerButton.input + Clear Sampler 8 Deck 1, Button: SHIFT & PAD8 (in Sampler-Mode, Deck 1 active) + 0x97 + 0x3F + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.paramMinusButton.input + Parameter1 Left Deck 1 (in Sampler-Mode, Deck 1 active) + 0x90 + 0x24 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.paramPlusButton.input + Parameter1 Right Deck 1 (in Sampler-Mode, Deck 1 active) + 0x90 + 0x2C + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.param2MinusButton.input + Parameter2 Left Deck 1 (in Sampler-Mode, Deck 1 active) + 0x90 + 0x31 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.param2PlusButton.input + Paremeter2 Right Deck 1 (in Sampler-Mode, Deck 1 active) + 0x90 + 0x39 + + + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 PITCH PLAY 1 + 0x97 + 0x70 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 PITCH PLAY 2 + 0x97 + 0x71 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 PITCH PLAY 3 + 0x97 + 0x72 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 PITCH PLAY 4 + 0x97 + 0x73 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 PITCH PLAY 5 + 0x97 + 0x74 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 PITCH PLAY 6 + 0x97 + 0x75 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 PITCH PLAY 7 + 0x97 + 0x76 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 PITCH PLAY 8 + 0x97 + 0x77 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.paramMinusButton.input + DECK 1 PITCH PLAY PARAMETER 1 MINUS + 0x90 + 0x2B + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.paramPlusButton.input + DECK 1 PITCH PLAY PARAMETER 1 PLUS + 0x90 + 0x33 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 SHIFT PITCH PLAY 1 + 0x97 + 0x78 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 SHIFT PITCH PLAY 2 + 0x97 + 0x79 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 SHIFT PITCH PLAY 3 + 0x97 + 0x7A + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 SHIFT PITCH PLAY 4 + 0x97 + 0x7B + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 SHIFT PITCH PLAY 5 + 0x97 + 0x7C + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 SHIFT PITCH PLAY 6 + 0x97 + 0x7D + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 SHIFT PITCH PLAY 7 + 0x97 + 0x7E + + + + + + [Channel1] + DDJSR2.deck[0].padSection.padPressed + DECK 1 SHIFT PITCH PLAY 8 + 0x97 + 0x7F + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.param2MinusButton.input + DECK 1 PITCH PLAY PARAMETER 2 MINUS + 0x90 + 0x08 + + + + + + [Channel1] + DDJSR2.deck[0].padSection.currentMode.param2PlusButton.input + DECK 1 PITCH PLAY PARAMETER 2 PLUS + 0x90 + 0x00 + + + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padModeButtonPressed + DECK 2 PADS - HOT CUE + 0x91 + 0x1B + + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padModeButtonPressed + DECK 2 PADS - ROLL + 0x91 + 0x1E + + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padModeButtonPressed + DECK 2 PADS - PITCHPLAY + 0x91 + 0x6E + + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + Hot-Cue 1 DECK 2, Button: PAD1 (in HOT-CUE-Mode, DECK 2 active) + 0x98 + 0x00 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + Hot-Cue 2 DECK 2, Button: PAD1 (in HOT-CUE-Mode, DECK 2 active) + 0x98 + 0x01 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + Hot-Cue 3 DECK 2, Button: PAD1 (in HOT-CUE-Mode, DECK 2 active) + 0x98 + 0x02 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + Hot-Cue 4 DECK 2, Button: PAD1 (in HOT-CUE-Mode, DECK 2 active) + 0x98 + 0x03 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + Hot-Cue 5 DECK 2, Button: PAD1 (in HOT-CUE-Mode, DECK 2 active) + 0x98 + 0x04 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + Hot-Cue 6 DECK 2, Button: PAD1 (in HOT-CUE-Mode, DECK 2 active) + 0x98 + 0x05 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + Hot-Cue 7 DECK 2, Button: PAD1 (in HOT-CUE-Mode, DECK 2 active) + 0x98 + 0x06 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + Hot-Cue 8 DECK 2, Button: PAD1 (in HOT-CUE-Mode, DECK 2 active) + 0x98 + 0x07 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 1 DECK 2, Button: SHIFT & PAD1 (in HOT-CUE-Mode, DECK 2 active) + 0x98 + 0x08 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 2 DECK 2, Button: SHIFT & PAD2 (in HOT-CUE-Mode, DECK 2 active) + 0x98 + 0x09 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 3 DECK 2, Button: SHIFT & PAD3 (in HOT-CUE-Mode, DECK 2 active) + 0x98 + 0x0A + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 4 DECK 2, Button: SHIFT & PAD4 (in HOT-CUE-Mode, DECK 2 active) + 0x98 + 0x0B + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 5 DECK 2, Button: SHIFT & PAD5 (in HOT-CUE-Mode, DECK 2 active) + 0x98 + 0x0C + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 6 DECK 2, Button: SHIFT & PAD6 (in HOT-CUE-Mode, DECK 2 active) + 0x98 + 0x0D + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 7 DECK 2, Button: SHIFT & PAD7 (in HOT-CUE-Mode, DECK 2 active) + 0x98 + 0x0E + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 8 DECK 2, Button: SHIFT & PAD8 (in HOT-CUE-Mode, DECK 2 active) + 0x98 + 0x0F + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.paramMinusButton.input + Parameter1 Left DECK 2 (in HOT-CUE-Mode, DECK 2 active) + 0x91 + 0x24 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.paramPlusButton.input + Parameter1 Right DECK 2 (in HOT-CUE-Mode, DECK 2 active) + 0x91 + 0x2C + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.param2MinusButton.input + Parameter2 Left DECK 2 (in HOT-CUE-Mode, DECK 2 active) + 0x91 + 0x01 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.param2PlusButton.input + Paremeter2 Right DECK 2 (in HOT-CUE-Mode, DECK 2 active) + 0x91 + 0x09 + + + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 ROLL 1 + 0x98 + 0x10 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 ROLL 2 + 0x98 + 0x11 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 ROLL 3 + 0x98 + 0x12 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 ROLL 4 + 0x98 + 0x13 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 ROLL 5 + 0x98 + 0x14 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 ROLL 6 + 0x98 + 0x15 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 ROLL 7 + 0x98 + 0x16 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 ROLL 8 + 0x98 + 0x17 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.paramMinusButton.input + DECK 2 ROLL PARAMETER 1 MINUS + 0x91 + 0x25 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.paramPlusButton.input + DECK 2 ROLL PARAMETER 1 PLUS + 0x91 + 0x2D + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.param2MinusButton.input + DECK 2 ROLL PARAMETER 2 MINUS + 0x91 + 0x02 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.param2PlusButton.input + DECK 2 ROLL PARAMETER 2 PLUS + 0x91 + 0x7A + + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + Sampler 1 Deck 2, Button: PAD1 (in Sampler-Mode, Deck 2 active) + 0x98 + 0x30 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + Sampler 2 Deck 2, Button: PAD2 (in Sampler-Mode, Deck 2 active) + 0x98 + 0x31 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + Sampler 3 Deck 2, Button: PAD3 (in Sampler-Mode, Deck 2 active) + 0x98 + 0x32 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + Sampler 4 Deck 2, Button: PAD4 (in Sampler-Mode, Deck 2 active) + 0x98 + 0x33 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + Sampler 5 Deck 2, Button: PAD5 (in Sampler-Mode, Deck 2 active) + 0x98 + 0x34 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + Sampler 6 Deck 2, Button: PAD6 (in Sampler-Mode, Deck 2 active) + 0x98 + 0x35 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + Sampler 7 Deck 2, Button: PAD7 (in Sampler-Mode, Deck 2 active) + 0x98 + 0x36 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + Sampler 8 Deck 2, Button: PAD8 (in Sampler-Mode, Deck 2 active) + 0x98 + 0x37 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.stopSamplerButton.input + Clear Sampler 1 Deck 2, Button: SHIFT & PAD1 (in Sampler-Mode, Deck 2 active) + 0x98 + 0x38 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.stopSamplerButton.input + Clear Sampler 2 Deck 2, Button: SHIFT & PAD2 (in Sampler-Mode, Deck 2 active) + 0x98 + 0x39 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.stopSamplerButton.input + Clear Sampler 3 Deck 2, Button: SHIFT & PAD3 (in Sampler-Mode, Deck 2 active) + 0x98 + 0x3A + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.stopSamplerButton.input + Clear Sampler 4 Deck 2, Button: SHIFT & PAD4 (in Sampler-Mode, Deck 2 active) + 0x98 + 0x3B + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.stopSamplerButton.input + Clear Sampler 5 Deck 2, Button: SHIFT & PAD5 (in Sampler-Mode, Deck 2 active) + 0x98 + 0x3C + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.stopSamplerButton.input + Clear Sampler 6 Deck 2, Button: SHIFT & PAD6 (in Sampler-Mode, Deck 2 active) + 0x98 + 0x3D + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.stopSamplerButton.input + Clear Sampler 7 Deck 2, Button: SHIFT & PAD7 (in Sampler-Mode, Deck 2 active) + 0x98 + 0x3E + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.stopSamplerButton.input + Clear Sampler 8 Deck 2, Button: SHIFT & PAD8 (in Sampler-Mode, Deck 2 active) + 0x98 + 0x3F + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.paramMinusButton.input + Parameter1 Left Deck 2 (in Sampler-Mode, Deck 2 active) + 0x91 + 0x24 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.paramPlusButton.input + Parameter1 Right Deck 2 (in Sampler-Mode, Deck 2 active) + 0x91 + 0x2C + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.param2MinusButton.input + Parameter2 Left Deck 2 (in Sampler-Mode, Deck 2 active) + 0x91 + 0x31 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.param2PlusButton.input + Paremeter2 Right Deck 2 (in Sampler-Mode, Deck 2 active) + 0x91 + 0x39 + + + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 PITCH PLAY 1 + 0x98 + 0x70 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 PITCH PLAY 2 + 0x98 + 0x71 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 PITCH PLAY 3 + 0x98 + 0x72 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 PITCH PLAY 4 + 0x98 + 0x73 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 PITCH PLAY 5 + 0x98 + 0x74 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 PITCH PLAY 6 + 0x98 + 0x75 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 PITCH PLAY 7 + 0x98 + 0x76 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 PITCH PLAY 8 + 0x98 + 0x77 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.paramMinusButton.input + DECK 2 PITCH PLAY PARAMETER 1 MINUS + 0x91 + 0x2B + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.paramPlusButton.input + DECK 2 PITCH PLAY PARAMETER 1 PLUS + 0x91 + 0x33 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 SHIFT PITCH PLAY 1 + 0x98 + 0x78 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 SHIFT PITCH PLAY 2 + 0x98 + 0x79 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 SHIFT PITCH PLAY 3 + 0x98 + 0x7A + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 SHIFT PITCH PLAY 4 + 0x98 + 0x7B + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 SHIFT PITCH PLAY 5 + 0x98 + 0x7C + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 SHIFT PITCH PLAY 6 + 0x98 + 0x7D + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 SHIFT PITCH PLAY 7 + 0x98 + 0x7E + + + + + + [Channel2] + DDJSR2.deck[1].padSection.padPressed + DECK 2 SHIFT PITCH PLAY 8 + 0x98 + 0x7F + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.param2MinusButton.input + DECK 2 PITCH PLAY PARAMETER 2 MINUS + 0x91 + 0x08 + + + + + + [Channel2] + DDJSR2.deck[1].padSection.currentMode.param2PlusButton.input + DECK 2 PITCH PLAY PARAMETER 2 PLUS + 0x91 + 0x00 + + + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padModeButtonPressed + DECK 3 PADS - HOT CUE + 0x92 + 0x1B + + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padModeButtonPressed + DECK 3 PADS - ROLL + 0x92 + 0x1E + + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padModeButtonPressed + DECK 3 PADS - SAMPLER + 0x92 + 0x22 + + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padModeButtonPressed + DECK 3 PADS - PITCHPLAY + 0x92 + 0x6E + + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + Hot-Cue 1 Deck 1, Button: PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x99 + 0x00 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + Hot-Cue 2 Deck 1, Button: PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x99 + 0x01 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + Hot-Cue 3 Deck 1, Button: PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x99 + 0x02 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + Hot-Cue 4 Deck 1, Button: PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x99 + 0x03 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + Hot-Cue 5 Deck 1, Button: PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x99 + 0x04 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + Hot-Cue 6 Deck 1, Button: PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x99 + 0x05 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + Hot-Cue 7 Deck 1, Button: PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x99 + 0x06 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + Hot-Cue 8 Deck 1, Button: PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x99 + 0x07 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 1 Deck 1, Button: SHIFT & PAD1 (in HOT-CUE-Mode, Deck 1 active) + 0x99 + 0x08 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 2 Deck 1, Button: SHIFT & PAD2 (in HOT-CUE-Mode, Deck 1 active) + 0x99 + 0x09 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 3 Deck 1, Button: SHIFT & PAD3 (in HOT-CUE-Mode, Deck 1 active) + 0x99 + 0x0A + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 4 Deck 1, Button: SHIFT & PAD4 (in HOT-CUE-Mode, Deck 1 active) + 0x99 + 0x0B + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 5 Deck 1, Button: SHIFT & PAD5 (in HOT-CUE-Mode, Deck 1 active) + 0x99 + 0x0C + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 6 Deck 1, Button: SHIFT & PAD6 (in HOT-CUE-Mode, Deck 1 active) + 0x99 + 0x0D + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 7 Deck 1, Button: SHIFT & PAD7 (in HOT-CUE-Mode, Deck 1 active) + 0x99 + 0x0E + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 8 Deck 1, Button: SHIFT & PAD8 (in HOT-CUE-Mode, Deck 1 active) + 0x99 + 0x0F + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.paramMinusButton.input + Parameter1 Left Deck 1 (in HOT-CUE-Mode, Deck 1 active) + 0x92 + 0x24 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.paramPlusButton.input + Parameter1 Right Deck 1 (in HOT-CUE-Mode, Deck 1 active) + 0x92 + 0x2C + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.param2MinusButton.input + Parameter2 Left Deck 1 (in HOT-CUE-Mode, Deck 1 active) + 0x92 + 0x01 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.param2PlusButton.input + Paremeter2 Right Deck 1 (in HOT-CUE-Mode, Deck 1 active) + 0x92 + 0x09 + + + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 ROLL 1 + 0x99 + 0x10 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 ROLL 2 + 0x99 + 0x11 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 ROLL 3 + 0x99 + 0x12 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 ROLL 4 + 0x99 + 0x13 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 ROLL 5 + 0x99 + 0x14 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 ROLL 6 + 0x99 + 0x15 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 ROLL 7 + 0x99 + 0x16 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 ROLL 8 + 0x99 + 0x17 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.paramMinusButton.input + DECK 3 ROLL PARAMETER 1 MINUS + 0x92 + 0x25 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.paramPlusButton.input + DECK 3 ROLL PARAMETER 1 PLUS + 0x92 + 0x2D + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.param2MinusButton.input + DECK 3 ROLL PARAMETER 2 MINUS + 0x92 + 0x02 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.param2PlusButton.input + DECK 3 ROLL PARAMETER 2 PLUS + 0x92 + 0x7A + + + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + Sampler 1 Deck 3, Button: PAD1 (in Sampler-Mode, Deck 3 active) + 0x99 + 0x30 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + Sampler 2 Deck 3, Button: PAD2 (in Sampler-Mode, Deck 3 active) + 0x99 + 0x31 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + Sampler 3 Deck 3, Button: PAD3 (in Sampler-Mode, Deck 3 active) + 0x99 + 0x32 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + Sampler 4 Deck 3, Button: PAD4 (in Sampler-Mode, Deck 3 active) + 0x99 + 0x33 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + Sampler 5 Deck 3, Button: PAD5 (in Sampler-Mode, Deck 3 active) + 0x99 + 0x34 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + Sampler 6 Deck 3, Button: PAD6 (in Sampler-Mode, Deck 3 active) + 0x99 + 0x35 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + Sampler 7 Deck 3, Button: PAD7 (in Sampler-Mode, Deck 3 active) + 0x99 + 0x36 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + Sampler 8 Deck 3, Button: PAD8 (in Sampler-Mode, Deck 3 active) + 0x99 + 0x37 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.stopSamplerButton.input + Clear Sampler 1 Deck 3, Button: SHIFT & PAD1 (in Sampler-Mode, Deck 3 active) + 0x99 + 0x38 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.stopSamplerButton.input + Clear Sampler 2 Deck 3, Button: SHIFT & PAD2 (in Sampler-Mode, Deck 3 active) + 0x99 + 0x39 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.stopSamplerButton.input + Clear Sampler 3 Deck 3, Button: SHIFT & PAD3 (in Sampler-Mode, Deck 3 active) + 0x99 + 0x3A + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.stopSamplerButton.input + Clear Sampler 4 Deck 3, Button: SHIFT & PAD4 (in Sampler-Mode, Deck 3 active) + 0x99 + 0x3B + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.stopSamplerButton.input + Clear Sampler 5 Deck 3, Button: SHIFT & PAD5 (in Sampler-Mode, Deck 3 active) + 0x99 + 0x3C + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.stopSamplerButton.input + Clear Sampler 6 Deck 3, Button: SHIFT & PAD6 (in Sampler-Mode, Deck 3 active) + 0x99 + 0x3D + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.stopSamplerButton.input + Clear Sampler 7 Deck 3, Button: SHIFT & PAD7 (in Sampler-Mode, Deck 3 active) + 0x99 + 0x3E + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.stopSamplerButton.input + Clear Sampler 8 Deck 3, Button: SHIFT & PAD8 (in Sampler-Mode, Deck 3 active) + 0x99 + 0x3F + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.paramMinusButton.input + Parameter1 Left Deck 3 (in Sampler-Mode, Deck 3 active) + 0x92 + 0x24 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.paramPlusButton.input + Parameter1 Right Deck 3 (in Sampler-Mode, Deck 3 active) + 0x92 + 0x2C + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.param2MinusButton.input + Parameter2 Left Deck 3 (in Sampler-Mode, Deck 3 active) + 0x92 + 0x31 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.param2PlusButton.input + Paremeter2 Right Deck 3 (in Sampler-Mode, Deck 3 active) + 0x92 + 0x39 + + + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 PITCH PLAY 1 + 0x99 + 0x70 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 PITCH PLAY 2 + 0x99 + 0x71 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 PITCH PLAY 3 + 0x99 + 0x72 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 PITCH PLAY 4 + 0x99 + 0x73 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 PITCH PLAY 5 + 0x99 + 0x74 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 PITCH PLAY 6 + 0x99 + 0x75 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 PITCH PLAY 7 + 0x99 + 0x76 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 PITCH PLAY 8 + 0x99 + 0x77 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.paramMinusButton.input + DECK 3 PITCH PLAY PARAMETER 1 MINUS + 0x92 + 0x2B + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.paramPlusButton.input + DECK 3 PITCH PLAY PARAMETER 1 PLUS + 0x92 + 0x33 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 SHIFT PITCH PLAY 1 + 0x99 + 0x78 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 SHIFT PITCH PLAY 2 + 0x99 + 0x79 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 SHIFT PITCH PLAY 3 + 0x99 + 0x7A + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 SHIFT PITCH PLAY 4 + 0x99 + 0x7B + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 SHIFT PITCH PLAY 5 + 0x99 + 0x7C + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 SHIFT PITCH PLAY 6 + 0x99 + 0x7D + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 SHIFT PITCH PLAY 7 + 0x99 + 0x7E + + + + + + [Channel3] + DDJSR2.deck[2].padSection.padPressed + DECK 3 SHIFT PITCH PLAY 8 + 0x99 + 0x7F + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.param2MinusButton.input + DECK 3 PITCH PLAY PARAMETER 2 MINUS + 0x92 + 0x08 + + + + + + [Channel3] + DDJSR2.deck[2].padSection.currentMode.param2PlusButton.input + DECK 3 PITCH PLAY PARAMETER 2 PLUS + 0x92 + 0x00 + + + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padModeButtonPressed + DECK 4 PADS - HOT CUE + 0x93 + 0x1B + + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padModeButtonPressed + DECK 4 PADS - ROLL + 0x93 + 0x1E + + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padModeButtonPressed + DECK 4 PADS - SAMPLER + 0x93 + 0x22 + + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padModeButtonPressed + DECK 4 PADS - PITCHPLAY + 0x93 + 0x6E + + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + Hot-Cue 1 DECK 4, Button: PAD1 (in HOT-CUE-Mode, DECK 4 active) + 0x9A + 0x00 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + Hot-Cue 2 DECK 4, Button: PAD1 (in HOT-CUE-Mode, DECK 4 active) + 0x9A + 0x01 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + Hot-Cue 3 DECK 4, Button: PAD1 (in HOT-CUE-Mode, DECK 4 active) + 0x9A + 0x02 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + Hot-Cue 4 DECK 4, Button: PAD1 (in HOT-CUE-Mode, DECK 4 active) + 0x9A + 0x03 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + Hot-Cue 5 DECK 4, Button: PAD1 (in HOT-CUE-Mode, DECK 4 active) + 0x9A + 0x04 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + Hot-Cue 6 DECK 4, Button: PAD1 (in HOT-CUE-Mode, DECK 4 active) + 0x9A + 0x05 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + Hot-Cue 7 DECK 4, Button: PAD1 (in HOT-CUE-Mode, DECK 4 active) + 0x9A + 0x06 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + Hot-Cue 8 DECK 4, Button: PAD1 (in HOT-CUE-Mode, DECK 4 active) + 0x9A + 0x07 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 1 DECK 4, Button: SHIFT & PAD1 (in HOT-CUE-Mode, DECK 4 active) + 0x9A + 0x08 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 2 DECK 4, Button: SHIFT & PAD2 (in HOT-CUE-Mode, DECK 4 active) + 0x9A + 0x09 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 3 DECK 4, Button: SHIFT & PAD3 (in HOT-CUE-Mode, DECK 4 active) + 0x9A + 0x0A + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 4 DECK 4, Button: SHIFT & PAD4 (in HOT-CUE-Mode, DECK 4 active) + 0x9A + 0x0B + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 5 DECK 4, Button: SHIFT & PAD5 (in HOT-CUE-Mode, DECK 4 active) + 0x9A + 0x0C + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 6 DECK 4, Button: SHIFT & PAD6 (in HOT-CUE-Mode, DECK 4 active) + 0x9A + 0x0D + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 7 DECK 4, Button: SHIFT & PAD7 (in HOT-CUE-Mode, DECK 4 active) + 0x9A + 0x0E + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.clearHotcueButton.input + Clear Hot-Cue 8 DECK 4, Button: SHIFT & PAD8 (in HOT-CUE-Mode, DECK 4 active) + 0x9A + 0x0F + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.paramMinusButton.input + Parameter1 Left DECK 4 (in HOT-CUE-Mode, DECK 4 active) + 0x93 + 0x24 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.paramPlusButton.input + Parameter1 Right DECK 4 (in HOT-CUE-Mode, DECK 4 active) + 0x93 + 0x2C + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.param2MinusButton.input + Parameter2 Left DECK 4 (in HOT-CUE-Mode, DECK 4 active) + 0x93 + 0x01 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.param2PlusButton.input + Paremeter2 Right DECK 4 (in HOT-CUE-Mode, DECK 4 active) + 0x93 + 0x09 + + + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 ROLL 1 + 0x9A + 0x10 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 ROLL 2 + 0x9A + 0x11 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 ROLL 3 + 0x9A + 0x12 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 ROLL 4 + 0x9A + 0x13 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 ROLL 5 + 0x9A + 0x14 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 ROLL 6 + 0x9A + 0x15 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 ROLL 7 + 0x9A + 0x16 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 ROLL 8 + 0x9A + 0x17 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.paramMinusButton.input + DECK 4 ROLL PARAMETER 1 MINUS + 0x93 + 0x25 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.paramPlusButton.input + DECK 4 ROLL PARAMETER 1 PLUS + 0x93 + 0x2D + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.param2MinusButton.input + DECK 4 ROLL PARAMETER 2 MINUS + 0x93 + 0x02 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.param2PlusButton.input + DECK 4 ROLL PARAMETER 2 PLUS + 0x93 + 0x7A + + + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + Sampler 1 Deck 4, Button: PAD1 (in Sampler-Mode, Deck 4 active) + 0x9A + 0x30 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + Sampler 2 Deck 4, Button: PAD2 (in Sampler-Mode, Deck 4 active) + 0x9A + 0x31 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + Sampler 3 Deck 4, Button: PAD3 (in Sampler-Mode, Deck 4 active) + 0x9A + 0x32 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + Sampler 4 Deck 4, Button: PAD4 (in Sampler-Mode, Deck 4 active) + 0x9A + 0x33 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + Sampler 5 Deck 4, Button: PAD5 (in Sampler-Mode, Deck 4 active) + 0x9A + 0x34 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + Sampler 6 Deck 4, Button: PAD6 (in Sampler-Mode, Deck 4 active) + 0x9A + 0x35 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + Sampler 7 Deck 4, Button: PAD7 (in Sampler-Mode, Deck 4 active) + 0x9A + 0x36 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + Sampler 8 Deck 4, Button: PAD8 (in Sampler-Mode, Deck 4 active) + 0x9A + 0x37 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.stopSamplerButton.input + Clear Sampler 1 Deck 4, Button: SHIFT & PAD1 (in Sampler-Mode, Deck 4 active) + 0x9A + 0x38 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.stopSamplerButton.input + Clear Sampler 2 Deck 4, Button: SHIFT & PAD2 (in Sampler-Mode, Deck 4 active) + 0x9A + 0x39 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.stopSamplerButton.input + Clear Sampler 3 Deck 4, Button: SHIFT & PAD3 (in Sampler-Mode, Deck 4 active) + 0x9A + 0x3A + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.stopSamplerButton.input + Clear Sampler 4 Deck 4, Button: SHIFT & PAD4 (in Sampler-Mode, Deck 4 active) + 0x9A + 0x3B + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.stopSamplerButton.input + Clear Sampler 5 Deck 4, Button: SHIFT & PAD5 (in Sampler-Mode, Deck 4 active) + 0x9A + 0x3C + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.stopSamplerButton.input + Clear Sampler 6 Deck 4, Button: SHIFT & PAD6 (in Sampler-Mode, Deck 4 active) + 0x9A + 0x3D + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.stopSamplerButton.input + Clear Sampler 7 Deck 4, Button: SHIFT & PAD7 (in Sampler-Mode, Deck 4 active) + 0x9A + 0x3E + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.stopSamplerButton.input + Clear Sampler 8 Deck 4, Button: SHIFT & PAD8 (in Sampler-Mode, Deck 4 active) + 0x9A + 0x3F + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.paramMinusButton.input + Parameter1 Left Deck 4 (in Sampler-Mode, Deck 4 active) + 0x93 + 0x24 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.paramPlusButton.input + Parameter1 Right Deck 4 (in Sampler-Mode, Deck 4 active) + 0x93 + 0x2C + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.param2MinusButton.input + Parameter2 Left Deck 4 (in Sampler-Mode, Deck 4 active) + 0x93 + 0x31 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.param2PlusButton.input + Paremeter2 Right Deck 4 (in Sampler-Mode, Deck 4 active) + 0x93 + 0x39 + + + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 PITCH PLAY 1 + 0x9A + 0x70 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 PITCH PLAY 2 + 0x9A + 0x71 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 PITCH PLAY 3 + 0x9A + 0x72 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 PITCH PLAY 4 + 0x9A + 0x73 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 PITCH PLAY 5 + 0x9A + 0x74 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 PITCH PLAY 6 + 0x9A + 0x75 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 PITCH PLAY 7 + 0x9A + 0x76 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 PITCH PLAY 8 + 0x9A + 0x77 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.paramMinusButton.input + DECK 4 PITCH PLAY PARAMETER 1 MINUS + 0x93 + 0x2B + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.paramPlusButton.input + DECK 4 PITCH PLAY PARAMETER 1 PLUS + 0x93 + 0x33 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 SHIFT PITCH PLAY 1 + 0x9A + 0x78 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 SHIFT PITCH PLAY 2 + 0x9A + 0x79 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 SHIFT PITCH PLAY 3 + 0x9A + 0x7A + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 SHIFT PITCH PLAY 4 + 0x9A + 0x7B + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 SHIFT PITCH PLAY 5 + 0x9A + 0x7C + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 SHIFT PITCH PLAY 6 + 0x9A + 0x7D + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 SHIFT PITCH PLAY 7 + 0x9A + 0x7E + + + + + + [Channel4] + DDJSR2.deck[3].padSection.padPressed + DECK 4 SHIFT PITCH PLAY 8 + 0x9A + 0x7F + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.param2MinusButton.input + DECK 4 PITCH PLAY PARAMETER 2 MINUS + 0x93 + 0x08 + + + + + + [Channel4] + DDJSR2.deck[3].padSection.currentMode.param2PlusButton.input + DECK 4 PITCH PLAY PARAMETER 2 PLUS + 0x93 + 0x00 + + + + + + [Master] + DDJSR2.mixer.crossfader.inputMSB + CROSS FADER (MSB) + 0xB6 + 0x1F + + + + + + [Master] + DDJSR2.mixer.crossfader.inputLSB + CROSS FADER (LSB) + 0xB6 + 0x3F + + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].dryWetKnob.input + Dry/Wet Mixing Ratio of Effect Unit 1, Knob: FX1 BEATS + 0xB4 + 0x00 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].dryWetKnob.input + Dry/Wet Mixing Ratio of Effect Unit 2, Knob: FX2 BEATS + 0xB5 + 0x00 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].knobs[1].inputMSB + FX1 Effect 1 Meta (MSB), Knob: FX1-1 + 0xB4 + 0x02 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].knobs[1].inputMSB + FX2 Effect 1 Meta (MSB), Knob: FX2-1 + 0xB5 + 0x02 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].knobs[2].inputMSB + FX1 Effect 2 Meta (MSB), Knob: FX1-2 + 0xB4 + 0x04 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].knobs[2].inputMSB + FX2 Effect 2 Meta (MSB), Knob: FX2-2 + 0xB5 + 0x04 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].knobs[3].inputMSB + FX1 Effect 3 Meta (MSB), Knob: FX1-3 + 0xB4 + 0x06 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].knobs[3].inputMSB + FX2 Effect 3 Meta (MSB), Knob: FX2-3 + 0xB5 + 0x06 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].dryWetKnob.input + Super1 Parameter of Effect Unit 1, Knob: SHIFT & FX1 BEATS + 0xB4 + 0x10 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].dryWetKnob.input + Super1 Parameter of Effect Unit 2, Knob: SHIFT & FX2 BEATS + 0xB5 + 0x10 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].knobs[1].inputMSB + FX1 Effect 1 Select (MSB), Knob: SHIFT + FX1-1 + 0xB4 + 0x12 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].knobs[1].inputMSB + FX2 Effect 1 Select (MSB), Knob: SHIFT + FX2-1 + 0xB5 + 0x12 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].knobs[2].inputMSB + FX1 Effect 2 Select (MSB), Knob: SHIFT + FX1-2 + 0xB4 + 0x14 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].knobs[2].inputMSB + FX2 Effect 2 Select (MSB), Knob: SHIFT + FX2-2 + 0xB5 + 0x14 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].knobs[3].inputMSB + FX1 Effect 3 Select (MSB), Knob: SHIFT + FX1-3 + 0xB4 + 0x16 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].knobs[3].inputMSB + FX2 Effect 3 Select (MSB), Knob: SHIFT + FX2-3 + 0xB5 + 0x16 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].knobs[1].inputLSB + FX1 Effect 1 Meta (LSB), Knob: FX1-1 + 0xB4 + 0x22 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].knobs[1].inputLSB + FX2 Effect 1 Meta (LSB), Knob: FX2-1 + 0xB5 + 0x22 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].knobs[2].inputLSB + FX1 Effect 2 Meta (LSB), Knob: FX1-2 + 0xB4 + 0x24 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].knobs[2].inputLSB + FX2 Effect 2 Meta (LSB), Knob: FX2-2 + 0xB5 + 0x24 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].knobs[3].inputLSB + FX1 Effect 3 Meta (LSB), Knob: FX1-3 + 0xB4 + 0x26 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].knobs[3].inputLSB + FX2 Effect 3 Meta (LSB), Knob: FX2-3 + 0xB5 + 0x26 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].knobs[1].inputLSB + FX1 Effect 1 Select (LSB), Knob: SHIFT + FX1-1 + 0xB4 + 0x32 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].knobs[1].inputLSB + FX2 Effect 1 Select (LSB), Knob: SHIFT + FX2-1 + 0xB5 + 0x32 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].knobs[2].inputLSB + FX1 Effect 2 Select (LSB), Knob: SHIFT + FX1-2 + 0xB4 + 0x34 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].knobs[2].inputLSB + FX2 Effect 2 Select (LSB), Knob: SHIFT + FX2-2 + 0xB5 + 0x34 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].knobs[3].inputLSB + FX1 Effect 3 Select (LSB), Knob: SHIFT + FX1-3 + 0xB4 + 0x36 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].knobs[3].inputLSB + FX2 Effect 3 Select (LSB), Knob: SHIFT + FX2-3 + 0xB5 + 0x36 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].enableButtons[1].input + Enable (if effectFocusButton pressed: Focus) Effect 1 of Effect Unit 1, Button: FX1-1 ON + 0x94 + 0x47 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].enableButtons[1].input + Enable (if effectFocusButton pressed: Focus) Effect 1 of Effect Unit 2, Button: FX2-1 ON + 0x95 + 0x47 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].enableButtons[2].input + Enable (if effectFocusButton pressed: Focus) Effect 2 of Effect Unit 1, Button: FX1-2 ON + 0x94 + 0x48 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].enableButtons[2].input + Enable (if effectFocusButton pressed: Focus) Effect 2 of Effect Unit 2, Button: FX2-2 ON + 0x95 + 0x48 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].enableButtons[3].input + Enable (if effectFocusButton pressed: Focus) Effect 3 of Effect Unit 1, Button: FX1-3 ON + 0x94 + 0x49 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].enableButtons[3].input + Enable (if effectFocusButton pressed: Focus) Effect 3 of Effect Unit 2, Button: FX2-3 ON + 0x95 + 0x49 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].effectFocusButton.input + Press hold: Enables effect focus selection, Shortpress: Toggles effect focus mode of EffectUnit 1, Button: FX1 TAP + 0x94 + 0x4A + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].effectFocusButton.input + Press hold: Enables effect focus selection, Shortpress: Toggles effect focus mode of EffectUnit 2, Button: FX2 TAP + 0x95 + 0x4A + + + + + + [Channel1] + DDJSR2.effectUnits[1].enableOnChannelButtons.Channel1.input + Effect Unit 1 assign Channel 1 Button: FX1 assign 1 + 0x96 + 0x4C + + + + + + [Channel1] + DDJSR2.effectUnits[2].enableOnChannelButtons.Channel1.input + Effect Unit 2 assignment channel 1, Button: FX2 assign Button 1 + 0x96 + 0x4D + + + + + + [Channel2] + DDJSR2.effectUnits[1].enableOnChannelButtons.Channel2.input + Effect Unit 1 assign Channel 2 Button: FX1 assign 2 + 0x96 + 0x50 + + + + + + [Channel2] + DDJSR2.effectUnits[2].enableOnChannelButtons.Channel2.input + Effect Unit 2 assignment channel 2, Button: FX2 assign Button 2 + 0x96 + 0x51 + + + + + + [Channel4] + DDJSR2.effectUnits[1].enableOnChannelButtons.Channel4.input + Effect Unit 1 assignment Channel 4, Button: FX1 assign SHIFT 2 + 0x96 + 0x54 + + + + + + [Channel4] + DDJSR2.effectUnits[2].enableOnChannelButtons.Channel4.input + Effect Unit 2 assignment channel 4, Button: Shift & FX2 assign Button 2 + 0x96 + 0x55 + + + + + + [EffectRack1_EffectUnit1] + DDJSR2.effectUnits[1].effectFocusButton.input + Switch between EffectUnits, Button: SHIFT & FX1 TAP + 0x94 + 0x66 + + + + + + [EffectRack1_EffectUnit2] + DDJSR2.effectUnits[2].effectFocusButton.input + Switch between EffectUnits, Button: SHIFT & FX2 TAP + 0x95 + 0x66 + + + + + + [Channel3] + DDJSR2.effectUnits[1].enableOnChannelButtons.Channel3.input + Effect Unit 1 assign Channel 3, Button: FX1 assign SHIFT 1 + 0x96 + 0x70 + + + + + + [Channel3] + DDJSR2.effectUnits[2].enableOnChannelButtons.Channel3.input + Effect Unit 2 assignment channel 3, Button: Shift & FX2 assign Button 1 + 0x96 + 0x71 + + + + + + [Master] + DDJSR2.effectUnits[1].effectFocusButton.input + FX 1 TAP + 0x94 + 0x43 + + + + + + [Master] + DDJSR2.effectUnits[2].effectFocusButton.input + FX 1 TAP + 0x95 + 0x43 + + + + + + + +