← Back to branch summary

~kabelfrickler/mixxx/modplug

« back to all changes in this revision

Viewing changes to mixxx/res/controllers/Denon-DN-SC2000.midi.js

  • Committer: Stefan Nuernberger
  • Date: 2013-03-14 18:11:40 UTC
  • mfrom: (3292.1.40 trunk)
  • Revision ID: kabelfrickler@googlemail.com-20130314181140-3ilxtuq46sxpjqa2
merge with latest trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mixxx/res/controllers/Denon-DN-SC2000.midi.js
 
1
DenonDNSC2000 = new function() {}
 
2
 
 
3
DenonDNSC2000.Deck = function (deckNumber, group) {
 
4
   this.deckNumber = deckNumber;
 
5
   this.group = group;
 
6
   this.scratchMode = false;
 
7
   this.controlPressed = -1;
 
8
}
 
9
 
 
10
DenonDNSC2000.init = function (id) {
 
11
        var leds = [0x11,0x13,0x15,0x17,0x19,0x1B,0x1D,0x20,/* cues */
 
12
                                0x24,0x40,0x2B,/* loops */
 
13
                                0x27,0x26,/* play,cue */
 
14
                                0x08,0x09,/* key lock, sync*/
 
15
                                0x5A,0x5B,/* flanger,scratch mode */
 
16
                                0x5D,0x5E,0x5F/* depth, delay, lfo */
 
17
                                ];
 
18
        for(var index = 0, count = leds.length;index < count; index ++) {
 
19
                midi.sendShortMsg(0xB0,0x4B,leds[index]);
 
20
                midi.sendShortMsg(0xB1,0x4B,leds[index]);
 
21
                midi.sendShortMsg(0xB2,0x4B,leds[index]);
 
22
                midi.sendShortMsg(0xB3,0x4B,leds[index]);
 
23
        }
 
24
}
 
25
 
 
26
DenonDNSC2000.shutdown = function (id) {
 
27
        DenonDNSC2000.init(id);
 
28
}
 
29
 
 
30
DenonDNSC2000.getDeckByGroup = function(group) {
 
31
        for(var index = 0, count = decks.length;index < count; index++) {
 
32
                if(decks[index].group == group)
 
33
                        return decks[index];
 
34
        }
 
35
   return null;
 
36
}
 
37
 
 
38
DenonDNSC2000.shift = function(midino, control, value, status, group) {
 
39
        shiftPressed = ((status & 0xF0) == 0x90);
 
40
        if(!shiftPressed)
 
41
                engine.setValue(group, 'reverse', 0);
 
42
}
 
43
 
 
44
DenonDNSC2000.changeDeck = function(midino, control, value, status, group) {
 
45
        DenonDNSC2000.handleLeds(group);
 
46
}
 
47
 
 
48
DenonDNSC2000.newValue = function(currentVal,min,max,increment,ticksCount) {
 
49
        var interval = (max - min) / 24;
 
50
        var newVal = 0;
 
51
        if(increment)
 
52
                newVal = Math.min(max,currentVal + interval);
 
53
        else
 
54
                newVal = Math.max(min,currentVal - interval);
 
55
        return newVal;
 
56
}
 
57
 
 
58
DenonDNSC2000.flanger = function (midino, control, value, status, group) {
 
59
        DenonDNSC2000.toggleBinaryValue(group,'flanger');
 
60
        engine.beginTimer(100, 'DenonDNSC2000.handleFlangerLed("'+group+'")', true);    
 
61
}
 
62
 
 
63
DenonDNSC2000.changeDepth = function (midino, control, value, status, group) {
 
64
        engine.setValue(group, 'lfoDepth', DenonDNSC2000.newValue(engine.getValue(group, 'lfoDepth'),0,1,(value == 0x00),24));
 
65
}
 
