########################################################################
#
# Ots Hardware Mapping Language (OHML) Source File
#
# Hardware      : Denon MC6000MK2 DJ MIDI Hardware Controller
# File Name     : (Ots) Denon MC6000MK2.ohm
# Last Updated  : 02-Jul-2018
# OtsAV Version : 1.90.000, 1.90.015, 1.90.044, 1.94.027
#
# Copyright 1996-2018 Ots Corporation
#
# IMPORTANT NOTE: This is an original file from Ots Labs. If you wish to
# make edits, it is recommended that you copy the contents of this file
# to a new file first. Should you fail to do this, your changes may be
# lost when Ots software updates are installed on your computer. If you
# need to obtain the original version of this file at a later stage,
# visit http://www.OtsAV.com
#
########################################################################



# ******* Declare variables *******


# Arguments: variable name, initial value, maximum value

!var[$abm_enabled,0,1] # for tracking auto-beatmixing mode
!var[$autodj_enabled,0,1] # for tracking auto-dj mode
!var[$abm_active,0,1] # tracks abm active state
!var[$video_master,0,1] # tracks video master deck
!var[$global_shift,0,1] # global shift state
!var[$deck_a_shift,0,1] # tracks shift button
!var[$deck_b_shift,0,1]
!var[$deck_a_loaded,0,1] # 0 = empty, 1 = loaded
!var[$deck_b_loaded,0,1]
!var[$deck_a_playing,0,1] # 1 = playing
!var[$deck_b_playing,0,1]
!var[$deck_a_jog_mode,0,1] # 0 = bending, 1 = scratching
!var[$deck_b_jog_mode,0,1]
!var[$deck_a_jog_button,0,1] # 1 = down (pressed)
!var[$deck_b_jog_button,0,1]
!var[$deck_a_bend_state,0,1] # tracks jog wheel state for bending
!var[$deck_b_bend_state,0,1]
!var[$deck_a_scratch_state,0,2] # tracks jog wheel state for scratching
!var[$deck_b_scratch_state,0,2]
!var[$deck_a_scratch,0,1] # 1 = currently scratching
!var[$deck_b_scratch,0,1]
!var[$deck_a_bend,0,1] # 1 = currently bending
!var[$deck_b_bend,0,1]
!var[$deck_a_bend_down,0,1] # 1 = currently bend down
!var[$deck_b_bend_down,0,1]
!var[$deck_a_bend_up,0,1] # 1 = currently bend up
!var[$deck_b_bend_up,0,1]
!var[$deck_a_frame_search,0,1] # 1 = in frame search mode
!var[$deck_b_frame_search,0,1]
!var[$deck_a_search_spin_counter,0,34] # for dividing (by 33) jog
!var[$deck_b_search_spin_counter,0,34] # pulses when frame searching
!var[$deck_a_search_rate,0,2] # frame search speed via jog
!var[$deck_b_search_rate,0,2]
!var[$deck_a_zorphing,0,1] # for tracking scratching/zorphing mode
!var[$deck_b_zorphing,0,1]
!var[$deck_a_bend_tempo,0,1] # for tracking bending mode
!var[$deck_b_bend_tempo,0,1]
!var[$deck_a_slider_index,0,2] # 0 = tempo, 1 = pitch, 2 = direction
!var[$deck_b_slider_index,0,2]
!var[$deck_a_video_block,0,1] # tracks video block state
!var[$deck_b_video_block,0,1]
!var[$deck_a_plus,0,1] # tracks plus loop button
!var[$deck_b_plus,0,1]
!var[$deck_a_a1,0,1] # tracks a1 button
!var[$deck_b_a1,0,1]
!var[$deck_a_a2,0,1] # tracks a2 button
!var[$deck_b_a2,0,1]
!var[$deck_a_minus,0,1] # tracks minus loop button
!var[$deck_b_minus,0,1]
!var[$deck_a_mod,0,3] # tracks plus/minus modifiers
!var[$deck_b_mod,0,3]



# ******* Declare subroutines *******


!sub[@deck_a_slider_range] # cycle slider range
!sub[@deck_b_slider_range]
!sub[@deck_a_try_bend] # this sub is used purely to gain
!sub[@deck_b_try_bend] # use of another conditional
!sub[@deck_a_try_scratch]
!sub[@deck_b_try_scratch]
!sub[@deck_a_try_scratch2]
!sub[@deck_b_try_scratch2]
!sub[@deck_a_bend_down_pressed]
!sub[@deck_b_bend_down_pressed]
!sub[@deck_a_bend_up_pressed]
!sub[@deck_b_bend_up_pressed]
!sub[@deck_a_try_loop1_press]
!sub[@deck_a_try_loop2_press]
!sub[@deck_b_try_loop1_press]
!sub[@deck_b_try_loop2_press]
!sub[@deck_a_jog_val_bend]	# important to use sub for midi.velval-based
!sub[@deck_b_jog_val_bend]	# controls which call more than one command
							# in order to be efficient (CPU resources)
!sub[@deck_a_jog_val_scratch]
!sub[@deck_b_jog_val_scratch]
!sub[@deck_a_cue_no_shift]
!sub[@deck_b_cue_no_shift]
!sub[@deck_a_slider_val] # new value from slider
!sub[@deck_b_slider_val]
!sub[@deck_a_slider_val_tempo]
!sub[@deck_b_slider_val_tempo]
!sub[@deck_a_slider_val_pitch]
!sub[@deck_b_slider_val_pitch]
!sub[@deck_a_slider_val_direction]
!sub[@deck_b_slider_val_direction]
!sub[@deck_a_playlist_loadnext] # load next item from playlist if
!sub[@deck_b_playlist_loadnext] # deck is not currently playing



# ******* Declare LEDs/blink assets *******


# Arguments: blink handle name, "M", midi off code, midi on code

!blink[~autodj_led,M,0xB0:0x51:0x63,0xB0:0x50:0x63]
!blink[~autobm_led,M,0xB0:0x51:0x64,0xB0:0x50:0x64]
!blink[~deck_a_cueselect_led,M,0xB0:0x51:0x45,0xB0:0x50:0x45]
!blink[~deck_b_cueselect_led,M,0xB0:0x51:0x4B,0xB0:0x50:0x4B]
!blink[~deck_a_slidermode_led,M,0xB0:0x4B:0x08,0xB0:0x4A:0x08]
!blink[~deck_b_slidermode_led,M,0xB2:0x4B:0x08,0xB2:0x4A:0x08]
!blink[~deck_a_fxch_3_led,M,0xB0:0x4B:0x54,0xB0:0x4A:0x54]
!blink[~deck_b_fxch_3_led,M,0xB0:0x4B:0x58,0xB0:0x4A:0x58]
!blink[~deck_a_fxch_1_led,M,0xB0:0x4B:0x56,0xB0:0x4A:0x56]
!blink[~deck_b_fxch_1_led,M,0xB0:0x4B:0x5A,0xB0:0x4A:0x5A]
!blink[~deck_a_fxch_2_led,M,0xB0:0x4B:0x57,0xB0:0x4A:0x57]
!blink[~deck_b_fxch_2_led,M,0xB0:0x4B:0x5B,0xB0:0x4A:0x5B]
!blink[~deck_a_fxch_4_led,M,0xB0:0x4B:0x55,0xB0:0x4A:0x55]
!blink[~deck_b_fxch_4_led,M,0xB0:0x4B:0x59,0xB0:0x4A:0x59]
!blink[~deck_a_fx_tap_led,M,0xB0:0x4B:0x5F,0xB0:0x4A:0x5F]
!blink[~deck_b_fx_tap_led,M,0xB0:0x4B:0x63,0xB0:0x4A:0x63]
!blink[~deck_a_loop_in_led,M,0xB0:0x4B:0x24,0xB0:0x4A:0x24]
!blink[~deck_b_loop_in_led,M,0xB2:0x4B:0x24,0xB2:0x4A:0x24]
!blink[~deck_a_loop_out_led,M,0xB0:0x4B:0x40,0xB0:0x4A:0x40]
!blink[~deck_b_loop_out_led,M,0xB2:0x4B:0x40,0xB2:0x4A:0x40]
!blink[~deck_a_loop_auto_led,M,0xB0:0x4B:0x2B,0xB0:0x4A:0x2B]
!blink[~deck_b_loop_auto_led,M,0xB2:0x4B:0x2B,0xB2:0x4A:0x2B]
!blink[~deck_a_fx_1_led,M,0xB0:0x4B:0x5C,0xB0:0x4A:0x5C]
!blink[~deck_b_fx_1_led,M,0xB0:0x4B:0x60,0xB0:0x4A:0x60]
!blink[~deck_a_fx_2_led,M,0xB0:0x4B:0x5D,0xB0:0x4A:0x5D]
!blink[~deck_b_fx_2_led,M,0xB0:0x4B:0x61,0xB0:0x4A:0x61]
!blink[~deck_a_fx_3_led,M,0xB0:0x4B:0x5E,0xB0:0x4A:0x5E]
!blink[~deck_b_fx_3_led,M,0xB0:0x4B:0x62,0xB0:0x4A:0x62]
!blink[~deck_a_jog_mode_led,M,0xB0:0x4B:0x06,0xB0:0x4A:0x06]
!blink[~deck_b_jog_mode_led,M,0xB2:0x4B:0x06,0xB2:0x4A:0x06]
!blink[~deck_a_cue_led,M,0xB0:0x4B:0x26,0xB0:0x4A:0x26]
!blink[~deck_b_cue_led,M,0xB2:0x4B:0x26,0xB2:0x4A:0x26]
!blink[~deck_a_playpause_led,M,0xB0:0x4B:0x27,0xB0:0x4A:0x27]
!blink[~deck_b_playpause_led,M,0xB2:0x4B:0x27,0xB2:0x4A:0x27]



