/Macro/PixelMap/pixel.c

Large files files are truncated, but you can click here to view the full file

/* Copyright (C) 2015-2019 by Jacob Alexander
 *
 * This file is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This file is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this file.  If not, see <http://www.gnu.org/licenses/>.
 */

// ----- Includes -----

// Compiler Includes
#include <Lib/MacroLib.h>

// Project Includes
#include <Lib/storage.h>
#include <cli.h>
#include <layer.h>
#include <trigger.h>
#include <kll_defs.h>
#include <latency.h>
#include <led.h>
#include <print.h>
#include <output_com.h>

// Interconnect module if compiled in
#if defined(ConnectEnabled_define)
#include <connect_scan.h>
#endif

// Local Includes
#include "pixel.h"



// ----- Function Declarations -----

void Pixel_loadConfig();
void Pixel_saveConfig();
void Pixel_printConfig();

void cliFunc_aniAdd     ( char* args );
void cliFunc_aniDel     ( char* args );
void cliFunc_aniStack   ( char* args );
void cliFunc_chanTest   ( char* args );
void cliFunc_pixelList  ( char* args );
void cliFunc_pixelSCTest( char* args );
void cliFunc_pixelTest  ( char* args );
void cliFunc_pixelXYTest( char* args );
void cliFunc_rectDisp   ( char* args );



// ----- Enums -----

typedef enum PixelTest {
	PixelTest_Off                 = 0,   // Disabled
	PixelTest_Chan_Single         = 1,
	PixelTest_Chan_SingleReverse  = 2,
	PixelTest_Chan_All            = 3,   // Enable all positions
	PixelTest_Chan_Roll           = 4,   // Iterate over all positions
	PixelTest_Chan_Full           = 5,   // Turn on all pixels
	PixelTest_Chan_Off            = 6,   // Turn off all pixels
	PixelTest_Pixel_Single        = 10,
	PixelTest_Pixel_SingleReverse = 11,
	PixelTest_Pixel_All           = 12,  // Enable all positions
	PixelTest_Pixel_Roll          = 13,  // Iterate over all positions
	PixelTest_Pixel_Full          = 14,  // Turn on all pixels
	PixelTest_Pixel_Off           = 15,  // Turn off all pixels
	PixelTest_Scan_Single         = 20,
	PixelTest_Scan_SingleReverse  = 21,
	PixelTest_Scan_All            = 22,
	PixelTest_Scan_Roll           = 23,
	PixelTest_XY_Single           = 30,
	PixelTest_XY_SingleReverse    = 31,
	PixelTest_XY_All              = 32,
	PixelTest_XY_Roll             = 33,
} PixelTest;

typedef enum PixelFadeControl {
	PixelFadeControl_Reset                = 0, // Resets fade profile to defaults (arg ignored)
	PixelFadeControl_Reset_All            = 1, // Resets all fade profiles to defaults (profile, arg ignored)
	PixelFadeControl_Brightness_Set       = 2, // Sets fade profile to a given brightness
	PixelFadeControl_Brightness_Increment = 3, // Increment brightness by given amount
	PixelFadeControl_Brightness_Decrement = 4, // Decrement brightness by given amount
	PixelFadeControl_Brightness_Default   = 5, // Set profile brightness to default
	PixelFadeControl_LAST,
} PixelFadeControl;



// ----- Variables -----

typedef struct {
	uint8_t index;
	uint8_t pos;
} PixelConfigElem;

typedef struct {
	PixelConfigElem animations[Pixel_AnimationStackSize];
	PixelPeriodConfig fade_periods[4][4];
	uint8_t fade_brightness[4];
} PixelConfig;

static PixelConfig settings;

#if Storage_Enable_define == 1
static PixelConfig defaults;

static StorageModule PixelStorage = {
	.name = "Pixel Map",
	.settings = &settings,
	.defaults = &defaults,
	.size = sizeof(PixelConfig),
	.onLoad = Pixel_loadConfig,
	.onSave = Pixel_saveConfig,
	.display = Pixel_printConfig
};
#endif

// Macro Module command dictionary
CLIDict_Entry( aniAdd,       "Add the given animation id to the stack" );
CLIDict_Entry( aniDel,       "Remove the given stack index animation" );
CLIDict_Entry( aniStack,     "Displays the animation stack contents" );
CLIDict_Entry( chanTest,     "Channel test. No arg - next pixel. # - pixel, r - roll-through. a - all, s - stop" );
CLIDict_Entry( pixelList,    "Prints out pixel:channel mappings." );
CLIDict_Entry( pixelSCTest,  "Scancode pixel test. No arg - next pixel. # - pixel, r - roll-through. a - all, s - stop" );
CLIDict_Entry( pixelTest,    "Pixel test. No arg - next pixel. # - pixel, r - roll-through. a - all, s - stop, f - full" );
CLIDict_Entry( pixelXYTest,  "XY pixel test. No arg - next pixel. # - pixel, r - roll-through. a - all, s - stop" );
CLIDict_Entry( rectDisp,     "Show the current output of the MCU pixel buffer." );

CLIDict_Def( pixelCLIDict, "Pixel Module Commands" ) = {
	CLIDict_Item( aniAdd ),
	CLIDict_Item( aniDel ),
	CLIDict_Item( aniStack ),
	CLIDict_Item( chanTest ),
	CLIDict_Item( pixelList ),
	CLIDict_Item( pixelSCTest ),
	CLIDict_Item( pixelTest ),
	CLIDict_Item( pixelXYTest ),
	CLIDict_Item( rectDisp ),
	{ 0, 0, 0 } // Null entry for dictionary end
};

// Gamma correction
extern const uint8_t gamma_table[];
static uint8_t gamma_enabled;

// Debug states
PixelTest Pixel_testMode;
volatile uint16_t  Pixel_testPos = 0;

// Frame State
//  Indicates to pixel and output modules current state of the buffer
FrameState Pixel_FrameState;

// Animation Stack
AnimationStack Pixel_AnimationStack;

// Animation Control
AnimationControl Pixel_animationControl;

// Memory Stor for Animation Elements
// Animation elements may be called multiple times, thus memory must be allocated per instance
AnimationStackElement Pixel_AnimationElement_Stor[Pixel_AnimationStackSize];

#if defined(_host_)
uint16_t Pixel_AnimationStack_HostSize = Pixel_AnimationStackSize;
uint8_t  Pixel_Buffers_HostLen = Pixel_BuffersLen_KLL;
uint8_t  Pixel_MaxChannelPerPixel_Host = Pixel_MaxChannelPerPixel;
uint16_t Pixel_Mapping_HostLen = 128; // TODO Define
uint8_t  Pixel_AnimationStackElement_HostSize = sizeof( AnimationStackElement );
#endif

// Pixel Fade Profile Mapping
// Assigned per pixel (rather than channel)
// 0 - Disabled
// 1 - Profile 1 - Keys
// 2 - Profile 2 - Underlighting
// 3 - Profile 3 - Indicator LEDs
// 4 - Profile 4 - Current active layer (defaultmap is excluded)
static uint8_t Pixel_pixel_fade_profile[Pixel_TotalPixels_KLL];

// Pixel Fade Profile Parameters
// TODO (HaaTa): Use KLL to determine number of profiles (currently only 4)
static PixelFadeProfile Pixel_pixel_fade_profile_entries[4];

