diff --git a/CHANGELOG b/CHANGELOG index 761be54aa50..4e6b6b5f30c 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -15,6 +15,7 @@ * Add controller mapping for Soundless joyMIDI #2425 * Add controller mapping for Hercules DJControl Inpulse 300 #2465 * Add controller mapping for Denon MC7000 #2546 +* Add controller mapping for Stanton DJC.4 #2607 ==== 2.2.3 2019-11-24 ==== * Don't make users reconfigure sound hardware when it has not changed #2253 diff --git a/res/controllers/Stanton-DJC-4-scripts.js b/res/controllers/Stanton-DJC-4-scripts.js new file mode 100644 index 00000000000..c0c2ebc70cb --- /dev/null +++ b/res/controllers/Stanton-DJC-4-scripts.js @@ -0,0 +1,378 @@ +/** + * Stanton DJC.4 controller script v1.0 for Mixxx v2.2.3 + * + * Written by Martin Bruset Solberg + * Adopted for v2.2.3 by Christoph Zimmermann + * + * Based on: + * Denon MC2000 script by Esteban Serrano Roloff, + * Denon MC7000 script by OsZ + * Roland DJ-505 script by Jan Holthuis + * + * TODO: + * Pitch range + * + **/ + +var DJC4 = {}; + +///////////////// +// Tweakables. // +///////////////// + +DJC4.autoShowFourDecks = false; +DJC4.showMasterVu = true; // if set to false, show channel VU meter + +// amount the dryWetKnob changes the value for each increment +DJC4.dryWetAdjustValue = 0.05; + +/////////// +// Code. // +/////////// + +// ---------- Global variables ---------- + +// MIDI Reception commands (from spec) +DJC4.leds = { + loopminus: 2, + loopplus: 3, + loopin: 4, + loopout: 5, + loopon: 6, + loopdel: 7, + hotcue1: 8, + hotcue2: 9, + hotcue3: 10, + hotcue4: 11, + sample1: 12, + sample2: 13, + sample3: 14, + sample4: 15, + keylock: 16, + sync: 18, + pbendminus: 19, + pbendplus: 20, + scratch: 21, + tap: 22, + cue: 23, + play: 24, + highkill: 25, + midkill: 26, + lowkill: 27, + pfl: 28, + fxon: 30, + fxexf1: 31, + fxexf2: 32, + fxexf3: 33, + loadac: 34, + loadbd: 35, + videofx: 36, + xflink: 37, + keyon: 38, + filteron: 39, + tx: 46, + fx: 47 +}; + +// ---------- Functions ---------- + +// Called when the MIDI device is opened & set up. +DJC4.init = function() { + var i; + + // Put all LEDs to default state. + DJC4.allLed2Default(); + + engine.makeConnection("[Channel3]", "track_loaded", DJC4.autoShowDecks); + engine.makeConnection("[Channel4]", "track_loaded", DJC4.autoShowDecks); + + if (engine.getValue("[Master]", "num_samplers") < 8) { + engine.setValue("[Master]", "num_samplers", 8); + } + + DJC4.browseEncoder = new components.Encoder({ + group: "[Library]", + inKey: "Move", + input: function(channel, control, value) { + if (value === 0x41) { + engine.setParameter(this.group, this.inKey + "Down", 1); + } else if (value === 0x3F) { + engine.setParameter(this.group, this.inKey + "Up", 1); + } + }, + unshift: function() { + this.inKey = "Move"; + }, + shift: function() { + this.inKey = "Scroll"; + }, + }); + + DJC4.deck = []; + for (i = 0; i < 4; i++) { + DJC4.deck[i] = new DJC4.Deck(i + 1); + DJC4.deck[i].setCurrentDeck("[Channel" + (i + 1) + "]"); + } + + DJC4.effectUnit = []; + for (i = 0; i <= 3; i++) { + DJC4.effectUnit[i] = new components.EffectUnit([i + 1]); + DJC4.effectUnit[i].shiftOffset = 0x32; + DJC4.effectUnit[i].shiftControl = true; + DJC4.effectUnit[i].enableButtons[1].midi = [0x90 + i, 0x1F]; + DJC4.effectUnit[i].enableButtons[2].midi = [0x90 + i, 0x20]; + DJC4.effectUnit[i].enableButtons[3].midi = [0x90 + i, 0x21]; + DJC4.effectUnit[i].effectFocusButton.midi = [0x90 + i, 0x1D]; + DJC4.effectUnit[i].knobs[1].midi = [0xB0 + i, 0x09]; + DJC4.effectUnit[i].knobs[2].midi = [0xB0 + i, 0x0A]; + DJC4.effectUnit[i].knobs[3].midi = [0xB0 + i, 0x0B]; + DJC4.effectUnit[i].dryWetKnob.midi = [0xB0 + i, 0x08]; + DJC4.effectUnit[i].dryWetKnob.input = function(channel, control, value) { + if (value === 0x41) { + this.inSetParameter(this.inGetParameter() + DJC4.dryWetAdjustValue); + } else if (value === 0x3F) { + this.inSetParameter(this.inGetParameter() - DJC4.dryWetAdjustValue); + } + }; + DJC4.effectUnit[i].init(); + } + + // === Master VU Meter === + if (DJC4.showMasterVu === true) { + DJC4.vuMeter = new components.Component({ + midi: [0xB0, 0x03], + group: "[Master]", + outKey: "VuMeterL", + output: function(value, group) { + // The red LEDs light up with MIDI values greater than 0x60. + // The Red LEDs should only be illuminated if the track is clipping. + if (engine.getValue(group, "PeakIndicator") === 1) { + value = 0x60; + } else { + value = Math.round(value * 0x54); + } + this.send(value); + }, + }); + + DJC4.vuMeter = new components.Component({ + midi: [0xB0, 0x04], + group: "[Master]", + outKey: "VuMeterR", + output: function(value, group) { + // The red LEDs light up with MIDI values greater than 0x60. + // The Red LEDs should only be illuminated if the track is clipping. + if (engine.getValue(group, "PeakIndicator") === 1) { + value = 0x60; + } else { + value = Math.round(value * 0x54); + } + this.send(value); + }, + }); + } +}; + +// Called when the MIDI device is closed +DJC4.shutdown = function() { + // Put all LEDs to default state. + DJC4.allLed2Default(); +}; + +DJC4.Deck = function(deckNumber) { + components.Deck.call(this, deckNumber); + + // === Instantiate controls === + this.beatLoopEncoder = new components.Encoder({ + midi: [0xB0 + deckNumber - 1, 0x01], + group: "[Channel" + deckNumber + "]", + inKey: "loop_move_1", + input: function(channel, control, value) { + if (value === 0x41) { + engine.setParameter(this.group, this.inKey + "_forward", 1); + } else if (value === 0x3F) { + engine.setParameter(this.group, this.inKey + "_backward", 1); + } + }, + }); + + this.samplerButtons = []; + for (var i = 0; i <= 3; i++) { + this.samplerButtons[i] = new components.SamplerButton({ + number: (deckNumber === 1 || deckNumber === 3) ? (i + 1) : (i + 5), + midi: [0x90+deckNumber-1, 0x0C+i], + }); + } + + // === Channel VU Meter === + if (DJC4.showMasterVu === false) { + DJC4.vuMeter = new components.Component({ + midi: [0xB0+deckNumber-1, 0x02], + group: "[Channel" + deckNumber + "]", + outKey: "VuMeter", + output: function(value, group) { + // The red LEDs light up with MIDI values greater than 0x60. + // The Red LEDs should only be illuminated if the track is clipping. + if (engine.getValue(group, "PeakIndicator") === 1) { + value = 0x60; + } else { + value = Math.round(value * 0x54); + } + this.send(value); + }, + }); + } + + // === Scratch control === + this.scratchMode = false; + + this.toggleScratchMode = function(channel, control, value) { + if (value === 0x7F) { + // Toggle setting + this.scratchMode = !this.scratchMode; + DJC4.setLed(script.deckFromGroup(this.currentDeck), DJC4.leds["scratch"], this.scratchMode); + } + }; + + // ============================= JOG WHEELS ============================== + this.wheelTouch = function(channel, control, value, status, group) { + if (engine.getValue(group, "play") === 0) { + // If not playing, do a fast search + if (value === 0x7F) { + var alpha = 1.0 / 8; + var beta = alpha / 32; + var rpm = 40.0; + + engine.scratchEnable(script.deckFromGroup(this.currentDeck), 128, rpm, alpha, beta, true); + } else { // If button up + engine.scratchDisable(script.deckFromGroup(this.currentDeck)); + } + } else if (this.scratchMode === true) { + // If scratch enabled + if (value === 0x7F) { + alpha = 1.0/8; + beta = alpha/32; + rpm = 150.0; + + engine.scratchEnable(script.deckFromGroup(this.currentDeck), 128, rpm, alpha, beta); + } else { // If button up + engine.scratchDisable(script.deckFromGroup(this.currentDeck)); + } + } else { // If button up + engine.scratchDisable(script.deckFromGroup(this.currentDeck)); + } + }; + + this.wheelTurn = function(channel, control, value) { + // When the jog wheel is turned in clockwise direction, value is + // greater than 64 (= 0x40). If it's turned in counter-clockwise + // direction, the value is smaller than 64. + var newValue = value - 64; + var deck = script.deckFromGroup(this.currentDeck); + if (engine.isScratching(deck)) { + engine.scratchTick(deck, newValue); // Scratch! + } else if (this.shifted === true) { // If shift is pressed + var oldPos = engine.getValue(this.currentDeck, "playposition"); + // Since ‘playposition’ is normalized to unity, we need to scale by + // song duration in order for the jog wheel to cover the same amount + // of time given a constant turning angle. + var duration = engine.getValue(this.currentDeck, "duration"); + var newPos = Math.max(0, oldPos + (newValue * DJC4.stripSearchScaling / duration)); + engine.setValue(this.currentDeck, "playposition", newPos); // Strip search + } else { + engine.setValue(this.currentDeck, "jog", newValue); // Pitch bend + } + }; +}; + +// === FOR MANAGING LEDS === + +DJC4.allLed2Default = function() { + // All LEDs OFF for deck 1 to 4 + var i = 0; + for (i = 1; i <= 4; i++) { + for (var led in DJC4.leds) { + DJC4.setLed(i, DJC4.leds[led], 0); + } + // Channel VU meter + midi.sendShortMsg(0xB0 + (i - 1), 2, 0); + } + // Master VU meter + midi.sendShortMsg(0xB0, 3, 0); + midi.sendShortMsg(0xB0, 4, 0); +}; + +// Set leds function +DJC4.setLed = function(deck, led, status) { + var ledStatus = 0x00; // Default OFF + switch (status) { + case 0: + ledStatus = 0x00; + break; // OFF + case false: + ledStatus = 0x00; + break; // OFF + case 1: + ledStatus = 0x7F; + break; // ON + case true: + ledStatus = 0x7F; + break; // ON + default: + break; + } + midi.sendShortMsg(0x90 + (deck - 1), led, ledStatus); +}; + +// === MISC COMMON === + +DJC4.autoShowDecks = function() { + var anyLoaded = engine.getValue("[Channel3]", "track_loaded") || engine.getValue("[Channel4]", "track_loaded"); + if (!DJC4.autoShowFourDecks) { + return; + } + engine.setValue("[Master]", "show_4decks", anyLoaded); +}; + +DJC4.shiftButton = function(channel, control, value) { + var i; + if (value === 0x7F) { + DJC4.browseEncoder.shift(); + for (i = 0; i < 4; i++) { + DJC4.deck[i].shift(); + DJC4.effectUnit[i].shift(); + } + } else { + DJC4.browseEncoder.unshift(); + for (i = 0; i < 4; i++) { + DJC4.deck[i].unshift(); + DJC4.effectUnit[i].unshift(); + } + } +}; + +DJC4.crossfaderCurve = function(channel, control, value) { + script.crossfaderCurve(value, 0, 0x7F); +}; + +// === Sampler Volume Control === +DJC4.samplerVolume = 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 Row opened with its details + engine.setValue("[SamplerRow1]", "expanded", true); + + // control up to 8 sampler volumes with the one knob on the mixer + for (var i = 1; i <= 8; i++) { + engine.setValue("[Sampler" + i + "]", "pregain", + script.absoluteNonLin(value, 0, 1.0, 4.0)); + } +}; + + +// give your custom Deck all the methods of the generic Deck in the Components library +DJC4.Deck.prototype = Object.create(components.Deck.prototype); diff --git a/res/controllers/Stanton-DJC-4.midi.xml b/res/controllers/Stanton-DJC-4.midi.xml new file mode 100644 index 00000000000..c91fe88fd7c --- /dev/null +++ b/res/controllers/Stanton-DJC-4.midi.xml @@ -0,0 +1,3506 @@ + + + + Stanton DJC.4 + Martin Bruset Solberg, Christoph Zimmermann + The Stanton DJC.4 is a 4 deck controller with large, touch-sensitive jog wheels and a built-in audio interface (2 inputs, 2 outputs). It features 4 FX units and a master VU meter. + https://mixxx.org/wiki/doku.php/stanton_djc.4 + + + + + + + + + + [Channel1] + DJC4.deck[0].beatLoopEncoder.input + 0xB0 + 0x01 + + + + + + [Channel1] + beatloop_activate + 0x90 + 0x01 + + + + + + [Channel2] + DJC4.deck[1].beatLoopEncoder.input + 0xB1 + 0x01 + + + + + + [Channel2] + beatloop_activate + 0x91 + 0x01 + + + + + + [Channel3] + DJC4.deck[2].beatLoopEncoder.input + 0xB2 + 0x01 + + + + + + [Channel3] + beatloop_activate + 0x92 + 0x01 + + + + + + [Channel4] + DJC4.deck[3].beatLoopEncoder.input + 0xB3 + 0x01 + + + + + + [Channel4] + beatloop_activate + 0x93 + 0x01 + + + + + + [Channel1] + DJC4.deck[0].wheelTurn + 0xB0 + 0x02 + + + + + + [Channel1] + loop_halve + 0x90 + 0x02 + + + + + + [Channel2] + DJC4.deck[1].wheelTurn + 0xB1 + 0x02 + + + + + + [Channel2] + loop_halve + 0x91 + 0x02 + + + + + + [Channel3] + DJC4.deck[2].wheelTurn + 0xB2 + 0x02 + + + + + + [Channel3] + loop_halve + 0x92 + 0x02 + + + + + + [Channel4] + DJC4.deck[3].wheelTurn + 0xB3 + 0x02 + + + + + + [Channel4] + loop_halve + 0x93 + 0x02 + + + + + + [Channel1] + loop_double + 0x90 + 0x03 + + + + + + [Channel1] + pregain + 0xB0 + 0x03 + + + + + + [Channel2] + loop_double + 0x91 + 0x03 + + + + + + [Channel2] + pregain + 0xB1 + 0x03 + + + + + + [Channel3] + loop_double + 0x92 + 0x03 + + + + + + [Channel3] + pregain + 0xB2 + 0x03 + + + + + + [Channel4] + loop_double + 0x93 + 0x03 + + + + + + [Channel4] + pregain + 0xB3 + 0x03 + + + + + + [Channel1] + loop_in + 0x90 + 0x04 + + + + + + [Channel2] + loop_in + 0x91 + 0x04 + + + + + + [Channel3] + loop_in + 0x92 + 0x04 + + + + + + [Channel4] + loop_in + 0x93 + 0x04 + + + + + + [EqualizerRack1_[Channel1]_Effect1] + parameter3 + 0xB0 + 0x04 + + + + + + [EqualizerRack1_[Channel2]_Effect1] + parameter3 + 0xB1 + 0x04 + + + + + + [EqualizerRack1_[Channel3]_Effect1] + parameter3 + 0xB2 + 0x04 + + + + + + [EqualizerRack1_[Channel4]_Effect1] + parameter3 + 0xB3 + 0x04 + + + + + + [Channel1] + loop_out + 0x90 + 0x05 + + + + + + [Channel2] + loop_out + 0x91 + 0x05 + + + + + + [Channel3] + loop_out + 0x92 + 0x05 + + + + + + [Channel4] + loop_out + 0x93 + 0x05 + + + + + + [EqualizerRack1_[Channel1]_Effect1] + parameter2 + 0xB0 + 0x05 + + + + + + [EqualizerRack1_[Channel2]_Effect1] + parameter2 + 0xB1 + 0x05 + + + + + + [EqualizerRack1_[Channel3]_Effect1] + parameter2 + 0xB2 + 0x05 + + + + + + [EqualizerRack1_[Channel4]_Effect1] + parameter2 + 0xB3 + 0x05 + + + + + + [Channel1] + reloop_toggle + 0x90 + 0x06 + + + + + + [Channel2] + reloop_toggle + 0x91 + 0x06 + + + + + + [Channel3] + reloop_toggle + 0x92 + 0x06 + + + + + + [Channel4] + reloop_toggle + 0x93 + 0x06 + + + + + + [EqualizerRack1_[Channel1]_Effect1] + parameter1 + 0xB0 + 0x06 + + + + + + [EqualizerRack1_[Channel2]_Effect1] + parameter1 + 0xB1 + 0x06 + + + + + + [EqualizerRack1_[Channel3]_Effect1] + parameter1 + 0xB2 + 0x06 + + + + + + [EqualizerRack1_[Channel4]_Effect1] + parameter1 + 0xB3 + 0x06 + + + + + + [Channel1] + volume + 0xB0 + 0x07 + + + + + + [Channel2] + volume + 0xB1 + 0x07 + + + + + + [Channel3] + volume + 0xB2 + 0x07 + + + + + + [Channel4] + volume + 0xB3 + 0x07 + + + + + + [EffectRack1_EffectUnit1] + DJC4.effectUnit[0].dryWetKnob.input + 0xB0 + 0x08 + + + + + + [EffectRack1_EffectUnit3] + DJC4.effectUnit[1].dryWetKnob.input + 0xB1 + 0x08 + + + + + + [EffectRack1_EffectUnit3] + DJC4.effectUnit[2].dryWetKnob.input + 0xB2 + 0x08 + + + + + + [EffectRack1_EffectUnit3] + DJC4.effectUnit[3].dryWetKnob.input + 0xB3 + 0x08 + + + + + + [Channel1] + hotcue_1_activate + 0x90 + 0x08 + + + + + + [Channel2] + hotcue_1_activate + 0x91 + 0x08 + + + + + + [Channel3] + hotcue_1_activate + 0x92 + 0x08 + + + + + + [Channel4] + hotcue_1_activate + 0x93 + 0x08 + + + + + + [Channel1] + hotcue_2_activate + 0x90 + 0x09 + + + + + + [Channel2] + hotcue_2_activate + 0x91 + 0x09 + + + + + + [Channel3] + hotcue_2_activate + 0x92 + 0x09 + + + + + + [Channel4] + hotcue_2_activate + 0x93 + 0x09 + + + + + + [EffectRack1_EffectUnit1_Effect1] + DJC4.effectUnit[0].knobs[1].input + 0xB0 + 0x09 + + + + + + [EffectRack1_EffectUnit2_Effect1] + DJC4.effectUnit[1].knobs[1].input + 0xB1 + 0x09 + + + + + + [EffectRack1_EffectUnit1_Effect1] + DJC4.effectUnit[2].knobs[1].input + 0xB2 + 0x09 + + + + + + [EffectRack1_EffectUnit2_Effect1] + DJC4.effectUnit[3].knobs[1].input + 0xB3 + 0x09 + + + + + + [Channel1] + hotcue_3_activate + 0x90 + 0x0A + + + + + + [Channel2] + hotcue_3_activate + 0x91 + 0x0A + + + + + + [Channel3] + hotcue_3_activate + 0x92 + 0x0A + + + + + + [Channel4] + hotcue_3_activate + 0x93 + 0x0A + + + + + + [EffectRack1_EffectUnit1_Effect2] + DJC4.effectUnit[0].knobs[2].input + 0xB0 + 0x0A + + + + + + [EffectRack1_EffectUnit2_Effect2] + DJC4.effectUnit[1].knobs[2].input + 0xB1 + 0x0A + + + + + + [EffectRack1_EffectUnit1_Effect2] + DJC4.effectUnit[2].knobs[2].input + 0xB2 + 0x0A + + + + + + [EffectRack1_EffectUnit2_Effect2] + DJC4.effectUnit[3].knobs[2].input + 0xB3 + 0x0A + + + + + + [Channel1] + hotcue_4_activate + 0x90 + 0x0B + + + + + + [Channel2] + hotcue_4_activate + 0x91 + 0x0B + + + + + + [Channel3] + hotcue_4_activate + 0x92 + 0x0B + + + + + + [Channel4] + hotcue_4_activate + 0x93 + 0x0B + + + + + + [EffectRack1_EffectUnit1_Effect3] + DJC4.effectUnit[0].knobs[3].input + 0xB0 + 0x0B + + + + + + [EffectRack1_EffectUnit2_Effect3] + DJC4.effectUnit[1].knobs[3].input + 0xB1 + 0x0B + + + + + + [EffectRack1_EffectUnit1_Effect3] + DJC4.effectUnit[2].knobs[3].input + 0xB2 + 0x0B + + + + + + [EffectRack1_EffectUnit2_Effect3] + DJC4.effectUnit[3].knobs[3].input + 0xB3 + 0x0B + + + + + + [Sampler1] + DJC4.deck[0].samplerButtons[0].input + 0x90 + 0x0C + + + + + + [Sampler5] + DJC4.deck[1].samplerButtons[0].input + 0x91 + 0x0C + + + + + + [Sampler1] + DJC4.deck[2].samplerButtons[0].input + 0x92 + 0x0C + + + + + + [Sampler5] + DJC4.deck[3].samplerButtons[0].input + 0x93 + 0x0C + + + + + + [Sampler2] + DJC4.deck[0].samplerButtons[1].input + 0x90 + 0x0D + + + + + + [Sampler6] + DJC4.deck[1].samplerButtons[1].input + 0x91 + 0x0D + + + + + + [Sampler2] + DJC4.deck[2].samplerButtons[1].input + 0x92 + 0x0D + + + + + + [Sampler6] + DJC4.deck[3].samplerButtons[1].input + 0x93 + 0x0D + + + + + + [Sampler] + DJC4.samplerVolume + 0xB0 + 0x0D + + + + + + [Library] + DJC4.browseEncoder.input + 0xB0 + 0x0E + + + + + + [Sampler3] + DJC4.deck[0].samplerButtons[2].input + 0x90 + 0x0E + + + + + + [Sampler7] + DJC4.deck[1].samplerButtons[2].input + 0x91 + 0x0E + + + + + + [Sampler3] + DJC4.deck[2].samplerButtons[2].input + 0x92 + 0x0E + + + + + + [Sampler7] + DJC4.deck[3].samplerButtons[2].input + 0x93 + 0x0E + + + + + + [Sampler4] + DJC4.deck[0].samplerButtons[3].input + 0x90 + 0x0F + + + + + + [Sampler8] + DJC4.deck[1].samplerButtons[3].input + 0x91 + 0x0F + + + + + + [Sampler4] + DJC4.deck[2].samplerButtons[3].input + 0x92 + 0x0F + + + + + + [Sampler8] + DJC4.deck[3].samplerButtons[3].input + 0x93 + 0x0F + + + + + + [Channel1] + keylock + 0x90 + 0x10 + + + + + + [Channel2] + keylock + 0x91 + 0x10 + + + + + + [Channel3] + keylock + 0x92 + 0x10 + + + + + + [Channel4] + keylock + 0x93 + 0x10 + + + + + + [Master] + crossfader + 0xB0 + 0x10 + + + + + + [Master] + DJC4.crossfaderCurve + 0xB0 + 0x12 + + + + + + [Channel1] + beatsync + 0x90 + 0x12 + + + + + + [Channel2] + beatsync + 0x91 + 0x12 + + + + + + [Channel3] + beatsync + 0x92 + 0x12 + + + + + + [Channel4] + beatsync + 0x93 + 0x12 + + + + + + [Channel1] + rate_temp_down + 0x90 + 0x13 + + + + + + [Channel2] + rate_temp_down + 0x91 + 0x13 + + + + + + [Channel3] + rate_temp_down + 0x92 + 0x13 + + + + + + [Channel4] + rate_temp_down + 0x93 + 0x13 + + + + + + [Master] + headMix + 0xB0 + 0x13 + + + + + + [Channel1] + rate_temp_up + 0x90 + 0x14 + + + + + + [Channel2] + rate_temp_up + 0x91 + 0x14 + + + + + + [Channel3] + rate_temp_up + 0x92 + 0x14 + + + + + + [Channel4] + rate_temp_up + 0x93 + 0x14 + + + + + + [Master] + headGain + 0xB0 + 0x14 + + + + + + [Channel1] + DJC4.deck[0].toggleScratchMode + 0x90 + 0x15 + + + + + + [Channel2] + DJC4.deck[1].toggleScratchMode + 0x91 + 0x15 + + + + + + [Channel3] + DJC4.deck[2].toggleScratchMode + 0x92 + 0x15 + + + + + + [Channel4] + DJC4.deck[3].toggleScratchMode + 0x93 + 0x15 + + + + + + [Channel1] + bpm_tap + 0x90 + 0x16 + + + + + + [Channel2] + bpm_tap + 0x91 + 0x16 + + + + + + [Channel3] + bpm_tap + 0x92 + 0x16 + + + + + + [Channel4] + bpm_tap + 0x93 + 0x16 + + + + + + [Channel1] + cue_default + 0x90 + 0x17 + + + + + + [Channel2] + cue_default + 0x91 + 0x17 + + + + + + [Channel3] + cue_default + 0x92 + 0x17 + + + + + + [Channel4] + cue_default + 0x93 + 0x17 + + + + + + [Channel1] + play + 0x90 + 0x18 + + + + + + [Channel2] + play + 0x91 + 0x18 + + + + + + [Channel3] + play + 0x92 + 0x18 + + + + + + [Channel4] + play + 0x93 + 0x18 + + + + + + [EqualizerRack1_[Channel1]_Effect1] + button_parameter3 + 0x90 + 0x19 + + + + + + [EqualizerRack1_[Channel2]_Effect1] + button_parameter3 + 0x91 + 0x19 + + + + + + [EqualizerRack1_[Channel3]_Effect1] + button_parameter3 + 0x92 + 0x19 + + + + + + [EqualizerRack1_[Channel4]_Effect1] + button_parameter3 + 0x93 + 0x19 + + + + + + [EqualizerRack1_[Channel1]_Effect1] + button_parameter2 + 0x90 + 0x1A + + + + + + [EqualizerRack1_[Channel2]_Effect1] + button_parameter2 + 0x91 + 0x1A + + + + + + [EqualizerRack1_[Channel3]_Effect1] + button_parameter2 + 0x92 + 0x1A + + + + + + [EqualizerRack1_[Channel4]_Effect1] + button_parameter2 + 0x93 + 0x1A + + + + + + [EqualizerRack1_[Channel1]_Effect1] + button_parameter1 + 0x90 + 0x1B + + + + + + [EqualizerRack1_[Channel2]_Effect1] + button_parameter1 + 0x91 + 0x1B + + + + + + [EqualizerRack1_[Channel3]_Effect1] + button_parameter1 + 0x92 + 0x1B + + + + + + [EqualizerRack1_[Channel4]_Effect1] + button_parameter1 + 0x93 + 0x1B + + + + + + [Channel1] + pfl + 0x90 + 0x1C + + + + + + [Channel2] + pfl + 0x91 + 0x1C + + + + + + [Channel3] + pfl + 0x92 + 0x1C + + + + + + [Channel4] + pfl + 0x93 + 0x1C + + + + + + [EffectRack1_EffectUnit1] + DJC4.effectUnit[0].effectFocusButton.input + 0x90 + 0x1D + + + + + + [EffectRack1_EffectUnit1] + DJC4.effectUnit[1].effectFocusButton.input + 0x91 + 0x1D + + + + + + [EffectRack1_EffectUnit1] + DJC4.effectUnit[2].effectFocusButton.input + 0x92 + 0x1D + + + + + + [EffectRack1_EffectUnit1] + DJC4.effectUnit[3].effectFocusButton.input + 0x93 + 0x1D + + + + + + [EffectRack1_EffectUnit1] + group_[Channel1]_enable + 0x90 + 0x1E + + + + + + [EffectRack1_EffectUnit2] + group_[Channel2]_enable + 0x91 + 0x1E + + + + + + [EffectRack1_EffectUnit3] + group_[Channel3]_enable + 0x92 + 0x1E + + + + + + [EffectRack1_EffectUnit4] + group_[Channel4]_enable + 0x93 + 0x1E + + + + + + [EffectRack1_EffectUnit1_Effect1] + DJC4.effectUnit[0].enableButtons[1].input + 0x90 + 0x1F + + + + + + [EffectRack1_EffectUnit2_Effect1] + DJC4.effectUnit[1].enableButtons[1].input + 0x91 + 0x1F + + + + + + [EffectRack1_EffectUnit3_Effect1] + DJC4.effectUnit[2].enableButtons[1].input + 0x92 + 0x1F + + + + + + [EffectRack1_EffectUnit4_Effect1] + DJC4.effectUnit[3].enableButtons[1].input + 0x93 + 0x1F + + + + + + [EffectRack1_EffectUnit1_Effect2] + DJC4.effectUnit[0].enableButtons[2].input + 0x90 + 0x20 + + + + + + [EffectRack1_EffectUnit2_Effect2] + DJC4.effectUnit[1].enableButtons[2].input + 0x91 + 0x20 + + + + + + [EffectRack1_EffectUnit3_Effect2] + DJC4.effectUnit[2].enableButtons[2].input + 0x92 + 0x20 + + + + + + [EffectRack1_EffectUnit4_Effect2] + DJC4.effectUnit[3].enableButtons[2].input + 0x93 + 0x20 + + + + + + [Channel1] + DJC4.deck[0].wheelTurn + 0xB0 + 0x20 + + + + + + [Channel2] + DJC4.deck[1].wheelTurn + 0xB1 + 0x20 + + + + + + [Channel3] + DJC4.deck[2].wheelTurn + 0xB2 + 0x20 + + + + + + [Channel4] + DJC4.deck[3].wheelTurn + 0xB3 + 0x20 + + + + + + [EffectRack1_EffectUnit1_Effect3] + DJC4.effectUnit[0].enableButtons[3].input + 0x90 + 0x21 + + + + + + [EffectRack1_EffectUnit2_Effect3] + DJC4.effectUnit[1].enableButtons[3].input + 0x91 + 0x21 + + + + + + [EffectRack1_EffectUnit1_Effect3] + DJC4.effectUnit[2].enableButtons[3].input + 0x92 + 0x21 + + + + + + [EffectRack1_EffectUnit2_Effect3] + DJC4.effectUnit[3].enableButtons[3].input + 0x93 + 0x21 + + + + + + [Channel1] + LoadSelectedTrack + 0x90 + 0x22 + + + + + + [Channel3] + LoadSelectedTrack + 0x92 + 0x22 + + + + + + [Channel2] + LoadSelectedTrack + 0x91 + 0x23 + + + + + + [Channel4] + LoadSelectedTrack + 0x93 + 0x23 + + + + + + [QuickEffectRack1_[Channel1]] + super1 + 0xB0 + 0x24 + + + + + + [QuickEffectRack1_[Channel2]] + super1 + 0xB1 + 0x24 + + + + + + [QuickEffectRack1_[Channel3]] + super1 + 0xB2 + 0x24 + + + + + + [QuickEffectRack1_[Channel4]] + super1 + 0xB3 + 0x24 + + + + + + [EffectRack1_EffectUnit1] + DJC4.effectUnit[0].dryWetKnob.input + 0xB0 + 0x26 + + + + + + [EffectRack1_EffectUnit2] + DJC4.effectUnit[1].dryWetKnob.input + 0xB1 + 0x26 + + + + + + [EffectRack1_EffectUnit2] + DJC4.effectUnit[2].dryWetKnob.input + 0xB2 + 0x26 + + + + + + [EffectRack1_EffectUnit3] + DJC4.effectUnit[3].dryWetKnob.input + 0xB3 + 0x26 + + + + + + [Channel1] + DJC4.deck[0].wheelTouch + 0x90 + 0x26 + + + + + + [Channel2] + DJC4.deck[1].wheelTouch + 0x91 + 0x26 + + + + + + [Channel3] + DJC4.deck[2].wheelTouch + 0x92 + 0x26 + + + + + + [Channel4] + DJC4.deck[3].wheelTouch + 0x93 + 0x26 + + + + + + [Library] + MoveFocus + 0x90 + 0x27 + + + + + + [Library] + DJC4.browseEncoder.input + 0xB0 + 0x2C + + + + + + [Master] + DJC4.shiftButton + 0x90 + 0x2D + + + + + + [Channel1] + beatlooproll_activate + 0x90 + 0x33 + + + + + + [Channel2] + beatlooproll_activate + 0x91 + 0x33 + + + + + + [Channel3] + beatlooproll_activate + 0x92 + 0x33 + + + + + + [Channel4] + beatlooproll_activate + 0x93 + 0x33 + + + + + + [Channel1] + loop_in_goto + 0x90 + 0x36 + + + + + + [Channel2] + loop_in_goto + 0x91 + 0x36 + + + + + + [Channel3] + loop_in_goto + 0x92 + 0x36 + + + + + + [Channel4] + loop_in_goto + 0x93 + 0x36 + + + + + + [Channel1] + loop_out_goto + 0x90 + 0x37 + + + + + + [Channel2] + loop_out_goto + 0x91 + 0x37 + + + + + + [Channel3] + loop_out_goto + 0x92 + 0x37 + + + + + + [Channel4] + loop_out_goto + 0x93 + 0x37 + + + + + + [Channel1] + reloop_andstop + 0x90 + 0x38 + + + + + + [Channel2] + reloop_andstop + 0x91 + 0x38 + + + + + + [Channel3] + reloop_andstop + 0x92 + 0x38 + + + + + + [Channel4] + reloop_andstop + 0x93 + 0x38 + + + + + + [Channel1] + hotcue_1_clear + 0x90 + 0x3A + + + + + + [Channel2] + hotcue_1_clear + 0x91 + 0x3A + + + + + + [Channel3] + hotcue_1_clear + 0x92 + 0x3A + + + + + + [Channel4] + hotcue_1_clear + 0x93 + 0x3A + + + + + + [Channel1] + hotcue_2_clear + 0x90 + 0x3B + + + + + + [Channel2] + hotcue_2_clear + 0x91 + 0x3B + + + + + + [Channel3] + hotcue_2_clear + 0x92 + 0x3B + + + + + + [Channel4] + hotcue_2_clear + 0x93 + 0x3B + + + + + + [Channel1] + hotcue_3_clear + 0x90 + 0x3C + + + + + + [Channel2] + hotcue_3_clear + 0x91 + 0x3C + + + + + + [Channel3] + hotcue_3_clear + 0x92 + 0x3C + + + + + + [Channel4] + hotcue_3_clear + 0x93 + 0x3C + + + + + + [Channel1] + hotcue_4_clear + 0x90 + 0x3D + + + + + + [Channel2] + hotcue_4_clear + 0x91 + 0x3D + + + + + + [Channel3] + hotcue_4_clear + 0x92 + 0x3D + + + + + + [Channel4] + hotcue_4_clear + 0x93 + 0x3D + + + + + + [Sampler1] + DJC4.deck[0].samplerButtons[0].input + 0x90 + 0x3E + + + + + + [Sampler5] + DJC4.deck[1].samplerButtons[0].input + 0x91 + 0x3E + + + + + + [Sampler1] + DJC4.deck[3].samplerButtons[0].input + 0x92 + 0x3E + + + + + + [Sampler5] + DJC4.deck[3].samplerButtons[0].input + 0x93 + 0x3E + + + + + + [Sampler2] + DJC4.deck[0].samplerButtons[1].input + 0x90 + 0x3F + + + + + + [Sampler6] + DJC4.deck[1].samplerButtons[1].input + 0x91 + 0x3F + + + + + + [Sampler2] + DJC4.deck[2].samplerButtons[1].input + 0x92 + 0x3F + + + + + + [Sampler6] + DJC4.deck[3].samplerButtons[1].input + 0x93 + 0x3F + + + + + + [Sampler3] + DJC4.deck[0].samplerButtons[2].input + 0x90 + 0x40 + + + + + + [Sampler7] + DJC4.deck[1].samplerButtons[2].input + 0x91 + 0x40 + + + + + + [Sampler3] + DJC4.deck[2].samplerButtons[2].input + 0x92 + 0x40 + + + + + + [Sampler7] + DJC4.deck[3].samplerButtons[2].input + 0x93 + 0x40 + + + + + + [Sampler4] + DJC4.deck[0].samplerButtons[3].input + 0x90 + 0x41 + + + + + + [Sampler8] + DJC4.deck[1].samplerButtons[3].input + 0x91 + 0x41 + + + + + + [Sampler4] + DJC4.deck[2].samplerButtons[3].input + 0x92 + 0x41 + + + + + + [Sampler8] + DJC4.deck[3].samplerButtons[3].input + 0x93 + 0x41 + + + + + + [Channel1] + quantize + 0x90 + 0x42 + + + + + + [Channel2] + quantize + 0x91 + 0x42 + + + + + + [Channel3] + quantize + 0x92 + 0x42 + + + + + + [Channel4] + quantize + 0x93 + 0x42 + + + + + + [Channel1] + reverse + 0x90 + 0x44 + + + + + + [Channel2] + reverse + 0x91 + 0x44 + + + + + + [Channel3] + reverse + 0x92 + 0x44 + + + + + + [Channel4] + reverse + 0x93 + 0x44 + + + + + + [Channel1] + cue_gotoandstop + 0x90 + 0x49 + + + + + + [Channel2] + cue_gotoandstop + 0x91 + 0x49 + + + + + + [Channel3] + cue_gotoandstop + 0x92 + 0x49 + + + + + + [Channel4] + cue_gotoandstop + 0x93 + 0x49 + + + + + + [Channel1] + cue_set + 0x90 + 0x4A + + + + + + [Channel2] + cue_set + 0x91 + 0x4A + + + + + + [Channel3] + cue_set + 0x92 + 0x4A + + + + + + [Channel4] + cue_set + 0x93 + 0x4A + + + + + + [QuickEffectRack1_[Channel1]_Effect1] + enabled + 0x90 + 0x4D + + + + + + [QuickEffectRack1_[Channel2]_Effect1] + enabled + 0x91 + 0x4D + + + + + + [QuickEffectRack1_[Channel3]_Effect1] + enabled + 0x92 + 0x4D + + + + + + [QuickEffectRack1_[Channel4]_Effect1] + enabled + 0x93 + 0x4D + + + + + + [EffectRack1_EffectUnit1] + DJC4.effectUnit[0].effectFocusButton.input + 0x90 + 0x4F + + + + + + [EffectRack1_EffectUnit1] + DJC4.effectUnit[1].effectFocusButton.input + 0x91 + 0x4F + + + + + + [EffectRack1_EffectUnit1] + DJC4.effectUnit[2].effectFocusButton.input + 0x92 + 0x4F + + + + + + [EffectRack1_EffectUnit1] + DJC4.effectUnit[3].effectFocusButton.input + 0x93 + 0x4F + + + + + + [EffectRack1_EffectUnit1_Effect1] + DJC4.effectUnit[0].enableButtons[1].input + 0x90 + 0x51 + + + + + + [EffectRack1_EffectUnit2_Effect1] + DJC4.effectUnit[1].enableButtons[1].input + 0x91 + 0x51 + + + + + + [EffectRack1_EffectUnit1_Effect1] + DJC4.effectUnit[2].enableButtons[1].input + 0x92 + 0x51 + + + + + + [EffectRack1_EffectUnit2_Effect1] + DJC4.effectUnit[3].enableButtons[1].input + 0x93 + 0x51 + + + + + + [EffectRack1_EffectUnit1_Effect2] + DJC4.effectUnit[0].enableButtons[2].input + 0x90 + 0x52 + + + + + + [EffectRack1_EffectUnit2_Effect2] + DJC4.effectUnit[1].enableButtons[2].input + 0x91 + 0x52 + + + + + + [EffectRack1_EffectUnit1_Effect2] + DJC4.effectUnit[2].enableButtons[2].input + 0x92 + 0x52 + + + + + + [EffectRack1_EffectUnit2_Effect2] + DJC4.effectUnit[3].enableButtons[2].input + 0x93 + 0x52 + + + + + + [EffectRack1_EffectUnit1_Effect3] + DJC4.effectUnit[0].enableButtons[3].input + 0x90 + 0x53 + + + + + + [EffectRack1_EffectUnit2_Effect3] + DJC4.effectUnit[1].enableButtons[3].input + 0x91 + 0x53 + + + + + + [EffectRack1_EffectUnit1_Effect3] + DJC4.effectUnit[2].enableButtons[3].input + 0x92 + 0x53 + + + + + + [EffectRack1_EffectUnit2_Effect3] + DJC4.effectUnit[3].enableButtons[3].input + 0x93 + 0x53 + + + + + + [Library] + MoveLeft + 0x90 + 0x54 + + + + + + [Library] + MoveRight + 0x91 + 0x55 + + + + + + [Library] + MoveLeft + 0x92 + 0x54 + + + + + + [Library] + MoveRight + 0x93 + 0x55 + + + + + + [Channel1] + DJC4.deck[0].wheelTouch + 0x90 + 0x58 + + + + + + [Channel2] + DJC4.deck[1].wheelTouch + 0x91 + 0x58 + + + + + + [Channel3] + DJC4.deck[2].wheelTouch + 0x92 + 0x58 + + + + + + [Channel4] + DJC4.deck[3].wheelTouch + 0x93 + 0x58 + + + + + + [Master] + maximize_library + 0x90 + 0x59 + + + + + + [Channel1] + rate + 0xE0 + + + + + + [Channel2] + rate + 0xE1 + + + + + + [Channel3] + rate + 0xE2 + + + + + + [Channel4] + rate + 0xE3 + + + + + + + + [Channel1] + loop_halve + 0x90 + 0x02 + 0x7F + 0x00 + 0.5 + + + [Channel2] + loop_halve + 0x91 + 0x02 + 0x7F + 0x00 + 0.5 + + + [Channel3] + loop_halve + 0x92 + 0x02 + 0x7F + 0x00 + 0.5 + + + [Channel4] + loop_halve + 0x93 + 0x02 + 0x7F + 0x00 + 0.5 + + + [Channel1] + loop_double + 0x90 + 0x03 + 0x7F + 0x00 + 0.5 + + + [Channel2] + loop_double + 0x91 + 0x03 + 0x7F + 0x00 + 0.5 + + + [Channel3] + loop_double + 0x92 + 0x03 + 0x7F + 0x00 + 0.5 + + + [Channel4] + loop_double + 0x93 + 0x03 + 0x7F + 0x00 + 0.5 + + + [Channel1] + loop_start_position + 0x90 + 0x04 + 0x7F + 0x00 + 0 + 2147483647 + + + [Channel2] + loop_start_position + 0x91 + 0x04 + 0x7F + 0x00 + 0 + 2147483647 + + + [Channel3] + loop_start_position + 0x92 + 0x04 + 0x7F + 0x00 + 0 + 2147483647 + + + [Channel4] + loop_start_position + 0x93 + 0x04 + 0x7F + 0x00 + 0 + 2147483647 + + + [Channel1] + loop_end_position + 0x90 + 0x05 + 0x7F + 0x00 + 0 + 2147483647 + + + [Channel2] + loop_end_position + 0x91 + 0x05 + 0x7F + 0x00 + 0 + 2147483647 + + + [Channel3] + loop_end_position + 0x92 + 0x05 + 0x7F + 0x00 + 0 + 2147483647 + + + [Channel4] + loop_end_position + 0x93 + 0x05 + 0x7F + 0x00 + 0 + 2147483647 + + + [Channel1] + loop_enabled + 0x90 + 0x06 + 0x7F + 0x00 + 0.5 + + + [Channel2] + loop_enabled + 0x91 + 0x06 + 0x7F + 0x00 + 0.5 + + + [Channel3] + loop_enabled + 0x92 + 0x06 + 0x7F + 0x00 + 0.5 + + + [Channel4] + loop_enabled + 0x93 + 0x06 + 0x7F + 0x00 + 0.5 + + + [Channel1] + hotcue_1_enabled + 0x90 + 0x08 + 0x7F + 0x00 + 0.5 + + + [Channel2] + hotcue_1_enabled + 0x91 + 0x08 + 0x7F + 0x00 + 0.5 + + + [Channel3] + hotcue_1_enabled + 0x92 + 0x08 + 0x7F + 0x00 + 0.5 + + + [Channel4] + hotcue_1_enabled + 0x93 + 0x08 + 0x7F + 0x00 + 0.5 + + + [Channel1] + hotcue_2_enabled + 0x90 + 0x09 + 0x7F + 0x00 + 0.5 + + + [Channel2] + hotcue_2_enabled + 0x91 + 0x09 + 0x7F + 0x00 + 0.5 + + + [Channel3] + hotcue_2_enabled + 0x92 + 0x09 + 0x7F + 0x00 + 0.5 + + + [Channel4] + hotcue_2_enabled + 0x93 + 0x09 + 0x7F + 0x00 + 0.5 + + + [Channel1] + hotcue_3_enabled + 0x90 + 0x0A + 0x7F + 0x00 + 0.5 + + + [Channel2] + hotcue_3_enabled + 0x91 + 0x0A + 0x7F + 0x00 + 0.5 + + + [Channel3] + hotcue_3_enabled + 0x92 + 0x0A + 0x7F + 0x00 + 0.5 + + + [Channel4] + hotcue_3_enabled + 0x93 + 0x0A + 0x7F + 0x00 + 0.5 + + + [Channel1] + hotcue_4_enabled + 0x90 + 0x0B + 0x7F + 0x00 + 0.5 + + + [Channel2] + hotcue_4_enabled + 0x91 + 0x0B + 0x7F + 0x00 + 0.5 + + + [Channel3] + hotcue_4_enabled + 0x92 + 0x0B + 0x7F + 0x00 + 0.5 + + + [Channel4] + hotcue_4_enabled + 0x93 + 0x0B + 0x7F + 0x00 + 0.5 + + + [Channel1] + keylock + 0x90 + 0x10 + 0x7F + 0x00 + 0.5 + + + [Channel2] + keylock + 0x91 + 0x10 + 0x7F + 0x00 + 0.5 + + + [Channel3] + keylock + 0x92 + 0x10 + 0x7F + 0x00 + 0.5 + + + [Channel4] + keylock + 0x93 + 0x10 + 0x7F + 0x00 + 0.5 + + + [Channel1] + beatsync + 0x90 + 0x12 + 0x7F + 0x00 + 0.5 + + + [Channel2] + beatsync + 0x91 + 0x12 + 0x7F + 0x00 + 0.5 + + + [Channel3] + beatsync + 0x92 + 0x12 + 0x7F + 0x00 + 0.5 + + + [Channel4] + beatsync + 0x93 + 0x12 + 0x7F + 0x00 + 0.5 + + + [Channel1] + rate_temp_down + 0x90 + 0x13 + 0x7F + 0x00 + 0.5 + + + [Channel2] + rate_temp_down + 0x91 + 0x13 + 0x7F + 0x00 + 0.5 + + + [Channel3] + rate_temp_down + 0x92 + 0x13 + 0x7F + 0x00 + 0.5 + + + [Channel4] + rate_temp_down + 0x93 + 0x13 + 0x7F + 0x00 + 0.5 + + + [Channel1] + rate_temp_up + 0x90 + 0x14 + 0x7F + 0x00 + 0.5 + + + [Channel2] + rate_temp_up + 0x91 + 0x14 + 0x7F + 0x00 + 0.5 + + + [Channel3] + rate_temp_up + 0x92 + 0x14 + 0x7F + 0x00 + 0.5 + + + [Channel4] + rate_temp_up + 0x93 + 0x14 + 0x7F + 0x00 + 0.5 + + + [Channel1] + play_indicator + 0x90 + 0x16 + 0x7F + 0x00 + 0.5 + + + [Channel2] + play_indicator + 0x91 + 0x16 + 0x7F + 0x00 + 0.5 + + + [Channel3] + play_indicator + 0x92 + 0x16 + 0x7F + 0x00 + 0.5 + + + [Channel4] + play_indicator + 0x93 + 0x16 + 0x7F + 0x00 + 0.5 + + + [Channel1] + cue_indicator + 0x90 + 0x17 + 0x7F + 0x00 + 0.5 + + + [Channel2] + cue_indicator + 0x91 + 0x17 + 0x7F + 0x00 + 0.5 + + + [Channel3] + cue_indicator + 0x92 + 0x17 + 0x7F + 0x00 + 0.5 + + + [Channel4] + cue_indicator + 0x93 + 0x17 + 0x7F + 0x00 + 0.5 + + + [Channel1] + play_indicator + 0x90 + 0x18 + 0x7F + 0x00 + 0.5 + + + [Channel2] + play_indicator + 0x91 + 0x18 + 0x7F + 0x00 + 0.5 + + + [Channel3] + play_indicator + 0x92 + 0x18 + 0x7F + 0x00 + 0.5 + + + [Channel4] + play_indicator + 0x93 + 0x18 + 0x7F + 0x00 + 0.5 + + + [EqualizerRack1_[Channel1]_Effect1] + button_parameter3 + 0x90 + 0x19 + 0x7F + 0x00 + 0.5 + + + [EqualizerRack1_[Channel2]_Effect1] + button_parameter3 + 0x91 + 0x19 + 0x7F + 0x00 + 0.5 + + + [EqualizerRack1_[Channel3]_Effect1] + button_parameter3 + 0x92 + 0x19 + 0x7F + 0x00 + 0.5 + + + [EqualizerRack1_[Channel4]_Effect1] + button_parameter3 + 0x93 + 0x19 + 0x7F + 0x00 + 0.5 + + + [EqualizerRack1_[Channel1]_Effect1] + button_parameter2 + 0x90 + 0x1A + 0x7F + 0x00 + 0.5 + + + [EqualizerRack1_[Channel2]_Effect1] + button_parameter2 + 0x91 + 0x1A + 0x7F + 0x00 + 0.5 + + + [EqualizerRack1_[Channel3]_Effect1] + button_parameter2 + 0x92 + 0x1A + 0x7F + 0x00 + 0.5 + + + [EqualizerRack1_[Channel4]_Effect1] + button_parameter2 + 0x93 + 0x1A + 0x7F + 0x00 + 0.5 + + + [EqualizerRack1_[Channel1]_Effect1] + button_parameter1 + 0x90 + 0x1B + 0x7F + 0x00 + 0.5 + + + [EqualizerRack1_[Channel2]_Effect1] + button_parameter1 + 0x91 + 0x1B + 0x7F + 0x00 + 0.5 + + + [EqualizerRack1_[Channel3]_Effect1] + button_parameter1 + 0x92 + 0x1B + 0x7F + 0x00 + 0.5 + + + [EqualizerRack1_[Channel4]_Effect1] + button_parameter1 + 0x93 + 0x1B + 0x7F + 0x00 + 0.5 + + + [Channel1] + pfl + 0x90 + 0x1C + 0x7F + 0x00 + 0.5 + + + [Channel2] + pfl + 0x91 + 0x1C + 0x7F + 0x00 + 0.5 + + + [Channel3] + pfl + 0x92 + 0x1C + 0x7F + 0x00 + 0.5 + + + [Channel4] + pfl + 0x93 + 0x1C + 0x7F + 0x00 + 0.5 + + + [EffectRack1_EffectUnit1] + group_[Channel1]_enable + 0x90 + 0x1E + 0x7F + 0x00 + 0.5 + + + [EffectRack1_EffectUnit2] + group_[Channel2]_enable + 0x91 + 0x1E + 0x7F + 0x00 + 0.5 + + + [EffectRack1_EffectUnit3] + group_[Channel3]_enable + 0x92 + 0x1E + 0x7F + 0x00 + 0.5 + + + [EffectRack1_EffectUnit4] + group_[Channel4]_enable + 0x93 + 0x1E + 0x7F + 0x00 + 0.5 + + + [Channel1] + play_indicator + 0x90 + 0x22 + 0x7F + 0x00 + 0.5 + 0.0 + + + [Channel3] + play_indicator + 0x92 + 0x22 + 0x7F + 0x00 + 0.5 + 0.0 + + + [Channel2] + play_indicator + 0x91 + 0x23 + 0x7F + 0x00 + 0.5 + 0.0 + + + [Channel4] + play_indicator + 0x93 + 0x23 + 0x7F + 0x00 + 0.5 + 0.0 + + + [QuickEffectRack1_[Channel1]_Effect1] + enabled + 0x90 + 0x27 + 0x7F + 0x00 + 0.5 + 0.0 + + + [QuickEffectRack1_[Channel2]_Effect1] + enabled + 0x91 + 0x27 + 0x7F + 0x00 + 0.5 + 0.0 + + + [QuickEffectRack1_[Channel3]_Effect1] + enabled + 0x92 + 0x27 + 0x7F + 0x00 + 0.5 + 0.0 + + + [QuickEffectRack1_[Channel4]_Effect1] + enabled + 0x93 + 0x27 + 0x7F + 0x00 + 0.5 + 0.0 + + + +