# ******* Initialisation *******


# Called by OHM subsystem at startup.
# Place any code here that is important to maintain state at launch

sub[@_init] {
# turn off all LEDs we don't explicitly handle
	# decks 1/2/3/4
	midiOut(0xB0:0x4B:0x11) # hot cue 1
	midiOut(0xB1:0x4B:0x11)
	midiOut(0xB2:0x4B:0x11)
	midiOut(0xB3:0x4B:0x11)
	midiOut(0xB0:0x4B:0x13) # hot cue 2
	midiOut(0xB1:0x4B:0x13)
	midiOut(0xB2:0x4B:0x13)
	midiOut(0xB3:0x4B:0x13)
	midiOut(0xB0:0x4B:0x15) # hot cue 3
	midiOut(0xB1:0x4B:0x15)
	midiOut(0xB2:0x4B:0x15)
	midiOut(0xB3:0x4B:0x15)
	midiOut(0xB0:0x4B:0x17) # hot cue 4
	midiOut(0xB1:0x4B:0x17)
	midiOut(0xB2:0x4B:0x17)
	midiOut(0xB3:0x4B:0x17)
	# decks 1/2
	midiOut(0xB0:0x4B:0x19) # sample 1
	midiOut(0xB2:0x4B:0x19)
	midiOut(0xB0:0x4B:0x1B) # sample 2
	midiOut(0xB2:0x4B:0x1B)
	midiOut(0xB0:0x4B:0x1D) # sample 3
	midiOut(0xB2:0x4B:0x1D)
	midiOut(0xB0:0x4B:0x20) # sample 4
	midiOut(0xB2:0x4B:0x20)
	# decks 3/4
	midiOut(0xB1:0x4B:0x24) # loop in
	midiOut(0xB3:0x4B:0x24)
	midiOut(0xB1:0x4B:0x40) # loop out
	midiOut(0xB3:0x4B:0x40)
	midiOut(0xB1:0x4B:0x2B) # auto loop
	midiOut(0xB3:0x4B:0x2B)
	midiOut(0xB1:0x4B:0x06) # vinyl
	midiOut(0xB3:0x4B:0x06)
	# channels 3/4
	midiOut(0xB0:0x51:0x51) # mon cue
	midiOut(0xB0:0x51:0x57)
# turn leds onto hardware blink mode for Deck 3/4 to warn these decks are not supported and to toggle back to Deck 1/2
	midiOut(0xB1:0x4C:0x08) # key lock
	midiOut(0xB3:0x4C:0x08)
	midiOut(0xB1:0x4C:0x64) # censor
	midiOut(0xB3:0x4C:0x64)
	midiOut(0xB1:0x4C:0x09) # sync
	midiOut(0xB3:0x4C:0x09)
	midiOut(0xB1:0x4C:0x26) # cue
	midiOut(0xB3:0x4C:0x26)
	midiOut(0xB1:0x4C:0x27) # play
	midiOut(0xB3:0x4C:0x27)
# turn off LEDs
	BlinkSet(~autodj_led,0)
	BlinkSet(~autobm_led,0)
	BlinkSet(~deck_a_cueselect_led,0)
	BlinkSet(~deck_b_cueselect_led,0)
	BlinkSet(~deck_a_slidermode_led,0)
	BlinkSet(~deck_b_slidermode_led,0)
	BlinkSet(~deck_a_fxch_3_led,0)
	BlinkSet(~deck_b_fxch_3_led,0)
	BlinkSet(~deck_a_fxch_1_led,0)
	BlinkSet(~deck_b_fxch_1_led,0)
	BlinkSet(~deck_a_fxch_2_led,0)
	BlinkSet(~deck_b_fxch_2_led,0)
	BlinkSet(~deck_a_fxch_4_led,0)
	BlinkSet(~deck_b_fxch_4_led,0)
	BlinkSet(~deck_a_fx_tap_led,0)
	BlinkSet(~deck_b_fx_tap_led,0)
	BlinkSet(~deck_a_loop_in_led,0)
	BlinkSet(~deck_b_loop_in_led,0)
	BlinkSet(~deck_a_loop_out_led,0)
	BlinkSet(~deck_b_loop_out_led,0)
	BlinkSet(~deck_a_loop_auto_led,0)
	BlinkSet(~deck_b_loop_auto_led,0)
	BlinkSet(~deck_a_fx_1_led,0)
	BlinkSet(~deck_b_fx_1_led,0)
	BlinkSet(~deck_a_fx_2_led,0)
	BlinkSet(~deck_b_fx_2_led,0)
	BlinkSet(~deck_a_fx_3_led,0)
	BlinkSet(~deck_b_fx_3_led,0)
	BlinkSet(~deck_a_jog_mode_led,0)
	BlinkSet(~deck_b_jog_mode_led,0)
	BlinkSet(~deck_a_cue_led,0)
	BlinkSet(~deck_b_cue_led,0)
	BlinkSet(~deck_a_playpause_led,0)
	BlinkSet(~deck_b_playpause_led,0)
# set slider mode LEDs (starts in Tempo mode)
	BlinkSet(~deck_a_slidermode_led,1)
	BlinkSet(~deck_b_slidermode_led,1)
# set default jog mode (currently 0 from declaration)
	VarSet($deck_a_jog_mode,1) # scratch
	VarSet($deck_b_jog_mode,1) # scratch
# turn x-fader audio mode on / video mode off
	midiOut(0xB0:0x50:0x61)	# audio mode on
	midiOut(0xB0:0x51:0x62)	# video mode off
# get current OtsAV state
	avStateRequest() # will generate appropriate Load, Play, etc events
# activate video master functionality
	avVideoMaster(E)
# enable playlist navigation	
	avPlaylistNav(E)
}



# ******* Respond to OtsAV/other events *******


########################################################
####### Deck A: Load/Cue/Play-Pause/Frame Search/etc
av[Load,A,E] { # Deck A Load (entered Loaded state)
	VarSet($deck_a_loaded,1) # save state for our own use
	BlinkSet(~deck_a_playpause_led,3) # medium blink
}
av[Load,A,D] { # Deck A Eject (left Loaded state)
	VarSet($deck_a_loaded,0) # clear state
	BlinkSet(~deck_a_playpause_led,0) # off
}
av[Play,A,E] { # Deck A Play (entered Playing state)
	VarSet($deck_a_playing,1) # save state for our own use
	BlinkSet(~deck_a_playpause_led,1) # on
}
av[Play,A,D] { # Deck A Stop (left Playing state)
	VarSet($deck_a_playing,0) # clear state
	BlinkSet(~deck_a_playpause_led,3) # medium blink
}
av[Cued,A,E] { # Deck A entered Cued state
	BlinkSet(~deck_a_cue_led,1) # on
}
av[Cued,A,D] { # Deck A left Cued state
	BlinkSet(~deck_a_cue_led,0) # off
}
av[PreMix,A,E] { # Deck A entered Pre-mix state
	BlinkSet(~deck_a_playpause_led,4) # fast blink
}
av[PreMix,A,D] { # Deck A left Pre-mix state
	BlinkSet(~deck_a_playpause_led,3) # medium blink
}
av[FrameSearch,A,E] { # Deck A entered Frame Search mode
	VarSet($deck_a_frame_search,1) # save state for our own use
	VarSet($deck_a_search_spin_counter,16)
	BlinkSet(~deck_a_cue_led,4) # fast blink
}
av[FrameSearch,A,D] { # Deck A left Frame Search mode
	VarSet($deck_a_frame_search,0) # clear state
	BlinkSet(~deck_a_cue_led,0) # off
}