// Latency Measurement Resource
static uint8_t pixelLatencyResource;



// ----- Function Declarations -----

uint8_t Pixel_animationProcess( AnimationStackElement *elem );
uint8_t Pixel_addAnimation( AnimationStackElement *element, CapabilityState cstate );
uint8_t Pixel_determineLastTriggerScanCode( TriggerMacro *trigger );

void Pixel_pixelSet( PixelElement *elem, uint32_t value );
void Pixel_clearAnimations();

void Pixel_SecondaryProcessing_profile_init();

PixelBuf *Pixel_bufferMap( uint16_t channel );

AnimationStackElement *Pixel_lookupAnimation( uint16_t index, uint16_t prev );



// ----- Capabilities -----
//
void Pixel_GammaControl_capability( TriggerMacro *trigger, uint8_t state, uint8_t stateType, uint8_t *args )
{
	CapabilityState cstate = KLL_CapabilityState( state, stateType );

	switch ( cstate )
	{
	case CapabilityState_Initial:
		// Only use capability on press
		break;
	case CapabilityState_Debug:
		// Display capability name
		print("Pixel_GammaControl_capability(func)");
		return;
	default:
		return;
	}

	uint8_t arg  = *(uint8_t*)(&args[0]);

	// Interconnect broadcasting
#if defined(ConnectEnabled_define)
	// By default send to the *next* node, which will determine where to go next
	extern uint8_t Connect_id; // connect_scan.c
	uint8_t addr = Connect_id + 1;

	// Send interconnect remote capability packet
	// generatedKeymap.h
	extern const Capability CapabilitiesList[];

	// Broadcast layerStackExact remote capability (0xFF is the broadcast id)
	Connect_send_RemoteCapability(
		addr,
		Pixel_GammaControl_capability_index,
		state,
		stateType,
		CapabilitiesList[ Pixel_GammaControl_capability_index ].argCount,
		args
	);
#endif

	// Decide how to handle function
	switch ( arg )
	{
	case 0: // Disabled
		gamma_enabled = 0;
		break;
	case 1: // Enabled
		gamma_enabled = 1;
		break;
	default: // Toggle
		gamma_enabled = !gamma_enabled;
		break;
	}
}

void Pixel_AnimationIndex_capability( TriggerMacro *trigger, uint8_t state, uint8_t stateType, uint8_t *args )
{
	CapabilityState cstate = KLL_CapabilityState( state, stateType );

	switch ( cstate )
	{
	case CapabilityState_Initial:
	case CapabilityState_Last:
		// Mainly used on press
		// Except some configurations may also use release
		break;
	case CapabilityState_Debug:
		// Display capability name
		print("Pixel_AnimationIndex_capability(settingindex)");
		return;
	default:
		return;
	}

	// Interconnect broadcasting
#if defined(ConnectEnabled_define)
	// By default send to the *next* node, which will determine where to go next
	extern uint8_t Connect_id; // connect_scan.c
	uint8_t addr = Connect_id + 1;

	// Send interconnect remote capability packet
	// generatedKeymap.h
	extern const Capability CapabilitiesList[];

	// Broadcast layerStackExact remote capability (0xFF is the broadcast id)
	Connect_send_RemoteCapability(
		addr,
		Pixel_AnimationIndex_capability_index,
		state,
		stateType,
		CapabilitiesList[ Pixel_AnimationIndex_capability_index ].argCount,
		args
	);
#endif

	// Lookup animation settings
	uint16_t index = *(uint16_t*)(&args[0]);

	// Check if a valid setting
	if ( index >= Pixel_AnimationSettingsNum_KLL )
	{
		warn_msg("Invalid AnimationSetting index: ");
		printInt16( index );
		print( NL );
		return;
	}

	AnimationStackElement element = Pixel_AnimationSettings[ index ];
	element.trigger = trigger;

	Pixel_addAnimation( &element, cstate );
}

// XXX (HaaTa): It's not recommended to use this capability, use AnimationIndex instead
void Pixel_Animation_capability( TriggerMacro *trigger, uint8_t state, uint8_t stateType, uint8_t *args )
{
	CapabilityState cstate = KLL_CapabilityState( state, stateType );

	switch ( cstate )
	{
	case CapabilityState_Initial:
		// Only use capability on press
		break;
	case CapabilityState_Debug:
		// Display capability name
		print("Pixel_Animation_capability(index,loops,pfunc,framedelay,frameoption,replace)");
		return;
	default:
		return;
	}

	AnimationStackElement element;
	element.trigger = trigger;
	element.pos = 0; // TODO (HaaTa) Start at specific frame
	element.subpos = 0;
	element.index = *(uint16_t*)(&args[0]);
	element.loops = *(uint8_t*)(&args[2]);
	element.pfunc = *(uint8_t*)(&args[3]);
	element.framedelay = *(uint8_t*)(&args[4]);
	element.frameoption = *(uint8_t*)(&args[5]);
	element.replace = *(uint8_t*)(&args[6]);

	Pixel_addAnimation( &element, cstate );
}

// XXX (HaaTa): TODO
void Pixel_Pixel_capability( TriggerMacro *trigger, uint8_t state, uint8_t stateType, uint8_t *args )
{
	CapabilityState cstate = KLL_CapabilityState( state, stateType );

	switch ( cstate )
	{
	case CapabilityState_Initial:
		// Only use capability on press
		break;
	case CapabilityState_Debug:
		// Display capability name
		print("Pixel_Pixel_capability(pixel,chan,value)");
		return;
	default:
		return;
	}

	/*
	PixelChange change = *(PixelChange*)(&args[0]);
	uint16_t channel = *(uint16_t*)(&args[1]);
	uint32_t value = *(uint32_t*)(&args[3]);
	*/

	// TODO (HaaTa) Apply the channel modification
}

void Pixel_AnimationControl_capability( TriggerMacro *trigger, uint8_t state, uint8_t stateType, uint8_t *args )
{
	CapabilityState cstate = KLL_CapabilityState( state, stateType );

	switch ( cstate )
	{
	case CapabilityState_Initial:
		// Only use capability on press
		break;
	case CapabilityState_Debug:
		// Display capability name
		print("Pixel_AnimationControl_capability(func)");
		return;
	default:
		return;
	}

	// Interconnect broadcasting
#if defined(ConnectEnabled_define)
	// By default send to the *next* node, which will determine where to go next
	extern uint8_t Connect_id; // connect_scan.c
	uint8_t addr = Connect_id + 1;

	// Send interconnect remote capability packet
	// generatedKeymap.h
	extern const Capability CapabilitiesList[];

	// Broadcast layerStackExact remote capability (0xFF is the broadcast id)
	Connect_send_RemoteCapability(
		addr,
		Pixel_AnimationControl_capability_index,
		state,
		stateType,
		CapabilitiesList[ Pixel_AnimationControl_capability_index ].argCount,
		args
	);
#endif

	uint8_t arg  = *(uint8_t*)(&args[0]);

	// Decide how to handle function
	switch ( arg )
	{
	case 0: // Pause/Resume
		// Determine how to handle Pause/Resume
		switch ( Pixel_animationControl )
		{
		case AnimationControl_Forward:
		case AnimationControl_ForwardOne:
			Pixel_animationControl = AnimationControl_Pause;
			break;
		case AnimationControl_Pause:
		default:
			Pixel_animationControl = AnimationControl_Forward;
			break;
		}
		break;
	case 1: // Forward one frame
		Pixel_animationControl = AnimationControl_ForwardOne;
		break;
	case 2: // Forward
		Pixel_animationControl = AnimationControl_Forward;
		break;
	case 3: // Stop (clears all animations)
		Pixel_animationControl = AnimationControl_Stop;
		break;
	case 4: // Reset (restarts animations)
		Pixel_animationControl = AnimationControl_Reset;
		break;
	case 5: // Pauses animations and clears display
		Pixel_animationControl = AnimationControl_WipePause;
		break;
	case 6: // Pauses animation
		Pixel_animationControl = AnimationControl_Pause;
		break;
	case 7: // Clears pixels (no pause and no stop)
		Pixel_animationControl = AnimationControl_Clear;
		break;
	}
}