66
 
 
67
DenonDNSC2000.changeDelay = function (midino, control, value, status, group) {
 
68
        engine.setValue(group, 'lfoDelay', DenonDNSC2000.newValue(engine.getValue(group, 'lfoDelay'),50,10000,(value == 0x00),24));
 
69
}
 
70
 
 
71
DenonDNSC2000.changeLFO = function (midino, control, value, status, group) {
 
72
        engine.setValue(group, 'lfoPeriod', DenonDNSC2000.newValue(engine.getValue(group, 'lfoPeriod'),50000,2000000,(value == 0x00),24));
 
73
}
 
74
 
 
75
DenonDNSC2000.resetDepth = function (midino, control, value, status, group) {
 
76
        engine.setValue(group, 'lfoDepth', 0.5);
 
77
}
 
78
 
 
79
DenonDNSC2000.resetDelay = function (midino, control, value, status, group) {
 
80
        engine.setValue(group, 'lfoDelay', 50 + (10000 - 50) / 2);
 
81
}
 
82
 
 
83
DenonDNSC2000.resetLFO = function (midino, control, value, status, group) {
 
84
        engine.setValue(group, 'lfoPeriod', 50000 + (2000000 - 50000) / 2);
 
85
}
 
86
 
 
87
DenonDNSC2000.selectTrack = function (midino, control, value, status, group) {
 
88
        if(value == 0x00)
 
89
                engine.setValue('[Playlist]', 'SelectNextTrack', 1);
 
90
        else
 
91
                engine.setValue('[Playlist]', 'SelectPrevTrack', 1);
 
92
}
 
93
 
 
94
DenonDNSC2000.loadSelectedTrack = function (midino, control, value, status, group) {
 
95
        engine.setValue(group, 'LoadSelectedTrack', 1);
 
96
        engine.beginTimer(1500, 'DenonDNSC2000.handleLeds("'+group+'")', true);
 
97
}
 
98
 
 
99
DenonDNSC2000.loopOrHotcues = function (midino, control, value, status, group) {
 
100
        var deck = DenonDNSC2000.getDeckByGroup(group);
 
101
        if ((status & 0xF0) == 0x80)
 
102
                deck.controlPressed = -1;
 
103
        else {
 
104
                deck.controlPressed = control;
 
105
                switch (control) {
 
106
                        // hotcue
 
107
                        case 0x17:
 
108
                                DenonDNSC2000.hotcue(1,group,value,shiftPressed);
 
109
                        break;
 
110
                        case 0x18:
 
111
                                DenonDNSC2000.hotcue(2,group,value,shiftPressed);
 
112
                        break;
 
113
                        case 0x19:
 
114
                                DenonDNSC2000.hotcue(3,group,value,shiftPressed);
 
115
                        break;
 
116
                        case 0x20:
 
117
                                DenonDNSC2000.hotcue(4,group,value,shiftPressed);
 
118
                        break;
 
119
                        case 0x21:
 
120
                                DenonDNSC2000.hotcue(5,group,value,shiftPressed);
 
121
                        break;
 
122
                        case 0x22:
 
123
                                DenonDNSC2000.hotcue(6,group,value,shiftPressed);
 
124
                        break;
 
125
                        case 0x23:
 
126
                                DenonDNSC2000.hotcue(7,group,value,shiftPressed);
 
127
                        break;
 
128
                        case 0x24:
 
129
                                DenonDNSC2000.hotcue(8,group,value,shiftPressed);
 
130
                        break;
 
131
                        // loop
 
132
                        case 0x37:
 
133
                                DenonDNSC2000.loopIn(group,value,shiftPressed);
 
134
                        break;
 
135
                        case 0x39:
 
136
                                DenonDNSC2000.loopOut(group,value,shiftPressed);
 
137
                        break;
 
138
                        case 0x1D:
 
139
                                DenonDNSC2000.reloop(group,value,shiftPressed);
 
140
                        break;
 
141
                }
 
142
        }
 
143
};
 
