mixxx-data 2.0.0~dfsg-4 / usr / share / mixxx / controllers / Denon-DN-SC2000.midi.js

DenonDNSC2000 = new function() {}

DenonDNSC2000.Deck = function (deckNumber, group) {
   this.deckNumber = deckNumber;
   this.group = group;
   this.scratchMode = false;
   this.controlPressed = -1;
}

DenonDNSC2000.init = function (id) {
	engine.setValue("[Master]", "num_decks", 4);
	var leds = [0x11,0x13,0x15,0x17,0x19,0x1B,0x1D,0x20,/* cues */
				0x24,0x40,0x2B,/* loops */
				0x27,0x26,/* play,cue */
				0x08,0x09,/* key lock, sync*/
				0x5A,0x5B,/* flanger,scratch mode */
				0x5D,0x5E,0x5F/* depth, delay, lfo */
				];
	for(var index = 0, count = leds.length;index < count; index ++) {
		midi.sendShortMsg(0xB0,0x4B,leds[index]);
		midi.sendShortMsg(0xB1,0x4B,leds[index]);
		midi.sendShortMsg(0xB2,0x4B,leds[index]);
		midi.sendShortMsg(0xB3,0x4B,leds[index]);
	}
}

DenonDNSC2000.shutdown = function (id) {
	DenonDNSC2000.init(id);
}

DenonDNSC2000.getDeckByGroup = function(group) {
	for(var index = 0, count = decks.length;index < count; index++) {
		if(decks[index].group == group)
			return decks[index];
	}
   return null;
}

DenonDNSC2000.shift = function(midino, control, value, status, group) {
	shiftPressed = ((status & 0xF0) == 0x90);
	if(!shiftPressed) {
		engine.setValue(group, 'reverse', 0);
		engine.setValue('[PreviewDeck1]', 'cue_gotoandstop', 1);
	}
}

DenonDNSC2000.changeDeck = function(midino, control, value, status, group) {
	DenonDNSC2000.handleLeds(group);
}

DenonDNSC2000.newValue = function(currentVal,min,max,increment,ticksCount) {
	var interval = (max - min) / 24;
	var newVal = 0;
	if(increment)
		newVal = Math.min(max,currentVal + interval);
	else
		newVal = Math.max(min,currentVal - interval);
	return newVal;
}

DenonDNSC2000.flanger = function (midino, control, value, status, group) {
	DenonDNSC2000.toggleBinaryValue(group,'flanger');
	engine.beginTimer(100, 'DenonDNSC2000.handleFlangerLed("'+group+'")', true);
}

DenonDNSC2000.changeDepth = function (midino, control, value, status, group) {
	engine.setValue(group, 'lfoDepth', DenonDNSC2000.newValue(engine.getValue(group, 'lfoDepth'),0,1,(value == 0x00),24));
}

DenonDNSC2000.changeDelay = function (midino, control, value, status, group) {
	engine.setValue(group, 'lfoDelay', DenonDNSC2000.newValue(engine.getValue(group, 'lfoDelay'),50,10000,(value == 0x00),24));
}

DenonDNSC2000.changeLFO = function (midino, control, value, status, group) {
	engine.setValue(group, 'lfoPeriod', DenonDNSC2000.newValue(engine.getValue(group, 'lfoPeriod'),50000,2000000,(value == 0x00),24));
}

DenonDNSC2000.resetDepth = function (midino, control, value, status, group) {
	engine.setValue(group, 'lfoDepth', 0.5);
}

DenonDNSC2000.resetDelay = function (midino, control, value, status, group) {
	engine.setValue(group, 'lfoDelay', 50 + (10000 - 50) / 2);
}

DenonDNSC2000.resetLFO = function (midino, control, value, status, group) {
	engine.setValue(group, 'lfoPeriod', 50000 + (2000000 - 50000) / 2);
}

DenonDNSC2000.selectTrack = function (midino, control, value, status, group) {
	if(value == 0x00)
		engine.setValue('[Playlist]', 'SelectNextTrack', 1);
	else
		engine.setValue('[Playlist]', 'SelectPrevTrack', 1);
}

DenonDNSC2000.loadSelectedTrack = function (midino, control, value, status, group) {
	if(shiftPressed) {
		engine.setValue('[PreviewDeck1]', 'LoadSelectedTrackAndPlay', 1);
	}
	else {
		engine.setValue(group, 'LoadSelectedTrack', 1);
		engine.beginTimer(1500, 'DenonDNSC2000.handleLeds("'+group+'")', true);
	}
}