void Pixel_FadeSet_capability( TriggerMacro *trigger, uint8_t state, uint8_t stateType, uint8_t *args )
{
	CapabilityState cstate = KLL_CapabilityState( state, stateType );

	switch ( cstate )
	{
	case CapabilityState_Initial:
		// Only use capability on press
		break;
	case CapabilityState_Debug:
		// Display capability name
		print("Pixel_FadeSet_capability(profile,config,period)");
		return;
	default:
		return;
	}

	// Interconnect broadcasting
#if defined(ConnectEnabled_define)
	// By default send to the *next* node, which will determine where to go next
	extern uint8_t Connect_id; // connect_scan.c
	uint8_t addr = Connect_id + 1;

	// Send interconnect remote capability packet
	// generatedKeymap.h
	extern const Capability CapabilitiesList[];

	// Broadcast layerStackExact remote capability (0xFF is the broadcast id)
	Connect_send_RemoteCapability(
		addr,
		Pixel_FadeSet_capability_index,
		state,
		stateType,
		CapabilitiesList[ Pixel_FadeSet_capability_index ].argCount,
		args
	);
#endif

	// Get arguments
	uint8_t profile = *(uint8_t*)(&args[0]);
	uint8_t config = *(uint8_t*)(&args[1]);
	uint8_t period = *(uint8_t*)(&args[2]);

	// Get period configuation
	const PixelPeriodConfig *period_config = &Pixel_LED_FadePeriods[period];

	// Set period configuration
	Pixel_pixel_fade_profile_entries[profile].conf[config].start = period_config->start;
	Pixel_pixel_fade_profile_entries[profile].conf[config].end = period_config->end;

	// Reset the current period being processed
	Pixel_pixel_fade_profile_entries[profile].pos = 0;
	Pixel_pixel_fade_profile_entries[profile].period_conf = PixelPeriodIndex_Off_to_On;
}

void Pixel_FadeLayerHighlight_capability( TriggerMacro *trigger, uint8_t state, uint8_t stateType, uint8_t *args )
{
	CapabilityState cstate = KLL_CapabilityState( state, stateType );

	// Get argument
	uint16_t layer = *(uint16_t*)(&args[0]);

	switch ( cstate )
	{
	case CapabilityState_Initial:
		// Refresh the fade profiles
		Pixel_SecondaryProcessing_profile_init();
		// Scan the layer for keys
		break;
	case CapabilityState_Last:
		// Refresh the fade profiles
		Pixel_SecondaryProcessing_profile_init();

		// If any layers are still active, re-run using top layer
		layer = Layer_topActive();
		if ( layer > 0 )
		{
			break;
		}
		return;
	case CapabilityState_Debug:
		// Display capability name
		print("Pixel_FadeLayerHighlight_capability(layer)");
		return;
	default:
		return;
	}

	// Interconnect broadcasting
#if defined(ConnectEnabled_define)
	// By default send to the *next* node, which will determine where to go next
	extern uint8_t Connect_id; // connect_scan.c
	uint8_t addr = Connect_id + 1;

	// Send interconnect remote capability packet
	// generatedKeymap.h
	extern const Capability CapabilitiesList[];

	// Broadcast layerStackExact remote capability (0xFF is the broadcast id)
	Connect_send_RemoteCapability(
		addr,
		Pixel_FadeLayerHighlight_capability_index,
		state,
		stateType,
		CapabilitiesList[ Pixel_FadeLayerHighlight_capability_index ].argCount,
		args
	);
#endif

	// Ignore if an invalid layer
	if ( layer >= LayerNum )
	{
		return;
	}

	// Lookup layer
	const Layer *layer_map = &LayerIndex[layer];

#if KLL_LED_FadeActiveLayerInvert_define == 1
	// Default layer
	const Layer *default_map = &LayerIndex[0];

	// Add keys not in layer
	uint8_t key = 1; // Scan Codes start at 1
	for ( ; key <= layer_map->first; key++ )
	{
		// If we've exceeded the pixel lookup, ignore
		if ( key > MaxPixelToScanCode_KLL )
		{
			return;
		}

		uint8_t index = key - default_map->first;

		// If the first entry in trigger list is a 0, ignore (otherwise, key is in layer)
		if ( !Trigger_DetermineScanCodeOnTrigger( default_map, index ) )
		{
			continue;
		}

		// Lookup pixel associated with scancode (remember -1 as all pixels and scancodes start at 1, not 0)
		uint16_t pixel = Pixel_ScanCodeToPixel[key - 1];

		// If pixel is 0, ignore
		if ( pixel == 0 )
		{
			continue;
		}

		// Set pixel to group #4
		Pixel_pixel_fade_profile[pixel - 1] = 4;
	}

	// Iterate over every key in layer, skipping active keys
	for ( ; key <= layer_map->last; key++ )
	{
		// If we've exceeded the pixel lookup, ignore
		if ( key > MaxPixelToScanCode_KLL )
		{
			return;
		}

		uint8_t index = key - layer_map->first;

		// If the first entry in trigger list is a 0, set as this key is not in the layer
		// Ignore otherwise
		if ( Trigger_DetermineScanCodeOnTrigger( layer_map, index ) )
		{
			continue;
		}

		// If the first entry in trigger list is a 0, ignore (otherwise, key is in layer)
		if ( !Trigger_DetermineScanCodeOnTrigger( default_map, index ) )
		{
			continue;
		}

		// Lookup pixel associated with scancode (remember -1 as all pixels and scancodes start at 1, not 0)
		uint16_t pixel = Pixel_ScanCodeToPixel[key - 1];

		// If pixel is 0, ignore
		if ( pixel == 0 )
		{
			continue;
		}

		// Set pixel to group #4
		Pixel_pixel_fade_profile[pixel - 1] = 4;
	}

	// Add keys not in layer
	for ( ; key <= default_map->last; key++ )
	{
		// If we've exceeded the pixel lookup, ignore
		if ( key > MaxPixelToScanCode_KLL )
		{
			return;
		}

		uint8_t index = key - default_map->first;

		// If the first entry in trigger list is a 0, ignore (otherwise, key is in layer)
		if ( !Trigger_DetermineScanCodeOnTrigger( default_map, index ) )
		{
			continue;
		}

		// Lookup pixel associated with scancode (remember -1 as all pixels and scancodes start at 1, not 0)
		uint16_t pixel = Pixel_ScanCodeToPixel[key - 1];

		// If pixel is 0, ignore
		if ( pixel == 0 )
		{
			continue;
		}

		// Set pixel to group #4
		Pixel_pixel_fade_profile[pixel - 1] = 4;
	}
#else
	// Lookup list of keys in layer
	for ( uint8_t key = layer_map->first; key <= layer_map->last; key++ )
	{
		uint8_t index = key - layer_map->first;

		// If the first entry in trigger list is a 0, ignore (otherwise, key is in layer)
		if ( !Trigger_DetermineScanCodeOnTrigger( layer_map, index ) )
		{
			continue;
		}

		// Lookup pixel associated with scancode (remember -1 as all pixels and scancodes start at 1, not 0)
		uint16_t pixel = Pixel_ScanCodeToPixel[key - 1];

		// If pixel is 0, ignore
		if ( pixel == 0 )
		{
			continue;
		}

		// Set pixel to group #4
		Pixel_pixel_fade_profile[pixel - 1] = 4;
	}
#endif
}