####### Deck B: Load/Cue/Play-Pause/Frame Search/etc
av[Load,B,E] { # Deck B Load (entered Loaded state)
	VarSet($deck_b_loaded,1) # save state for our own use
	BlinkSet(~deck_b_playpause_led,3) # medium blink
}
av[Load,B,D] { # Deck B Eject (left Loaded state)
	VarSet($deck_b_loaded,0) # clear state
	BlinkSet(~deck_b_playpause_led,0) # off
}
av[Play,B,E] { # Deck B Play (entered Playing state)
	VarSet($deck_b_playing,1) # save state for our own use
	BlinkSet(~deck_b_playpause_led,1) # on
}
av[Play,B,D] { # Deck B Stop (left Playing state)
	VarSet($deck_b_playing,0) # clear state
	BlinkSet(~deck_b_playpause_led,3) # medium blink
}
av[Cued,B,E] { # Deck B entered Cued state
	BlinkSet(~deck_b_cue_led,1) # on
}
av[Cued,B,D] { # Deck B left Cued state
	BlinkSet(~deck_b_cue_led,0) # off
}
av[PreMix,B,E] { # Deck B entered Pre-mix state
	BlinkSet(~deck_b_playpause_led,4) # fast blink
}
av[PreMix,B,D] { # Deck B left Pre-mix state
	BlinkSet(~deck_b_playpause_led,3) # medium blink
}
av[FrameSearch,B,E] { # Deck B entered Frame Search mode
	VarSet($deck_b_frame_search,1) # save state for our own use
	VarSet($deck_b_search_spin_counter,16)
	BlinkSet(~deck_b_cue_led,4) # fast blink
}
av[FrameSearch,B,D] { # Deck B left Frame Search mode
	VarSet($deck_b_frame_search,0) # clear state
	BlinkSet(~deck_b_cue_led,0) # off
}


########################################################
####### Deck A: Primary transport controls
midi.trigger[0x90:0x43:0x40] { # Deck A Play/Pause button down
	($global_shift=0)	avPlayPause(A,E)
	($global_shift=1)	avPlay(A)
}
midi.trigger[0x80:0x43:0x00] { # Deck A Play/Pause button up
	avPlayPause(A,D)
}
midi.trigger[0x90:0x42:0x40] { # Deck A Cue button down
	($global_shift=0)	SubCall(@deck_a_cue_no_shift)
	($global_shift=1)	avCueSet(A)
}
sub[@deck_a_cue_no_shift] { # Deck A Cue button down without shift
	($deck_a_scratch=0)	avCue(A,E)
	($deck_a_scratch=1)	avCueSet(A)
}
midi.trigger[0x80:0x42:0x00] { # Deck A Cue button up
	avCue(A,D)
}
midi.trigger[0x90:0x0D:0x40] { # Deck A Frame Search (back) button down
	($global_shift=1)	avFrameSearch(A,-1)
}
midi.trigger[0x90:0x0C:0x40] { # Deck A Frame Search (forward) button down
	($global_shift=1)	avFrameSearch(A,+1)
}
midi.relval[0xB0:0x51,0x00,0xC0,0x40]	($deck_a_frame_search=1)	VarDec($deck_a_search_spin_counter)
midi.relval[0xB0:0x51,0x40,0xC0,0x40]	($deck_a_frame_search=1)	VarInc($deck_a_search_spin_counter)
midi.relval[0xB0:0x52,0x00,0xC0,0x40]	($deck_a_frame_search=1)	VarDec($deck_a_search_spin_counter)
midi.relval[0xB0:0x52,0x40,0xC0,0x40]	($deck_a_frame_search=1)	VarInc($deck_a_search_spin_counter)
var.set[$deck_a_search_spin_counter=0] {
	($deck_a_search_rate=0)	avFrameSearch(A,-1)
	($deck_a_search_rate=1)	avFrameSearch(A,-5)
	($deck_a_search_rate=2)	avFrameSearch(A,-20)
	VarInc($deck_a_search_rate)
	VarSet($deck_a_search_spin_counter,33)
}
var.set[$deck_a_search_spin_counter=34] {
	($deck_a_search_rate=0)	avFrameSearch(A,+1)
	($deck_a_search_rate=1)	avFrameSearch(A,+5)
	($deck_a_search_rate=2)	avFrameSearch(A,+20)
	VarInc($deck_a_search_rate)
	VarSet($deck_a_search_spin_counter,1)
}
timer.tick	VarDec($deck_a_search_rate)

####### Deck B: Primary transport controls
midi.trigger[0x92:0x43:0x40] { # Deck B Play/Pause button down
	($global_shift=0)	avPlayPause(B,E)
	($global_shift=1)	avPlay(B)
}
midi.trigger[0x82:0x43:0x00] { # Deck B Play/Pause button up
	avPlayPause(B,D)
}
midi.trigger[0x92:0x42:0x40] { # Deck B Cue button down
	($global_shift=0)	SubCall(@deck_b_cue_no_shift)
	($global_shift=1)	avCueSet(B)
}
sub[@deck_b_cue_no_shift] { # Deck B Cue button down without shift
	($deck_b_scratch=0)	avCue(B,E)
	($deck_b_scratch=1)	avCueSet(B)
}
midi.trigger[0x82:0x42:0x00] { # Deck B Cue button up
	avCue(B,D)
}
midi.trigger[0x92:0x0D:0x40] { # Deck B Frame Search (back) button down
	($global_shift=1)	avFrameSearch(B,-1)
}
midi.trigger[0x92:0x0C:0x40] { # Deck B Frame Search (forward) button down
	($global_shift=1)	avFrameSearch(B,+1)
}
midi.relval[0xB2:0x51,0x00,0xC0,0x40]	($deck_b_frame_search=1)	VarDec($deck_b_search_spin_counter)
midi.relval[0xB2:0x51,0x40,0xC0,0x40]	($deck_b_frame_search=1)	VarInc($deck_b_search_spin_counter)
midi.relval[0xB2:0x52,0x00,0xC0,0x40]	($deck_b_frame_search=1)	VarDec($deck_b_search_spin_counter)
midi.relval[0xB2:0x52,0x40,0xC0,0x40]	($deck_b_frame_search=1)	VarInc($deck_b_search_spin_counter)
var.set[$deck_b_search_spin_counter=0] {
	($deck_b_search_rate=0)	avFrameSearch(B,-1)
	($deck_b_search_rate=1)	avFrameSearch(B,-5)
	($deck_b_search_rate=2)	avFrameSearch(B,-20)
	VarInc($deck_b_search_rate)
	VarSet($deck_b_search_spin_counter,33)
}
var.set[$deck_b_search_spin_counter=34] {
	($deck_b_search_rate=0)	avFrameSearch(B,+1)
	($deck_b_search_rate=1)	avFrameSearch(B,+5)
	($deck_b_search_rate=2)	avFrameSearch(B,+20)
	VarInc($deck_b_search_rate)
	VarSet($deck_b_search_spin_counter,1)
}
timer.tick	VarDec($deck_b_search_rate)


########################################################
####### Deck A: Shift key
midi.trigger[0x90:0x60:0x40]	VarSet($deck_a_shift,1)
midi.trigger[0x80:0x60:0x00]	VarSet($deck_a_shift,0)

####### Deck B: Shift key
midi.trigger[0x92:0x61:0x40]	VarSet($deck_b_shift,1)
midi.trigger[0x82:0x61:0x00]	VarSet($deck_b_shift,0)

####### Global Shift state
var.set[$deck_a_shift=1] {
	VarSet($global_shift,1)
	($deck_b_shift=1)	avNext() # "mix now" when both shifts pressed
}
var.set[$deck_a_shift=0]	($deck_b_shift=0)	VarSet($global_shift,0)
var.set[$deck_b_shift=1] {
	VarSet($global_shift,1)
	($deck_a_shift=1)	avNext() # "mix now" when both shifts pressed
}
var.set[$deck_b_shift=0]	($deck_a_shift=0)	VarSet($global_shift,0)