DenonDNSC2000.loopOrHotcues = function (midino, control, value, status, group) {
	var deck = DenonDNSC2000.getDeckByGroup(group);
	if ((status & 0xF0) == 0x80)
		deck.controlPressed = -1;
	else {
		deck.controlPressed = control;
		switch (control) {
			// hotcue
			case 0x17:
				DenonDNSC2000.hotcue(1,group,value,shiftPressed);
			break;
			case 0x18:
				DenonDNSC2000.hotcue(2,group,value,shiftPressed);
			break;
			case 0x19:
				DenonDNSC2000.hotcue(3,group,value,shiftPressed);
			break;
			case 0x20:
				DenonDNSC2000.hotcue(4,group,value,shiftPressed);
			break;
			case 0x21:
				DenonDNSC2000.hotcue(5,group,value,shiftPressed);
			break;
			case 0x22:
				DenonDNSC2000.hotcue(6,group,value,shiftPressed);
			break;
			case 0x23:
				DenonDNSC2000.hotcue(7,group,value,shiftPressed);
			break;
			case 0x24:
				DenonDNSC2000.hotcue(8,group,value,shiftPressed);
			break;
			// loop
			case 0x37:
				DenonDNSC2000.loopIn(group,value,shiftPressed);
			break;
			case 0x39:
				DenonDNSC2000.loopOut(group,value,shiftPressed);
			break;
			case 0x1D:
				DenonDNSC2000.reloop(group,value,shiftPressed);
			break;
		}
	}
};

DenonDNSC2000.hotcue = function(cueIndex, group, value, shift) {
	if(!shift) {
		engine.setValue(group, 'hotcue_' + cueIndex + '_activate', 1);
	}
	else {
		if(engine.getValue(group, 'hotcue_' + cueIndex + '_enabled') == 0) {
			var samplesPerBeat = DenonDNSC2000.samplesPerBeat(group);
			var positionInBeats = (engine.getValue(group,'playposition') * engine.getValue(group,'track_samples')) / samplesPerBeat;
			if((positionInBeats - Math.floor(positionInBeats)) > 0.5)
				positionInBeats = Math.floor(0.5 + positionInBeats) * samplesPerBeat;
			else
				positionInBeats = Math.floor(positionInBeats) * samplesPerBeat;
			positionInBeats = Math.floor(0.5 + positionInBeats);
			positionInBeats = Math.max(0,positionInBeats - positionInBeats % 2);
			engine.setValue(group, 'hotcue_' + cueIndex + '_activate', 1);
			engine.setValue(group, 'hotcue_' + cueIndex + '_position',positionInBeats);
		}
		else
		engine.setValue(group, 'hotcue_' + cueIndex + '_clear',1);
	}
	engine.beginTimer(100, 'DenonDNSC2000.handleLoopAndHotcuesLeds("'+group+'")', true);
}

DenonDNSC2000.loopIn = function(group, value, shift) {
	if(shiftPressed) {
		engine.setValue(group, 'loop_start_position', -1);
	}
	else
		engine.setValue(group, 'loop_in', 1);
	engine.beginTimer(100, 'DenonDNSC2000.handleLoopAndHotcuesLeds("'+group+'")', true);
}

DenonDNSC2000.loopOut = function(group, value, shift) {
	if(shiftPressed) {
		engine.setValue(group, 'loop_end_position', -1);
		if(engine.getValue(group,'loop_enabled'))
			engine.setValue(group, 'reloop_exit', 1);
	}
	else
		engine.setValue(group, 'loop_out', 1);
	engine.beginTimer(100, 'DenonDNSC2000.handleLoopAndHotcuesLeds("'+group+'")', true);
}