void Pixel_FadeControl_capability( TriggerMacro *trigger, uint8_t state, uint8_t stateType, uint8_t *args )
{
	CapabilityState cstate = KLL_CapabilityState( state, stateType );

	switch ( cstate )
	{
	case CapabilityState_Initial:
		// Only activate on press event
		break;
	case CapabilityState_Debug:
		// Display capability name
		print("Pixel_FadeControl_capability(test)");
		return;
	default:
		return;
	}

	// Get arguments
	uint8_t profile = args[0];
	uint8_t command = args[1];
	uint8_t arg = args[2];

	// Make sure profile is valid
	if ( profile >= sizeof(Pixel_pixel_fade_profile_entries) )
	{
		return;
	}

	// Process command
	uint16_t tmp;
	switch ( command )
	{
	case PixelFadeControl_Reset:
		for ( uint8_t config = 0; config < 4; config++ )
		{
			Pixel_pixel_fade_profile_entries[profile].conf[config] = \
				Pixel_LED_FadePeriods[Pixel_LED_FadePeriod_Defaults[profile][config]];
		}
		Pixel_pixel_fade_profile_entries[profile].pos = 0;
		Pixel_pixel_fade_profile_entries[profile].period_conf = PixelPeriodIndex_Off_to_On;
		Pixel_pixel_fade_profile_entries[profile].brightness = Pixel_LED_FadeBrightness[profile];
		break;

	case PixelFadeControl_Reset_All:
		// Setup fade defaults
		for ( uint8_t pr = 0; pr < 4; pr++ )
		{
			for ( uint8_t config = 0; config < 4; config++ )
			{
				Pixel_pixel_fade_profile_entries[pr].conf[config] = \
					Pixel_LED_FadePeriods[Pixel_LED_FadePeriod_Defaults[pr][config]];
			}
			Pixel_pixel_fade_profile_entries[pr].pos = 0;
			Pixel_pixel_fade_profile_entries[pr].period_conf = PixelPeriodIndex_Off_to_On;
			Pixel_pixel_fade_profile_entries[profile].brightness = Pixel_LED_FadeBrightness[pr];
		}
		break;

	case PixelFadeControl_Brightness_Set:
		// Set brightness
		Pixel_pixel_fade_profile_entries[profile].brightness = arg;
		break;

	case PixelFadeControl_Brightness_Increment:
		// Increment with no rollover
		tmp = Pixel_pixel_fade_profile_entries[profile].brightness;
		if ( tmp + arg > 0xFF )
		{
			Pixel_pixel_fade_profile_entries[profile].brightness = 0xFF;
			break;
		}
		Pixel_pixel_fade_profile_entries[profile].brightness += arg;
		break;

	case PixelFadeControl_Brightness_Decrement:
		// Decrement with no rollover
		tmp = Pixel_pixel_fade_profile_entries[profile].brightness;
		if ( tmp - arg < 0x00 )
		{
			Pixel_pixel_fade_profile_entries[profile].brightness = 0x00;
			break;
		}
		Pixel_pixel_fade_profile_entries[profile].brightness -= arg;
		break;

	case PixelFadeControl_Brightness_Default:
		Pixel_pixel_fade_profile_entries[profile].brightness = Pixel_LED_FadeBrightness[profile];
		break;

	default:
		return;
	}
}

void Pixel_LEDTest_capability( TriggerMacro *trigger, uint8_t state, uint8_t stateType, uint8_t *args )
{
	CapabilityState cstate = KLL_CapabilityState( state, stateType );

	switch ( cstate )
	{
	case CapabilityState_Initial:
		// Only activate on press event
		break;
	case CapabilityState_Debug:
		// Display capability name
		print("Pixel_LEDTest_capability(test)");
		return;
	default:
		return;
	}

	// Get arguments
	PixelTest test = *(PixelTest*)(&args[0]);
	uint16_t index = *(uint16_t*)(&args[1]);

	// If index is not set to 0xFFFF, make sure to update the test position
	if ( index != 0xFFFF )
	{
		Pixel_testPos = index;
	}

	// Set the test mode
	Pixel_testMode = test;
}



// ----- Functions -----

// -- Debug Functions --

// Debug info for PixelElement
void Pixel_showPixelElement( PixelElement *elem )
{
	print("W:");
	printInt8( elem->width );
	print(" C:");
	printInt8( elem->channels );
	print(" I:");
	printInt16( elem->indices[0] );
	for ( uint8_t c = 1; c < elem->channels; c++ )
	{
		print(",");
		printInt16( elem->indices[c] );

	}
}


// -- Utility Functions --

// TODO Support non-8bit channels
uint8_t Pixel_8bitInterpolation( uint8_t start, uint8_t end, uint8_t dist )
{
	return (start * (256 - dist) + end * dist) >> 8;
}

void Pixel_pixelInterpolate( PixelElement *elem, uint8_t position, uint8_t intensity )
{
	// Toggle each of the channels of the pixel

	for ( uint8_t ch = 0; ch < elem->channels; ch++ )
	{
		uint16_t ch_pos = elem->indices[ch];
		PixelBuf *pixbuf = Pixel_bufferMap( ch_pos );
		PixelBuf16( pixbuf, ch_pos ) = Pixel_8bitInterpolation( 0, intensity, position * (ch + 1) );
	}
}



// -- Animation Stack --

// Locates animation memory slot using default settings for the animation
// Initiates animation to process on the next cycle
// Returns 1 on success, 0 on failure to allocate
uint8_t Pixel_addDefaultAnimation( uint32_t index )
{
	if ( index >= Pixel_AnimationSettingsNum_KLL )
	{
		warn_msg("Invalid AnimationSetting index: ");
		printInt32( index );
		print( NL );
		return 0;
	}

	return Pixel_addAnimation( (AnimationStackElement*)&Pixel_AnimationSettings[ index ], CapabilityState_None );
}