144
 
 
145
DenonDNSC2000.hotcue = function(cueIndex, group, value, shift) {
 
146
        if(!shift) {
 
147
                engine.setValue(group, 'hotcue_' + cueIndex + '_activate', 1);
 
148
        }
 
149
        else {
 
150
                if(engine.getValue(group, 'hotcue_' + cueIndex + '_enabled') == 0) {
 
151
                        var samplesPerBeat = DenonDNSC2000.samplesPerBeat(group);
 
152
                        var positionInBeats = (engine.getValue(group,'playposition') * engine.getValue(group,'track_samples')) / samplesPerBeat;
 
153
                        if((positionInBeats - Math.floor(positionInBeats)) > 0.5)
 
154
                                positionInBeats = Math.floor(0.5 + positionInBeats) * samplesPerBeat;
 
155
                        else
 
156
                                positionInBeats = Math.floor(positionInBeats) * samplesPerBeat;
 
157
                        positionInBeats = Math.floor(0.5 + positionInBeats);
 
158
                        positionInBeats = Math.max(0,positionInBeats - positionInBeats % 2);
 
159
                        engine.setValue(group, 'hotcue_' + cueIndex + '_activate', 1);
 
160
                        engine.setValue(group, 'hotcue_' + cueIndex + '_position',positionInBeats);
 
161
                }
 
162
                else
 
163
                engine.setValue(group, 'hotcue_' + cueIndex + '_clear',1);
 
164
        }
 
165
        engine.beginTimer(100, 'DenonDNSC2000.handleLoopAndHotcuesLeds("'+group+'")', true);
 
166
}
 
167
 
 
168
DenonDNSC2000.loopIn = function(group, value, shift) {
 
169
        if(shiftPressed) {
 
170
                engine.setValue(group, 'loop_start_position', -1);
 
171
        }
 
172
        else
 
173
                engine.setValue(group, 'loop_in', 1);
 
174
        engine.beginTimer(100, 'DenonDNSC2000.handleLoopAndHotcuesLeds("'+group+'")', true);
 
175
}
 
176
 
 
177
DenonDNSC2000.loopOut = function(group, value, shift) {
 
178
        if(shiftPressed) {
 
179
                engine.setValue(group, 'loop_end_position', -1);
 
180
                if(engine.getValue(group,'loop_enabled'))
 
181
                        engine.setValue(group, 'reloop_exit', 1);
 
182
        }
 
183
        else
 
184
                engine.setValue(group, 'loop_out', 1);
 
185
        engine.beginTimer(100, 'DenonDNSC2000.handleLoopAndHotcuesLeds("'+group+'")', true);
 
186
}
 
187
 
 
188
DenonDNSC2000.reloop = function(group, value, shift) {  
 
189
        var loopInPosition = engine.getValue(group,'loop_start_position');
 
190
        var loopOutPosition = engine.getValue(group,'loop_end_position');
 
191
        if(loopInPosition != -1 && loopOutPosition!=-1) {
 
192
                engine.setValue(group, 'reloop_exit', 1);
 
193
        }
 
194
        else {
 
195
                var samplesPerBeat = DenonDNSC2000.samplesPerBeat(group);
 
196
                loopInPosition = engine.getValue(group,'playposition') * engine.getValue(group,'track_samples');
 
197
                if(shiftPressed) {
 
198
                        var loopInPositionInBeats = loopInPosition / samplesPerBeat;
 
199
                        if((loopInPositionInBeats - Math.floor(loopInPositionInBeats)) > 0.5)
 
200
                                loopInPosition = Math.floor(0.5 + loopInPositionInBeats) * samplesPerBeat;
 
201
                        else
 
202
                                loopInPosition = Math.floor(loopInPositionInBeats) * samplesPerBeat;
 
203
                }
 
204
                else
 
205
                        loopInPosition = engine.getValue(group,'playposition') * engine.getValue(group,'track_samples');
 
206
                loopInPosition = Math.floor(0.5 + loopInPosition);
 
207
                loopInPosition = Math.max(0,loopInPosition - loopInPosition % 2);
 
208
                var loopOutPosition = loopInPosition + Math.floor(0.5 + samplesPerBeat);
 
209
                loopOutPosition = Math.max(0,loopOutPosition - loopOutPosition % 2);
 
210
                if(loopInPosition + samplesPerBeat < engine.getValue(group,'track_samples')) {
 
211
                        engine.setValue(group, 'loop_start_position', loopInPosition);
 
212
                        engine.setValue(group, 'loop_end_position', loopOutPosition);
 
213
                        engine.setValue(group, 'reloop_exit', 1);
 
214
                }
 
215
        }
 
216
        engine.beginTimer(100, 'DenonDNSC2000.handleLoopAndHotcuesLeds("'+group+'")', true);
 
217
}
 