########################################################
####### Deck A: Jog mode/Bending/Scratching
midi.trigger[0x90:0x04:0x40] { # Deck A Jog Mode button down
	($deck_a_frame_search=0)	VarIncWrap($deck_a_jog_mode)
}
var.set[$deck_a_jog_mode=0]	{
	($deck_a_scratch=1)	VarSet($deck_a_scratch,0) # cancel scratching if enabled
	BlinkSet(~deck_a_jog_mode_led,0)
}
var.set[$deck_a_jog_mode=1]	{
	($deck_a_bend=1)	VarSet($deck_a_bend,0) # cancel bending if enabled
	BlinkSet(~deck_a_jog_mode_led,1)
}
var.set[$deck_a_playing=0] { # Deck A Stop (left Playing state)
	($deck_a_bend=1)	VarSet($deck_a_bend,0) # cancel bending if enabled
	($deck_a_bend_down=1)	VarSet($deck_a_bend_down,0) # cancel bend down if enabled
	($deck_a_bend_up=1)	VarSet($deck_a_bend_up,0) # cancel bend up if enabled
	($deck_a_scratch=1)	VarSet($deck_a_scratch,0) # cancel scratching if enabled
}
var.set[$deck_a_frame_search=1] { # Deck A entered Frame Search mode
	($deck_a_bend=1)	VarSet($deck_a_bend,0) # cancel bending if enabled
	($deck_a_scratch=1)	VarSet($deck_a_scratch,0) # cancel scratching if enabled
}
midi.trigger[0x90:0x51:0x40] { # Deck A Jog button down
	VarSet($deck_a_jog_button,1)
}
var.set[$deck_a_jog_button=1] {
	($deck_a_jog_mode=1)	SubCall(@deck_a_try_scratch)
}
sub[@deck_a_try_scratch]	($deck_a_playing=1)	SubCall(@deck_a_try_scratch2)
sub[@deck_a_try_scratch2] {
	($deck_a_frame_search=0)	VarSet($deck_a_scratch,1)
}
midi.trigger[0x80:0x51:0x00] { # Deck A Jog button up
	VarSet($deck_a_jog_button,0)
}
var.set[$deck_a_jog_button=0] {
	($deck_a_scratch_state!=1)	VarSet($deck_a_scratch,0) # cancel scratching if jog inactive
}
var.set[$deck_a_scratch=1] {
	avScratch(A,E,0.0)
	BlinkSet(~deck_a_cue_led,4) # fast blink
}
var.set[$deck_a_scratch=0] {
	avScratch(A,D,0.0)
	BlinkSet(~deck_a_cue_led,0)
}
sub[@deck_a_try_bend]	($deck_a_frame_search=0)	VarSet($deck_a_bend,1)
var.set[$deck_a_bend=1] {
	($deck_a_bend_down=1)	VarSet($deck_a_bend_down,0) # cancel bend down if enabled
	($deck_a_bend_up=1)	VarSet($deck_a_bend_up,0) # cancel bend up if enabled
	avBend(A,E,0.0)
}
var.set[$deck_a_bend=0] {
	avBend(A,D,0.0)
}
midi.velval[R,0xB0:0x52,0x40,0x40,0,2.9,0.1,$deck_a_bend_state,0]	($deck_a_jog_mode=0)	SubCall(@deck_a_jog_val_bend)
midi.velval[R,0xB0:0x51,0x40,0x40,0,1.2,0.3,$deck_a_scratch_state,0]	($deck_a_jog_mode=1)	SubCall(@deck_a_jog_val_scratch)
sub[@deck_a_jog_val_bend] { # new value from jog wheel
	($deck_a_bend=1)	avBendSet(A,_)
}
var.set[$deck_a_bend_state!=0] { # jog wheel active in bending mode
	($deck_a_playing=1)	SubCall(@deck_a_try_bend)
}
var.set[$deck_a_bend_state=0] { # jog wheel inactive in bending mode
	VarSet($deck_a_bend,0) # cancel bending
}
sub[@deck_a_jog_val_scratch] { # new value from jog wheel
	($deck_a_scratch=1)	avScratchSet(A,_)
}
var.set[$deck_a_scratch_state!=1] { # jog wheel inactive in scratching mode
	($deck_a_jog_button=0)	VarSet($deck_a_scratch,0) # cancel scratching if jog button not down
}
midi.trigger[0x90:0x0D:0x40]	($global_shift=0)	SubCall(@deck_a_bend_down_pressed) # check shift not pressed first
sub[@deck_a_bend_down_pressed]	($deck_a_playing=1)	VarSet($deck_a_bend_down,1)
midi.trigger[0x80:0x0D:0x00]	($deck_a_bend_down=1)	VarSet($deck_a_bend_down,0)
midi.trigger[0x90:0x0C:0x40]	($global_shift=0)	SubCall(@deck_a_bend_up_pressed) # check shift not pressed first
sub[@deck_a_bend_up_pressed]	($deck_a_playing=1)	VarSet($deck_a_bend_up,1)
midi.trigger[0x80:0x0C:0x00]	($deck_a_bend_up=1)	VarSet($deck_a_bend_up,0)
var.set[$deck_a_bend_down=1] {
	($deck_a_bend=1)	VarSet($deck_a_bend,0) # cancel bending if enabled
	($deck_a_bend_up=1)	VarSet($deck_a_bend_up,0) # cancel bend up if enabled
	avBend(A,E,-0.4) # bend down at 4%
}
var.set[$deck_a_bend_down=0] {
	avBend(A,D,0.0) # cancel bend down
}
var.set[$deck_a_bend_up=1] {
	($deck_a_bend=1)	VarSet($deck_a_bend,0) # cancel bending if enabled
	($deck_a_bend_down=1)	VarSet($deck_a_bend_down,0) # cancel bend down if enabled
	avBend(A,E,+0.4) # bend up at 4%
}
var.set[$deck_a_bend_up=0] {
	avBend(A,D,0.0) # cancel bend up
}
midi.trigger[0x90:0x5A:0x40]	avBendTempoModeSet(A,T)
av[BendTempoMode,A,D] {
	VarSet($deck_a_bend_tempo,0)
	($abm_active=0)	BlinkSet(~deck_a_fxch_3_led,0)
}
av[BendTempoMode,A,E] {
	VarSet($deck_a_bend_tempo,1)
	($abm_active=0)	BlinkSet(~deck_a_fxch_3_led,1)
}
midi.trigger[0x90:0x58:0x40]	avZorphingModeSet(A,T)
av[ZorphingMode,A,D] {
	VarSet($deck_a_zorphing,0)
	($abm_active=0)	BlinkSet(~deck_a_fxch_1_led,0)
}
av[ZorphingMode,A,E] {
	VarSet($deck_a_zorphing,1)
	($abm_active=0)	BlinkSet(~deck_a_fxch_1_led,3) # medium blink
}