DenonDNSC2000.reloop = function(group, value, shift) {
	var loopInPosition = engine.getValue(group,'loop_start_position');
	var loopOutPosition = engine.getValue(group,'loop_end_position');
	if(loopInPosition != -1 && loopOutPosition!=-1) {
		engine.setValue(group, 'reloop_exit', 1);
	}
	else {
		var samplesPerBeat = DenonDNSC2000.samplesPerBeat(group);
		loopInPosition = engine.getValue(group,'playposition') * engine.getValue(group,'track_samples');
		if(shiftPressed) {
			var loopInPositionInBeats = loopInPosition / samplesPerBeat;
			if((loopInPositionInBeats - Math.floor(loopInPositionInBeats)) > 0.5)
				loopInPosition = Math.floor(0.5 + loopInPositionInBeats) * samplesPerBeat;
			else
				loopInPosition = Math.floor(loopInPositionInBeats) * samplesPerBeat;
		}
		else
			loopInPosition = engine.getValue(group,'playposition') * engine.getValue(group,'track_samples');
		loopInPosition = Math.floor(0.5 + loopInPosition);
		loopInPosition = Math.max(0,loopInPosition - loopInPosition % 2);
		var loopOutPosition = loopInPosition + Math.floor(0.5 + samplesPerBeat);
		loopOutPosition = Math.max(0,loopOutPosition - loopOutPosition % 2);
		if(loopInPosition + samplesPerBeat < engine.getValue(group,'track_samples')) {
			engine.setValue(group, 'loop_start_position', loopInPosition);
			engine.setValue(group, 'loop_end_position', loopOutPosition);
			engine.setValue(group, 'reloop_exit', 1);
		}
	}
	engine.beginTimer(100, 'DenonDNSC2000.handleLoopAndHotcuesLeds("'+group+'")', true);
}

DenonDNSC2000.resizeLoop = function(midino, control, value, status, group) {
	var increment = true;
	if(value == 0x7F)
		increment = false;
	var loopInPosition = engine.getValue(group,'loop_start_position');
	var loopOutPosition = engine.getValue(group,'loop_end_position');
	if(loopInPosition != -1 && loopOutPosition!= -1) {
		var samplesPerBeat = DenonDNSC2000.samplesPerBeat(group);
		var deltaSamples = loopOutPosition - loopInPosition;
		var newLoopOutPosition = loopOutPosition;
		var loopLengthes = [
						Math.floor(0.5 + samplesPerBeat * 1 / 32),
						Math.floor(0.5 + samplesPerBeat * 1 / 16),
						Math.floor(0.5 + samplesPerBeat * 1 / 8),
						Math.floor(0.5 + samplesPerBeat * 1 / 4),
						Math.floor(0.5 + samplesPerBeat * 1 / 2),
						Math.floor(0.5 + samplesPerBeat),
						Math.floor(0.5 + samplesPerBeat * 2),
						Math.floor(0.5 + samplesPerBeat * 4),
						Math.floor(0.5 + samplesPerBeat * 8),
						Math.floor(0.5 + samplesPerBeat * 16),
						Math.floor(0.5 + samplesPerBeat * 32)
						];

		if(increment) {
			for(var index = 0, count = loopLengthes.length;index < count; index++) {
				if(deltaSamples < loopLengthes[index]) {
					newLoopOutPosition = loopInPosition + loopLengthes[index];
					break;
				}
			}
		}
		else {
			for(var index = loopLengthes.length-1;index >= 0; index--) {
				if(deltaSamples > loopLengthes[index]) {
					newLoopOutPosition = loopInPosition + loopLengthes[index];
					break;
				}
			}
		}
		newLoopOutPosition = Math.max(0,newLoopOutPosition - newLoopOutPosition % 2);
		engine.setValue(group, 'loop_end_position', newLoopOutPosition);
	}
	engine.beginTimer(100, 'DenonDNSC2000.handleLoopAndHotcuesLeds("'+group+'")', true);
}

DenonDNSC2000.moveLoopLeft = function(midino, control, value, status, group) {
	var samplesPerBeat = Math.floor(0.5 + DenonDNSC2000.samplesPerBeat(group));
	var loopInPosition = engine.getValue(group,'loop_start_position');
	var loopOutPosition = engine.getValue(group,'loop_end_position');
	if(loopInPosition != -1 && loopOutPosition != -1 && loopInPosition > samplesPerBeat) {
		loopInPosition = loopInPosition - samplesPerBeat;
		loopInPosition = Math.max(0,loopInPosition - loopInPosition % 2);
		loopOutPosition = loopOutPosition - samplesPerBeat;
		loopOutPosition = Math.max(0,loopOutPosition - loopOutPosition % 2);
		engine.setValue(group, 'loop_start_position', loopInPosition);
		engine.setValue(group, 'loop_end_position', loopOutPosition);
	}
}