218
 
 
219
DenonDNSC2000.resizeLoop = function(midino, control, value, status, group) {
 
220
        var increment = true;
 
221
        if(value == 0x7F)
 
222
                increment = false;
 
223
        var loopInPosition = engine.getValue(group,'loop_start_position');
 
224
        var loopOutPosition = engine.getValue(group,'loop_end_position');
 
225
        if(loopInPosition != -1 && loopOutPosition!= -1) {
 
226
                var samplesPerBeat = DenonDNSC2000.samplesPerBeat(group);
 
227
                var deltaSamples = loopOutPosition - loopInPosition;
 
228
                var newLoopOutPosition = loopOutPosition;
 
229
                var loopLengthes = [ 
 
230
                                                Math.floor(0.5 + samplesPerBeat * 1 / 32),
 
231
                                                Math.floor(0.5 + samplesPerBeat * 1 / 16),
 
232
                                                Math.floor(0.5 + samplesPerBeat * 1 / 8),
 
233
                                                Math.floor(0.5 + samplesPerBeat * 1 / 4),
 
234
                                                Math.floor(0.5 + samplesPerBeat * 1 / 2),
 
235
                                                Math.floor(0.5 + samplesPerBeat),
 
236
                                                Math.floor(0.5 + samplesPerBeat * 2),
 
237
                                                Math.floor(0.5 + samplesPerBeat * 4),
 
238
                                                Math.floor(0.5 + samplesPerBeat * 8),
 
239
                                                Math.floor(0.5 + samplesPerBeat * 16),
 
240
                                                Math.floor(0.5 + samplesPerBeat * 32)
 
241
                                                ];
 
242
                
 
243
                if(increment) {
 
244
                        for(var index = 0, count = loopLengthes.length;index < count; index++) {
 
245
                                if(deltaSamples < loopLengthes[index]) {
 
246
                                        newLoopOutPosition = loopInPosition + loopLengthes[index];
 
247
                                        break;
 
248
                                }
 
249
                        }
 
250
                }
 
251
                else {
 
252
                        for(var index = loopLengthes.length-1;index >= 0; index--) {
 
253
                                if(deltaSamples > loopLengthes[index]) {
 
254
                                        newLoopOutPosition = loopInPosition + loopLengthes[index];
 
255
                                        break;
 
256
                                }
 
257
                        }
 
258
                }
 
259
                newLoopOutPosition = Math.max(0,newLoopOutPosition - newLoopOutPosition % 2);
 
260
                engine.setValue(group, 'loop_end_position', newLoopOutPosition);
 
261
        }
 
262
        engine.beginTimer(100, 'DenonDNSC2000.handleLoopAndHotcuesLeds("'+group+'")', true);
 
263
}
 