####### Deck B: Jog mode/Bending/Scratching
midi.trigger[0x92:0x04:0x40] { # Deck B Jog Mode button down
	($deck_b_frame_search=0)	VarIncWrap($deck_b_jog_mode)
}
var.set[$deck_b_jog_mode=0]	{
	($deck_b_scratch=1)	VarSet($deck_b_scratch,0) # cancel scratching if enabled
	BlinkSet(~deck_b_jog_mode_led,0)
}
var.set[$deck_b_jog_mode=1]	{
	($deck_b_bend=1)	VarSet($deck_b_bend,0) # cancel bending if enabled
	BlinkSet(~deck_b_jog_mode_led,1)
}
var.set[$deck_b_playing=0] { # Deck B Stop (left Playing state)
	($deck_b_bend=1)	VarSet($deck_b_bend,0) # cancel bending if enabled
	($deck_b_bend_down=1)	VarSet($deck_b_bend_down,0) # cancel bend down if enabled
	($deck_b_bend_up=1)	VarSet($deck_b_bend_up,0) # cancel bend up if enabled
	($deck_b_scratch=1)	VarSet($deck_b_scratch,0) # cancel scratching if enabled
}
var.set[$deck_b_frame_search=1] { # Deck B entered Frame Search mode
	($deck_b_bend=1)	VarSet($deck_b_bend,0) # cancel bending if enabled
	($deck_b_scratch=1)	VarSet($deck_b_scratch,0) # cancel scratching if enabled
}
midi.trigger[0x92:0x51:0x40] { # Deck B Jog button down
	VarSet($deck_b_jog_button,1)
}
var.set[$deck_b_jog_button=1] {
	($deck_b_jog_mode=1)	SubCall(@deck_b_try_scratch)
}
sub[@deck_b_try_scratch]	($deck_b_playing=1)	SubCall(@deck_b_try_scratch2)
sub[@deck_b_try_scratch2] {
	($deck_b_frame_search=0)	VarSet($deck_b_scratch,1)
}
midi.trigger[0x82:0x51:0x00] { # Deck B Jog button up
	VarSet($deck_b_jog_button,0)
}
var.set[$deck_b_jog_button=0] {
	($deck_b_scratch_state!=1)	VarSet($deck_b_scratch,0) # cancel scratching if jog inactive
}
var.set[$deck_b_scratch=1] {
	avScratch(B,E,0.0)
	BlinkSet(~deck_b_cue_led,4) # fast blink
}
var.set[$deck_b_scratch=0] {
	avScratch(B,D,0.0)
	BlinkSet(~deck_b_cue_led,0)
}
sub[@deck_b_try_bend]	($deck_b_frame_search=0)	VarSet($deck_b_bend,1)
var.set[$deck_b_bend=1] {
	($deck_b_bend_down=1)	VarSet($deck_b_bend_down,0) # cancel bend down if enabled
	($deck_b_bend_up=1)	VarSet($deck_b_bend_up,0) # cancel bend up if enabled
	avBend(B,E,0.0)
}
var.set[$deck_b_bend=0] {
	avBend(B,D,0.0)
}
midi.velval[R,0xB2:0x52,0x40,0x40,0,2.9,0.1,$deck_b_bend_state,0]	($deck_b_jog_mode=0)	SubCall(@deck_b_jog_val_bend)
midi.velval[R,0xB2:0x51,0x40,0x40,0,1.2,0.3,$deck_b_scratch_state,0]	($deck_b_jog_mode=1)	SubCall(@deck_b_jog_val_scratch)
sub[@deck_b_jog_val_bend] { # new value from jog wheel
	($deck_b_bend=1)	avBendSet(B,_)
}
var.set[$deck_b_bend_state!=0] { # jog wheel active in bending mode
	($deck_b_playing=1)	SubCall(@deck_b_try_bend)
}
var.set[$deck_b_bend_state=0] { # jog wheel inactive in bending mode
	VarSet($deck_b_bend,0) # cancel bending
}
sub[@deck_b_jog_val_scratch] { # new value from jog wheel
	($deck_b_scratch=1)	avScratchSet(B,_)
}
var.set[$deck_b_scratch_state!=1] { # jog wheel inactive in scratching mode
	($deck_b_jog_button=0)	VarSet($deck_b_scratch,0) # cancel scratching if jog button not down
}
midi.trigger[0x92:0x0D:0x40]	($global_shift=0)	SubCall(@deck_b_bend_down_pressed) # check shift not pressed first
sub[@deck_b_bend_down_pressed]	($deck_b_playing=1)	VarSet($deck_b_bend_down,1)
midi.trigger[0x82:0x0D:0x00]	($deck_b_bend_down=1)	VarSet($deck_b_bend_down,0)
midi.trigger[0x92:0x0C:0x40]	($global_shift=0)	SubCall(@deck_b_bend_up_pressed) # check shift not pressed first
sub[@deck_b_bend_up_pressed]	($deck_b_playing=1)	VarSet($deck_b_bend_up,1)
midi.trigger[0x82:0x0C:0x00]	($deck_b_bend_up=1)	VarSet($deck_b_bend_up,0)
var.set[$deck_b_bend_down=1] {
	($deck_b_bend=1)	VarSet($deck_b_bend,0) # cancel bending if enabled
	($deck_b_bend_up=1)	VarSet($deck_b_bend_up,0) # cancel bend up if enabled
	avBend(B,E,-0.4) # bend down at 4%
}
var.set[$deck_b_bend_down=0] {
	avBend(B,D,0.0) # cancel bend down
}
var.set[$deck_b_bend_up=1] {
	($deck_b_bend=1)	VarSet($deck_b_bend,0) # cancel bending if enabled
	($deck_b_bend_down=1)	VarSet($deck_b_bend_down,0) # cancel bend down if enabled
	avBend(B,E,+0.4) # bend up at 4%
}
var.set[$deck_b_bend_up=0] {
	avBend(B,D,0.0) # cancel bend up
}
midi.trigger[0x90:0x5E:0x40]	avBendTempoModeSet(B,T)
av[BendTempoMode,B,D] {
	VarSet($deck_b_bend_tempo,0)
	($abm_active=0)	BlinkSet(~deck_b_fxch_3_led,0)
}
av[BendTempoMode,B,E] {
	VarSet($deck_b_bend_tempo,1)
	($abm_active=0)	BlinkSet(~deck_b_fxch_3_led,1)
}
midi.trigger[0x90:0x5C:0x40]	avZorphingModeSet(B,T)
av[ZorphingMode,B,D] {
	VarSet($deck_b_zorphing,0)
	($abm_active=0)	BlinkSet(~deck_b_fxch_1_led,0)
}
av[ZorphingMode,B,E] {
	VarSet($deck_b_zorphing,1)
	($abm_active=0)	BlinkSet(~deck_b_fxch_1_led,3) # medium blink
}


########################################################
####### Deck A: Bass/Mid/High EQ knobs
midi.absval[S,0xB0:0x04,0x00,0x40,0x7F] { # Deck A - Low EQ knob capture
	avEQGainBass(A,_) # Set Deck A Bass Level
}
midi.absval[S,0xB0:0x03,0x00,0x40,0x7F] { # Deck A - Mid EQ knob capture
	avEQGainMid(A,_) # Set Deck A Mid Level
}
midi.absval[S,0xB0:0x02,0x00,0x40,0x7F] { # Deck A - High EQ knob capture
	avEQGainHigh(A,_) # Set Deck A High Level
}

####### Deck B: Bass/Mid/High EQ knobs
midi.absval[S,0xB0:0x0A,0x00,0x40,0x7F] { # Deck B - Low EQ knob capture
	avEQGainBass(B,_) # Set Deck B Bass Level
}
midi.absval[S,0xB0:0x09,0x00,0x40,0x7F] { # Deck B - Mid EQ knob capture
	avEQGainMid(B,_) # Set Deck B Mid Level
}
midi.absval[S,0xB0:0x08,0x00,0x40,0x7F] { # Deck B - High EQ knob capture
	avEQGainHigh(B,_) # Set Deck B High Level
}


########################################################
####### Deck A: Bass/Mid/High cut
midi.trigger[0x90:0x15:0x40] { # Deck A FX-1 button down
	avEQCutBass(A,T) # Toggle Deck A Bass Cut
}
midi.trigger[0x90:0x12:0x40] { # Deck A FX-2 button down
	avEQCutMid(A,T) # Toggle Deck A Mid Cut
}
midi.trigger[0x90:0x13:0x40] { # Deck A FX-3 button down
	avEQCutHigh(A,T) # Toggle Deck A High Cut
}
av[EQCutBass,A,E] { # Deck A Bass Cut enabled
	BlinkSet(~deck_a_fx_1_led,1)
}
av[EQCutBass,A,D] { # Deck A Bass Cut disabled
	BlinkSet(~deck_a_fx_1_led,0)
}
av[EQCutMid,A,E] { # Deck A Mid Cut enabled
	BlinkSet(~deck_a_fx_2_led,1)
}
av[EQCutMid,A,D] { # Deck A Mid Cut disabled
	BlinkSet(~deck_a_fx_2_led,0)
}
av[EQCutHigh,A,E] { # Deck A High Cut enabled
	BlinkSet(~deck_a_fx_3_led,1)
}
av[EQCutHigh,A,D] { # Deck A High Cut disabled
	BlinkSet(~deck_a_fx_3_led,0)
}

####### Deck B: Bass/Mid/High cut
midi.trigger[0x90:0x55:0x40] { # Deck B FX-1 button down
	avEQCutBass(B,T) # Toggle Deck B Bass Cut
}
midi.trigger[0x90:0x52:0x40] { # Deck B FX-2 button down
	avEQCutMid(B,T) # Toggle Deck B Mid Cut
}
midi.trigger[0x90:0x53:0x40] { # Deck B FX-3 button down
	avEQCutHigh(B,T) # Toggle Deck B High Cut
}
av[EQCutBass,B,E] { # Deck B Bass Cut enabled
	BlinkSet(~deck_b_fx_1_led,1)
}
av[EQCutBass,B,D] { # Deck B Bass Cut disabled
	BlinkSet(~deck_b_fx_1_led,0)
}
av[EQCutMid,B,E] { # Deck B Mid Cut enabled
	BlinkSet(~deck_b_fx_2_led,1)
}
av[EQCutMid,B,D] { # Deck B Mid Cut disabled
	BlinkSet(~deck_b_fx_2_led,0)
}
av[EQCutHigh,B,E] { # Deck B High Cut enabled
	BlinkSet(~deck_b_fx_3_led,1)
}
av[EQCutHigh,B,D] { # Deck B High Cut disabled
	BlinkSet(~deck_b_fx_3_led,0)
}