DenonDNSC2000.moveLoopRight = function(midino, control, value, status, group) {
	var samplesPerBeat = Math.floor(0.5 + DenonDNSC2000.samplesPerBeat(group));
	var loopInPosition = engine.getValue(group,'loop_start_position');
	var loopOutPosition = engine.getValue(group,'loop_end_position');
	if(loopInPosition != -1 && loopOutPosition != -1 && loopOutPosition + samplesPerBeat < engine.getValue(group,'track_samples')) {
		loopInPosition = loopInPosition + samplesPerBeat;
		loopInPosition = Math.max(0,loopInPosition - loopInPosition % 2);
		loopOutPosition = loopOutPosition + samplesPerBeat;
		loopOutPosition = Math.max(0,loopOutPosition - loopOutPosition % 2);
		engine.setValue(group, 'loop_start_position', loopInPosition);
		engine.setValue(group, 'loop_end_position', loopOutPosition);
	}
}

DenonDNSC2000.play = function (midino, control, value, status, group) {
	if(shiftPressed) {
		if ((status & 0xF0) == 0x90 && engine.getValue(group, 'play') == 1)
			engine.setValue(group, 'reverse', 1);
		else
		if ((status & 0xF0) == 0x80 && engine.getValue(group, 'play') == 1)
			engine.setValue(group, 'reverse', 0);
	}
	else {
		if((status & 0xF0) == 0x90) {
			DenonDNSC2000.toggleBinaryValue(group,'play');
		}
	}
	engine.beginTimer(100, 'DenonDNSC2000.handlePlayLed("'+group+'")', true);
}

DenonDNSC2000.cue = function (midino, control, value, status, group) {
	var ledChannel = DenonDNSC2000.getLedChannelByGroup(group);
	if ((status & 0xF0) == 0x90) {
		engine.setValue(group, 'cue_default', 1);
		midi.sendShortMsg(ledChannel,0x4A,0x26);
	}
	else
	if ((status & 0xF0) == 0x80) {
		engine.setValue(group, 'cue_default', 0);
		midi.sendShortMsg(ledChannel,0x4B,0x26);
	}
}

DenonDNSC2000.keyLock = function (midino, control, value, status, group) {
	if ((status & 0xF0) == 0x90) {
		DenonDNSC2000.toggleBinaryValue(group,'keylock');
		engine.beginTimer(100, 'DenonDNSC2000.handleKeyLockLed("'+group+'")', true);
	}
}

DenonDNSC2000.beatSync = function (midino, control, value, status, group) {
	if ((status & 0xF0) == 0x90) {
		DenonDNSC2000.toggleBinaryValue(group,'beatsync');
		engine.beginTimer(100, 'DenonDNSC2000.handleBeatSyncLed("'+group+'")', true);
	}
}

DenonDNSC2000.pitchBend = function (midino, control, value, status, group) {
	switch(control) {
		case 0x0D:
		if ((status & 0xF0) == 0x90)
			engine.setValue(group, 'rate_temp_down', 1);
		else
			engine.setValue(group, 'rate_temp_down', 0);
		break;
		case 0x0C:
		if ((status & 0xF0) == 0x90)
			engine.setValue(group, 'rate_temp_up', 1);
		else
			engine.setValue(group, 'rate_temp_up', 0);
		break;
	}
}

DenonDNSC2000.jog = function (midino, control, value, status, group) {
	if(shiftPressed) {
		if(!(engine.getValue('[PreviewDeck1]', 'play') == 0)) {
			var currentPosition = engine.getValue('[PreviewDeck1]', 'playposition');
			engine.setValue('[PreviewDeck1]', 'playposition', currentPosition + (value - 64) * 0.0001);
		}
	}
	else {
		var deck = DenonDNSC2000.getDeckByGroup(group);
		if(!deck.scratchMode)
			deck.picthJog(value);
		else
			deck.scratchJog(value);
	}
}

DenonDNSC2000.jogTouch = function (midino, control, value, status, group) {
	DenonDNSC2000.getDeckByGroup(group).jogTouch(midino, control, value, status, group);
}

DenonDNSC2000.handleLoopAndHotcuesLeds = function(group) {
	var ledChannel = DenonDNSC2000.getLedChannelByGroup(group);
	var cueLeds = [0x11,0x13,0x15,0x17,0x19,0x1B,0x1D,0x20];
	for(var index = 0, count = cueLeds.length;index < count; index ++) {
		DenonDNSC2000.handleLed(ledChannel,(engine.getValue(group,'hotcue_' + (index + 1) + '_position') != -1),cueLeds[index],0x4A,0x4B);
	}

	var ledChannel = DenonDNSC2000.getLedChannelByGroup(group);
	DenonDNSC2000.handleLed(ledChannel,(engine.getValue(group, 'loop_start_position') != -1),0x24,0x4A,0x4B);
	DenonDNSC2000.handleLed(ledChannel,(engine.getValue(group, 'loop_end_position') != -1),0x40,0x4A,0x4B);
	DenonDNSC2000.handleLed(ledChannel,(engine.getValue(group, 'loop_enabled') == 1),0x2B,0x4A,0x4B);
}