// Allocates animaton memory slot
// Initiates animation to process on the next cycle
// Returns 1 on success, 0 on failure to allocate
uint8_t Pixel_addAnimation( AnimationStackElement *element, CapabilityState cstate )
{
	AnimationStackElement *found;
	switch ( element->replace )
	{
	case AnimationReplaceType_Basic:
	case AnimationReplaceType_All:
		found = Pixel_lookupAnimation( element->index, 0 );

		// If found, modify stack element
		if ( found != NULL && ( found->trigger == element->trigger || element->replace == AnimationReplaceType_All ) )
		{
			found->pos = element->pos;
			found->subpos = element->subpos;
			found->loops = element->loops;
			found->pfunc = element->pfunc;
			found->ffunc = element->ffunc;
			found->framedelay = element->framedelay;
			found->frameoption = element->frameoption;
			found->replace = element->replace;
			found->state = element->state;
			return 0;
		}
		break;

	// Replace on press and release
	// Press starts the animation
	// Release stops the animation
	case AnimationReplaceType_State:
		found = Pixel_lookupAnimation( element->index, 0 );

		switch ( cstate )
		{
		// Press
		case CapabilityState_Initial:
			// If found, modify stack element
			if ( found && found->trigger == element->trigger )
			{
				found->pos = element->pos;
				found->subpos = element->subpos;
				found->loops = element->loops;
				found->pfunc = element->pfunc;
				found->ffunc = element->ffunc;
				found->framedelay = element->framedelay;
				found->frameoption = element->frameoption;
				found->replace = element->replace;
				found->state = element->state;
				return 0;
			}
			break;

		// Release
		case CapabilityState_Last:
			// Only need to do something if the animation was found (which is stop)
			if ( found && found->trigger == element->trigger )
			{
				found->state = AnimationPlayState_Stop;
			}
			return 0;

		default:
			break;
		}
		break;

	// Clear all current animations from stack before adding new animation
	case AnimationReplaceType_Clear:
		Pixel_clearAnimations();
		break;

	// Clear all current animations from stack before adding new animation
	// Unless it's paused, and if it's paused do a replace if necessary
	case AnimationReplaceType_ClearActive:
		found = Pixel_lookupAnimation( element->index, 0 );
		// If found, modify stack element
		if ( found )
		{
			found->pos = element->pos;
			found->subpos = element->subpos;
			found->loops = element->loops;
			found->pfunc = element->pfunc;
			found->ffunc = element->ffunc;
			found->framedelay = element->framedelay;
			found->frameoption = element->frameoption;
			found->replace = element->replace;
			found->state = element->state;
			return 0;
		}

		// Iterate through stack, stopping animations that are not paused
		// and ignoring the found animation
		for ( uint16_t pos = 0; pos < Pixel_AnimationStack.size; pos++ )
		{
			// Ignore found animation
			if ( Pixel_AnimationStack.stack[pos] == found )
			{
				continue;
			}

			// Ignore paused animations (single will be paused on the next frame)
			if (
				( Pixel_AnimationStack.stack[pos]->state & 0x7F ) == AnimationPlayState_Pause ||
				( Pixel_AnimationStack.stack[pos]->state & 0x7F ) == AnimationPlayState_Single
			)
			{
				continue;
			}

			// Otherwise stop
			Pixel_AnimationStack.stack[pos]->state = AnimationPlayState_Stop;
		}
		break;

	default:
		break;
	}

	// Make sure there is room left on the stack
	if ( Pixel_AnimationStack.size >= Pixel_AnimationStackSize )
	{
		warn_print("Animation stack is full...");
		return 0;
	}

	// Add to animation stack
	// Processing is done from bottom to top of the stack
	// First find a free memory slot, this is not ordered, so we have to search for it
	uint16_t pos = 0;
	for ( ; pos < Pixel_AnimationStackSize; pos++ )
	{
		// Check if memory is unused
		if ( Pixel_AnimationElement_Stor[pos].index == 0xFFFF )
		{
			break;
		}
	}

	// No memory left
	// XXX This shouldn't happen
	if ( pos >= Pixel_AnimationStackSize )
	{
		erro_print("Animation Stack memory leak...this is a bug!");
		return 0;
	}

	// Set stack location
	Pixel_AnimationStack.stack[Pixel_AnimationStack.size++] = &Pixel_AnimationElement_Stor[pos];

	// Copy animation settings
	memcpy( &Pixel_AnimationElement_Stor[pos], element, sizeof(AnimationStackElement) );

	return 1;
}

// Removes the first index of an animation
// Will be popped from the stack on the next animation processing loop
uint8_t Pixel_delAnimation( uint16_t index, uint8_t finish )
{
	// Find animation by index, look for the *first* one
	uint16_t pos = 0;
	for ( ; pos < Pixel_AnimationStackSize; pos++ )
	{
		// Check if memory is unused
		if ( Pixel_AnimationElement_Stor[pos].index == index )
		{
			// Let animation finish it's last frame
			if ( finish )
			{
				Pixel_AnimationElement_Stor[pos].loops = 1;
			}
			else
			{
				Pixel_AnimationElement_Stor[pos].index = 0xFFFF;
			}
			return 1;
		}
	}

	return 0;
}

// Cleans/resets animation stack. Removes all running animations.
// NOTE: Does not clear the output buffer
void Pixel_clearAnimations()
{
	// Set stack size to 0
	Pixel_AnimationStack.size = 0;

	// Set indices to max value to indicate un-allocated
	for ( uint16_t pos = 0; pos < Pixel_AnimationStackSize; pos++ )
	{
		Pixel_AnimationElement_Stor[pos].index = 0xFFFF;
	}
}

// Clears all pixels
void Pixel_clearPixels()
{
	// Update all positions
	for ( uint16_t px = 0; px < Pixel_TotalPixels_KLL; px++ )
	{
		// Unset pixel
		Pixel_pixelSet( (PixelElement*)&Pixel_Mapping[ px ], 0 );
	}
}

// Animation ID lookup
// - Does lookup from bottom to top
// - Set previous element to look for the next one
// - Set prev to 0 to start from the beginning
// - Returns NULL/0 if not found
AnimationStackElement *Pixel_lookupAnimation( uint16_t index, uint16_t prev )
{
	uint16_t pos = prev;

	// Look for next instance of index
	for ( ; pos < Pixel_AnimationStack.size; pos++ )
	{
		// Check if index matches
		if ( Pixel_AnimationStack.stack[pos]->index == index )
		{
			return Pixel_AnimationStack.stack[pos];
		}
	}

	// Could not find, return NULL
	return NULL;
}

// Iterate over each element in the Animation Stack
// If the animation is complete, do not re-add to the stack
// - The stack is re-built each time.
// - Ignores any stack element indices set to 0xFFFF/-1 (max)
void Pixel_stackProcess()
{
	uint16_t pos = 0;
	uint16_t size = Pixel_AnimationStack.size;

	// We reset the stack size, and rebuild the stack on the fly
	Pixel_AnimationStack.size = 0;

	// Process each element of the stack
	for ( ; pos < size; pos++ )
	{
		// Lookup animation stack element
		AnimationStackElement *elem = Pixel_AnimationStack.stack[pos];

		// Ignore animation if index is 0xFFFF (max)
		if ( elem->index == 0xFFFF )
		{
			continue;
		}

		// Store index, in case we need to send an event
		uint16_t cur_index = elem->index;

		// Process animation element
		if ( Pixel_animationProcess( elem ) )
		{
			// Re-add animation to stack
			Pixel_AnimationStack.stack[Pixel_AnimationStack.size++] = elem;
		}
		else
		{
			// Signal that animation finished
			Macro_animationState( cur_index, ScheduleType_Done );
		}
	}
}



// -- Pixel Control --