########################################################
####### Cue A and Cue B button functionality
midi.trigger[0x90:0x01:0x40]	{
	avMixer.Cue(A,T) # Toggle Deck A Mixer Cue Button
}
midi.trigger[0x90:0x02:0x40]	{
	avMixer.Cue(B,T) # Toggle Deck B Mixer Cue Button
}
av[Mixer.Cue,A,E] {
	BlinkSet(~deck_a_cueselect_led,1)
}
av[Mixer.Cue,B,E] {
	BlinkSet(~deck_b_cueselect_led,1)
}
av[Mixer.Cue,A,D] {
	BlinkSet(~deck_a_cueselect_led,0)
}
av[Mixer.Cue,B,D] {
	BlinkSet(~deck_b_cueselect_led,0)
}


########################################################
####### Mixer Level Sliders / Gain Knobs
# Note: Disable knob or slider code with comment character (#) if you want to change preference

####### Level Sliders
midi.absval[S,0xB0:0x05,0x00,0x3F,0x7F]	{
	($global_shift=0)	avLevelSet(A,_) # Sets Deck A level on OtsAV Mixer
	($global_shift=1)	avLevelSet(A,_,F0|F4) # bypass sync logic and snap value
}
midi.absval[S,0xB0:0x0B,0x00,0x3F,0x7F]	{
	($global_shift=0)	avLevelSet(B,_) # Sets Deck B level on OtsAV Mixer
	($global_shift=1)	avLevelSet(B,_,F0|F4) # bypass sync logic and snap value
}

####### Gain Knobs
#midi.absval[S,0xB0:0x01,0x00,0x3F,0x7F]	{
#	($global_shift=0)	avLevelSet(A,_) # Sets Deck A level on OtsAV Mixer
#	($global_shift=1)	avLevelSet(A,_,F0|F4) # bypass sync logic and snap value
#}
#midi.absval[S,0xB0:0x07,0x00,0x3F,0x7F]	{
#	($global_shift=0)	avLevelSet(B,_) # Sets Deck B level on OtsAV Mixer
#	($global_shift=1)	avLevelSet(B,_,F0|F4) # bypass sync logic and snap value
#}


########################################################
####### Deck A: Slider/slider mode/slider range
midi.absval[D,0xE0,1,7,0x7F7F,0x0040,0x0000]	SubCall(@deck_a_slider_val)
sub[@deck_a_slider_val] { # new value from slider
	($deck_a_slider_index=0)	SubCall(@deck_a_slider_val_tempo)
	($deck_a_slider_index=1)	SubCall(@deck_a_slider_val_pitch)
	($deck_a_slider_index=2)	SubCall(@deck_a_slider_val_direction)
}
sub[@deck_a_slider_val_tempo] { # slider pos -- tempo
	($global_shift=0)	avTempoSet(A,_) # normal sync logic
	($global_shift=1)	avTempoSet(A,_,F1) # force synced state
}
sub[@deck_a_slider_val_pitch] { # slider pos -- pitch
	($global_shift=0)	avPitchSet(A,_) # normal sync logic
	($global_shift=1)	avPitchSet(A,_,F1) # force synced state
}
sub[@deck_a_slider_val_direction] { # slider pos -- direction
	($global_shift=0)	avDirectionSet(A,_) # normal sync logic
	($global_shift=1)	avDirectionSet(A,_,F0|F4) # bypass sync logic and snap value
}
midi.trigger[0x90:0x06:0x40] { # slider mode (key lock) / range button down
	($global_shift=0)	VarIncWrap($deck_a_slider_index)
	($global_shift=1)	SubCall(@deck_a_slider_range)
}
sub[@deck_a_slider_range] { # cycle to next range
	($deck_a_slider_index=0)	avSliderRangeSet.Tempo(A,0)
	($deck_a_slider_index=1)	avSliderRangeSet.Pitch(A,0)
}
var.set[$deck_a_slider_index=0] { # Tempo
	avTempoSet(A,0.0,F2|F6|F7) # init sync from Direction
	BlinkSet(~deck_a_slidermode_led,1)
	avPitchSet(A,0.0,F5) # force pitch slider to be visible (would be direction)
}
var.set[$deck_a_slider_index=1] { # Pitch
	avPitchSet(A,0.0,F2|F6) # init sync from Tempo
	BlinkSet(~deck_a_slidermode_led,0)
}
var.set[$deck_a_slider_index=2] { # Direction
	avDirectionSet(A,0.0,F2|F7) # init sync from Pitch
	BlinkSet(~deck_a_slidermode_led,4) # fast blink
}
av[SliderRangeNew.Tempo,A] {
	($deck_a_slider_index=0)	avTempoSet(A,0.0,F2|F6) # init sync from Tempo
}
av[SliderRangeNew.Pitch,A] {
	($deck_a_slider_index=1)	avPitchSet(A,0.0,F2|F7) # init sync from Pitch
}
midi.trigger[0x90:0x6B:0x40] {
	avBPMMatch.Tempo(A)
}

####### Deck B: Slider/slider mode/slider range
midi.absval[D,0xE2,1,7,0x7F7F,0x0040,0x0000]	SubCall(@deck_b_slider_val)
sub[@deck_b_slider_val] { # new value from slider
	($deck_b_slider_index=0)	SubCall(@deck_b_slider_val_tempo)
	($deck_b_slider_index=1)	SubCall(@deck_b_slider_val_pitch)
	($deck_b_slider_index=2)	SubCall(@deck_b_slider_val_direction)
}
sub[@deck_b_slider_val_tempo] { # slider pos -- tempo
	($global_shift=0)	avTempoSet(B,_) # normal sync logic
	($global_shift=1)	avTempoSet(B,_,F1) # force synced state
}
sub[@deck_b_slider_val_pitch] { # slider pos -- pitch
	($global_shift=0)	avPitchSet(B,_) # normal sync logic
	($global_shift=1)	avPitchSet(B,_,F1) # force synced state
}
sub[@deck_b_slider_val_direction] { # slider pos -- direction
	($global_shift=0)	avDirectionSet(B,_) # normal sync logic
	($global_shift=1)	avDirectionSet(B,_,F0|F4) # bypass sync logic and snap value
}
midi.trigger[0x92:0x06:0x40] { # slider mode (key lock) / range button down
	($global_shift=0)	VarIncWrap($deck_b_slider_index)
	($global_shift=1)	SubCall(@deck_b_slider_range)
}
sub[@deck_b_slider_range] { # cycle to next range
	($deck_b_slider_index=0)	avSliderRangeSet.Tempo(B,0)
	($deck_b_slider_index=1)	avSliderRangeSet.Pitch(B,0)
}
var.set[$deck_b_slider_index=0] { # Tempo
	avTempoSet(B,0.0,F2|F6|F7) # init sync from Direction
	BlinkSet(~deck_b_slidermode_led,1)
	avPitchSet(B,0.0,F5) # force pitch slider to be visible (would be direction)
}
var.set[$deck_b_slider_index=1] { # Pitch
	avPitchSet(B,0.0,F2|F6) # init sync from Tempo
	BlinkSet(~deck_b_slidermode_led,0)
}
var.set[$deck_b_slider_index=2] { # Direction
	avDirectionSet(B,0.0,F2|F7) # init sync from Pitch
	BlinkSet(~deck_b_slidermode_led,4) # fast blink
}
av[SliderRangeNew.Tempo,B] {
	($deck_b_slider_index=0)	avTempoSet(B,0.0,F2|F6) # init sync from Tempo
}
av[SliderRangeNew.Pitch,B] {
	($deck_b_slider_index=1)	avPitchSet(B,0.0,F2|F7) # init sync from Pitch
}
midi.trigger[0x92:0x6B:0x40] {
	avBPMMatch.Tempo(B)
}


########################################################
####### Deck A: Video Block/Master functionality
midi.trigger[0x90:0x59:0x40]	avVideoBlock(A,T) # toggle video block
av[VideoBlock,A,E] {
	VarSet($deck_a_video_block,1)
	($abm_active=0)	BlinkSet(~deck_a_fxch_2_led,3) # medium blink
}
av[VideoBlock,A,D] {
	VarSet($deck_a_video_block,0)
	($abm_active=0)	BlinkSet(~deck_a_fxch_2_led,0)
}
midi.trigger[0x90:0x5B:0x40] { # Deck A Master Video (FX CH 4) button down
	($video_master!=0)	avVideoMasterSet(A) # set as video master
	($video_master=0)	avVideoMasterSet(B) # make other deck master
}
av[VideoMasterSet,A] {
	VarSet($video_master,0)
	($abm_active=0)	BlinkSet(~deck_a_fxch_4_led,1)
	($abm_active=0)	BlinkSet(~deck_b_fxch_4_led,0)
}

