diff --git a/CHANGELOG b/CHANGELOG index ece5b56cb5c..761be54aa50 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -14,6 +14,7 @@ * Add controller mapping for Native Instruments Traktor Kontrol S2 MK3 #2348 * Add controller mapping for Soundless joyMIDI #2425 * Add controller mapping for Hercules DJControl Inpulse 300 #2465 +* Add controller mapping for Denon MC7000 #2546 ==== 2.2.3 2019-11-24 ==== * Don't make users reconfigure sound hardware when it has not changed #2253 diff --git a/res/controllers/Denon-MC7000-scripts.js b/res/controllers/Denon-MC7000-scripts.js new file mode 100644 index 00000000000..f26d246d941 --- /dev/null +++ b/res/controllers/Denon-MC7000-scripts.js @@ -0,0 +1,867 @@ +/** + * Denon DJ MC7000 DJ controller script for Mixxx 2.2.3 + * + * Started in Dec. 2019 by OsZ + * + * 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. + * + * Before using the mapping please make sure your MC7000 controller works for + * your operating system. For Windows you need driver software by Denon, Mac users + * should be lucky as it shall work out-of-the-box. Linux users need to know that + * the MC7000 internal audio interface is not available out-of-the-box for + * older Linux Kernels. You should upgrade your Kernel to minimum versions + * LTS: 4.19.105 or 5.4.21, stable branch 5.5.5 or current 5.6 (2020-Feb-19). + * Newer Kernels will surely also provide native audio support for this controller. +**/ + +var MC7000 = {}; + +/*/////////////////////////////////// +// USER VARIABLES BEGIN // +///////////////////////////////////*/ + +// Wanna have Needle Search active while playing a track ? +// In any case Needle Search is available holding "SHIFT" down. +// can be true or false (recommended: false) +MC7000.needleSearchPlay = false; + +// Possible pitchfader rateranges given in percent. +// can be cycled through be the RANGE buttons. +MC7000.rateRanges = [ + 4/100, // default: 4/100 + 6/100, // default: 6/100 + 10/100, // default: 10/100 + 16/100, // default: 16/100 + 24/100, // default: 24/100 +]; + +// Platter Ring LED mode +// Mode 0 = Single "off" LED chase (all others "on") +// Mode 1 = Single "on" LED chase (all others "off") +// use "SHIFT" + "DECK #" to toggle between both modes +MC7000.modeSingleLED = 1; // default: 1 + +// Set Vinyl Mode on ("true") or off ("false") when MIXXX starts. +// This sets the Jog Wheel touch detection / Vinyl Mode +// and the Jog LEDs ("VINYL" on = spinny, "VINYL" off = track position). +MC7000.VinylModeOn = true; // default: true + +// Scratch algorithm parameters +MC7000.scratchParams = { + recordSpeed: 33.3, // default: 33.3 + alpha: (1.0/10), // default: (1.0/10) + beta: (1.0/10)/32 // default: (1.0/10)/32 +}; + +// Sensitivity of the jog wheel (also depends on audio latency) +MC7000.jogParams = { + // Lower values for less, higher values for more sensitive + jogSensitivity: 30, // default: 30 + // this will limit the parameter of "jog" (keep between 0.5 and 3) + maxJogValue: 3 // default: 3 +}; + +/*///////////////////////////////// +// USER VARIABLES END // +/////////////////////////////////*/ + + +/* OTHER VARIABLES - DONT'T TOUCH EXCEPT YOU KNOW WHAT YOU DO */ + +// Resolution of the jog wheel, set so the spinny +// Jog LED to match exactly the movement of the Jog Wheel +// The physical resolution seems to be around 1100 +MC7000.jogWheelTicksPerRevolution = 894; + +// must be "true" for Needle Search to be active +MC7000.needleSearchTouched = [true, true, true, true]; + +// initial value for VINYL mode per Deck (see above for user input) +MC7000.isVinylMode = [MC7000.VinylModeOn, MC7000.VinylModeOn, MC7000.VinylModeOn, MC7000.VinylModeOn]; + +// used to keep track of which the rateRange of each slider. +// value used as an index to MC7000.rateRanges +MC7000.currentRateRangeIndex = [0, 0, 0, 0]; + +// initialize the "factor" function for Spinback +MC7000.factor = []; + +// initialize the PAD Mode to Hot Cue and all others off when starting +MC7000.PADModeCue = [true, true, true, true]; +MC7000.PADModeCueLoop = [false, false, false, false]; +MC7000.PADModeFlip = [false, false, false, false]; +MC7000.PADModeRoll = [false, false, false, false]; +MC7000.PADModeSavedLoop = [false, false, false, false]; +MC7000.PADModeSlicer = [false, false, false, false]; +MC7000.PADModeSlicerLoop = [false, false, false, false]; +MC7000.PADModeSampler = [false, false, false, false]; +MC7000.PADModeVelSamp = [false, false, false, false]; +MC7000.PADModePitch = [false, false, false, false]; + +// Define the MIDI signal for red LED at VU Meters +MC7000.VuMeterLEDPeakValue = 0x76; + +// PAD Mode Colors +MC7000.padColor = { + "alloff": 0x01, // switch off completely + // Hot Cue + "hotcueon": 0x04, // darkblue Hot Cue active + "hotcueoff": 0x02, // lightblue Hot Cue inactive + // Cue Loop + "cueloopon": 0x0D, // Cueloop colour for activated cue point + "cueloopoff": 0x1A, // Cueloop colour inactive + // Roll + "rollon": 0x20, // BeatloopRoll active colour + "rolloff": 0x06, // BeatloopRoll off colour + // Slicer + "sliceron": 0x11, // activated Slicer + "slicerJumpFwd": 0x31, // Sliver forward jump + "slicerJumpBack": 0x31, // Sliver backward jump + // Sampler + "samplerloaded": 0x38, // dark pink Sampler loaded colour + "samplerplay": 0x09, // green Sampler playing + "sampleroff": 0x12 // light pink Sampler standard colour +}; + +/* DECK INITIALIZATION */ +MC7000.init = function() { + + // set default Master Volume to 85% to give a little head room for mixing + // engine.setValue("[Master]", "gain", 0.85); + + // VU meters + engine.makeConnection("[Channel1]", "VuMeter", MC7000.VuMeter); + engine.makeConnection("[Channel2]", "VuMeter", MC7000.VuMeter); + engine.makeConnection("[Channel3]", "VuMeter", MC7000.VuMeter); + engine.makeConnection("[Channel4]", "VuMeter", MC7000.VuMeter); + + // Platter Ring LED + midi.sendShortMsg(0x90, 0x64, MC7000.modeSingleLED); + midi.sendShortMsg(0x91, 0x64, MC7000.modeSingleLED); + midi.sendShortMsg(0x92, 0x64, MC7000.modeSingleLED); + midi.sendShortMsg(0x93, 0x64, MC7000.modeSingleLED); + engine.makeConnection("[Channel1]", "playposition", MC7000.JogLed); + engine.makeConnection("[Channel2]", "playposition", MC7000.JogLed); + engine.makeConnection("[Channel3]", "playposition", MC7000.JogLed); + engine.makeConnection("[Channel4]", "playposition", MC7000.JogLed); + + // Vinyl mode LEDs + midi.sendShortMsg(0x90, 0x07, MC7000.isVinylMode ? 0x7F: 0x01); + midi.sendShortMsg(0x91, 0x07, MC7000.isVinylMode ? 0x7F: 0x01); + midi.sendShortMsg(0x92, 0x07, MC7000.isVinylMode ? 0x7F: 0x01); + midi.sendShortMsg(0x93, 0x07, MC7000.isVinylMode ? 0x7F: 0x01); + + // HotCue Mode LEDs + for (var i = 1; i <= 8; i++) { + engine.makeConnection("[Channel1]", "hotcue_"+i+"_enabled", MC7000.HotCueLED); + engine.makeConnection("[Channel2]", "hotcue_"+i+"_enabled", MC7000.HotCueLED); + engine.makeConnection("[Channel3]", "hotcue_"+i+"_enabled", MC7000.HotCueLED); + engine.makeConnection("[Channel4]", "hotcue_"+i+"_enabled", MC7000.HotCueLED); + } + + // Sampler Mode LEDs + for (i = 1; i <= 8; i++) { + engine.makeConnection("[Sampler"+i+"]", "track_loaded", MC7000.SamplerLED); + engine.makeConnection("[Sampler"+i+"]", "play", MC7000.SamplerLED); + } + + // Sampler Volume Control + MC7000.samplerLevel = function(channel, control, value) { + // check if the Sampler Volume is at Zero and if so hide the sampler bank + if (value > 0x00) { + engine.setValue("[Samplers]", "show_samplers", true); + } else { + engine.setValue("[Samplers]", "show_samplers", false); + } + // get the Sampler Rows opened with its details + engine.setValue("[SamplerRow1]", "expanded", true); + engine.setValue("[SamplerRow2]", "expanded", true); + + //control up to 16 sampler volumes with the one knob on the mixer + for (var i = 1; i <= 16; i++) { + engine.setValue("[Sampler"+i+"]", "pregain", script.absoluteNonLin(value, 0, 1.0, 4.0)); + } + }; + + // The SysEx message to send to the controller to force the midi controller + // to send the status of every item on the control surface. + var ControllerStatusSysex = [0xF0, 0x00, 0x20, 0x7F, 0x03, 0x01, 0xF7]; + + // After midi controller receive this Outbound Message request SysEx Message, + // midi controller will send the status of every item on the + // control surface. (Mixxx will be initialized with current values) + midi.sendSysexMsg(ControllerStatusSysex, ControllerStatusSysex.length); +}; + +// PAD Mode Hot Cue +MC7000.padModeCue = function(channel, control, value, status, group) { + var deckNumber = script.deckFromGroup(group); + if (value === 0x00) + return; // don't respond to note off messages + if (value === 0x7F) { + // set HotCue Mode true + MC7000.PADModeCue[deckNumber] = true; + MC7000.PADModeCueLoop[deckNumber] = false; + MC7000.PADModeFlip[deckNumber] = false; + MC7000.PADModeRoll[deckNumber] = false; + MC7000.PADModeSavedLoop[deckNumber] = false; + MC7000.PADModeSlicer[deckNumber] = false; + MC7000.PADModeSlicerLoop[deckNumber] = false; + MC7000.PADModeSampler[deckNumber] = false; + MC7000.PADModeVelSamp[deckNumber] = false; + MC7000.PADModePitch[deckNumber] = false; + } + // change PAD color when switching to Hot Cue Mode + for (var i = 1; i <= 8; i++) { + if (engine.getValue(group, "hotcue_" + i + "_enabled", true)) { + midi.sendShortMsg(0x94 + deckNumber - 1, 0x14 + i - 1, + MC7000.padColor.hotcueon); + } else { + midi.sendShortMsg(0x94 + deckNumber - 1, 0x14 + i - 1, + MC7000.padColor.hotcueoff); + } + } +}; +// PAD Mode Cue Loop +MC7000.padModeCueLoop = function(channel, control, value, status, group) { + var deckNumber = script.deckFromGroup(group); + if (value === 0x00) + return; // don't respond to note off messages + if (value === 0x7F) { + MC7000.PADModeCue[deckNumber] = false; + MC7000.PADModeCueLoop[deckNumber] = true; + MC7000.PADModeFlip[deckNumber] = false; + MC7000.PADModeRoll[deckNumber] = false; + MC7000.PADModeSavedLoop[deckNumber] = false; + MC7000.PADModeSlicer[deckNumber] = false; + MC7000.PADModeSlicerLoop[deckNumber] = false; + MC7000.PADModeSampler[deckNumber] = false; + MC7000.PADModeVelSamp[deckNumber] = false; + MC7000.PADModePitch[deckNumber] = false; + } + for (var i = 1; i <= 8; i++) { + midi.sendShortMsg(0x94 + deckNumber - 1, 0x14 + i - 1, + MC7000.padColor.alloff); + } +}; +// PAD Mode Flip +MC7000.padModeFlip = function(channel, control, value, status, group) { + var deckNumber = script.deckFromGroup(group); + if (value === 0x00) + return; // don't respond to note off messages + if (value === 0x7F) { + MC7000.PADModeCue[deckNumber] = false; + MC7000.PADModeCueLoop[deckNumber] = false; + MC7000.PADModeFlip[deckNumber] = true; + MC7000.PADModeRoll[deckNumber] = false; + MC7000.PADModeSavedLoop[deckNumber] = false; + MC7000.PADModeSlicer[deckNumber] = false; + MC7000.PADModeSlicerLoop[deckNumber] = false; + MC7000.PADModeSampler[deckNumber] = false; + MC7000.PADModeVelSamp[deckNumber] = false; + MC7000.PADModePitch[deckNumber] = false; + } + for (var i = 1; i <= 8; i++) { + midi.sendShortMsg(0x94 + deckNumber - 1, 0x1C + i - 1, + MC7000.padColor.alloff); + } +}; +// PAD Mode Roll +MC7000.padModeRoll = function(channel, control, value, status, group) { + var deckNumber = script.deckFromGroup(group); + if (value === 0x00) + return; // don't respond to note off messages + if (value === 0x7F) { + MC7000.PADModeCue[deckNumber] = false; + MC7000.PADModeCueLoop[deckNumber] = false; + MC7000.PADModeFlip[deckNumber] = false; + MC7000.PADModeRoll[deckNumber] = true; + MC7000.PADModeSavedLoop[deckNumber] = false; + MC7000.PADModeSlicer[deckNumber] = false; + MC7000.PADModeSlicerLoop[deckNumber] = false; + MC7000.PADModeSampler[deckNumber] = false; + MC7000.PADModeVelSamp[deckNumber] = false; + MC7000.PADModePitch[deckNumber] = false; + } + for (var i = 1; i <= 8; i++) { + midi.sendShortMsg(0x94 + deckNumber - 1, 0x14 + i - 1, + MC7000.padColor.rolloff); + } +}; +// PAD Mode Saved Loop +MC7000.padModeSavedLoop = function(channel, control, value, status, group) { + var deckNumber = script.deckFromGroup(group); + if (value === 0x00) + return; // don't respond to note off messages + if (value === 0x7F) { + MC7000.PADModeCue[deckNumber] = false; + MC7000.PADModeCueLoop[deckNumber] = false; + MC7000.PADModeFlip[deckNumber] = false; + MC7000.PADModeRoll[deckNumber] = false; + MC7000.PADModeSavedLoop[deckNumber] = true; + MC7000.PADModeSlicer[deckNumber] = false; + MC7000.PADModeSlicerLoop[deckNumber] = false; + MC7000.PADModeSampler[deckNumber] = false; + MC7000.PADModeVelSamp[deckNumber] = false; + MC7000.PADModePitch[deckNumber] = false; + } + for (var i = 1; i <= 8; i++) { + midi.sendShortMsg(0x94 + deckNumber - 1, 0x14 + i - 1, + MC7000.padColor.alloff); + } +}; +// PAD Mode Slicer +MC7000.padModeSlicer = function(channel, control, value, status, group) { + var deckNumber = script.deckFromGroup(group); + if (value === 0x00) + return; // don't respond to note off messages + if (value === 0x7F) { + MC7000.PADModeCue[deckNumber] = false; + MC7000.PADModeCueLoop[deckNumber] = false; + MC7000.PADModeFlip[deckNumber] = false; + MC7000.PADModeRoll[deckNumber] = false; + MC7000.PADModeSavedLoop[deckNumber] = false; + MC7000.PADModeSlicer[deckNumber] = true; + MC7000.PADModeSlicerLoop[deckNumber] = false; + MC7000.PADModeSampler[deckNumber] = false; + MC7000.PADModeVelSamp[deckNumber] = false; + MC7000.PADModePitch[deckNumber] = false; + } + for (var i = 1; i <= 8; i++) { + midi.sendShortMsg(0x94 + deckNumber - 1, 0x14 + i - 1, + MC7000.padColor.sliceron); + } +}; +// PAD Mode Slicer Loop +MC7000.padModeSlicerLoop = function(channel, control, value, status, group) { + var deckNumber = script.deckFromGroup(group); + if (value === 0x00) + return; // don't respond to note off messages + if (value === 0x7F) { + MC7000.PADModeCue[deckNumber] = false; + MC7000.PADModeCueLoop[deckNumber] = false; + MC7000.PADModeFlip[deckNumber] = false; + MC7000.PADModeRoll[deckNumber] = false; + MC7000.PADModeSavedLoop[deckNumber] = false; + MC7000.PADModeSlicer[deckNumber] = false; + MC7000.PADModeSlicerLoop[deckNumber] = true; + MC7000.PADModeSampler[deckNumber] = false; + MC7000.PADModeVelSamp[deckNumber] = false; + MC7000.PADModePitch[deckNumber] = false; + } + for (var i = 1; i <= 8; i++) { + midi.sendShortMsg(0x94 + deckNumber - 1, 0x14 + i - 1, + MC7000.padColor.alloff); + } +}; +// PAD Mode Sampler +MC7000.padModeSampler = function(channel, control, value, status, group) { + var deckNumber = script.deckFromGroup(group); + if (value === 0x00) + return; // don't respond to note off messages + if (value === 0x7F) { + MC7000.PADModeCue[deckNumber] = false; + MC7000.PADModeCueLoop[deckNumber] = false; + MC7000.PADModeFlip[deckNumber] = false; + MC7000.PADModeRoll[deckNumber] = false; + MC7000.PADModeSavedLoop[deckNumber] = false; + MC7000.PADModeSlicer[deckNumber] = false; + MC7000.PADModeSlicerLoop[deckNumber] = false; + MC7000.PADModeSampler[deckNumber] = true; + MC7000.PADModeVelSamp[deckNumber] = false; + MC7000.PADModePitch[deckNumber] = false; + } + // change PAD color when switching to Sampler Mode + for (var i = 1; i <= 8; i++) { + if (engine.getValue("[Sampler" + i + "]", "play")) { + midi.sendShortMsg(0x94 + deckNumber - 1, 0x14 + i - 1, + MC7000.padColor.samplerplay); + } else if (engine.getValue("[Sampler" + i + "]", "track_loaded") === 0) { + midi.sendShortMsg(0x94 + deckNumber - 1, 0x14 + i - 1, + MC7000.padColor.sampleroff); + } else if (engine.getValue("[Sampler" + i + "]", "track_loaded") === 1 && + engine.getValue("[Sampler" + i + "]", "play") === 0) { + midi.sendShortMsg(0x94 + deckNumber - 1, 0x14 + i - 1, + MC7000.padColor.samplerloaded); + } + } +}; +// PAD Mode Velocity Sampler +MC7000.padModeVelSamp = function(channel, control, value, status, group) { + var deckNumber = script.deckFromGroup(group); + if (value === 0x00) + return; // don't respond to note off messages + if (value === 0x7F) { + MC7000.PADModeCue[deckNumber] = false; + MC7000.PADModeCueLoop[deckNumber] = false; + MC7000.PADModeFlip[deckNumber] = false; + MC7000.PADModeRoll[deckNumber] = false; + MC7000.PADModeSavedLoop[deckNumber] = false; + MC7000.PADModeSlicer[deckNumber] = false; + MC7000.PADModeSlicerLoop[deckNumber] = false; + MC7000.PADModeSampler[deckNumber] = false; + MC7000.PADModeVelSamp[deckNumber] = true; + MC7000.PADModePitch[deckNumber] = false; + } + for (var i = 1; i <= 8; i++) { + midi.sendShortMsg(0x94 + deckNumber - 1, 0x14 + i - 1, + MC7000.padColor.alloff); + } +}; +// PAD Mode Pitch +MC7000.padModePitch = function(channel, control, value, status, group) { + var deckNumber = script.deckFromGroup(group); + if (value === 0x00) + return; // don't respond to note off messages + if (value === 0x7F) { + MC7000.PADModeCue[deckNumber] = false; + MC7000.PADModeCueLoop[deckNumber] = false; + MC7000.PADModeFlip[deckNumber] = false; + MC7000.PADModeRoll[deckNumber] = false; + MC7000.PADModeSavedLoop[deckNumber] = false; + MC7000.PADModeSlicer[deckNumber] = true; + MC7000.PADModeSlicerLoop[deckNumber] = false; + MC7000.PADModeSampler[deckNumber] = false; + MC7000.PADModeVelSamp[deckNumber] = false; + MC7000.PADModePitch[deckNumber] = true; + } + for (var i = 1; i <= 8; i++) { + midi.sendShortMsg(0x94 + deckNumber - 1, 0x14 + i - 1, + MC7000.padColor.alloff); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x1C + i - 1, + MC7000.padColor.alloff); + } +}; + +// PAD buttons +MC7000.PadButtons = function(channel, control, value, status, group) { + var deckNumber = script.deckFromGroup(group); + + // activate and clear Hot Cues + if (MC7000.PADModeCue[deckNumber] && + engine.getValue(group, "track_loaded") === 1) { + for (var i = 1; i <= 8; i++) { + if (control === 0x14 + i - 1 && value >= 0x01) { + engine.setValue(group, "hotcue_" + i + "_activate", true); + } else { + engine.setValue(group, "hotcue_" + i + "_activate", false); + } + if (control === 0x1C + i - 1 && value >= 0x01) { + engine.setValue(group, "hotcue_" + i + "_clear", true); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x1C + i - 1, + MC7000.padColor.hotcueoff); + } + } + } else if (MC7000.PADModeFlip[deckNumber]) { + return; + } else if (MC7000.PADModeFlip[deckNumber]) { + return; + } else if (MC7000.PADModeRoll[deckNumber]) { + if (control === 0x14 && value >= 0x01) { + engine.setValue(group, "beatlooproll_0.0625_activate", true); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x14, MC7000.padColor.rollon); + } else if (control === 0x14 && value >= 0x00) { + engine.setValue(group, "beatlooproll_0.0625_activate", false); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x14, MC7000.padColor.rolloff); + } else if (control === 0x15 && value >= 0x01) { + engine.setValue(group, "beatlooproll_0.125_activate", true); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x15, MC7000.padColor.rollon); + } else if (control === 0x15 && value >= 0x00) { + engine.setValue(group, "beatlooproll_0.125_activate", false); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x15, MC7000.padColor.rolloff); + } else if (control === 0x16 && value >= 0x01) { + engine.setValue(group, "beatlooproll_0.25_activate", true); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x16, MC7000.padColor.rollon); + } else if (control === 0x16 && value >= 0x00) { + engine.setValue(group, "beatlooproll_0.25_activate", false); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x16, MC7000.padColor.rolloff); + } else if (control === 0x17 && value >= 0x01) { + engine.setValue(group, "beatlooproll_0.5_activate", true); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x17, MC7000.padColor.rollon); + } else if (control === 0x17 && value >= 0x00) { + engine.setValue(group, "beatlooproll_0.5_activate", false); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x17, MC7000.padColor.rolloff); + } else if (control === 0x18 && value >= 0x01) { + engine.setValue(group, "beatlooproll_1_activate", true); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x18, MC7000.padColor.rollon); + } else if (control === 0x18 && value >= 0x00) { + engine.setValue(group, "beatlooproll_1_activate", false); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x18, MC7000.padColor.rolloff); + } else if (control === 0x19 && value >= 0x01) { + engine.setValue(group, "beatlooproll_2_activate", true); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x19, MC7000.padColor.rollon); + } else if (control === 0x19 && value >= 0x00) { + engine.setValue(group, "beatlooproll_2_activate", false); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x19, MC7000.padColor.rolloff); + } else if (control === 0x1A && value >= 0x01) { + engine.setValue(group, "beatlooproll_4_activate", true); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x1A, MC7000.padColor.rollon); + } else if (control === 0x1A && value >= 0x00) { + engine.setValue(group, "beatlooproll_4_activate", false); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x1A, MC7000.padColor.rolloff); + } else if (control === 0x1B && value >= 0x01) { + engine.setValue(group, "beatlooproll_8_activate", true); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x1B, MC7000.padColor.rollon); + } else if (control === 0x1B && value >= 0x00) { + engine.setValue(group, "beatlooproll_8_activate", false); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x1B, MC7000.padColor.rolloff); + } + } else if (MC7000.PADModeSavedLoop[deckNumber]) { + return; + } else if (MC7000.PADModeSlicer[deckNumber]) { + if (value > 0) { + var beats = 1 << (control % 4); + if (control > 0x17) { + engine.setValue(group, "beatjump_" + beats + "_backward", value); + midi.sendShortMsg(0x94 + deckNumber -1, control, MC7000.padColor.slicerJumpBack); + } else { + engine.setValue(group, "beatjump_" + beats + "_forward", value); + midi.sendShortMsg(0x94 + deckNumber -1, control, MC7000.padColor.slicerJumpFwd); + } + } else { + midi.sendShortMsg(0x94 + deckNumber -1, control, MC7000.padColor.sliceron); + } + } else if (MC7000.PADModeSlicerLoop[deckNumber]) { + return; + } else if (MC7000.PADModeSampler[deckNumber]) { + for (i = 1; i <= 8; i++) { + if (control === 0x14 + i - 1 && value >= 0x01) { + if (engine.getValue("[Sampler" + i + "]", "track_loaded") === 0) { + engine.setValue("[Sampler" + i + "]", "LoadSelectedTrack", 1); + } else if (engine.getValue("[Sampler" + i + "]", "track_loaded") === + 1) { + engine.setValue("[Sampler" + i + "]", "cue_gotoandplay", 1); + } + } else if (control === 0x1C + i - 1 && value >= 0x01) { + if (engine.getValue("[Sampler" + i + "]", "play") === 1) { + engine.setValue("[Sampler" + i + "]", "cue_gotoandstop", 1); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x1C + i - 1, + MC7000.padColor.samplerloaded); + } else { + engine.setValue("[Sampler" + i + "]", "eject", 1); + midi.sendShortMsg(0x94 + deckNumber - 1, 0x1C + i - 1, + MC7000.padColor.sampleroff); + engine.setValue("[Sampler" + i + "]", "eject", 0); + } + } + } + } else if (MC7000.PADModeVelSamp[deckNumber]) { + return; + } else if (MC7000.PADModePitch[deckNumber]) { + return; + } +}; + +// Toggle Vinyl Mode +MC7000.vinylModeToggle = function(channel, control, value, status, group) { + if (value === 0x00) + return; // don't respond to note off messages + + if (value === 0x7F) { + var deckNumber = script.deckFromGroup(group); + MC7000.isVinylMode[deckNumber] = !MC7000.isVinylMode[deckNumber]; + midi.sendShortMsg(0x90 + channel, 0x07, + MC7000.isVinylMode[deckNumber] ? 0x7F : 0x01); + } +}; + +// The button that enables/disables scratching +MC7000.wheelTouch = function(channel, control, value, status, group) { + var deckNumber = script.deckFromGroup(group); + if (MC7000.isVinylMode[deckNumber]) { + if (value === 0x7F) { + engine.scratchEnable(deckNumber, MC7000.jogWheelTicksPerRevolution, + MC7000.scratchParams.recordSpeed, + MC7000.scratchParams.alpha, + MC7000.scratchParams.beta); + } else { + engine.scratchDisable(deckNumber); + } + } +}; + +// The wheel that actually controls the scratching +MC7000.wheelTurn = function(channel, control, value, status, group) { + // A: For a control that centers on 0: + var numTicks = (value < 0x64) ? value : (value - 128); + var deckNumber = script.deckFromGroup(group); + if (engine.isScratching(deckNumber)) { + // Scratch! + engine.scratchTick(deckNumber, numTicks); + } else { + // Pitch bend + var jogDelta = numTicks / MC7000.jogWheelTicksPerRevolution * + MC7000.jogParams.jogSensitivity; + var jogAbsolute = jogDelta + engine.getValue(group, "jog"); + engine.setValue( + group, "jog", + Math.max(-MC7000.jogParams.maxJogValue, + Math.min(MC7000.jogParams.maxJogValue, jogAbsolute))); + } +}; + +// Needle Search Touch detection +MC7000.needleSearchTouch = function(channel, control, value, status, group) { + var deckNumber = script.deckFromGroup(group); + if (engine.getValue(group, "play")) { + MC7000.needleSearchTouched[deckNumber] = + MC7000.needleSearchPlay && (!!value); + } else { + MC7000.needleSearchTouched[deckNumber] = !!value; + } +}; + +// Needle Search Touch while "SHIFT" button is pressed +MC7000.needleSearchTouchShift = function(channel, control, value, status, + group) { + var deckNumber = script.deckFromGroup(group); + MC7000.needleSearchTouched[deckNumber] = !!value; +}; + +// Needle Search Position detection (MSB) +MC7000.needleSearchMSB = function(channel, control, value) { + MC7000.needleDropMSB = value; // just defining rough position +}; + +// Needle Search Position detection (MSB + LSB) +MC7000.needleSearchStripPosition = function(channel, control, value, status, + group) { + var deckNumber = script.deckFromGroup(group); + if (MC7000.needleSearchTouched[deckNumber]) { + var fullValue = (MC7000.needleDropMSB << 7) + + value; // move MSB 7 binary gigits to the left and add LSB + var position = (fullValue / 0x3FFF); // devide by all possible positions to + // get relative between 0 - 1 + engine.setParameter(group, "playposition", position); + } +}; + +// Pitch Fader (MSB) +MC7000.pitchFaderMSB = function(channel, control, value) { + MC7000.pitchMSB = value; // just defining rough position +}; + +// Pitch Fader Position (MSB + LSB) +MC7000.pitchFaderPosition = function(channel, control, value, status, group) { + var fullValue = (MC7000.pitchMSB << 7) + value; + var position = + 1 - (fullValue / 0x3FFF); // 1 - () to turn around the direction + engine.setParameter(group, "rate", position); +}; + +// Next Rate range toggle +MC7000.nextRateRange = function(midichan, control, value, status, group) { + if (value === 0) + return; // don't respond to note off messages + var deckNumber = script.deckFromGroup(group); + // increment currentRateRangeIndex and check for overflow + if (++MC7000.currentRateRangeIndex[deckNumber - 1] === + MC7000.rateRanges.length) { + MC7000.currentRateRangeIndex[deckNumber - 1] = 0; + } + engine.setValue( + group, "rateRange", + MC7000.rateRanges[MC7000.currentRateRangeIndex[deckNumber - 1]]); +}; + +// Previous Rate range toggle +MC7000.prevRateRange = function(midichan, control, value, status, group) { + if (value === 0) + return; // don't respond to note off messages + var deckNumber = script.deckFromGroup(group); + // decrement currentRateRangeIndex and check for underflow + if (--MC7000.currentRateRangeIndex[deckNumber - 1] < 0) { + MC7000.currentRateRangeIndex[deckNumber - 1] = MC7000.rateRanges.length - 1; + } + engine.setValue( + group, "rateRange", + MC7000.rateRanges[MC7000.currentRateRangeIndex[deckNumber - 1]]); +}; + +// Key Select +MC7000.keySelect = function(midichan, control, value, status, group) { + if (value === 0x01) { + engine.setValue(group, "pitch_up", true); + } else if (value === 0x7F) { + engine.setValue(group, "pitch_down", true); + } +}; + +// Assign Channel to Crossfader +MC7000.crossfaderAssign = function(channel, control, value, status, group) { + if (value === 0x00) { + engine.setValue(group, "orientation", 1); // Centre position + } else if (value === 0x01) { + engine.setValue(group, "orientation", 0); // Right position + } else if (value === 0x02) { + engine.setValue(group, "orientation", 2); // Left position + } +}; + +// Assign Spinback length to STOP TIME knob +MC7000.stopTime = function(channel, control, value, status, group) { + var deckNumber = script.deckFromGroup(group); + // "factor" for engine.brake() + // this formula produces factors between 31 (min STOP TIME for ca 7 sec back + // in track) and 1 (max STOP TIME for ca 18.0 sec back in track) + MC7000.factor[deckNumber] = (1.1 - (value / 127)) * 30 - 2; +}; + +// Use the CENSOR button as Spinback with STOP TIME adjusted length +MC7000.censor = function(channel, control, value, status, group) { + var deckNumber = script.deckFromGroup(group); + var deck = + parseInt(group.substring(8, 9)); // work out which deck we are using + engine.brake(deck, value > 0, MC7000.factor[deckNumber], + -15); // start at a rate of -15 and decrease by "factor" +}; + +/* SET CROSSFADER CURVE */ +MC7000.crossFaderCurve = function(control, value) { + script.crossfaderCurve(value); +}; + +/* Set FX wet/dry value */ +MC7000.fxWetDry = function(midichan, control, value, status, group) { + var numTicks = (value < 0x64) ? value: (value - 128); + var newVal = engine.getValue(group, "mix") + numTicks/64*2; + engine.setValue(group, "mix", Math.max(0, Math.min(1, newVal))); + + +}; + +/* LEDs for VuMeter */ +// VuMeters only for Channel 1-4 / Master is on Hardware +MC7000.VuMeter = function(value, group) { + var VULevelOutValue = engine.getValue(group, "PeakIndicator") ? MC7000.VuMeterLEDPeakValue : value*value*value*value*0x69, + deckNumber = script.deckFromGroup(group); + + midi.sendShortMsg(0xB0 + deckNumber - 1, 0x1F, VULevelOutValue); +}; + +/* LEDs around Jog wheel */ +MC7000.JogLed = function(value, group) { + var deckNumber = script.deckFromGroup(group); + // do nothing before track starts + if (value < 0) return; + + var trackDuration = engine.getValue(group, "duration"), + position = value * trackDuration / 60 * MC7000.scratchParams.recordSpeed, + // LED ring contains 48 segments with each LED activated by the next even number + LEDmidiSignal = 48 * 2, + activeLED = MC7000.isVinylMode[deckNumber] ? Math.round(position * LEDmidiSignal) % LEDmidiSignal : value * LEDmidiSignal; + + midi.sendShortMsg(0x90 + deckNumber -1, 0x06, activeLED); +}; + +// initial HotCue LED when loading a track with already existing hotcues +MC7000.HotCueLED = function(value, group) { + var deckNumber = script.deckFromGroup(group); + if (MC7000.PADModeCue[deckNumber]) { + for (var i = 1; i <= 8; i++) { + if (value === 1) { + if (engine.getValue(group, "hotcue_"+i+"_enabled") === 1) { + midi.sendShortMsg(0x94 + deckNumber - 1, 0x14 + i - 1, MC7000.padColor.hotcueon); + } + } else { + if (engine.getValue(group, "hotcue_"+i+"_enabled") === 0) { + midi.sendShortMsg(0x94 + deckNumber - 1, 0x14 + i - 1, MC7000.padColor.hotcueoff); + } + } + } + } +}; + +// Sampler LED +MC7000.SamplerLED = function() { + for (var j = 1; j <= 4; j++) { + for (var i = 1; i <= 8; i++) { + if (MC7000.PADModeSampler[j]) { + if (engine.getValue("[Sampler"+i+"]", "track_loaded") === 1) { + if (engine.getValue("[Sampler"+i+"]", "play") === 0) { + midi.sendShortMsg(0x94 + j - 1, 0x14 + i - 1, MC7000.padColor.samplerloaded); + } else { + midi.sendShortMsg(0x94 + j - 1, 0x14 + i - 1, MC7000.padColor.samplerplay); + } + } else if (engine.getValue("[Sampler"+i+"]", "track_loaded") === 0) { + midi.sendShortMsg(0x94 + j - 1, 0x14 + i - 1, MC7000.padColor.sampleroff); + } + } + } + } +}; + +/* CONTROLLER SHUTDOWN */ +MC7000.shutdown = function() { + + // Need to switch off LEDs one by one, + // otherwise the controller cannot handle the signal traffic + + // Switch off Transport section LEDs + for (var i = 0; i <= 3; i++) { + midi.sendShortMsg(0x90 + i, 0x00, 0x01); + midi.sendShortMsg(0x90 + i, 0x01, 0x01); + midi.sendShortMsg(0x90 + i, 0x02, 0x01); + midi.sendShortMsg(0x90 + i, 0x03, 0x01); + midi.sendShortMsg(0x90 + i, 0x04, 0x01); + midi.sendShortMsg(0x90 + i, 0x05, 0x01); + } + // Switch off Loop Section LEDs + for (i = 0; i <= 3; i++) { + midi.sendShortMsg(0x94 + i, 0x32, 0x01); + midi.sendShortMsg(0x94 + i, 0x33, 0x01); + midi.sendShortMsg(0x94 + i, 0x34, 0x01); + midi.sendShortMsg(0x94 + i, 0x35, 0x01); + midi.sendShortMsg(0x94 + i, 0x38, 0x01); + midi.sendShortMsg(0x94 + i, 0x39, 0x01); + // switch PAD Mode to CUE LED + midi.sendShortMsg(0x94 + i, 0x00, 0x04); + } + // Switch all PAD LEDs to HotCue mode + for (i = 0x14; i <= 0x1B; i++) { + midi.sendShortMsg(0x94, i, 0x02); + midi.sendShortMsg(0x95, i, 0x02); + midi.sendShortMsg(0x96, i, 0x02); + midi.sendShortMsg(0x97, i, 0x02); + } + // Switch off Channel Cue, VINYL, SLIP, KEY LOCK LEDs + for (i = 0; i <= 3; i++) { + midi.sendShortMsg(0x90 + i, 0x07, 0x01); + midi.sendShortMsg(0x90 + i, 0x0F, 0x01); + midi.sendShortMsg(0x90 + i, 0x0D, 0x01); + midi.sendShortMsg(0x90 + i, 0x1B, 0x01); + } + // Switch off FX Section LEDs + for (i = 0; i <= 1; i++) { + midi.sendShortMsg(0x98 + i, 0x00, 0x01); + midi.sendShortMsg(0x98 + i, 0x01, 0x01); + midi.sendShortMsg(0x98 + i, 0x02, 0x01); + midi.sendShortMsg(0x98 + i, 0x04, 0x01); + midi.sendShortMsg(0x98 + i, 0x0A, 0x01); + midi.sendShortMsg(0x98 + i, 0x05, 0x01); + midi.sendShortMsg(0x98 + i, 0x06, 0x01); + midi.sendShortMsg(0x98 + i, 0x07, 0x01); + midi.sendShortMsg(0x98 + i, 0x08, 0x01); + } + // Reset Level Meters and JogLED + for (i = 0; i <= 3; i++) { + // Switch off Level Meters + midi.sendShortMsg(0xB0 + i, 0x1F, 0x00); + // Platter Ring: Reset JogLED to Zero position + midi.sendShortMsg(0x90 + i, 0x06, 0x00); + // Platter Ring: Switch all LEDs on + midi.sendShortMsg(0x90 + i, 0x64, 0x00); + } +}; diff --git a/res/controllers/Denon-MC7000.midi.xml b/res/controllers/Denon-MC7000.midi.xml new file mode 100644 index 00000000000..0aa79f6cd8a --- /dev/null +++ b/res/controllers/Denon-MC7000.midi.xml @@ -0,0 +1,4054 @@ + + + + Denon MC7000 + OsZ + Denon MC7000 mapping for testing. Check your Linux Kernel version to get the Audio Interface working - see WIKI page. + https://www.mixxx.org/forums/ + https://www.mixxx.org/wiki/doku.php/denon_mc7000 + + + + + + + + + + [Channel1] + MC7000.padModeCue + Pad Mode HotCues + 0x94 + 0x00 + + + + + + [Channel2] + MC7000.padModeCue + Pad Mode HotCues + 0x95 + 0x00 + + + + + + [Channel3] + MC7000.padModeCue + Pad Mode HotCues + 0x96 + 0x00 + + + + + + [Channel4] + MC7000.padModeCue + Pad Mode HotCues + 0x97 + 0x00 + + + + + + [Channel1] + MC7000.padModeCueLoop + Pad Mode HotCues + 0x94 + 0x03 + + + + + + [Channel2] + MC7000.padModeCueLoop + Pad Mode HotCues + 0x95 + 0x03 + + + + + + [Channel3] + MC7000.padModeCueLoop + Pad Mode HotCues + 0x96 + 0x03 + + + + + + [Channel4] + MC7000.padModeCueLoop + Pad Mode HotCues + 0x97 + 0x03 + + + + + + [Channel1] + MC7000.padModeFlip + Pad Mode HotCues + 0x94 + 0x02 + + + + + + [Channel2] + MC7000.padModeFlip + Pad Mode HotCues + 0x95 + 0x02 + + + + + + [Channel3] + MC7000.padModeFlip + Pad Mode HotCues + 0x96 + 0x02 + + + + + + [Channel4] + MC7000.padModeFlip + Pad Mode HotCues + 0x97 + 0x02 + + + + + + [Channel1] + MC7000.padModeRoll + Pad Mode HotCues + 0x94 + 0x07 + + + + + + [Channel2] + MC7000.padModeRoll + Pad Mode HotCues + 0x95 + 0x07 + + + + + + [Channel3] + MC7000.padModeRoll + Pad Mode HotCues + 0x96 + 0x07 + + + + + + [Channel4] + MC7000.padModeRoll + Pad Mode HotCues + 0x97 + 0x07 + + + + + + [Channel1] + MC7000.padModeSavedLoop + Pad Mode HotCues + 0x94 + 0x0D + + + + + + [Channel2] + MC7000.padModeSavedLoop + Pad Mode HotCues + 0x95 + 0x0D + + + + + + [Channel3] + MC7000.padModeSavedLoop + Pad Mode HotCues + 0x96 + 0x0D + + + + + + [Channel4] + MC7000.padModeSavedLoop + Pad Mode HotCues + 0x97 + 0x0D + + + + + + [Channel1] + MC7000.padModeSlicer + Pad Mode HotCues + 0x94 + 0x09 + + + + + + [Channel2] + MC7000.padModeSlicer + Pad Mode HotCues + 0x95 + 0x09 + + + + + + [Channel3] + MC7000.padModeSlicer + Pad Mode HotCues + 0x96 + 0x09 + + + + + + [Channel4] + MC7000.padModeSlicer + Pad Mode HotCues + 0x97 + 0x09 + + + + + + [Channel1] + MC7000.padModeSlicerLoop + Pad Mode HotCues + 0x94 + 0x0A + + + + + + [Channel2] + MC7000.padModeSlicerLoop + Pad Mode HotCues + 0x95 + 0x0A + + + + + + [Channel3] + MC7000.padModeSlicerLoop + Pad Mode HotCues + 0x96 + 0x0A + + + + + + [Channel4] + MC7000.padModeSlicerLoop + Pad Mode HotCues + 0x97 + 0x0A + + + + + + [Channel1] + MC7000.padModeSampler + Pad Mode HotCues + 0x94 + 0x0B + + + + + + [Channel2] + MC7000.padModeSampler + Pad Mode HotCues + 0x95 + 0x0B + + + + + + [Channel3] + MC7000.padModeSampler + Pad Mode HotCues + 0x96 + 0x0B + + + + + + [Channel4] + MC7000.padModeSampler + Pad Mode HotCues + 0x97 + 0x0B + + + + + + [Channel1] + MC7000.padModeVelSamp + Pad Mode HotCues + 0x94 + 0x0C + + + + + + [Channel2] + MC7000.padModeVelSamp + Pad Mode HotCues + 0x95 + 0x0C + + + + + + [Channel3] + MC7000.padModeVelSamp + Pad Mode HotCues + 0x96 + 0x0C + + + + + + [Channel4] + MC7000.padModeVelSamp + Pad Mode HotCues + 0x97 + 0x0C + + + + + + [Channel1] + MC7000.padModePitch + Pad Mode HotCues + 0x94 + 0x0F + + + + + + [Channel2] + MC7000.padModePitch + Pad Mode HotCues + 0x95 + 0x0F + + + + + + [Channel3] + MC7000.padModePitch + Pad Mode HotCues + 0x96 + 0x0F + + + + + + [Channel4] + MC7000.padModePitch + Pad Mode HotCues + 0x97 + 0x0F + + + + + + + [Channel1] + MC7000.pitchFaderPosition + MIDI Learned from 180 messages. + 0xB0 + 0x77 + + + + + + [Channel2] + MC7000.pitchFaderPosition + MIDI Learned from 144 messages. + 0xB1 + 0x77 + + + + + + [Channel3] + MC7000.pitchFaderPosition + MIDI Learned from 150 messages. + 0xB2 + 0x77 + + + + + + [Channel4] + MC7000.pitchFaderPosition + MIDI Learned from 128 messages. + 0xB3 + 0x77 + + + + + + [Channel1] + MC7000.pitchFaderMSB + MIDI Learned from 180 messages. + 0xB0 + 0x09 + + + + + + [Channel2] + MC7000.pitchFaderMSB + MIDI Learned from 144 messages. + 0xB1 + 0x09 + + + + + + [Channel3] + MC7000.pitchFaderMSB + MIDI Learned from 150 messages. + 0xB2 + 0x09 + + + + + + [Channel4] + MC7000.pitchFaderMSB + MIDI Learned from 128 messages. + 0xB3 + 0x09 + + + + + + + [Channel1] + MC7000.keySelect + Pitch +/- needs tuning + 0xB0 + 0x26 + + + + + + [Channel2] + MC7000.keySelect + Pitch +/- needs tuning + 0xB1 + 0x26 + + + + + + [Channel3] + MC7000.keySelect + Pitch +/- needs tuning + 0xB2 + 0x26 + + + + + + [Channel4] + MC7000.keySelect + Pitch +/- needs tuning + 0xB3 + 0x26 + + + + + + + [Channel1] + MC7000.crossfaderAssign + Ch1 THRU + 0x90 + 0x1E + + + + + + [Channel2] + MC7000.crossfaderAssign + Ch2 THRU + 0x91 + 0x1E + + + + + + [Channel3] + MC7000.crossfaderAssign + Ch3 THRU + 0x92 + 0x1E + + + + + + [Channel4] + MC7000.crossfaderAssign + Ch4 THRU + 0x93 + 0x1E + + + + + + + [Channel1] + MC7000.prevRateRange + Toggle next Rate Range + 0x90 + 0x2C + + + + + + [Channel2] + MC7000.prevRateRange + Toggle next Rate Range + 0x91 + 0x2C + + + + + + [Channel3] + MC7000.prevRateRange + Toggle next Rate Range + 0x92 + 0x2C + + + + + + [Channel4] + MC7000.prevRateRange + Toggle next Rate Range + 0x93 + 0x2C + + + + + + [Channel1] + MC7000.nextRateRange + Toggle next Rate Range + 0x90 + 0x2B + + + + + + [Channel2] + MC7000.nextRateRange + Toggle next Rate Range + 0x91 + 0x2B + + + + + + [Channel3] + MC7000.nextRateRange + Toggle next Rate Range + 0x92 + 0x2B + + + + + + [Channel4] + MC7000.nextRateRange + Toggle next Rate Range + 0x93 + 0x2B + + + + + + + [Channel1] + MC7000.needleSearchTouch + Touch detection for Needle Search + 0x90 + 0x50 + + + + + + [Channel1] + MC7000.needleSearchTouchShift + "Shift" + Touch detection for Needle Search + 0x90 + 0x51 + + + + + + [Channel1] + MC7000.needleSearchMSB + Jump to track position (Needle Search) + 0xB0 + 0x2B + + + + + + [Channel1] + MC7000.needleSearchStripPosition + Jump to track position (Needle Search) + 0xB0 + 0x78 + + + + + + [Channel2] + MC7000.needleSearchTouch + Touch detection for Needle Search + 0x91 + 0x50 + + + + + + [Channel2] + MC7000.needleSearchTouchShift + "Shift" + Touch detection for Needle Search + 0x91 + 0x51 + + + + + + [Channel2] + MC7000.needleSearchMSB + Jump to track position (Needle Search) + 0xB1 + 0x2B + + + + + + [Channel2] + MC7000.needleSearchStripPosition + Jump to track position (Needle Search) + 0xB1 + 0x78 + + + + + + [Channel3] + MC7000.needleSearchTouch + Touch detection for Needle Search + 0x92 + 0x50 + + + + + + [Channel3] + MC7000.needleSearchTouchShift + "Shift" + Touch detection for Needle Search + 0x92 + 0x51 + + + + + + [Channel3] + MC7000.needleSearchMSB + Jump to track position (Needle Search) + 0xB2 + 0x2B + + + + + + [Channel3] + MC7000.needleSearchStripPosition + Jump to track position (Needle Search) + 0xB2 + 0x78 + + + + + + [Channel4] + MC7000.needleSearchTouch + Touch detection for Needle Search + 0x93 + 0x50 + + + + + + [Channel4] + MC7000.needleSearchTouchShift + "Shift" + Touch detection for Needle Search + 0x93 + 0x51 + + + + + + [Channel4] + MC7000.needleSearchMSB + Jump to track position (Needle Search) + 0xB3 + 0x2B + + + + + + [Channel4] + MC7000.needleSearchStripPosition + Jump to track position (Needle Search) + 0xB3 + 0x78 + + + + + + + [EffectRack1_EffectUnit1] + MC7000.fxWetDry + 0xB8 + 0x03 + + + + + + [EffectRack1_EffectUnit2] + MC7000.fxWetDry + 0xB9 + 0x03 + + + + + + [Master] + MC7000.samplerLevel + 0xBF + 0x1A + + + + + + [Mixer Profile] + MC7000.crossFaderCurve + sets the Crossfader Curve + 0xBF + 0x09 + + + + + + + [Channel1] + MC7000.vinylModeToggle + Vinyl toggle + 0x90 + 0x07 + + + + + + [Channel2] + MC7000.vinylModeToggle + Vinyl toggle + 0x91 + 0x07 + + + + + + [Channel3] + MC7000.vinylModeToggle + Vinyl toggle + 0x92 + 0x07 + + + + + + [Channel4] + MC7000.vinylModeToggle + Vinyl toggle + 0x93 + 0x07 + + + + + + [Channel1] + MC7000.wheelTouch + MIDI Learned from 759 messages. + 0x90 + 0x06 + + + + + + [Channel2] + MC7000.wheelTouch + MIDI Learned from 759 messages. + 0x91 + 0x06 + + + + + + [Channel3] + MC7000.wheelTouch + MIDI Learned from 759 messages. + 0x92 + 0x06 + + + + + + [Channel4] + MC7000.wheelTouch + MIDI Learned from 759 messages. + 0x93 + 0x06 + + + + + + [Channel1] + MC7000.wheelTurn + MIDI Learned from 759 messages. + 0xB0 + 0x06 + + + + + + [Channel2] + MC7000.wheelTurn + MIDI Learned from 759 messages. + 0xB1 + 0x06 + + + + + + [Channel3] + MC7000.wheelTurn + MIDI Learned from 759 messages. + 0xB2 + 0x06 + + + + + + [Channel4] + MC7000.wheelTurn + MIDI Learned from 759 messages. + 0xB3 + 0x06 + + + + + + + [EqualizerRack1_[Channel1]_Effect1] + parameter3 + Hi Ch1 + 0xB0 + 0x17 + + + + + + [EqualizerRack1_[Channel2]_Effect1] + parameter3 + Hi Ch2 + 0xB1 + 0x17 + + + + + + [EqualizerRack1_[Channel3]_Effect1] + parameter3 + Hi Ch3 + 0xB2 + 0x17 + + + + + + [EqualizerRack1_[Channel4]_Effect1] + parameter3 + Hi Ch4 + 0xB3 + 0x17 + + + + + + [EqualizerRack1_[Channel1]_Effect1] + parameter2 + MID Ch1 + 0xB0 + 0x18 + + + + + + [EqualizerRack1_[Channel2]_Effect1] + parameter2 + MID Ch2 + 0xB1 + 0x18 + + + + + + [EqualizerRack1_[Channel3]_Effect1] + parameter2 + MID Ch3 + 0xB2 + 0x18 + + + + + + [EqualizerRack1_[Channel4]_Effect1] + parameter2 + MID Ch4 + 0xB3 + 0x18 + + + + + + [EqualizerRack1_[Channel1]_Effect1] + parameter1 + LOW Ch1 + 0xB0 + 0x19 + + + + + + [EqualizerRack1_[Channel2]_Effect1] + parameter1 + LOW Ch2 + 0xB1 + 0x19 + + + + + + [EqualizerRack1_[Channel3]_Effect1] + parameter1 + LOW Ch3 + 0xB2 + 0x19 + + + + + + [EqualizerRack1_[Channel4]_Effect1] + parameter1 + LOW Ch4 + 0xB3 + 0x19 + + + + + + [QuickEffectRack1_[Channel1]] + super1 + Filter Ch1 + 0xB0 + 0x1A + + + + + + [QuickEffectRack1_[Channel2]] + super1 + Filter Ch2 + 0xB1 + 0x1A + + + + + + [QuickEffectRack1_[Channel3]] + super1 + Filter Ch3 + 0xB2 + 0x1A + + + + + + [QuickEffectRack1_[Channel4]] + super1 + Filter Ch4 + 0xB3 + 0x1A + + + + + + + [Channel1] + pregain + Level / Gain Ch1 + 0xB0 + 0x16 + + + + + + [Channel2] + pregain + Level / Gain Ch2 + 0xB1 + 0x16 + + + + + + [Channel3] + pregain + Level / Gain Ch3 + 0xB2 + 0x16 + + + + + + [Channel4] + pregain + Level / Gain Ch4 + 0xB3 + 0x16 + + + + + + [Channel1] + volume + Line Fader Ch1 + 0xB0 + 0x1C + + + + + + [Channel2] + volume + Line Fader Ch2 + 0xB1 + 0x1C + + + + + + [Channel3] + volume + Line Fader Ch3 + 0xB2 + 0x1C + + + + + + [Channel4] + volume + Line Fader Ch4 + 0xB3 + 0x1C + + + + + + [Master] + crossfader + Crossfader + 0xBF + 0x08 + + + + + + [Channel1] + pfl + PFL Ch1 + 0x90 + 0x1B + + + + + + [Channel2] + pfl + PFL Ch2 + 0x91 + 0x1B + + + + + + [Channel3] + pfl + PFL Ch3 + 0x92 + 0x1B + + + + + + [Channel4] + pfl + PFL Ch4 + 0x93 + 0x1B + + + + + + + [Channel1] + play + Play Ch1 + 0x90 + 0x00 + + + + + + [Channel2] + play + Play Ch2 + 0x91 + 0x00 + + + + + + [Channel3] + play + Play Ch3 + 0x92 + 0x00 + + + + + + [Channel4] + play + Play Ch4 + 0x93 + 0x00 + + + + + + [Channel1] + play_stutter + Stutter play Ch1 + 0x90 + 0x04 + + + + + + [Channel2] + play_stutter + Stutter play Ch2 + 0x91 + 0x04 + + + + + + [Channel3] + play_stutter + Stutter play Ch3 + 0x92 + 0x04 + + + + + + [Channel4] + play_stutter + Stutter play Ch4 + 0x93 + 0x04 + + + + + + [PreviewDeck1] + play + Play Preview Deck + 0x9F + 0x10 + + + + + + [Channel1] + cue_default + CUE Ch1 + 0x90 + 0x01 + + + + + + [Channel2] + cue_default + CUE Ch2 + 0x91 + 0x01 + + + + + + [Channel3] + cue_default + CUE Ch3 + 0x92 + 0x01 + + + + + + [Channel4] + cue_default + CUE Ch4 + 0x93 + 0x01 + + + + + + [Channel1] + start_stop + start stop Ch1 + 0x90 + 0x05 + + + + + + [Channel2] + start_stop + start stop Ch2 + 0x91 + 0x05 + + + + + + [Channel3] + start_stop + start stop Ch3 + 0x92 + 0x05 + + + + + + [Channel4] + start_stop + start stop Ch4 + 0x93 + 0x05 + + + + + + [Channel1] + sync_enabled + SYNC Ch1 + 0x90 + 0x02 + + + + + + [Channel2] + sync_enabled + SYNC Ch2 + 0x91 + 0x02 + + + + + + [Channel3] + sync_enabled + SYNC Ch3 + 0x92 + 0x02 + + + + + + [Channel4] + sync_enabled + SYNC Ch4 + 0x93 + 0x02 + + + + + + + [Channel1] + beats_translate_curpos + BeatGrid Adjust Ch1 + 0x94 + 0x46 + + + + + + [Channel2] + beats_translate_curpos + BeatGrid Adjust Ch2 + 0x95 + 0x46 + + + + + + [Channel3] + beats_translate_curpos + BeatGrid Adjust Ch3 + 0x96 + 0x46 + + + + + + [Channel4] + beats_translate_curpos + BeatGrid Adjust Ch4 + 0x97 + 0x46 + + + + + + [Channel1] + beats_translate_match_alignment + BeatGrid Slide Ch1 + 0x94 + 0x48 + + + + + + [Channel2] + beats_translate_match_alignment + BeatGrid Slide Ch2 + 0x95 + 0x48 + + + + + + [Channel3] + beats_translate_match_alignment + BeatGrid Slide Ch3 + 0x96 + 0x48 + + + + + + [Channel4] + beats_translate_match_alignment + BeatGrid Slide Ch4 + 0x97 + 0x48 + + + + + + [Channel1] + quantize + Quantize + 0x94 + 0x47 + + + + + + [Channel2] + quantize + Quantize + 0x95 + 0x47 + + + + + + [Channel3] + quantize + Quantize + 0x96 + 0x47 + + + + + + [Channel4] + quantize + Quantize + 0x97 + 0x47 + + + + + + [Channel1] + beatloop_activate + AutoLoop Ch1 + 0x94 + 0x32 + + + + + + [Channel2] + beatloop_activate + AutoLoop Ch2 + 0x95 + 0x32 + + + + + + [Channel3] + beatloop_activate + AutoLoop Ch3 + 0x96 + 0x32 + + + + + + [Channel4] + beatloop_activate + AutoLoop Ch4 + 0x97 + 0x32 + + + + + + [Channel1] + loop_halve + X1/2 Ch1 + 0x94 + 0x34 + + + + + + [Channel2] + loop_halve + X1/2 Ch2 + 0x95 + 0x34 + + + + + + [Channel3] + loop_halve + X1/2 Ch3 + 0x96 + 0x34 + + + + + + [Channel4] + loop_halve + X1/2 Ch4 + 0x97 + 0x34 + + + + + + [Channel1] + loop_double + X2 Ch1 + 0x94 + 0x35 + + + + + + [Channel2] + loop_double + X2 Ch2 + 0x95 + 0x35 + + + + + + [Channel3] + loop_double + X2 Ch3 + 0x96 + 0x35 + + + + + + [Channel4] + loop_double + X2 Ch4 + 0x97 + 0x35 + + + + + + [Channel1] + loop_in + Loop in Ch1 + 0x94 + 0x38 + + + + + + [Channel2] + loop_in + Loop in Ch2 + 0x95 + 0x38 + + + + + + [Channel3] + loop_in + Loop in Ch3 + 0x96 + 0x38 + + + + + + [Channel4] + loop_in + Loop in Ch4 + 0x97 + 0x38 + + + + + + [Channel1] + loop_out + Loop out Ch1 + 0x94 + 0x39 + + + + + + [Channel2] + loop_out + Loop out Ch2 + 0x95 + 0x39 + + + + + + [Channel3] + loop_out + Loop out Ch3 + 0x96 + 0x39 + + + + + + [Channel4] + loop_out + Loop out Ch4 + 0x97 + 0x39 + + + + + + [Channel1] + reloop_toggle + Reloop Ch1 + 0x94 + 0x33 + + + + + + [Channel2] + reloop_toggle + Reloop Ch2 + 0x95 + 0x33 + + + + + + [Channel3] + reloop_toggle + Reloop Ch3 + 0x96 + 0x33 + + + + + + [Channel4] + reloop_toggle + Reloop Ch4 + 0x97 + 0x33 + + + + + + + [Channel1] + beatjump_8_backward + MIDI Learned from 10 messages. + 0x94 + 0x28 + + + + + + [Channel1] + beatjump_8_forward + MIDI Learned from 2 messages. + 0x94 + 0x29 + + + + + + [Channel1] + beatjump_32_backward + MIDI Learned from 8 messages. + 0x94 + 0x2A + + + + + + [Channel1] + beatjump_32_forward + MIDI Learned from 6 messages. + 0x94 + 0x2B + + + + + + [Channel2] + beatjump_8_backward + MIDI Learned from 10 messages. + 0x95 + 0x28 + + + + + + [Channel2] + beatjump_8_forward + MIDI Learned from 2 messages. + 0x95 + 0x29 + + + + + + [Channel2] + beatjump_32_backward + MIDI Learned from 8 messages. + 0x95 + 0x2A + + + + + + [Channel2] + beatjump_32_forward + MIDI Learned from 6 messages. + 0x95 + 0x2B + + + + + + [Channel3] + beatjump_8_backward + MIDI Learned from 10 messages. + 0x96 + 0x28 + + + + + + [Channel3] + beatjump_8_forward + MIDI Learned from 2 messages. + 0x96 + 0x29 + + + + + + [Channel3] + beatjump_32_backward + MIDI Learned from 8 messages. + 0x96 + 0x2A + + + + + + [Channel3] + beatjump_32_forward + MIDI Learned from 6 messages. + 0x96 + 0x2B + + + + + + [Channel4] + beatjump_8_backward + MIDI Learned from 10 messages. + 0x97 + 0x28 + + + + + + [Channel4] + beatjump_8_forward + MIDI Learned from 2 messages. + 0x97 + 0x29 + + + + + + [Channel4] + beatjump_32_backward + MIDI Learned from 8 messages. + 0x97 + 0x2A + + + + + + [Channel4] + beatjump_32_forward + MIDI Learned from 6 messages. + 0x97 + 0x2B + + + + + + + [Library] + MoveVertical + Select line + 0xBF + 0x00 + + + + + + [Library] + ScrollVertical + Select page + 0xBF + 0x01 + + + + + + [Channel1] + LoadSelectedTrack + MIDI Learned from 2 messages. + 0x9F + 0x02 + + + + + + [Channel2] + LoadSelectedTrack + MIDI Learned from 2 messages. + 0x9F + 0x03 + + + + + + [Channel3] + LoadSelectedTrack + MIDI Learned from 2 messages. + 0x9F + 0x04 + + + + + + [Channel4] + LoadSelectedTrack + MIDI Learned from 2 messages. + 0x9F + 0x05 + + + + + + [Library] + GoToItem + Select Item + 0x9F + 0x1F + + + + + + [Library] + MoveFocusForward + change active panel + 0x9F + 0x06 + + + + + + [Library] + MoveFocusBackward + change active panel + 0x9F + 0x07 + + + + + + [PreviewDeck1] + LoadSelectedTrack + Load in Preview deck + 0x9F + 0x1B + + + + + + [EffectRack1] + show + Show Effect Rack + 0x9F + 0x11 + + + + + + [Master] + maximize_library + Full screen Library + 0x9F + 0x0F + + + + + + + + [EffectRack1_EffectUnit1] + group_[Channel1]_enable + FX 1 to Ch1 + 0x98 + 0x05 + + + + + + [EffectRack1_EffectUnit1] + group_[Channel2]_enable + FX 1 to Ch2 + 0x98 + 0x06 + + + + + + [EffectRack1_EffectUnit1] + group_[Channel3]_enable + FX 1 to Ch3 + 0x98 + 0x07 + + + + + + [EffectRack1_EffectUnit1] + group_[Channel4]_enable + FX 1 to Ch4 + 0x98 + 0x08 + + + + + + [EffectRack1_EffectUnit2] + group_[Channel1]_enable + FX 2 to Ch1 + 0x99 + 0x05 + + + + + + [EffectRack1_EffectUnit2] + group_[Channel2]_enable + FX 2 to Ch2 + 0x99 + 0x06 + + + + + + [EffectRack1_EffectUnit2] + group_[Channel3]_enable + FX 2 to Ch3 + 0x99 + 0x07 + + + + + + [EffectRack1_EffectUnit2] + group_[Channel4]_enable + FX 2 to Ch4 + 0x99 + 0x08 + + + + + + + [EffectRack1_EffectUnit1_Effect1] + enabled + FX1 1 on + 0x98 + 0x00 + + + + + + [EffectRack1_EffectUnit1_Effect2] + enabled + FX1 2 on + 0x98 + 0x01 + + + + + + [EffectRack1_EffectUnit1_Effect3] + enabled + FX1 3 on + 0x98 + 0x02 + + + + + + [EffectRack1_EffectUnit1_Effect1] + meta + FX1 Level 1 + 0xB8 + 0x00 + + + + + + [EffectRack1_EffectUnit1_Effect2] + meta + FX1 Level 2 + 0xB8 + 0x01 + + + + + + [EffectRack1_EffectUnit1_Effect3] + meta + FX1 Level 3 + 0xB8 + 0x02 + + + + + + + [EffectRack1_EffectUnit2_Effect1] + enabled + FX2 1 on + 0x99 + 0x00 + + + + + + [EffectRack1_EffectUnit2_Effect2] + enabled + FX2 2 on + 0x99 + 0x01 + + + + + + [EffectRack1_EffectUnit2_Effect3] + enabled + FX2 3 on + 0x99 + 0x02 + + + + + + [EffectRack1_EffectUnit2_Effect1] + meta + FX2 Level 1 + 0xB9 + 0x00 + + + + + + [EffectRack1_EffectUnit2_Effect2] + meta + FX2 Level 2 + 0xB9 + 0x01 + + + + + + [EffectRack1_EffectUnit2_Effect3] + meta + FX2 Level 3 + 0xB9 + 0x02 + + + + + + + [EffectRack1_EffectUnit1_Effect1] + next_effect + FX1 1 + 0x98 + 0x0B + + + + + + [EffectRack1_EffectUnit2_Effect1] + next_effect + FX2 1 + 0x99 + 0x0B + + + + + + [EffectRack1_EffectUnit1_Effect3] + next_effect + FX1 3 + 0x98 + 0x0D + + + + + + [EffectRack1_EffectUnit1_Effect2] + next_effect + FX1 2 + 0x98 + 0x0C + + + + + + [EffectRack1_EffectUnit2_Effect3] + next_effect + FX2 3 + 0x99 + 0x0D + + + + + + [EffectRack1_EffectUnit2_Effect2] + next_effect + FX2 2 + 0x99 + 0x0C + + + + + + + [EffectRack1_EffectUnit1] + group_[Master]_enable + FX1 on master + 0x98 + 0x04 + + + + + + [EffectRack1_EffectUnit2] + group_[Master]_enable + FX2 on master + 0x99 + 0x04 + + + + + + [EffectRack1_EffectUnit1] + group_[Headphone]_enable + MIDI Learned from 2 messages. + 0x98 + 0x0A + + + + + + [EffectRack1_EffectUnit2] + group_[Headphone]_enable + MIDI Learned from 2 messages. + 0x99 + 0x0A + + + + + + + [Channel1] + slip_enabled + MIDI Learned from 12 messages. + 0x90 + 0x0F + + + + + + [Channel2] + slip_enabled + MIDI Learned from 124 messages. + 0x91 + 0x0F + + + + + + [Channel3] + slip_enabled + MIDI Learned from 70 messages. + 0x92 + 0x0F + + + + + + [Channel4] + slip_enabled + MIDI Learned from 160 messages. + 0x93 + 0x0F + + + + + + [Channel1] + MC7000.censor + Backspin Ch1 + 0x90 + 0x10 + + + + + + [Channel2] + MC7000.censor + Backspin Ch2 + 0x91 + 0x10 + + + + + + [Channel3] + MC7000.censor + Backspin Ch3 + 0x92 + 0x10 + + + + + + [Channel4] + MC7000.censor + Backspin Ch4 + 0x93 + 0x10 + + + + + + [Channel1] + MC7000.stopTime + Stop Time Ch1 + 0xB0 + 0x13 + + + + + + [Channel2] + MC7000.stopTime + Stop Time Ch2 + 0xB1 + 0x13 + + + + + + [Channel3] + MC7000.stopTime + Stop Time Ch3 + 0xB2 + 0x13 + + + + + + [Channel4] + MC7000.stopTime + Stop Time Ch4 + 0xB3 + 0x13 + + + + + + [Channel1] + reverse + Reverse Ch1 + 0x90 + 0x11 + + + + + + [Channel2] + reverse + Reverse Ch2 + 0x91 + 0x11 + + + + + + [Channel3] + reverse + Reverse Ch3 + 0x92 + 0x11 + + + + + + [Channel4] + reverse + Reverse Ch4 + 0x93 + 0x11 + + + + + + + [Channel1] + keylock + Keylock Ch1 + 0x90 + 0x0D + + + + + + [Channel2] + keylock + Keylock Ch2 + 0x91 + 0x0D + + + + + + [Channel3] + keylock + Keylock Ch3 + 0x92 + 0x0D + + + + + + [Channel4] + keylock + Keylock Ch4 + 0x93 + 0x0D + + + + + + [Channel1] + sync_key + sync_key Ch1 + 0x90 + 0x29 + + + + + + [Channel2] + sync_key + sync_key Ch2 + 0x91 + 0x29 + + + + + + [Channel3] + sync_key + sync_key Ch3 + 0x92 + 0x29 + + + + + + [Channel4] + sync_key + sync_key Ch4 + 0x93 + 0x29 + + + + + + [Channel1] + reset_key + Default Key + 0x90 + 0x2A + + + + + + [Channel2] + reset_key + Default Key + 0x91 + 0x2A + + + + + + [Channel3] + reset_key + Default Key + 0x92 + 0x2A + + + + + + [Channel4] + reset_key + Default Key + 0x93 + 0x2A + + + + + + + [Channel1] + rate_temp_down_small + Pitch Bend - + 0x90 + 0x0C + + + + + + [Channel2] + rate_temp_down_small + Pitch Bend - + 0x91 + 0x0C + + + + + + [Channel3] + rate_temp_down_small + Pitch Bend - + 0x92 + 0x0C + + + + + + [Channel4] + rate_temp_down_small + Pitch Bend - + 0x93 + 0x0C + + + + + + [Channel1] + rate_temp_up_small + Pitch Bend + + 0x90 + 0x0B + + + + + + [Channel2] + rate_temp_up_small + Pitch Bend + + 0x91 + 0x0B + + + + + + [Channel3] + rate_temp_up_small + Pitch Bend + + 0x92 + 0x0B + + + + + + [Channel4] + rate_temp_up_small + Pitch Bend + + 0x93 + 0x0B + + + + + + + [Channel1] + MC7000.PadButtons + PAD-1 + 0x94 + 0x14 + + + + + + [Channel2] + MC7000.PadButtons + PAD-1 + 0x95 + 0x14 + + + + + + [Channel3] + MC7000.PadButtons + PAD-1 + 0x96 + 0x14 + + + + + + [Channel4] + MC7000.PadButtons + PAD-1 + 0x97 + 0x14 + + + + + + [Channel1] + MC7000.PadButtons + PAD-2 + 0x94 + 0x15 + + + + + + [Channel2] + MC7000.PadButtons + PAD-2 + 0x95 + 0x15 + + + + + + [Channel3] + MC7000.PadButtons + PAD-2 + 0x96 + 0x15 + + + + + + [Channel4] + MC7000.PadButtons + PAD-2 + 0x97 + 0x15 + + + + + + [Channel1] + MC7000.PadButtons + PAD_3 + 0x94 + 0x16 + + + + + + [Channel2] + MC7000.PadButtons + PAD_3 + 0x95 + 0x16 + + + + + + [Channel3] + MC7000.PadButtons + PAD_3 + 0x96 + 0x16 + + + + + + [Channel4] + MC7000.PadButtons + PAD_3 + 0x97 + 0x16 + + + + + + [Channel1] + MC7000.PadButtons + PAD_4 + 0x94 + 0x17 + + + + + + [Channel2] + MC7000.PadButtons + PAD_4 + 0x95 + 0x17 + + + + + + [Channel3] + MC7000.PadButtons + PAD_4 + 0x96 + 0x17 + + + + + + [Channel4] + MC7000.PadButtons + PAD_4 + 0x97 + 0x17 + + + + + + [Channel1] + MC7000.PadButtons + PAD_5 + 0x94 + 0x18 + + + + + + [Channel2] + MC7000.PadButtons + PAD_5 + 0x95 + 0x18 + + + + + + [Channel3] + MC7000.PadButtons + PAD_5 + 0x96 + 0x18 + + + + + + [Channel4] + MC7000.PadButtons + PAD_5 + 0x97 + 0x18 + + + + + + [Channel1] + MC7000.PadButtons + PAD_6 + 0x94 + 0x19 + + + + + + [Channel2] + MC7000.PadButtons + PAD_6 + 0x95 + 0x19 + + + + + + [Channel3] + MC7000.PadButtons + PAD_6 + 0x96 + 0x19 + + + + + + [Channel4] + MC7000.PadButtons + PAD_6 + 0x97 + 0x19 + + + + + + [Channel1] + MC7000.PadButtons + PAD_7 + 0x94 + 0x1A + + + + + + [Channel2] + MC7000.PadButtons + PAD_7 + 0x95 + 0x1A + + + + + + [Channel3] + MC7000.PadButtons + PAD_7 + 0x96 + 0x1A + + + + + + [Channel4] + MC7000.PadButtons + PAD_7 + 0x97 + 0x1A + + + + + + [Channel1] + MC7000.PadButtons + PAD_8 + 0x94 + 0x1B + + + + + + [Channel2] + MC7000.PadButtons + PAD_8 + 0x95 + 0x1B + + + + + + [Channel3] + MC7000.PadButtons + PAD_8 + 0x96 + 0x1B + + + + + + [Channel4] + MC7000.PadButtons + PAD_8 + 0x97 + 0x1B + + + + + + + [Channel1] + MC7000.PadButtons + CLEAR_PAD-1 + 0x94 + 0x1C + + + + + + [Channel2] + MC7000.PadButtons + CLEAR_PAD-1 + 0x95 + 0x1C + + + + + + [Channel3] + MC7000.PadButtons + CLEAR_PAD-1 + 0x96 + 0x1C + + + + + + [Channel4] + MC7000.PadButtons + CLEAR_PAD-1 + 0x97 + 0x1C + + + + + + [Channel1] + MC7000.PadButtons + CLEAR_PAD-2 + 0x94 + 0x1D + + + + + + [Channel2] + MC7000.PadButtons + CLEAR_PAD-2 + 0x95 + 0x1D + + + + + + [Channel3] + MC7000.PadButtons + CLEAR_PAD-2 + 0x96 + 0x1D + + + + + + [Channel4] + MC7000.PadButtons + CLEAR_PAD-2 + 0x97 + 0x1D + + + + + + [Channel1] + MC7000.PadButtons + CLEAR_PAD_3 + 0x94 + 0x1E + + + + + + [Channel2] + MC7000.PadButtons + CLEAR_PAD_3 + 0x95 + 0x1E + + + + + + [Channel3] + MC7000.PadButtons + CLEAR_PAD_3 + 0x96 + 0x1E + + + + + + [Channel4] + MC7000.PadButtons + CLEAR_PAD_3 + 0x97 + 0x1E + + + + + + [Channel1] + MC7000.PadButtons + CLEAR_PAD_4 + 0x94 + 0x1F + + + + + + [Channel2] + MC7000.PadButtons + CLEAR_PAD_4 + 0x95 + 0x1F + + + + + + [Channel3] + MC7000.PadButtons + CLEAR_PAD_4 + 0x96 + 0x1F + + + + + + [Channel4] + MC7000.PadButtons + CLEAR_PAD_4 + 0x97 + 0x1F + + + + + + [Channel1] + MC7000.PadButtons + CLEAR_PAD_5 + 0x94 + 0x20 + + + + + + [Channel2] + MC7000.PadButtons + CLEAR_PAD_5 + 0x95 + 0x20 + + + + + + [Channel3] + MC7000.PadButtons + CLEAR_PAD_5 + 0x96 + 0x20 + + + + + + [Channel4] + MC7000.PadButtons + CLEAR_PAD_5 + 0x97 + 0x20 + + + + + + [Channel1] + MC7000.PadButtons + CLEAR_PAD_6 + 0x94 + 0x21 + + + + + + [Channel2] + MC7000.PadButtons + CLEAR_PAD_6 + 0x95 + 0x21 + + + + + + [Channel3] + MC7000.PadButtons + CLEAR_PAD_6 + 0x96 + 0x21 + + + + + + [Channel4] + MC7000.PadButtons + CLEAR_PAD_6 + 0x97 + 0x21 + + + + + + [Channel1] + MC7000.PadButtons + CLEAR_PAD_7 + 0x94 + 0x22 + + + + + + [Channel2] + MC7000.PadButtons + CLEAR_PAD_7 + 0x95 + 0x22 + + + + + + [Channel3] + MC7000.PadButtons + CLEAR_PAD_7 + 0x96 + 0x22 + + + + + + [Channel4] + MC7000.PadButtons + CLEAR_PAD_7 + 0x97 + 0x22 + + + + + + [Channel1] + MC7000.PadButtons + CLEAR_PAD_8 + 0x94 + 0x23 + + + + + + [Channel2] + MC7000.PadButtons + CLEAR_PAD_8 + 0x95 + 0x23 + + + + + + [Channel3] + MC7000.PadButtons + CLEAR_PAD_8 + 0x96 + 0x23 + + + + + + [Channel4] + MC7000.PadButtons + CLEAR_PAD_8 + 0x97 + 0x23 + + + + + + + + + [Channel1] + loop_enabled + Autoloop LED + 0x94 + 0x32 + 0x01 + 0.5 + + + [Channel1] + loop_enabled + Reloop LED + 0x94 + 0x33 + 0x02 + 0x01 + 0.5 + + + [Channel2] + loop_enabled + Autoloop LED + 0x95 + 0x32 + 0x01 + 0.5 + + + [Channel2] + loop_enabled + Reloop LED + 0x95 + 0x33 + 0x02 + 0x01 + 0.5 + + + [Channel3] + loop_enabled + Autoloop LED + 0x96 + 0x32 + 0x01 + 0.5 + + + [Channel3] + loop_enabled + Reloop LED + 0x96 + 0x33 + 0x02 + 0x01 + 0.5 + + + [Channel4] + loop_enabled + Autoloop LED + 0x97 + 0x32 + 0x01 + 0.5 + + + [Channel4] + loop_enabled + Reloop LED + 0x97 + 0x33 + 0x02 + 0x01 + 0.5 + + + [Channel1] + play_indicator + Play LED + 0x90 + 0x00 + 0x01 + 0.5 + + + [Channel2] + play_indicator + Play LED + 0x91 + 0x00 + 0x01 + 0.5 + + + [Channel3] + play_indicator + Play LED + 0x92 + 0x00 + 0x01 + 0.5 + + + [Channel4] + play_indicator + Play LED + 0x93 + 0x00 + 0x01 + 0.5 + + + [Channel1] + cue_indicator + Cue LED + 0x90 + 0x01 + 0x01 + 0.5 + + + [Channel2] + cue_indicator + Cue LED + 0x91 + 0x01 + 0x01 + 0.5 + + + [Channel3] + cue_indicator + Cue LED + 0x92 + 0x01 + 0x01 + 0.5 + + + [Channel4] + cue_indicator + Cue LED + 0x93 + 0x01 + 0x01 + 0.5 + + + [Channel1] + sync_enabled + Sync LED + 0x90 + 0x02 + 0x01 + 0.5 + + + [Channel2] + sync_enabled + Sync LED + 0x91 + 0x02 + 0x01 + 0.5 + + + [Channel3] + sync_enabled + Sync LED + 0x92 + 0x02 + 0x01 + 0.5 + + + [Channel4] + sync_enabled + Sync LED + 0x93 + 0x02 + 0x01 + 0.5 + + + [Channel1] + slip_enabled + Slip LED + 0x90 + 0x0F + 0x01 + 0.5 + + + [Channel2] + slip_enabled + Slip LED + 0x91 + 0x0F + 0x01 + 0.5 + + + [Channel3] + slip_enabled + Slip LED + 0x92 + 0x0F + 0x01 + 0.5 + + + [Channel4] + slip_enabled + Slip LED + 0x93 + 0x0F + 0x01 + 0.5 + + + [Channel1] + pfl + PFL LED + 0x90 + 0x1B + 0x01 + 0.5 + + + [Channel2] + pfl + PFL LED + 0x91 + 0x1B + 0x01 + 0.5 + + + [Channel3] + pfl + PFL LED + 0x92 + 0x1B + 0x01 + 0.5 + + + [Channel4] + pfl + PFL LED + 0x93 + 0x1B + 0x01 + 0.5 + + + [Channel1] + keylock + keylock LED + 0x90 + 0x0D + 0x01 + 0.5 + + + [Channel2] + keylock + keylock LED + 0x91 + 0x0D + 0x01 + 0.5 + + + [Channel3] + keylock + keylock LED + 0x92 + 0x0D + 0x01 + 0.5 + + + [Channel4] + keylock + keylock LED + 0x93 + 0x0D + 0x01 + 0.5 + + + [Channel1] + reverseroll + Censor LED + 0x90 + 0x10 + 0x01 + 0.5 + + + [Channel2] + reverseroll + Censor LED + 0x91 + 0x10 + 0x01 + 0.5 + + + [Channel3] + reverseroll + Censor LED + 0x92 + 0x10 + 0x01 + 0.5 + + + [Channel4] + reverseroll + Censor LED + 0x93 + 0x10 + 0x01 + 0.5 + + + + + + [EffectRack1_EffectUnit1] + group_[Channel1]_enable + FX 1 to Ch1 + 0x98 + 0x05 + 0x01 + 0.5 + + + [EffectRack1_EffectUnit1] + group_[Channel2]_enable + FX 1 to Ch2 + 0x98 + 0x06 + 0x01 + 0.5 + + + [EffectRack1_EffectUnit1] + group_[Channel3]_enable + FX 1 to Ch3 + 0x98 + 0x07 + 0x01 + 0.5 + + + [EffectRack1_EffectUnit1] + group_[Channel4]_enable + FX 1 to Ch4 + 0x98 + 0x08 + 0x01 + 0.5 + + + [EffectRack1_EffectUnit2] + group_[Channel1]_enable + FX 2 to Ch1 + 0x99 + 0x05 + 0x01 + 0.5 + + + [EffectRack1_EffectUnit2] + group_[Channel2]_enable + FX 2 to Ch2 + 0x99 + 0x06 + 0x01 + 0.5 + + + [EffectRack1_EffectUnit2] + group_[Channel3]_enable + FX 2 to Ch3 + 0x99 + 0x07 + 0x01 + 0.5 + + + [EffectRack1_EffectUnit2] + group_[Channel4]_enable + FX 2 to Ch4 + 0x99 + 0x08 + 0x01 + 0.5 + + + + [EffectRack1_EffectUnit1_Effect1] + enabled + FX1 1 on + 0x98 + 0x00 + 0x01 + 0.5 + + + [EffectRack1_EffectUnit1_Effect2] + enabled + FX1 2 on + 0x98 + 0x01 + 0x01 + 0.5 + + + [EffectRack1_EffectUnit1_Effect3] + enabled + FX1 3 on + 0x98 + 0x02 + 0x01 + 0.5 + + + [EffectRack1_EffectUnit2_Effect1] + enabled + FX2 1 on + 0x99 + 0x00 + 0x01 + 0.5 + + + [EffectRack1_EffectUnit2_Effect2] + enabled + FX2 2 on + 0x99 + 0x01 + 0x01 + 0.5 + + + [EffectRack1_EffectUnit2_Effect3] + enabled + FX2 3 on + 0x99 + 0x02 + 0x01 + 0.5 + + + + [EffectRack1_EffectUnit1] + group_[Master]_enable + FX1 on master + 0x98 + 0x04 + 0x01 + 0.5 + + + [EffectRack1_EffectUnit2] + group_[Master]_enable + FX2 on master + 0x99 + 0x04 + 0x01 + 0.5 + + + [EffectRack1_EffectUnit1] + group_[Headphone]_enable + 0x98 + 0x0A + 0x02 + 0x01 + 0.5 + + + [EffectRack1_EffectUnit2] + group_[Headphone]_enable + 0x99 + 0x0A + 0x02 + 0x01 + 0.5 + + + [Channel1] + sync_key + sync_key Ch1 + 0x90 + 0x29 + 0x02 + 0xFF + 0.5 + + + [Channel2] + sync_key + sync_key Ch2 + 0x91 + 0x29 + 0x02 + 0xFF + 0.5 + + + [Channel3] + sync_key + sync_key Ch3 + 0x92 + 0x29 + 0x02 + 0xFF + 0.5 + + + [Channel4] + sync_key + sync_key Ch4 + 0x93 + 0x29 + 0x02 + 0xFF + 0.5 + + + [Channel1] + reset_key + Default Key + 0x90 + 0x29 + 0x01 + 0.5 + + + [Channel2] + reset_key + Default Key + 0x91 + 0x29 + 0x01 + 0.5 + + + [Channel3] + reset_key + Default Key + 0x92 + 0x29 + 0x01 + 0.5 + + + [Channel4] + reset_key + Default Key + 0x93 + 0x29 + 0x01 + 0.5 + + + [Channel1] + quantize + Quantize + 0x94 + 0x47 + 0x02 + 0x01 + 0.5 + + + [Channel2] + quantize + Quantize + 0x95 + 0x47 + 0x02 + 0x01 + 0.5 + + + [Channel3] + quantize + Quantize + 0x96 + 0x47 + 0x02 + 0x01 + 0.5 + + + [Channel4] + quantize + Quantize + 0x97 + 0x47 + 0x02 + 0x01 + 0.5 + + + +