// PixelBuf lookup
// - Determines which buffer a channel resides in
PixelBuf *Pixel_bufferMap( uint16_t channel )
{
	// TODO Generate based on keyboard
#if ISSI_Chip_31FL3731_define == 1 || ISSI_Chip_31FL3732_define == 1
	if      ( channel < 144 ) return &Pixel_Buffers[0];
	else if ( channel < 288 ) return &Pixel_Buffers[1];
	else if ( channel < 432 ) return &Pixel_Buffers[2];
	else if ( channel < 576 ) return &Pixel_Buffers[3];
#elif ISSI_Chip_31FL3733_define == 1
	if      ( channel < 192 ) return &Pixel_Buffers[0];
	else if ( channel < 384 ) return &Pixel_Buffers[1];
	else if ( channel < 576 ) return &Pixel_Buffers[2];
#else
	if      ( channel < 192 ) return &Pixel_Buffers[0];
	else if ( channel < 384 ) return &Pixel_Buffers[1];
	else if ( channel < 576 ) return &Pixel_Buffers[2];
#endif

	// Invalid channel, return first channel and display error
	erro_msg("Invalid channel: ");
	printHex( channel );
	print( NL );
	return 0;
}

// PixelBuf lookup (LED_Buffers)
// - Determines which buffer a channel resides in
PixelBuf *LED_bufferMap( uint16_t channel )
{
	// TODO Generate based on keyboard
#if ISSI_Chip_31FL3731_define == 1 || ISSI_Chip_31FL3732_define == 1
	if      ( channel < 144 ) return &LED_Buffers[0];
	else if ( channel < 288 ) return &LED_Buffers[1];
	else if ( channel < 432 ) return &LED_Buffers[2];
	else if ( channel < 576 ) return &LED_Buffers[3];
#elif ISSI_Chip_31FL3733_define == 1
	if      ( channel < 192 ) return &LED_Buffers[0];
	else if ( channel < 384 ) return &LED_Buffers[1];
	else if ( channel < 576 ) return &LED_Buffers[2];
#else
	if      ( channel < 192 ) return &LED_Buffers[0];
	else if ( channel < 384 ) return &LED_Buffers[1];
	else if ( channel < 576 ) return &LED_Buffers[2];
#endif

	// Invalid channel, return first channel and display error
	erro_msg("Invalid channel (LED): ");
	printHex( channel );
	print( NL );
	return 0;
}