####### Deck B: Video Block/Master functionality
midi.trigger[0x90:0x5D:0x40]	avVideoBlock(B,T) # toggle video block
av[VideoBlock,B,E] {
	VarSet($deck_b_video_block,1)
	($abm_active=0)	BlinkSet(~deck_b_fxch_2_led,3) # medium blink
}
av[VideoBlock,B,D] {
	VarSet($deck_b_video_block,0)
	($abm_active=0)	BlinkSet(~deck_b_fxch_2_led,0)
}
midi.trigger[0x90:0x5F:0x40] { # Deck B Master Video (FX CH 4) button down
	($video_master!=1)	avVideoMasterSet(B) # set as video master
	($video_master=1)	avVideoMasterSet(A) # make other deck master
}
av[VideoMasterSet,B] {
	VarSet($video_master,1)
	($abm_active=0)	BlinkSet(~deck_b_fxch_4_led,1)
	($abm_active=0)	BlinkSet(~deck_a_fxch_4_led,0)
}


########################################################
####### Playlist Navigation
midi.trigger[0x90:0x30:0x40]	avPlaylistNav(T) # Back button pressed
midi.trigger[0x90:0x29:0x40]	avPlaylistNav(T) # Fwd button pressed
midi.trigger[0x90:0x28:0x40]	avPlaylistNav(T) # Knob button pressed
midi.trigger[0xB0:0x54:0x7F]	($global_shift=0)	avPlaylistNav.Walk(-1) # Knob anti-clockwise
midi.trigger[0xB0:0x54:0x7F]	($global_shift=1)	avPlaylistNav.Walk(-3) # Knob anti-clockwise shifted
midi.trigger[0xB0:0x54:0x00]	($global_shift=0)	avPlaylistNav.Walk(+1) # Knob clockwise
midi.trigger[0xB0:0x54:0x00]	($global_shift=1)	avPlaylistNav.Walk(+3) # Knob clockwise shifted
midi.trigger[0x90:0x62:0x40]	($deck_a_playing=0)	Subcall(@deck_a_playlist_loadnext) # Load A button pressed
sub[@deck_a_playlist_loadnext] { # load next item from playlist
	($global_shift=0)	avPlaylistNav.Load(A,F1) # Load selected item
	($global_shift=1)	avLoadNext(A,F1) # Load next item (shifted)
}
midi.trigger[0x92:0x63:0x40]	($deck_b_playing=0)	Subcall(@deck_b_playlist_loadnext) # Load B button pressed
sub[@deck_b_playlist_loadnext] { # load next item from playlist
	($global_shift=0)	avPlaylistNav.Load(B,F1) # Load selected item
	($global_shift=1)	avLoadNext(B,F1) # Load next item (shifted)
}
av[PlaylistNav,D] {
	avPlaylistNav(T)
}


########################################################
####### Auto DJ / ABM
midi.trigger[0x90:0x16:0x40]	avAutoDJ(T)
av[AutoDJ,E] {
	VarSet($autodj_enabled,1)
	BlinkSet(~autodj_led,1)
	($abm_enabled=1)	BlinkSet(~autobm_led,1)
}
av[AutoDJ,D] {
	VarSet($autodj_enabled,0)
	BlinkSet(~autodj_led,0)
	BlinkSet(~autobm_led,0)	
}
midi.trigger[0x90:0x1E:0x40]	avABM(T)
av[ABM,E]	VarSet($abm_enabled,1)
av[ABM,E]	BlinkSet(~autobm_led,1)
av[ABM,D]	VarSet($abm_enabled,0)
av[ABM,D]	BlinkSet(~autobm_led,0)
midi.trigger[0x80:0x1E:0x00]	($autodj_enabled=0)	BlinkSet(~autobm_led,0) # turn off Auto-BM led on button up if Auto DJ disabled 


########################################################
####### ABM Active
av[ABMActive,E] {
	VarSet($abm_active,1)
}
av[ABMActive,D] {
	VarSet($abm_active,0)
}
var.set[$abm_active=1] {
	BlinkSet(~deck_a_fxch_3_led,4) # fast blink
	BlinkSet(~deck_a_fxch_1_led,12) # inverse fast blink
	BlinkSet(~deck_a_fxch_2_led,4)
	BlinkSet(~deck_a_fxch_4_led,12)
	BlinkSet(~deck_a_fx_tap_led,4)
	BlinkSet(~deck_b_fxch_3_led,12)
	BlinkSet(~deck_b_fxch_1_led,4)
	BlinkSet(~deck_b_fxch_2_led,12)
	BlinkSet(~deck_b_fxch_4_led,4)
	BlinkSet(~deck_b_fx_tap_led,12)
}
var.set[$abm_active=0] {
	($deck_a_bend_tempo=0)	BlinkSet(~deck_a_fxch_3_led,0)
	($deck_a_bend_tempo=1)	BlinkSet(~deck_a_fxch_3_led,1)
	($deck_a_zorphing=0)	BlinkSet(~deck_a_fxch_1_led,0)
	($deck_a_zorphing=1)	BlinkSet(~deck_a_fxch_1_led,3) # medium blink
	($deck_a_video_block=0)	BlinkSet(~deck_a_fxch_2_led,0)
	($deck_a_video_block=1)	BlinkSet(~deck_a_fxch_2_led,3) # medium blink
	($video_master=0)	BlinkSet(~deck_a_fxch_4_led,1)
	($video_master!=0)	BlinkSet(~deck_a_fxch_4_led,0)
	BlinkSet(~deck_a_fx_tap_led,0)
	($deck_b_bend_tempo=0)	BlinkSet(~deck_b_fxch_3_led,0)
	($deck_b_bend_tempo=1)	BlinkSet(~deck_b_fxch_3_led,1)
	($deck_b_zorphing=0)	BlinkSet(~deck_b_fxch_1_led,0)
	($deck_b_zorphing=1)	BlinkSet(~deck_b_fxch_1_led,3) # medium blink
	($deck_b_video_block=0)	BlinkSet(~deck_b_fxch_2_led,0)
	($deck_b_video_block=1)	BlinkSet(~deck_b_fxch_2_led,3) # medium blink
	($video_master=1)	BlinkSet(~deck_b_fxch_4_led,1)
	($video_master!=1)	BlinkSet(~deck_b_fxch_4_led,0)
	BlinkSet(~deck_b_fx_tap_led,0)
}
av[ABMBeat.1] {
	($abm_active=1)	BlinkSet(~deck_a_fxch_3_led,1)
	($abm_active=1)	BlinkSet(~deck_b_fxch_3_led,1)
	($abm_active=1)	BlinkSet(~deck_a_fx_tap_led,1)
	($abm_active=1)	BlinkSet(~deck_b_fx_tap_led,1)
	($abm_active=1)	BlinkSet(~deck_a_fxch_4_led,0)
	($abm_active=1)	BlinkSet(~deck_b_fxch_4_led,0)
}
av[ABMBeat.2] {
	($abm_active=1)	BlinkSet(~deck_a_fxch_1_led,1)
	($abm_active=1)	BlinkSet(~deck_b_fxch_1_led,1)
	($abm_active=1)	BlinkSet(~deck_a_fxch_3_led,0)
	($abm_active=1)	BlinkSet(~deck_b_fxch_3_led,0)
	($abm_active=1)	BlinkSet(~deck_a_fx_tap_led,0)
	($abm_active=1)	BlinkSet(~deck_b_fx_tap_led,0)
}
av[ABMBeat.3] {
	($abm_active=1)	BlinkSet(~deck_a_fxch_2_led,1)
	($abm_active=1)	BlinkSet(~deck_b_fxch_2_led,1)
	($abm_active=1)	BlinkSet(~deck_a_fxch_1_led,0)
	($abm_active=1)	BlinkSet(~deck_b_fxch_1_led,0)
}
av[ABMBeat.4] {
	($abm_active=1)	BlinkSet(~deck_a_fxch_4_led,1)
	($abm_active=1)	BlinkSet(~deck_b_fxch_4_led,1)
	($abm_active=1)	BlinkSet(~deck_a_fxch_2_led,0)
	($abm_active=1)	BlinkSet(~deck_b_fxch_2_led,0)
}