264
 
 
265
DenonDNSC2000.moveLoopLeft = function(midino, control, value, status, group) {
 
266
        var samplesPerBeat = Math.floor(0.5 + DenonDNSC2000.samplesPerBeat(group));
 
267
        var loopInPosition = engine.getValue(group,'loop_start_position');
 
268
        var loopOutPosition = engine.getValue(group,'loop_end_position'); 
 
269
        if(loopInPosition != -1 && loopOutPosition != -1 && loopInPosition > samplesPerBeat) {
 
270
                loopInPosition = loopInPosition - samplesPerBeat;
 
271
                loopInPosition = Math.max(0,loopInPosition - loopInPosition % 2);
 
272
                loopOutPosition = loopOutPosition - samplesPerBeat;
 
273
                loopOutPosition = Math.max(0,loopOutPosition - loopOutPosition % 2);            
 
274
                engine.setValue(group, 'loop_start_position', loopInPosition);
 
275
                engine.setValue(group, 'loop_end_position', loopOutPosition);
 
276
        }
 
277
}
 
278
 
 
279
DenonDNSC2000.moveLoopRight = function(midino, control, value, status, group) {
 
280
        var samplesPerBeat = Math.floor(0.5 + DenonDNSC2000.samplesPerBeat(group));
 
281
        var loopInPosition = engine.getValue(group,'loop_start_position');
 
282
        var loopOutPosition = engine.getValue(group,'loop_end_position'); 
 
283
        if(loopInPosition != -1 && loopOutPosition != -1 && loopOutPosition + samplesPerBeat < engine.getValue(group,'track_samples')) {
 
284
                loopInPosition = loopInPosition + samplesPerBeat;
 
285
                loopInPosition = Math.max(0,loopInPosition - loopInPosition % 2);
 
286
                loopOutPosition = loopOutPosition + samplesPerBeat;
 
287
                loopOutPosition = Math.max(0,loopOutPosition - loopOutPosition % 2);            
 
288
                engine.setValue(group, 'loop_start_position', loopInPosition);
 
289
                engine.setValue(group, 'loop_end_position', loopOutPosition);
 
290
        }
 
291
}
 
292
 
 
293
DenonDNSC2000.play = function (midino, control, value, status, group) {
 
294
        if(shiftPressed) {
 
295
                if ((status & 0xF0) == 0x90 && engine.getValue(group, 'play') == 1)
 
296
                        engine.setValue(group, 'reverse', 1);
 
297
                else
 
298
                if ((status & 0xF0) == 0x80 && engine.getValue(group, 'play') == 1)
 
299
                        engine.setValue(group, 'reverse', 0);
 
300
        }
 
301
        else {
 
302
                if((status & 0xF0) == 0x90) {
 
303
                        DenonDNSC2000.toggleBinaryValue(group,'play');
 
304
                }
 
305
        }
 
306
        engine.beginTimer(100, 'DenonDNSC2000.handlePlayLed("'+group+'")', true);
 
307
}
 
308
 
 
309
DenonDNSC2000.cue = function (midino, control, value, status, group) {
 
310
        var ledChannel = DenonDNSC2000.getLedChannelByGroup(group);
 
311
        if ((status & 0xF0) == 0x90) {
 
312
                engine.setValue(group, 'cue_default', 1);
 
313
                midi.sendShortMsg(ledChannel,0x4A,0x26);
 
314
        }
 
315
        else 
 
316
        if ((status & 0xF0) == 0x80) {
 
317
                engine.setValue(group, 'cue_default', 0);
 
318
                midi.sendShortMsg(ledChannel,0x4B,0x26);
 
319
        }
 
320
}
 
321
 
 
322
DenonDNSC2000.keyLock = function (midino, control, value, status, group) {
 
323
        if ((status & 0xF0) == 0x90) {
 
324
                DenonDNSC2000.toggleBinaryValue(group,'keylock');
 
325
                engine.beginTimer(100, 'DenonDNSC2000.handleKeyLockLed("'+group+'")', true);
 
326
        }
 
327
}
 
328
 
 
329
DenonDNSC2000.beatSync = function (midino, control, value, status, group) {
 
330
        if ((status & 0xF0) == 0x90) {
 
331
                DenonDNSC2000.toggleBinaryValue(group,'beatsync');
 
332
                engine.beginTimer(100, 'DenonDNSC2000.handleBeatSyncLed("'+group+'")', true);
 
333
        }
 
334
}
 