DenonDNSC2000.handlePlayLed = function(group) {
	DenonDNSC2000.handleLed(DenonDNSC2000.getLedChannelByGroup(group),(engine.getValue(group, 'play') == 1),0x27,0x4A,0x4C);
}

DenonDNSC2000.handleKeyLockLed = function (group) {
	DenonDNSC2000.handleLed(DenonDNSC2000.getLedChannelByGroup(group),(engine.getValue(group, 'keylock') == 1),0x08,0x4A,0x4B);
}

DenonDNSC2000.handleBeatSyncLed = function (group) {
	DenonDNSC2000.handleLed(DenonDNSC2000.getLedChannelByGroup(group),(engine.getValue(group, 'beatsync') == 1),0x09,0x4A,0x4B);
}

DenonDNSC2000.handleFlangerLed = function (group) {
	var flangerOn = (engine.getValue(group, 'flanger') == 1);
	DenonDNSC2000.handleLed(DenonDNSC2000.getLedChannelByGroup(group),flangerOn,0x5A,0x4A,0x4B);
	DenonDNSC2000.handleLed(DenonDNSC2000.getLedChannelByGroup(group),flangerOn,0x5D,0x4A,0x4B);
	DenonDNSC2000.handleLed(DenonDNSC2000.getLedChannelByGroup(group),flangerOn,0x5E,0x4A,0x4B);
	DenonDNSC2000.handleLed(DenonDNSC2000.getLedChannelByGroup(group),flangerOn,0x5F,0x4A,0x4B);
}

DenonDNSC2000.handleLed = function (ledChannel,test,led,stateTrue, stateFalse) {
	if(test) {
		midi.sendShortMsg(ledChannel,stateTrue,led);
	}
	else {
		midi.sendShortMsg(ledChannel,stateFalse,led);
	}
}

DenonDNSC2000.handleLeds = function(group) {
	DenonDNSC2000.handleLoopAndHotcuesLeds(group);
	DenonDNSC2000.handleLoopAndHotcuesLeds(group);
	DenonDNSC2000.handlePlayLed(group);
	DenonDNSC2000.handleKeyLockLed(group);
	DenonDNSC2000.handleBeatSyncLed(group);
	DenonDNSC2000.handleFlangerLed(group);
}

DenonDNSC2000.getLedChannelByGroup = function(group) {
	if(group == '[Channel1]')
		return 0xB0;
	else
	if(group == '[Channel2]')
		return 0xB1;
	else
	if(group == '[Channel3]')
		return 0xB2;
	else
	if(group == '[Channel4]')
		return 0xB3;
}

DenonDNSC2000.toggleBinaryValue = function(group,key) {
	engine.setValue(group,key,engine.getValue(group,key)*-1 + 1);
}

DenonDNSC2000.samplesPerBeat = function(group) {
	return 2 * engine.getValue(group,'track_samplerate') * 60 / engine.getValue(group, "file_bpm");
}
/*******************************************************************************/
DenonDNSC2000.Deck.prototype.picthJog = function(value) {
	value = (value - 0x40)/4;
	if(value > 0) {
		value = value * value;
	} else {
		value = -value * value;
	}
	engine.setValue(this.group,"jog", value);
}

DenonDNSC2000.Deck.prototype.jogTouch = function (midino, control, value, status, group) {
	if ((status & 0xF0) == 0x90) {
		engine.scratchEnable(this.deckNumber, 2048, 33+1/3, 1.0/8, (1.0/8)/32);
		this.scratchMode = true;
	}
	else
	if ((status & 0xF0) == 0x80) {
		engine.scratchDisable(this.deckNumber);
		this.scratchMode = false;
	}
}

DenonDNSC2000.Deck.prototype.scratchJog = function (value) {
	engine.scratchTick(this.deckNumber,value-0x40);
}
/*******************************************************************************/
var shiftPressed = false;
var decks = [new DenonDNSC2000.Deck(1,'[Channel1]'),
			 new DenonDNSC2000.Deck(2,'[Channel2]'),
			 new DenonDNSC2000.Deck(3,'[Channel3]'),
			 new DenonDNSC2000.Deck(4,'[Channel4]'),
			];