########################################################
####### X-fader slider
midi.trigger[0xB0:0x4B:0x02] { # turn x-fader audio mode on / video mode off if X-F LINK button pressed (defeat toggle)
	midiOut(0xB0:0x50:0x61)	# audio mode on
	midiOut(0xB0:0x51:0x62)	# video mode off
}
midi.absval[S,0xB0:0x16,0x00,0x3F,0x7F]	avXFaderSet(_)


########################################################
####### Deck A: Looping functionality
# maintain button states for plus, a1 (in button), a2 (auto-loop button) & minus
midi.trigger[0x90:0x6A:0x40]	VarSet($deck_a_plus,1)
midi.trigger[0x80:0x6A:0x00]	VarSet($deck_a_plus,0)
midi.trigger[0x90:0x37:0x40]	VarSet($deck_a_a1,1)
midi.trigger[0x80:0x37:0x00]	VarSet($deck_a_a1,0)
midi.trigger[0x90:0x1D:0x40]	VarSet($deck_a_a2,1)
midi.trigger[0x80:0x1D:0x00]	VarSet($deck_a_a2,0)
midi.trigger[0x90:0x69:0x40]	VarSet($deck_a_minus,1)
midi.trigger[0x80:0x69:0x00]	VarSet($deck_a_minus,0)
# maintain $deck_a_mod: 0 = neither buttons held,
# 1 = plus held, 2 = minus held, 3 = both held
var.set[$deck_a_plus=1] {
	($deck_a_minus=0) VarSet($deck_a_mod,1)
	($deck_a_minus=1) VarSet($deck_a_mod,3)
}
var.set[$deck_a_plus=0] {
	($deck_a_minus=0) VarSet($deck_a_mod,0)
	($deck_a_minus=1) VarSet($deck_a_mod,2)
}
var.set[$deck_a_minus=1] {
	($deck_a_plus=0) VarSet($deck_a_mod,2)
	($deck_a_plus=1) VarSet($deck_a_mod,3)
}
var.set[$deck_a_minus=0] {
	($deck_a_plus=0) VarSet($deck_a_mod,0)
	($deck_a_plus=1) VarSet($deck_a_mod,1)
}
# dispatch commands
midi.trigger[0x90:0x37:0x40]	($deck_a_loaded=1)	Subcall(@deck_a_try_loop1_press) # Loop A1 (in button) pressed (only execute if Deck A loaded)
sub[@deck_a_try_loop1_press] {
	($deck_a_mod=0) avLooping.MarkA.1(A)
	($deck_a_mod=0) BlinkSet(~deck_a_loop_in_led,1)
	($deck_a_mod=0) BlinkSet(~deck_a_loop_out_led,4)
	($deck_a_mod=2) avLooping.EnterLoop.1(A)
	($deck_a_mod=2) BlinkSet(~deck_a_loop_in_led,1)
	BlinkSet(~deck_a_loop_auto_led,0)
}
midi.trigger[0x90:0x1D:0x40]	($deck_a_loaded=1)	Subcall(@deck_a_try_loop2_press) # Loop A2 (auto-loop button) pressed (only execute if Deck A loaded)
sub[@deck_a_try_loop2_press] {
	($deck_a_mod=0) avLooping.MarkA.2(A)
	($deck_a_mod=0) BlinkSet(~deck_a_loop_auto_led,1)
	($deck_a_mod=0) BlinkSet(~deck_a_loop_out_led,4)
	($deck_a_mod=2) avLooping.EnterLoop.2(A)
	($deck_a_mod=2) BlinkSet(~deck_a_loop_auto_led,1)
	BlinkSet(~deck_a_loop_in_led,0)
}
midi.trigger[0x90:0x39:0x40] { # B (out button)
	($deck_a_mod=0) avLooping.MarkB(A)
	($deck_a_mod=1) avLooping.MarkB(A,F0) # suppress beat-snapping
	BlinkSet(~deck_a_loop_out_led,0)
}
midi.trigger[0x90:0x69:0x40] { # Exit/reloop (minus button)
	avLooping.CancelAll(A,F0)
	BlinkSet(~deck_a_loop_in_led,0)
	BlinkSet(~deck_a_loop_auto_led,0)
	BlinkSet(~deck_a_loop_out_led,0)
}
midi.trigger[0x90:0x46:0x40] { # send beat trigger for BPM detection (tap button)
	avTapBPM(A)
}
var.set[$deck_a_loaded=0] { # Deck A ejected
	BlinkSet(~deck_a_loop_in_led,0)
	BlinkSet(~deck_a_loop_auto_led,0)
	BlinkSet(~deck_a_loop_out_led,0)
}

####### Deck B: Looping functionality
# maintain button states for plus, a1 (in button), a2 (auto-loop button) & minus
midi.trigger[0x92:0x6A:0x40]	VarSet($deck_b_plus,1)
midi.trigger[0x82:0x6A:0x00]	VarSet($deck_b_plus,0)
midi.trigger[0x92:0x37:0x40]	VarSet($deck_b_a1,1)
midi.trigger[0x82:0x37:0x00]	VarSet($deck_b_a1,0)
midi.trigger[0x92:0x1D:0x40]	VarSet($deck_b_a2,1)
midi.trigger[0x82:0x1D:0x00]	VarSet($deck_b_a2,0)
midi.trigger[0x92:0x69:0x40]	VarSet($deck_b_minus,1)
midi.trigger[0x82:0x69:0x00]	VarSet($deck_b_minus,0)
# maintain $deck_b_mod: 0 = neither buttons held,
# 1 = plus held, 2 = minus held, 3 = both held
var.set[$deck_b_plus=1] {
	($deck_b_minus=0) VarSet($deck_b_mod,1)
	($deck_b_minus=1) VarSet($deck_b_mod,3)
}
var.set[$deck_b_plus=0] {
	($deck_b_minus=0) VarSet($deck_b_mod,0)
	($deck_b_minus=1) VarSet($deck_b_mod,2)
}
var.set[$deck_b_minus=1] {
	($deck_b_plus=0) VarSet($deck_b_mod,2)
	($deck_b_plus=1) VarSet($deck_b_mod,3)
}
var.set[$deck_b_minus=0] {
	($deck_b_plus=0) VarSet($deck_b_mod,0)
	($deck_b_plus=1) VarSet($deck_b_mod,1)
}
# dispatch commands
midi.trigger[0x92:0x37:0x40]	($deck_b_loaded=1)	Subcall(@deck_b_try_loop1_press) # Loop A1 (in button) pressed (only execute if Deck B loaded)
sub[@deck_b_try_loop1_press] {
	($deck_b_mod=0) avLooping.MarkA.1(B)
	($deck_b_mod=0) BlinkSet(~deck_b_loop_in_led,1)
	($deck_b_mod=0) BlinkSet(~deck_b_loop_out_led,4)
	($deck_b_mod=2) avLooping.EnterLoop.1(B)
	($deck_b_mod=2) BlinkSet(~deck_b_loop_in_led,1)
	BlinkSet(~deck_b_loop_auto_led,0)
}
midi.trigger[0x92:0x1D:0x40]	($deck_b_loaded=1)	Subcall(@deck_b_try_loop2_press) # Loop A2 (auto-loop button) pressed (only execute if Deck B loaded)
sub[@deck_b_try_loop2_press] {
	($deck_b_mod=0) avLooping.MarkA.2(B)
	($deck_b_mod=0) BlinkSet(~deck_b_loop_auto_led,1)
	($deck_b_mod=0) BlinkSet(~deck_b_loop_out_led,4)
	($deck_b_mod=2) avLooping.EnterLoop.2(B)
	($deck_b_mod=2) BlinkSet(~deck_b_loop_auto_led,1)
	BlinkSet(~deck_b_loop_in_led,0)
}
midi.trigger[0x92:0x39:0x40] { # B (out button)
	($deck_b_mod=0) avLooping.MarkB(B)
	($deck_b_mod=1) avLooping.MarkB(B,F0) # suppress beat-snapping
	BlinkSet(~deck_b_loop_out_led,0)
}
midi.trigger[0x92:0x69:0x40] { # Exit/reloop (minus button)
	avLooping.CancelAll(B,F0)
	BlinkSet(~deck_b_loop_in_led,0)
	BlinkSet(~deck_b_loop_auto_led,0)
	BlinkSet(~deck_b_loop_out_led,0)
}
midi.trigger[0x90:0x47:0x40] { # send beat trigger for BPM detection (tap button)
	avTapBPM(B)
}
var.set[$deck_b_loaded=0] { # Deck B ejected
	BlinkSet(~deck_b_loop_in_led,0)
	BlinkSet(~deck_b_loop_auto_led,0)
	BlinkSet(~deck_b_loop_out_led,0)
}