335
 
 
336
DenonDNSC2000.pitchBend = function (midino, control, value, status, group) {
 
337
        switch(control) {
 
338
                case 0x0D:
 
339
                if ((status & 0xF0) == 0x90)
 
340
                        engine.setValue(group, 'rate_temp_down', 1);
 
341
                else
 
342
                        engine.setValue(group, 'rate_temp_down', 0);
 
343
                break;
 
344
                case 0x0C:
 
345
                if ((status & 0xF0) == 0x90)
 
346
                        engine.setValue(group, 'rate_temp_up', 1);
 
347
                else
 
348
                        engine.setValue(group, 'rate_temp_up', 0);
 
349
                break;
 
350
        }
 
351
}
 
352
 
 
353
DenonDNSC2000.jog = function (midino, control, value, status, group) {
 
354
        var deck = DenonDNSC2000.getDeckByGroup(group);
 
355
        if(!deck.scratchMode)
 
356
                deck.picthJog(value);
 
357
        else
 
358
                deck.scratchJog(value);
 
359
}
 
360
 
 
361
DenonDNSC2000.jogTouch = function (midino, control, value, status, group) {
 
362
        DenonDNSC2000.getDeckByGroup(group).jogTouch(midino, control, value, status, group);
 
363
}
 
364
 
 
365
DenonDNSC2000.handleLoopAndHotcuesLeds = function(group) {
 
366
        var ledChannel = DenonDNSC2000.getLedChannelByGroup(group);
 
367
        var cueLeds = [0x11,0x13,0x15,0x17,0x19,0x1B,0x1D,0x20];
 
368
        for(var index = 0, count = cueLeds.length;index < count; index ++) {
 
369
                DenonDNSC2000.handleLed(ledChannel,(engine.getValue(group,'hotcue_' + (index + 1) + '_position') != -1),cueLeds[index],0x4A,0x4B);
 
370
        }
 
371
        
 
372
        var ledChannel = DenonDNSC2000.getLedChannelByGroup(group);
 
373
        DenonDNSC2000.handleLed(ledChannel,(engine.getValue(group, 'loop_start_position') != -1),0x24,0x4A,0x4B);
 
374
        DenonDNSC2000.handleLed(ledChannel,(engine.getValue(group, 'loop_end_position') != -1),0x40,0x4A,0x4B); 
 
375
        DenonDNSC2000.handleLed(ledChannel,(engine.getValue(group, 'loop_enabled') == 1),0x2B,0x4A,0x4B);
 
376
}
 
377
 
 
378
DenonDNSC2000.handlePlayLed = function(group) {
 
379
        DenonDNSC2000.handleLed(DenonDNSC2000.getLedChannelByGroup(group),(engine.getValue(group, 'play') == 1),0x27,0x4A,0x4C);
 
380
}
 
381
 
 
382
DenonDNSC2000.handleKeyLockLed = function (group) {
 
383
        DenonDNSC2000.handleLed(DenonDNSC2000.getLedChannelByGroup(group),(engine.getValue(group, 'keylock') == 1),0x08,0x4A,0x4B);
 
384
}
 
385
 
 
386
DenonDNSC2000.handleBeatSyncLed = function (group) {
 
387
        DenonDNSC2000.handleLed(DenonDNSC2000.getLedChannelByGroup(group),(engine.getValue(group, 'beatsync') == 1),0x09,0x4A,0x4B);
 
388
}
 