#define PixelChange_Expansion(pixbuf, ch_pos, mod_value, op) \
	/* Lookup buffer to data width mapping */ \
	switch ( pixbuf->width ) \
	{ \
	case 8:  /*  8 bit mapping */ \
		PixelBuf8( pixbuf, ch_pos ) op (uint8_t)mod_value; break; \
	case 16: /* 16 bit mapping */ \
		PixelBuf16( pixbuf, ch_pos ) op (uint16_t)mod_value; break; \
	case 32: /* 32 bit mapping */ \
		PixelBuf32( pixbuf, ch_pos ) op (uint32_t)mod_value; break; \
	default: \
		warn_print("Invalid width mapping for "#op ); \
		break; \
	}

// Pixel Evaluation
// - Iterates over each of the Pixel channels and applies modifications
void Pixel_pixelEvaluation( PixelModElement *mod, PixelElement *elem )
{
	// Ignore if no element
	if ( elem == 0 )
	{
		return;
	}

	// Lookup number of channels in pixel
	uint8_t channels = elem->channels;

	// Data position iterator
	uint8_t position_iter = 0;

	// Apply operation to each channel of the pixel
	for ( uint8_t ch = 0; ch < channels; ch++ )
	{
		// Lookup channel position
		uint16_t ch_pos = elem->indices[ch];

		// Determine which buffer we are in
		PixelBuf *pixbuf = Pixel_bufferMap( ch_pos );

		// Invalid channel, stop
		if ( pixbuf == 0 )
		{
			break;
		}

		// Change Type (first 8 bits of each channel of data, see pixel.h for layout)
		PixelChange change = (PixelChange)mod->data[ position_iter++ ];

		// Modification Value
		uint32_t mod_value = 0;

		// Lookup modification value
		switch ( elem->width )
		{
		case 8:
			mod_value = mod->data[ position_iter++ ];
			break;

		case 16:
			mod_value = mod->data[ position_iter + 1 ] |
				( mod->data[ position_iter + 2 ] << 8 );
			position_iter += 2;
			break;

		case 32:
			mod_value = mod->data[ position_iter + 1 ] |
				( mod->data[ position_iter + 2 ] << 8 ) |
				( mod->data[ position_iter + 3 ] << 16 ) |
				( mod->data[ position_iter + 4 ] << 24 );
			position_iter += 4;
			break;

		default:
			warn_print("Invalid PixelElement width mapping");
			break;
		}

		// Operation
		switch ( change )
		{
		case PixelChange_Set:             // =
			PixelChange_Expansion( pixbuf, ch_pos, mod_value, = );
			break;

		case PixelChange_Add:             // +
			PixelChange_Expansion( pixbuf, ch_pos, mod_value, += );
			break;

		case PixelChange_Subtract:        // -
			PixelChange_Expansion( pixbuf, ch_pos, mod_value, -= );
			break;

		case PixelChange_LeftShift:       // <<
			PixelChange_Expansion( pixbuf, ch_pos, mod_value, <<= );
			break;

		case PixelChange_RightShift:      // >>
			PixelChange_Expansion( pixbuf, ch_pos, mod_value, >>= );
			break;

		case PixelChange_NoRoll_Add:      // +:
			// Lookup buffer to data width mapping
			switch ( pixbuf->width )
			{
			case 8:  //  8  bit mapping
			{
				uint8_t prev = PixelBuf8( pixbuf, ch_pos );
				PixelBuf8( pixbuf, ch_pos ) += (uint8_t)mod_value;
				if ( prev > PixelBuf8( pixbuf, ch_pos ) )
					PixelBuf8( pixbuf, ch_pos ) = 0xFF;
				break;
			}
			case 16: // 16  bit mapping
			{
				// TODO Fix for 16 on 8 bit (i.e. early K-Type)
				//uint16_t prev = PixelBuf16( pixbuf, ch_pos );
				PixelBuf16( pixbuf, ch_pos ) += (uint16_t)mod_value;
				/*
				if ( prev > PixelBuf16( pixbuf, ch_pos ) )
					PixelBuf16( pixbuf, ch_pos ) = 0xFFFF;
				*/
				if ( 0xFF < PixelBuf16( pixbuf, ch_pos ) )
					PixelBuf16( pixbuf, ch_pos ) = 0xFF;
				break;
			}
			case 32: // 32  bit mapping
			{
				uint32_t prev = PixelBuf32( pixbuf, ch_pos );
				PixelBuf32( pixbuf, ch_pos ) += (uint32_t)mod_value;
				if ( prev > PixelBuf32( pixbuf, ch_pos ) )
					PixelBuf32( pixbuf, ch_pos ) = 0xFFFFFFFF;
				break;
			}

			default:
				warn_print("Invalid width mapping on set");
				break;
			}
			break;

		case PixelChange_NoRoll_Subtract: // -:
			// Lookup buffer to data width mapping
			switch ( pixbuf->width )
			{
			case 8:  //  8  bit mapping
			{
				uint8_t prev = PixelBuf8( pixbuf, ch_pos );
				PixelBuf8( pixbuf, ch_pos ) -= (uint8_t)mod_value;
				if ( prev < PixelBuf8( pixbuf, ch_pos ) )
					PixelBuf8( pixbuf, ch_pos ) = 0;
				break;
			}
			case 16: // 16  bit mapping
			{
				uint16_t prev = PixelBuf16( pixbuf, ch_pos );
				PixelBuf16( pixbuf, ch_pos ) -= (uint16_t)mod_value;
				if ( prev < PixelBuf16( pixbuf, ch_pos ) )
					PixelBuf16( pixbuf, ch_pos ) = 0;
				break;
			}
			case 32: // 32  bit mapping
			{
				uint32_t prev = PixelBuf32( pixbuf, ch_pos );
				PixelBuf32( pixbuf, ch_pos ) -= (uint32_t)mod_value;
				if ( prev < PixelBuf32( pixbuf, ch_pos ) )
					PixelBuf32( pixbuf, ch_pos ) = 0;
				break;
			}

			default:
				warn_print("Invalid width mapping on set");
				break;
			}
			break;

		default:
			warn_print("Unimplemented pixel modifier");
			break;
		}
	}
}



// -- Fill Algorithms --

// Fill Algorithm Pixel Lookup
// - **elem stores a pointer to the PixelElement which can be used to lookup the channel buffer location
// - Determines which pixel element to work on next
// - If type:index has more than one pixel, non-0 is returned
// - The return value signifies the next value to set the prev argument
// - Once the function returns 0, all pixels have been processed
uint16_t Pixel_fillPixelLookup(
	PixelModElement *mod,
	PixelElement **elem,
	uint16_t prev,
	AnimationStackElement *stack_elem,
	uint16_t *valid
)
{
	// Used to determine next pixel in column or row (fill)
	uint16_t cur = prev;
	uint16_t index = 0;

	// Assume invalid (i.e. do not evaluate pixel unless we are sure it's valid)
	*valid = 0;

	// Default to nothing found
	*elem = 0;

	// Lookup fill algorith
	switch ( mod->type )
	{
	case PixelAddressType_Index:
		// Lookup pixel by absolute index
		*elem = (PixelElement*)&Pixel_Mapping[mod->index] - 1;
		if ( mod->index <= Pixel_TotalPixels_KLL )
		{
			*valid = 1;
		}
		break;

	case PixelAddressType_Rect:
		// Make sure row,column exists
		if ( mod->rect.col >= Pixel_DisplayMapping_Cols_KLL
			&& mod->rect.row >= Pixel_DisplayMapping_Rows_KLL )
		{
			erro_msg("Invalid row,column index: ");
			printInt16( mod->rect.row );
			print(",");
			printInt16( mod->rect.col );
			print( NL );
			break;
		}

		// Lookup pixel in rectangle display organization
		*elem = (PixelElement*)&Pixel_Mapping[
			Pixel_DisplayMapping[
				mod->rect.row * Pixel_DisplayMapping_Cols_KLL + mod->rect.col
			] - 1
		];
		*valid = 1;
		break;

	case PixelAddressType_ColumnFill:
		// Lookup pixel until either, non-0 index or we reached the last row
		do {
			// Check if we've processed all rows
			if ( cur >= Pixel_DisplayMapping_Rows_KLL )
			{
				return 0;
			}

			// Pixel index
			index = Pixel_DisplayMapping[ cur * Pixel_DisplayMapping_Cols_KLL + mod->rect.col ];

			cur++;
		} while ( index == 0 );

		// Validate index is actually a valid evaluation
		if ( index <= Pixel_TotalPixels_KLL )
		{
			*valid = 1;
		}

		// Lookup pixel, pixels are 1 indexed, hence the -1
		*elem = (PixelElement*)&Pixel_Mapping[ index - 1 ];
		return cur;

	case PixelAddressType_RowFill:
		// Lookup pixel until either, non-0 index or we reached the last column
		do {
			// Check if we've processed all rows
			if ( cur >= Pixel_DisplayMapping_Cols_KLL )
			{
				return 0;
			}

			// Pixel index
			index = Pixel_DisplayMapping[ mod->rect.row * Pixel_DisplayMapping_Cols_KLL + cur ];

			cur++;
		} while ( index == 0 );

		// Validate index is actually a valid evaluation
		if ( index <= Pixel_TotalPixels_KLL )
		{
			*valid = 1;
		}

		// Lookup pixel, pixels are 1 indexed, hence the -1
		*elem = (PixelElement*)&Pixel_Mapping[ index - 1 ];
		return cur;

	case PixelAddressType_ScanCode:
		// Make sure ScanCode exists
		if ( mod->index > MaxScanCode_KLL )
		{
			erro_msg("Invalid ScanCode: ");
			printInt16( mod->index );
			print( NL );
			break;
		}
		*valid = 1;

		// Lookup ScanCode - Indices are 1-indexed in both arrays (hence the -1)
		uint16_t pixel = Pixel_ScanCodeToPixel[ mod->index - 1 ];
		*elem = (PixelElement*)&Pixel_Mapping[ pixel - 1 ];
		break;

	case PixelAddressType_RelativeIndex:
		// TODO
		break;

	case PixelAddressType_RelativeRect:
	{
		// Determine scancode to be relative from
		uint8_t scan_code = Pixel_determineLastTriggerScanCode( stack_elem->trigger );

		// Lookup display position of scancode
		uint16_t position = Pixel_ScanCodeToDisplay[ scan_code - 1 ];

		// Calculate rectangle offset
		position += (int16_t)mod->rect.row * Pixel_DisplayMapping_Cols_KLL + (int16_t)mod->rect.col;

		// Make sure position exists
		if ( position >= Pixel_DisplayMapping_Cols_KLL * Pixel_DisplayMapping_Rows_KLL )
		{
			break;
		}

		// Lookup pixel, pixels are 1 indexed, hence the -1
		index = Pixel_DisplayMapping[ position ];

		// Validate index is actually a valid evaluation
		if ( index <= Pixel_TotalPixels_KLL && index != 0 )
		{
			*valid = 1;
			*elem = (PixelElement*)&Pixel_Mapping[ index - 1 ];
		}
		break;
	}
	case PixelAddressType_RelativeColumnFill:
	{
		// Determine scancode to be relative from
		uint8_t scan_code = Pixel_determineLastTriggerScanCode( stack_elem->trigger );

		// Lookup display position of scancode
		uint16_t position = Pixel_ScanCodeToDisplay[ scan_code - 1 ];

		// Calculate rectangle offset
		position += (int16_t)mod->rect.col;

		// Make sure column exists
		if ( position >= Pixel_DisplayMapping_Cols_KLL * Pixel_DisplayMapping_Rows_KLL )
		{
			erro_msg("Invalid position index (relcol): ");
			printInt16( position );
			print( NL );
			break;
		}

		// Determine first row in column
		position %= Pixel_DisplayMapping_Cols_KLL;

		// Lookup pixel until either, non-0 index or we reached the last row
		do {
			// Current position
			uint16_t curpos = cur++ * Pixel_DisplayMapping_Cols_KLL + position;

			// Check if we've gone too far (and finished all rows)
			if ( curpos >= Pixel_DisplayMapping_Cols_KLL * Pixel_DisplayMapping_Rows_KLL )
			{
				return 0;
			}

			// Pixel index
			index = Pixel_DisplayMapping[ curpos ];
		} while ( index == 0 );

		// Validate index is actually a valid evaluation
		if ( index <= Pixel_TotalPixels_KLL )
		{
			*valid = 1;
		}

		// Lookup pixel, pixels are 1 indexed, hence the -1
		*elem = (PixelElement*)&Pixel_Mapping[ index - 1 ];
		return cur;
	}
	case PixelAddressType_RelativeRowFill:
	{
		// Determine scancode to be relative from
		uint8_t scan_code = Pixel_determineLastTriggerScanCode( stack_elem->trigger );

		// Lookup display position of scancode
		uint16_t position = Pixel_ScanCodeToDisplay[ scan_code - 1 ];

		// Calculate rectangle offset
		position += (int16_t)mod->rect.row * Pixel_DisplayMapping_Rows_KLL;

		// Make sure column exists
		if ( position >= Pixel_DisplayMapping_Cols_KLL * Pixel_DisplayMapping_Rows_KLL )
		{
			erro_msg("Invalid position index (relrow): ");
			printInt16( position );
			print( NL );
			break;
		}

		// Determine which row we are in
		position /= Pixel_DisplayMapping_Cols_KLL;

		// Lookup pixel until either, non-0 index or we reached the last row
		do {
			// Current position
			uint16_t curpos = cur++ + Pixel_DisplayMapping_Cols_KLL * position;

			// Check if we've gone too far (and finished all rows)
			if ( cur >= Pixel_DisplayMapping_Cols_KLL )
			{
				return 0;
			}

			// Pixel index
			index = Pixel_DisplayMapping[ curpos ];
		} while ( index == 0 );

		// Validate index is actually a valid evaluation
		if ( index <= Pixel_TotalPixels_KLL )
		{
			*valid = 1;
		}

		// Lookup pixel, pixels are 1 indexed, hence the -1
		*elem = (PixelElement*)&Pixel_Mapping[ index - 1 ];
		return cur;
	}
	// Skip
	default:
		break;
	}

	return 0;
}



// -- Pixel Tweening --

uint16_t Pixel_pixelTweenNextPos( PixelElement *elem, PixelElement *prev )
{
	// No elem found
	// XXX (HaaTa) This is actually a hard problem for relative animations
	//             We may not find any element initially, so we don't know anothing to increment the position
	//             The best solution may be to just find a relatively nearby pixel and use that info...
	//             Or waste enough more flash...

	uint16_t ret = 0;

#if Pixel_HardCode_ChanWidth_define != 0 && Pixel_HardCode_Channels_define != 0
	// More efficient tweening, as we know the number of channels and width at compile time in all cases.
	ret = (
		( Pixel_HardCode_ChanWidth_define / 8 + sizeof( PixelChange ) )
		* Pixel_HardCode_Channels_define
	) + sizeof( PixelModElement );

#else
	// Determine tweening using nearby pixel definitions
	// First try the next element
	if ( elem != 0 )
	{
		ret = ( ( elem->width / 8 + sizeof( PixelChange ) ) * elem->channels ) + sizeof( PixelModElement );
		return ret;
	}

	// Next try the previous element
	if ( prev != 0 )
	{
		ret = ( ( prev->width / 8 + sizeof( PixelChange ) ) * prev->channels ) + sizeof( PixelModElement );
		return ret;
	}

	// BAD BAD BAD
	// TODO - This is BAD, will break in most cases, except for K-Type like keyboards.
	erro_print("Pixel Tween Bug!");
	ret = ( ( 8 / 8 + sizeof( PixelChange ) ) * 3 ) + sizeof( PixelModElement );
#endif

	return ret;
}

// Standard Pixel Pixel Function (standard lookup, no additonal processing)
void Pixel_pixelTweenStandard( const uint8_t *frame, AnimationStackElement *stack_elem )
{
	// Iterate over all of the Pixel Modifier elements of the Animation Frame
	uint16_t pos = 0;
	PixelModElement *mod = (PixelModElement*)&frame[pos];
	while ( mod->type != PixelAddressType_End )
	{
		// Lookup type of pixel, choose fill algorith and query all sub-pixels
		uint16_t next = 0;
		uint16_t valid = 0;
		PixelElement *prev_pixel_elem = 0;
		PixelElement *elem = 0;
		do {
			// Last element
			prev_pixel_elem = elem;

			// Lookup pixel, and check if there are any more pixels left
			next = Pixel_fillPixelLookup( mod, &elem, next, stack_elem, &valid );

			// Apply operation to pixel
			Pixel_pixelEvaluation( mod, elem );
		} while ( next );

		// Determine next position
		pos += Pixel_pixelTweenNextPos( elem, prev_pixel_elem );

		// Lookup next mod element
		mod = (PixelModElement*)&frame[pos];
	}
}

// Basic interpolation Pixel Pixel Function
// TODO - Only works with Colummn and Row fill currently
void Pixel_pixelTweenInterpolation( const uint8_t *frame, AnimationStackElement *stack_elem )
{
	// Iterate over all of the Pixel Modifier elements of the Animation Frame
	uint16_t pos = 0;
	PixelModElement *prev = 0;
	PixelModElement *mod = (PixelModElement*)&frame[pos];
	while ( mod->type != PixelAddressType_End )
	{
		// By default, no interpolation
		int32_t start = mod->index;
		int32_t end = mod->index;

		// Calculate interpolation position
		// TODO Depends on addressing type
		// TODO Work with dis-similar PixelModElement address types
		switch ( mod->type )
		{
		case PixelAddressType_ColumnFill:
			// If this is the first pixel, just set start at the same spot
			start = prev != 0 ? prev->rect.col : mod->rect.col;
			end = mod->rect.col;
			break;

		case PixelAddressType_RowFill:
			// If this is the first pixel, just set start at the same spot
			start = prev != 0 ? prev->rect.row : mod->rect.row;
			end = mod->rect.row;
			break;

		case PixelAddressType_Rect:
			// TODO - This is not correct (just a quick and dirty hack)
			if ( prev != 0 )
			{
				// TODO - Diagonal interpolation?
				if ( prev->rect.col != mod->rect.col )
				{
					start = prev->rect.col;
				}
				if ( prev->rect.row != mod->rect.row )
				{
					start = prev->rect.row;
				}
			}
			else
			{
				start = mod->rect.col;
			}
			//end = ( mod->rect.col + mod->rect.row ) / 2;
			end = mod->rect.col;
			break;

		case PixelAddressType_ScanCode:
			// If this is the first pixel, just set start at the same spot
			start = prev != 0 ? prev->index : mod->index;
			end = mod->index;
			break;

		case PixelAddressType_Index:
			// If this is the first pixel, just set start at the same spot
			start = prev != 0 ? prev->index : mod->index;
			end = mod->index;
			break;

		default:
			break;
		}

		// Lookup prev and mod PixelElements
		PixelElement *prev_elem = 0;
		uint16_t valid = 0;
		if ( prev != 0 )
		{
			Pixel_fillPixelLookup( prev, &prev_elem, 0, stack_elem, &valid );
		}
		PixelElement *mod_elem = 0;
		Pixel_fillPixelLookup( mod, &mod_elem, 0, stack_elem, &valid );

		// Data variable for PixelModElement
		// TODO (HaaTa) Allow for smal…