389
 
 
390
DenonDNSC2000.handleFlangerLed = function (group) {
 
391
        var flangerOn = (engine.getValue(group, 'flanger') == 1);
 
392
        DenonDNSC2000.handleLed(DenonDNSC2000.getLedChannelByGroup(group),flangerOn,0x5A,0x4A,0x4B);
 
393
        DenonDNSC2000.handleLed(DenonDNSC2000.getLedChannelByGroup(group),flangerOn,0x5D,0x4A,0x4B);
 
394
        DenonDNSC2000.handleLed(DenonDNSC2000.getLedChannelByGroup(group),flangerOn,0x5E,0x4A,0x4B);
 
395
        DenonDNSC2000.handleLed(DenonDNSC2000.getLedChannelByGroup(group),flangerOn,0x5F,0x4A,0x4B);
 
396
}
 
397
 
 
398
DenonDNSC2000.handleLed = function (ledChannel,test,led,stateTrue, stateFalse) {
 
399
        if(test) {
 
400
                midi.sendShortMsg(ledChannel,stateTrue,led);
 
401
        }
 
402
        else {
 
403
                midi.sendShortMsg(ledChannel,stateFalse,led);
 
404
        }
 
405
}
 
406
 
 
407
DenonDNSC2000.handleLeds = function(group) {
 
408
        DenonDNSC2000.handleLoopAndHotcuesLeds(group);
 
409
        DenonDNSC2000.handleLoopAndHotcuesLeds(group);
 
410
        DenonDNSC2000.handlePlayLed(group);
 
411
        DenonDNSC2000.handleKeyLockLed(group);
 
412
        DenonDNSC2000.handleBeatSyncLed(group);
 
413
        DenonDNSC2000.handleFlangerLed(group);
 
414
}
 
415
 
 
416
DenonDNSC2000.getLedChannelByGroup = function(group) {
 
417
        if(group == '[Channel1]')
 
418
                return 0xB0;
 
419
        else
 
420
        if(group == '[Channel2]')
 
421
                return 0xB1;
 
422
        else
 
423
        if(group == '[Channel3]')
 
424
                return 0xB2;
 
425
        else
 
426
        if(group == '[Channel4]')
 
427
                return 0xB3;
 
428
}
 
429
 
 
430
DenonDNSC2000.toggleBinaryValue = function(group,key) {
 
431
        engine.setValue(group,key,engine.getValue(group,key)*-1 + 1);
 
432
}
 
433
 
 
434
DenonDNSC2000.samplesPerBeat = function(group) {
 
435
        return 2 * engine.getValue(group,'track_samplerate') * 60 / engine.getValue(group, "file_bpm");
 
436
}
 
437
/*******************************************************************************/
 
438
DenonDNSC2000.Deck.prototype.picthJog = function(value) {
 
439
        value = (value - 0x40)/4;
 
440
        if(value > 0) {
 
441
                value = value * value;
 
442
        } else {
 
443
                value = -value * value; 
 
444
        }
 
445
        engine.setValue(this.group,"jog", value);
 
446
}
 
447
 
 
448
DenonDNSC2000.Deck.prototype.jogTouch = function (midino, control, value, status, group) {
 
449
        if ((status & 0xF0) == 0x90) {
 
450
                engine.scratchEnable(this.deckNumber, 2048, 33+1/3, 1.0/8, (1.0/8)/32);
 
451
                this.scratchMode = true;
 
452
        }
 
453
        else 
 
454
        if ((status & 0xF0) == 0x80) {
 
455
                engine.scratchDisable(this.deckNumber);
 
456
                this.scratchMode = false;
 
457
        }       
 
458
}
 
459
 
 
460
DenonDNSC2000.Deck.prototype.scratchJog = function (value) {
 
461
        engine.scratchTick(this.deckNumber,value-0x40);
 
462
}
 
463
/*******************************************************************************/
 
464
var shiftPressed = false;
 
465
var decks = [new DenonDNSC2000.Deck(1,'[Channel1]'),
 
466
                         new DenonDNSC2000.Deck(2,'[Channel2]'),
 
467
                         new DenonDNSC2000.Deck(3,'[Channel3]'),
 
468
                         new DenonDNSC2000.Deck(4,'[Channel4]'),
 
469
                        ];
 
 
b'\\ No newline at end of file'