New GDISP now supports multiple controllers with different pixel formats.

You can now have a main color display and a secondary monochrome display.
You can now optionally set GDISP_PIXELFORMAT to any color or grayscale format for your application and the driver will internally convert to the display hardware format.

21 files changed, 442 insertions, 108 deletions

diff --git a/drivers/gdisp/ED060SC4/gdisp_lld_ED060SC4.c b/drivers/gdisp/ED060SC4/gdisp_lld_ED060SC4.c
index 14e7f88a..3ab1de79 100644
--- a/drivers/gdisp/ED060SC4/gdisp_lld_ED060SC4.c
+++ b/drivers/gdisp/ED060SC4/gdisp_lld_ED060SC4.c
@@ -524,7 +524,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		bitpos = (6 - 2 * (dx % EINK_PPB));
 		byte = block->data[dy][dx / EINK_PPB];
 		byte &= ~(PIXELMASK << bitpos);
-		if (g->p.color != Black)
+		if (COLOR2NATIVE(g->p.color) != Black)
 			byte |= PIXEL_WHITE << bitpos;
 		else
 			byte |= PIXEL_BLACK << bitpos;
diff --git a/drivers/gdisp/HX8347D/gdisp_lld_HX8347D.c b/drivers/gdisp/HX8347D/gdisp_lld_HX8347D.c
index fecf115c..4514b495 100644
--- a/drivers/gdisp/HX8347D/gdisp_lld_HX8347D.c
+++ b/drivers/gdisp/HX8347D/gdisp_lld_HX8347D.c
@@ -167,7 +167,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		busmode16(g);
 	}
 	LLDSPEC	void gdisp_lld_write_color(GDisplay *g) {
-		write_ram16(g, g->p.color);
+		write_ram16(g, COLOR2NATIVE(g->p.color));
 	}
 	LLDSPEC	void gdisp_lld_write_stop(GDisplay *g) {
 		busmode8(g);
diff --git a/drivers/gdisp/ILI9320/gdisp_lld_ILI9320.c b/drivers/gdisp/ILI9320/gdisp_lld_ILI9320.c
index a18c2d82..e65e0a77 100644
--- a/drivers/gdisp/ILI9320/gdisp_lld_ILI9320.c
+++ b/drivers/gdisp/ILI9320/gdisp_lld_ILI9320.c
@@ -204,7 +204,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		#endif
 	}
 	LLDSPEC	void gdisp_lld_write_color(GDisplay *g) {
-		write_data(g, g->p.color);
+		write_data(g, COLOR2NATIVE(g->p.color));
 	}
 	LLDSPEC	void gdisp_lld_write_stop(GDisplay *g) {
 		release_bus(g);
@@ -225,7 +225,10 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		dummy_read(g);
 	}
 	LLDSPEC	color_t gdisp_lld_read_color(GDisplay *g) {
-		return read_data(g);
+		uint16_t	data;
+
+		data = read_data(g);
+		return NATIVE2COLOR(data);
 	}
 	LLDSPEC	void gdisp_lld_read_stop(GDisplay *g) {
 		setwritemode(g);
diff --git a/drivers/gdisp/ILI9325/gdisp_lld_ILI9325.c b/drivers/gdisp/ILI9325/gdisp_lld_ILI9325.c
index 75b4cd13..ffd67cf7 100644
--- a/drivers/gdisp/ILI9325/gdisp_lld_ILI9325.c
+++ b/drivers/gdisp/ILI9325/gdisp_lld_ILI9325.c
@@ -200,7 +200,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		set_viewport(g);
 	}
 	LLDSPEC	void gdisp_lld_write_color(GDisplay *g) {
-		write_data(g, g->p.color);
+		write_data(g, COLOR2NATIVE(g->p.color));
 	}
 	LLDSPEC	void gdisp_lld_write_stop(GDisplay *g) {
 		release_bus(g);
@@ -219,7 +219,10 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		dummy_read(g);
 	}
 	LLDSPEC	color_t gdisp_lld_read_color(GDisplay *g) {
-		return read_data(g);
+		uint16_t	data;
+
+		data = read_data(g);
+		return NATIVE2COLOR(data);
 	}
 	LLDSPEC	void gdisp_lld_read_stop(GDisplay *g) {
 		setwritemode(g);
diff --git a/drivers/gdisp/ILI9341/gdisp_lld_ILI9341.c b/drivers/gdisp/ILI9341/gdisp_lld_ILI9341.c
index 33ca68d4..2513c48d 100644
--- a/drivers/gdisp/ILI9341/gdisp_lld_ILI9341.c
+++ b/drivers/gdisp/ILI9341/gdisp_lld_ILI9341.c
@@ -246,7 +246,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		write_index(g, 0x2C);
 	}
 	LLDSPEC	void gdisp_lld_write_color(GDisplay *g) {
-		write_data16(g, g->p.color);
+		write_data16(g, COLOR2NATIVE(g->p.color));
 	}
 	LLDSPEC	void gdisp_lld_write_stop(GDisplay *g) {
 		release_bus(g);
@@ -262,7 +262,10 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		dummy_read(g);
 	}
 	LLDSPEC	color_t gdisp_lld_read_color(GDisplay *g) {
-		return read_data(g);
+		uint16_t	data;
+
+		data = read_data(g);
+		return NATIVE2COLOR(data);
 	}
 	LLDSPEC	void gdisp_lld_read_stop(GDisplay *g) {
 		setwritemode(g);
diff --git a/drivers/gdisp/ILI9481/gdisp_lld_ILI9481.c b/drivers/gdisp/ILI9481/gdisp_lld_ILI9481.c
index 49e28b23..2b2f0917 100644
--- a/drivers/gdisp/ILI9481/gdisp_lld_ILI9481.c
+++ b/drivers/gdisp/ILI9481/gdisp_lld_ILI9481.c
@@ -211,7 +211,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		set_viewport(g);
 	}
 	LLDSPEC	void gdisp_lld_write_color(GDisplay *g) {
-		write_data(g, g->p.color);
+		write_data(g, COLOR2NATIVE(g->p.color));
 	}
 	LLDSPEC	void gdisp_lld_write_stop(GDisplay *g) {
 		release_bus(g);
@@ -226,7 +226,10 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		dummy_read(g);
 	}
 	LLDSPEC	color_t gdisp_lld_read_color(GDisplay *g) {
-		return read_data(g);
+		uint16_t	data;
+
+		data = read_data(g);
+		return NATIVE2COLOR(data);
 	}
 	LLDSPEC	void gdisp_lld_read_stop(GDisplay *g) {
 		setwritemode(g);
diff --git a/drivers/gdisp/Nokia6610GE12/gdisp_lld_Nokia6610GE12.c b/drivers/gdisp/Nokia6610GE12/gdisp_lld_Nokia6610GE12.c
index d1086c46..28a2fceb 100644
--- a/drivers/gdisp/Nokia6610GE12/gdisp_lld_Nokia6610GE12.c
+++ b/drivers/gdisp/Nokia6610GE12/gdisp_lld_Nokia6610GE12.c
@@ -70,8 +70,8 @@
 /*===========================================================================*/
 
 // Use the priv pointer itself to save our color. This save allocating ram for it
-//	and works provided sizeof(color_t) <= sizeof(void *)
-#define savecolor(g)					(*(color_t *)&g->priv)
+//	and works provided sizeof(uint16_t) <= sizeof(void *)
+#define savecolor(g)					(*(uint16_t *)&g->priv)
 
 #define GDISP_FLG_ODDBYTE				(GDISP_FLG_DRIVER<<0)
 
@@ -143,14 +143,17 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		g->flags &= ~GDISP_FLG_ODDBYTE;
 	}
 	LLDSPEC	void gdisp_lld_write_color(GDisplay *g) {
+		uint16_t	c;
+
+		c = COLOR2NATIVE(g->p.color);
 		if ((g->flags & GDISP_FLG_ODDBYTE)) {
 			// Write the pair of pixels to the display
 			write_data3(g, ((savecolor(g) >> 4) & 0xFF),
-					(((savecolor(g) << 4) & 0xF0)|((g->p.color >> 8) & 0x0F)),
-					(g->p.color & 0xFF));
+					(((savecolor(g) << 4) & 0xF0)|((c >> 8) & 0x0F)),
+					(c & 0xFF));
 			g->flags &= ~GDISP_FLG_ODDBYTE;
 		} else {
-			savecolor(g) = g->p.color;
+			savecolor(g) = c;
 			g->flags |= GDISP_FLG_ODDBYTE;
 		}
 	}
diff --git a/drivers/gdisp/Nokia6610GE8/gdisp_lld_Nokia6610GE8.c b/drivers/gdisp/Nokia6610GE8/gdisp_lld_Nokia6610GE8.c
index e0cfb997..f6ce4278 100644
--- a/drivers/gdisp/Nokia6610GE8/gdisp_lld_Nokia6610GE8.c
+++ b/drivers/gdisp/Nokia6610GE8/gdisp_lld_Nokia6610GE8.c
@@ -111,9 +111,9 @@
 
 #if GDISP_HARDWARE_STREAM_WRITE
 	typedef struct dvrPriv {
-		color_t			savecolor;
+		uint16_t			savecolor;
 		#if GDISP_GE8_BROKEN_CONTROLLER
-			color_t		firstcolor;
+			uint16_t		firstcolor;
 		#endif
 	} dvrPriv;
 	#define PRIV		((dvrPriv *)g->priv)
@@ -231,20 +231,23 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		g->flags &= ~(GDISP_FLG_ODDBYTE|GDISP_FLG_RUNBYTE);
 	}
 	LLDSPEC	void gdisp_lld_write_color(GDisplay *g) {
+		uint16_t	c;
+
+		c = COLOR2NATIVE(g->p.color);
 		#if GDISP_GE8_BROKEN_CONTROLLER
 			if (!(g->flags & GDISP_FLG_RUNBYTE)) {
-				PRIV->firstcolor = g->p.color;
+				PRIV->firstcolor = c;
 				g->flags |= GDISP_FLG_RUNBYTE;
 			}
 		#endif
 		if ((g->flags & GDISP_FLG_ODDBYTE)) {
 			// Write the pair of pixels to the display
 			write_data3(g, ((PRIV->savecolor >> 4) & 0xFF),
-					(((PRIV->savecolor << 4) & 0xF0)|((g->p.color >> 8) & 0x0F)),
-					(g->p.color & 0xFF));
+					(((PRIV->savecolor << 4) & 0xF0)|((c >> 8) & 0x0F)),
+					(c & 0xFF));
 			g->flags &= ~GDISP_FLG_ODDBYTE;
 		} else {
-			PRIV->savecolor = g->p.color;
+			PRIV->savecolor = c;
 			g->flags |= GDISP_FLG_ODDBYTE;
 		}
 	}
@@ -284,9 +287,12 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 
 #if GDISP_HARDWARE_DRAWPIXEL
 	LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) {
+		uint16_t	c;
+
+		c = COLOR2NATIVE(g->p.color);
 		acquire_bus(g);
 		set_viewport(g);
-		write_data3(g, 0, (g->p.color>>8) & 0x0F, g->p.color & 0xFF);
+		write_data3(g, 0, (c>>8) & 0x0F, c & 0xFF);
 		release_bus(g);
 	}
 #endif
@@ -295,15 +301,17 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 
 #if GDISP_HARDWARE_FILLS
 	LLDSPEC void gdisp_lld_fill_area(GDisplay *g) {
-		unsigned tuples;
+		unsigned	tuples;
+		uint16_t	c;
 
 		tuples = (g->p.cx*g->p.cy+1)>>1;	// With an odd sized area we over-print by one pixel.
 											// This extra pixel overwrites the first pixel (harmless as it is the same colour)
 
+		c = COLOR2NATIVE(g->p.color);
 		acquire_bus(g);
 		set_viewport(g);
 		while(tuples--)
-			write_data3(g, ((g->p.color >> 4) & 0xFF), (((g->p.color << 4) & 0xF0)|((g->p.color >> 8) & 0x0F)), (g->p.color & 0xFF));
+			write_data3(g, ((c >> 4) & 0xFF), (((c << 4) & 0xF0)|((c >> 8) & 0x0F)), (c & 0xFF));
 		release_bus(g);
 	}
 #endif
@@ -311,7 +319,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 #if GDISP_HARDWARE_BITFILLS
 	LLDSPEC void gdisp_lld_blit_area(GDisplay *g) {
 		coord_t			lg, x, y;
-		color_t			c1, c2;
+		uint16_t		c1, c2;
 		unsigned		tuples;
 		const pixel_t	*buffer;
 		#if GDISP_PACKED_PIXELS
@@ -328,7 +336,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		acquire_bus(g);
 		set_viewport(g);
 
-		/* to surpress compiler warnings */
+		/* to suppress compiler warnings */
 		x = 0;
 		y = 0;
 
@@ -356,7 +364,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 
 			while(tuples--) {
 				/* Get a pixel */
-				c1 = *p++;
+				c1 = COLOR2NATIVE(*p++);
 
 				/* Check for line or buffer wrapping */
 				if (++x >= g->p.cx) {
@@ -369,7 +377,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 				}
 
 				/* Get the next pixel */
-				c2 = *p++;
+				c2 = COLOR2NATIVE(*p++);
 
 				/* Check for line or buffer wrapping */
 				if (++x >= g->p.cx) {
@@ -385,7 +393,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 				write_data3(g, ((c1 >> 4) & 0xFF), (((c1 << 4) & 0xF0)|((c2 >> 8) & 0x0F)), (c2 & 0xFF));
 			}
 
-		#else
+		#elif GDISP_PIXELFORMAT == GDISP_LLD_PIXELFORMAT
 
 			// Although this controller uses packed pixels, we may have to feed it into
 			//  the controller with different packing to the source bitmap
@@ -440,6 +448,9 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 				/* Write the pair of pixels to the display */
 				write_data3(g, ((c1 >> 4) & 0xFF), (((c1 << 4) & 0xF0)|((c2 >> 8) & 0x0F)), (c2 & 0xFF));
 			}
+
+		#else
+			#error "Packed pixels is broken if you are not running native pixel format"
 		#endif
 
 		/* All done */
diff --git a/drivers/gdisp/RA8875/gdisp_lld_RA8875.c b/drivers/gdisp/RA8875/gdisp_lld_RA8875.c
index fb81c43a..d28670c6 100644
--- a/drivers/gdisp/RA8875/gdisp_lld_RA8875.c
+++ b/drivers/gdisp/RA8875/gdisp_lld_RA8875.c
@@ -184,7 +184,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		set_viewport(g);
 	}
 	LLDSPEC	void gdisp_lld_write_color(GDisplay *g) {
-		write_data(g, g->p.color);
+		write_data(g, COLOR2NATIVE(g->p.color));
 	}
 	LLDSPEC	void gdisp_lld_write_stop(GDisplay *g) {
 		release_bus(g);
diff --git a/drivers/gdisp/S6D1121/gdisp_lld_S6D1121.c b/drivers/gdisp/S6D1121/gdisp_lld_S6D1121.c
index cbaa7199..cca9d67e 100644
--- a/drivers/gdisp/S6D1121/gdisp_lld_S6D1121.c
+++ b/drivers/gdisp/S6D1121/gdisp_lld_S6D1121.c
@@ -221,7 +221,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		set_viewport(g);
 	}
 	LLDSPEC	void gdisp_lld_write_color(GDisplay *g) {
-		write_data(g, g->p.color);
+		write_data(g, COLOR2NATIVE(g->p.color));
 	}
 	LLDSPEC	void gdisp_lld_write_stop(GDisplay *g) {
 		release_bus(g);
@@ -240,7 +240,10 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		dummy_read(g);
 	}
 	LLDSPEC	color_t gdisp_lld_read_color(GDisplay *g) {
-		return read_data(g);
+		uint16_t	data;
+
+		data = read_data(g);
+		return NATIVE2COLOR(data);
 	}
 	LLDSPEC	void gdisp_lld_read_stop(GDisplay *g) {
 		setwritemode(g);
diff --git a/drivers/gdisp/SSD1289/gdisp_lld_SSD1289.c b/drivers/gdisp/SSD1289/gdisp_lld_SSD1289.c
index 6692e7d7..a33b6564 100644
--- a/drivers/gdisp/SSD1289/gdisp_lld_SSD1289.c
+++ b/drivers/gdisp/SSD1289/gdisp_lld_SSD1289.c
@@ -200,7 +200,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		#endif
 	}
 	LLDSPEC	void gdisp_lld_write_color(GDisplay *g) {
-		write_data(g, g->p.color);
+		write_data(g, COLOR2NATIVE(g->p.color));
 	}
 	LLDSPEC	void gdisp_lld_write_stop(GDisplay *g) {
 		release_bus(g);
@@ -221,7 +221,10 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		dummy_read(g);
 	}
 	LLDSPEC	color_t gdisp_lld_read_color(GDisplay *g) {
-		return read_data(g);
+		uint16_t	data;
+
+		data = read_data(g);
+		return NATIVE2COLOR(data);
 	}
 	LLDSPEC	void gdisp_lld_read_stop(GDisplay *g) {
 		setwritemode(g);
@@ -231,15 +234,22 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 
 #if GDISP_HARDWARE_FILLS && defined(GDISP_USE_DMA)
 	LLDSPEC void gdisp_lld_fill_area(GDisplay *g) {
+		uint16_t	c;
+
+		c = COLOR2NATIVE(g->p.color);
 		acquire_bus(g);
 		set_viewport(g);
 		set_cursor(g);
-		dma_with_noinc(g, &color, g->p.cx*g->p.cy)
+		dma_with_noinc(g, &c, g->p.cx*g->p.cy)
 		release_bus(g);
 	}
 #endif
 
 #if GDISP_HARDWARE_BITFILLS && defined(GDISP_USE_DMA)
+	#if GDISP_PIXELFORMAT != GDISP_LLD_PIXELFORMAT
+		#error "GDISP: SSD1289: BitBlit is only available in RGB565 pixel format"
+	#endif
+
 	LLDSPEC void gdisp_lld_blit_area(GDisplay *g) {
 		pixel_t		*buffer;
 		coord_t		ycnt;
diff --git a/drivers/gdisp/SSD1289/gdisp_lld_config.h b/drivers/gdisp/SSD1289/gdisp_lld_config.h
index 4cf5fa5c..a9166553 100644
--- a/drivers/gdisp/SSD1289/gdisp_lld_config.h
+++ b/drivers/gdisp/SSD1289/gdisp_lld_config.h
@@ -28,8 +28,11 @@
 #define GDISP_HARDWARE_CONTROL			TRUE
 
 #if defined(GDISP_USE_DMA)

-	#define GDISP_HARDWARE_FILLS		TRUE

-	#define GDISP_HARDWARE_BITFILLS		TRUE
+	#define GDISP_HARDWARE_FILLS		TRUE
+	#if !defined(GDISP_PIXELFORMAT) || GDISP_PIXELFORMAT == 0x2565
+		// Hardware BitBlts are only supported in native pixel format on this controller

+		#define GDISP_HARDWARE_BITFILLS		TRUE
+	#endif
 #endif

 

 #define GDISP_LLD_PIXELFORMAT			GDISP_PIXELFORMAT_RGB565

diff --git a/drivers/gdisp/SSD1306/gdisp_lld_SSD1306.c b/drivers/gdisp/SSD1306/gdisp_lld_SSD1306.c
index bd3e386d..b72ba781 100644
--- a/drivers/gdisp/SSD1306/gdisp_lld_SSD1306.c
+++ b/drivers/gdisp/SSD1306/gdisp_lld_SSD1306.c
@@ -176,7 +176,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 			x = g->p.x;
 			break;
 		}
-		if (g->p.color != Black)
+		if (COLOR2NATIVE(g->p.color) != Black)
 			RAM(g)[xyaddr(x, y)] |= xybit(y);
 		else
 			RAM(g)[xyaddr(x, y)] &= ~xybit(y);
diff --git a/drivers/gdisp/SSD1963/gdisp_lld_SSD1963.c b/drivers/gdisp/SSD1963/gdisp_lld_SSD1963.c
index b94c1a40..eb1b9b15 100644
--- a/drivers/gdisp/SSD1963/gdisp_lld_SSD1963.c
+++ b/drivers/gdisp/SSD1963/gdisp_lld_SSD1963.c
@@ -188,7 +188,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		set_viewport(g);
 	}
 	LLDSPEC	void gdisp_lld_write_color(GDisplay *g) {
-		write_data(g, g->p.color);
+		write_data(g, COLOR2NATIVE(g->p.color));
 	}
 	LLDSPEC	void gdisp_lld_write_stop(GDisplay *g) {
 		release_bus(g);
diff --git a/drivers/gdisp/SSD2119/gdisp_lld_SSD2119.c b/drivers/gdisp/SSD2119/gdisp_lld_SSD2119.c
index df05fc2c..9594ff95 100644
--- a/drivers/gdisp/SSD2119/gdisp_lld_SSD2119.c
+++ b/drivers/gdisp/SSD2119/gdisp_lld_SSD2119.c
@@ -238,7 +238,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay* g) {
 		set_viewport(g);
 	}
 	LLDSPEC void gdisp_lld_write_color(GDisplay* g) {
-		write_data(g, g->p.color);
+		write_data(g, COLOR2NATIVE(g->p.color));
 	}
 	LLDSPEC void gdisp_lld_write_stop(GDisplay* g) {
 		release_bus(g);
@@ -257,7 +257,10 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay* g) {
 		dummy_read(g);
 	}
 	LLDSPEC color_t gdisp_lld_read_color(GDisplay* g) {
-		return read_data(g);
+		uint16_t	data;
+
+		data = read_data(g);
+		return NATIVE2COLOR(data);
 	}
 	LLDSPEC void gdisp_lld_read_stop(GDisplay* g) {
 		setwritemode(g);
@@ -267,15 +270,22 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay* g) {
 
 #if GDISP_HARDWARE_FILLS && defined(GDISP_USE_DMA)
 	LLDSPEC void gdisp_lld_fill_area(GDisplay* g) {
+		uint16_t	c;
+
+		c = COLOR2NATIVE(g->p.color);
 		acquire_bus(g);
 		set_viewport(g);
 		set_cursor(g);	
-		dma_with_noinc(g, &g->p.color, g->p.cx * g->p.cy);
+		dma_with_noinc(g, &c, g->p.cx * g->p.cy);
 		release_bus(g);
 	}
 #endif
 
 #if GDISP_HARDWARE_BITFILLS && defined(GDISP_USE_DMA)
+	#if GDISP_PIXELFORMAT != GDISP_LLD_PIXELFORMAT
+		#error "GDISP: SSD2119: BitBlit is only available in RGB565 pixel format"
+	#endif
+
 	LLDSPEC void gdisp_lld_blit_area(GDisplay* g) {
 		pixel_t*	buffer;
 		coord_t		ynct;
diff --git a/drivers/gdisp/SSD2119/gdisp_lld_config.h b/drivers/gdisp/SSD2119/gdisp_lld_config.h
index a974c623..ec034bef 100644
--- a/drivers/gdisp/SSD2119/gdisp_lld_config.h
+++ b/drivers/gdisp/SSD2119/gdisp_lld_config.h
@@ -29,7 +29,10 @@
 
 #if defined(GDISP_USE_DMA)
 	#define GDISP_HARDWARE_FILLS		TRUE
-	#define GDISP_HARDWARE_BITFILLS		TRUE
+	#if !defined(GDISP_PIXELFORMAT) || GDISP_PIXELFORMAT == 0x2565
+		// Hardware BitBlts are only supported in native pixel format on this controller
+		#define GDISP_HARDWARE_BITFILLS		TRUE
+	#endif
 #endif
 
 #define GDISP_LLD_PIXELFORMAT			GDISP_PIXELFORMAT_RGB565
diff --git a/drivers/gdisp/ST7565/gdisp_lld_ST7565.c b/drivers/gdisp/ST7565/gdisp_lld_ST7565.c
index bd8c7b74..2bb5406f 100644
--- a/drivers/gdisp/ST7565/gdisp_lld_ST7565.c
+++ b/drivers/gdisp/ST7565/gdisp_lld_ST7565.c
@@ -167,7 +167,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 			y = g->p.x;
 			break;
 		}
-		if (g->p.color != Black)
+		if (COLOR2NATIVE(g->p.color) != Black)
 			RAM(g)[xyaddr(x, y)] |= xybit(y);
 		else
 			RAM(g)[xyaddr(x, y)] &= ~xybit(y);
diff --git a/drivers/multiple/Win32/gdisp_lld_Win32.c b/drivers/multiple/Win32/gdisp_lld_Win32.c
index 6cbf9cd4..9484c823 100644
--- a/drivers/multiple/Win32/gdisp_lld_Win32.c
+++ b/drivers/multiple/Win32/gdisp_lld_Win32.c
@@ -23,9 +23,7 @@
 #ifndef GDISP_SCREEN_HEIGHT
 	#define GDISP_SCREEN_HEIGHT	480
 #endif
-#if GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB888
-	#error "GDISP Win32: This driver currently only supports the RGB888 pixel format."
-#endif
+
 // Setting this to TRUE delays updating the screen
 // to the windows paint routine. Due to the
 // drawing lock this does not add as much speed
@@ -89,9 +87,6 @@ static HANDLE			drawMutex;
 
 #define APP_NAME "uGFX"
 
-#define COLOR2BGR(c)	((((c) & 0xFF)<<16)|((c) & 0xFF00)|(((c)>>16) & 0xFF))
-#define BGR2COLOR(c)	COLOR2BGR(c)
-
 typedef struct winPriv {
 	HWND			hwnd;
 	HDC				dcBuffer;
@@ -291,9 +286,9 @@ static LRESULT myWindowProc(HWND hWnd,	UINT Msg, WPARAM wParam, LPARAM lParam)
 		// Paint the toggle area
 		#if GINPUT_NEED_TOGGLE
 			if (ps.rcPaint.bottom >= GDISP_SCREEN_HEIGHT && (g->flags & GDISP_FLG_HASTOGGLE)) {
-				pen = CreatePen(PS_SOLID, 1, COLOR2BGR(Black));
-				hbrOn = CreateSolidBrush(COLOR2BGR(Blue));
-				hbrOff = CreateSolidBrush(COLOR2BGR(Gray));
+				pen = CreatePen(PS_SOLID, 1, COLOR2NATIVE(Black));
+				hbrOn = CreateSolidBrush(COLOR2NATIVE(Blue));
+				hbrOff = CreateSolidBrush(COLOR2NATIVE(Gray));
 				old = SelectObject(dc, pen);
 				MoveToEx(dc, 0, GDISP_SCREEN_HEIGHT, &p);
 				LineTo(dc, GDISP_SCREEN_WIDTH, GDISP_SCREEN_HEIGHT);
@@ -519,7 +514,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		COLORREF	color;
 
 		priv = g->priv;
-		color = COLOR2BGR(g->p.color);
+		color = COLOR2NATIVE(g->p.color);
 
 		if (!(g->flags & GDISP_FLG_WSTREAM))
 			BAD_PARAMETER("write_color: not in streaming mode");
@@ -667,7 +662,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 			}
 		}
 
-		return BGR2COLOR(color);
+		return NATIVE2COLOR(color);
 	}
 	LLDSPEC	void gdisp_lld_read_stop(GDisplay *g) {
 		if (!(g->flags & GDISP_FLG_WSTREAM))
@@ -683,7 +678,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		COLORREF	color;
 	
 		priv = g->priv;
-		color = COLOR2BGR(g->p.color);
+		color = COLOR2NATIVE(g->p.color);
 	
 		#if GDISP_NEED_CONTROL
 			switch(g->g.Orientation) {
@@ -742,7 +737,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		COLORREF	color;
 
 		priv = g->priv;
-		color = COLOR2BGR(g->p.color);
+		color = COLOR2NATIVE(g->p.color);
 		hbr = CreateSolidBrush(color);
 
 		#if GDISP_NEED_CONTROL
@@ -841,6 +836,10 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 #endif
 	
 #if GDISP_HARDWARE_BITFILLS
+	#if COLOR_SYSTEM != GDISP_COLORSYSTEM_TRUECOLOR || COLOR_TYPE_BITS <= 8
+		#error "GDISP Win32: This driver's bitblit currently only supports true-color with bit depths > 8 bits."
+	#endif
+
 	LLDSPEC void gdisp_lld_blit_area(GDisplay *g) {
 		winPriv	*		priv;
 		pixel_t	*		buffer;
@@ -855,7 +854,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		memset(&bmpInfo, 0, sizeof(bmpInfo));
 		bmpInfo.bV4Size = sizeof(bmpInfo);
 		bmpInfo.bV4Planes = 1;
-		bmpInfo.bV4BitCount = sizeof(pixel_t)*8;
+		bmpInfo.bV4BitCount = COLOR_TYPE_BITS;
 		bmpInfo.bV4AlphaMask = 0;
 		bmpInfo.bV4RedMask		= RGB2COLOR(255,0,0);
 		bmpInfo.bV4GreenMask	= RGB2COLOR(0,255,0);
@@ -969,7 +968,7 @@ LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
 		#endif
 		ReleaseMutex(drawMutex);
 		
-		return BGR2COLOR(color);
+		return NATIVE2COLOR(color);
 	}
 #endif
 
diff --git a/drivers/multiple/Win32/gdisp_lld_config.h b/drivers/multiple/Win32/gdisp_lld_config.h
index 4985bc43..1554161b 100644
--- a/drivers/multiple/Win32/gdisp_lld_config.h
+++ b/drivers/multiple/Win32/gdisp_lld_config.h
@@ -41,11 +41,19 @@
 	#define GDISP_HARDWARE_DRAWPIXEL		TRUE
 	#define GDISP_HARDWARE_FILLS			TRUE
 	#define GDISP_HARDWARE_PIXELREAD		TRUE
-	#define GDISP_HARDWARE_BITFILLS			TRUE
 	#define GDISP_HARDWARE_SCROLL			TRUE
+
+	// Bit-blits on Win32 are currently only supported for True-Color bit-depths greater than 8 bits
+	// Note: At the time this file is included we have not calculated all our color
+	//			definitions so we need to do this by hand.
+	#if !defined(GDISP_PIXELFORMAT)
+		#define GDISP_HARDWARE_BITFILLS			TRUE
+	#elif (GDISP_PIXELFORMAT & 0x2000) && (((GDISP_PIXELFORMAT & 0x0F00)>>8)+((GDISP_PIXELFORMAT & 0x00F0)>>4)+((GDISP_PIXELFORMAT & 0x000F))) > 8
+		#define GDISP_HARDWARE_BITFILLS			TRUE
+	#endif
 #endif
 
-#define GDISP_LLD_PIXELFORMAT				GDISP_PIXELFORMAT_RGB888
+#define GDISP_LLD_PIXELFORMAT				GDISP_PIXELFORMAT_BGR888
 

 #endif	/* GFX_USE_GDISP */

 

diff --git a/include/gdisp/colors.h b/include/gdisp/colors.h
index 486424b7..efd7076c 100644
--- a/include/gdisp/colors.h
+++ b/include/gdisp/colors.h
@@ -48,6 +48,9 @@
  * @{
  */
 #define GDISP_PIXELFORMAT_MONO		(GDISP_COLORSYSTEM_GRAYSCALE|0x0001)
+#define GDISP_PIXELFORMAT_GRAY4		(GDISP_COLORSYSTEM_GRAYSCALE|0x0002)
+#define GDISP_PIXELFORMAT_GRAY16	(GDISP_COLORSYSTEM_GRAYSCALE|0x0004)
+#define GDISP_PIXELFORMAT_GRAY256	(GDISP_COLORSYSTEM_GRAYSCALE|0x0008)
 #define GDISP_PIXELFORMAT_RGB565	(GDISP_COLORSYSTEM_RGB|0x0565)
 #define GDISP_PIXELFORMAT_BGR565	(GDISP_COLORSYSTEM_BGR|0x0565)
 #define GDISP_PIXELFORMAT_RGB888	(GDISP_COLORSYSTEM_RGB|0x0888)
@@ -133,6 +136,15 @@
 	 */
 	#define COLOR_TYPE_BITS		16
 	/**
+	 * @brief   Convert a luminance (0 to 255) into a color value.
+	 * @note	The word "Luma" is used instead of grey or gray due to the spelling ambiguities of the word grey
+	 * @note	This is not a weighted luminance conversion in the color tv style.
+	 * @note	@p LUMA2COLOR() uses a linear conversion (0.33R + 0.33G + 0.33B). Note this is different to color
+	 * 			tv luminance (0.26126R + 0.7152G + 0.0722B),  digital tv luminance of (0.299R + 0.587G + 0.114B), or
+	 * 			@p LUMA_OF() which uses (0.25R + 0.5G + 0.25B).
+	 */
+	#define LUMA2COLOR(l)		((color_t)((((l) & 0xF8)<<8) | (((l) & 0xFC)<<3) | (((l) & 0xF8)>>3)))
+	/**
 	 * @brief   Convert red, green, blue (each 0 to 255) into a color value.
 	 */
 	#define RGB2COLOR(r,g,b)	((color_t)((((r) & 0xF8)<<8) | (((g) & 0xFC)<<3) | (((b) & 0xF8)>>3)))
@@ -141,27 +153,35 @@
 	 */
 	#define HTML2COLOR(h)		((color_t)((((h) & 0xF80000)>>8) | (((h) & 0x00FC00)>>5) | (((h) & 0x0000F8)>>3)))
 	/**
-	 * @brief   Extract the red/green/blue component (0 to 255) of a color value.
+	 * @brief   Extract the luma/red/green/blue component (0 to 255) of a color value.
 	 * @note	This uses quick and dirty bit shifting. If you want more exact colors
 	 * 			use @p EXACT_RED_OF() etc which uses multiplies and divides. For constant
-	 * 			colors using @p EXACT_REF_OF() is no more expensive because the compiler
+	 * 			colors using @p EXACT_RED_OF() is no more expensive because the compiler
 	 * 			evaluates the arithmetic.
-	 * @note	A 5 bit maximum value (0x1F) converts to 0xF8 (slightly off-color)
+	 * @note	@p LUMA_OF() returns a roughly weighted luminance (0.25R + 0.5G + 0.25B). Note this is
+	 * 			different to @p LUMA2COLOR() which uses a linear conversion (0.33R + 0.33G + 0.33B) and
+	 * 			color tv luminance of (0.26126R + 0.7152G + 0.0722B) and digital tv luminance of (0.299R + 0.587G + 0.114B).
+	 * @note	A 5 bit color component maximum value (0x1F) converts to 0xF8 (slightly off-color)
 	 * @{
 	 */
+	#define LUMA_OF(c)			((RED_OF(c)+((uint16_t)GREEN_OF(c)<<1)+BLUE_OF(c))>>2)
 	#define RED_OF(c)			(((c) & 0xF800)>>8)
 	#define GREEN_OF(c)			(((c)&0x007E)>>3)
 	#define BLUE_OF(c)			(((c)&0x001F)<<3)
 	/** @} */
 	/**
-	 * @brief   Extract the exact red/green/blue component (0 to 255) of a color value.
+	 * @brief   Extract the exact luma/red/green/blue component (0 to 255) of a color value.
 	 * @note	This uses multiplies and divides rather than bit shifting.
 	 * 			This gives exact equivalent colors at the expense of more cpu intensive
 	 * 			operations. Note for constants this is no more expensive than @p REF_OF()
 	 * 			because the compiler evaluates the arithmetic.
-	 * @note	A 5 bit maximum value (0x1F) converts to 0xFF ( the true equivalent color)
+	 * @note	@p EXACT_LUMA_OF() returns a roughly weighted luminance (0.25R + 0.5G + 0.25B). Note this is
+	 * 			different to @p LUMA2COLOR() which uses a linear conversion (0.33R + 0.33G + 0.33B) and
+	 * 			color tv luminance of (0.26126R + 0.7152G + 0.0722B) and digital tv luminance of (0.299R + 0.587G + 0.114B).
+	 * @note	A 5 bit color component maximum value (0x1F) converts to 0xFF (the true equivalent color)
 	 * @{
 	 */
+	#define EXACT_LUMA_OF(c)	((EXACT_RED_OF(c)+((uint16_t)EXACT_GREEN_OF(c)<<1)+EXACT_BLUE_OF(c))>>2)
 	#define EXACT_RED_OF(c)		(((((c)>>11)&0x1F)*255)/31)
 	#define EXACT_GREEN_OF(c)	(((((c)>>5)&0x3F)*255)/63)
 	#define EXACT_BLUE_OF(c)	(((((c)>>0)&0x1F)*255)/31)
@@ -219,61 +239,64 @@
 
 	// Calculate RED_OF, GREEN_OF, BLUE_OF and RGB2COLOR
 	#if COLOR_BITS_R + COLOR_SHIFT_R == 8
-		#define RED_OF(val)			((val) & (((1<<COLOR_BITS_R)-1) << COLOR_SHIFT_R))
-		#define RGB2COLOR_R(val)	((COLOR_TYPE)((val) & (0xFF & ~((1<<(8-COLOR_BITS_R))-1))))
+		#define RED_OF(c)			((c) & (((1<<COLOR_BITS_R)-1) << COLOR_SHIFT_R))
+		#define RGB2COLOR_R(r)		((COLOR_TYPE)((r) & (0xFF & ~((1<<(8-COLOR_BITS_R))-1))))
 	#elif COLOR_BITS_R + COLOR_SHIFT_R > 8
-		#define RED_OF(val)			(((val) & (((1<<COLOR_BITS_R)-1) << COLOR_SHIFT_R)) >> (COLOR_BITS_R+COLOR_SHIFT_R-8))
-		#define RGB2COLOR_R(val)	(((COLOR_TYPE)((val) & (0xFF & ~((1<<(8-COLOR_BITS_R))-1)))) << (COLOR_BITS_R+COLOR_SHIFT_R-8))
+		#define RED_OF(c)			(((c) & (((1<<COLOR_BITS_R)-1) << COLOR_SHIFT_R)) >> (COLOR_BITS_R+COLOR_SHIFT_R-8))
+		#define RGB2COLOR_R(r)		(((COLOR_TYPE)((r) & (0xFF & ~((1<<(8-COLOR_BITS_R))-1)))) << (COLOR_BITS_R+COLOR_SHIFT_R-8))
 	#else // COLOR_BITS_R + COLOR_SHIFT_R < 8
-		#define RED_OF(val)			(((val) & (((1<<COLOR_BITS_R)-1) << COLOR_SHIFT_R)) << (8-(COLOR_BITS_R+COLOR_SHIFT_R)))
-		#define RGB2COLOR_R(val)	(((COLOR_TYPE)((val) & (0xFF & ~((1<<(8-COLOR_BITS_R))-1)))) >> (8-(COLOR_BITS_R+COLOR_SHIFT_R)))
+		#define RED_OF(c)			(((c) & (((1<<COLOR_BITS_R)-1) << COLOR_SHIFT_R)) << (8-(COLOR_BITS_R+COLOR_SHIFT_R)))
+		#define RGB2COLOR_R(r)		(((COLOR_TYPE)((r) & (0xFF & ~((1<<(8-COLOR_BITS_R))-1)))) >> (8-(COLOR_BITS_R+COLOR_SHIFT_R)))
 	#endif
 	#if COLOR_BITS_G + COLOR_SHIFT_G == 8
-		#define GREEN_OF(val)		((val) & (((1<<COLOR_BITS_G)-1) << COLOR_SHIFT_G))
-		#define RGB2COLOR_G(val)	((COLOR_TYPE)((val) & (0xFF & ~((1<<(8-COLOR_BITS_G))-1))))
+		#define GREEN_OF(c)			((c) & (((1<<COLOR_BITS_G)-1) << COLOR_SHIFT_G))
+		#define RGB2COLOR_G(g)		((COLOR_TYPE)((g) & (0xFF & ~((1<<(8-COLOR_BITS_G))-1))))
 	#elif COLOR_BITS_G + COLOR_SHIFT_G > 8
-		#define GREEN_OF(val)		(((val) & (((1<<COLOR_BITS_G)-1) << COLOR_SHIFT_G)) >> (COLOR_BITS_G+COLOR_SHIFT_G-8))
-		#define RGB2COLOR_G(val)	(((COLOR_TYPE)((val) & (0xFF & ~((1<<(8-COLOR_BITS_G))-1)))) << (COLOR_BITS_G+COLOR_SHIFT_G-8))
+		#define GREEN_OF(c)			(((c) & (((1<<COLOR_BITS_G)-1) << COLOR_SHIFT_G)) >> (COLOR_BITS_G+COLOR_SHIFT_G-8))
+		#define RGB2COLOR_G(g)		(((COLOR_TYPE)((g) & (0xFF & ~((1<<(8-COLOR_BITS_G))-1)))) << (COLOR_BITS_G+COLOR_SHIFT_G-8))
 	#else // COLOR_BITS_G + COLOR_SHIFT_G < 8
-		#define GREEN_OF(val)		(((val) & (((1<<COLOR_BITS_G)-1) << COLOR_SHIFT_G)) << (8-(COLOR_BITS_G+COLOR_SHIFT_G)))
-		#define RGB2COLOR_G(val)	(((COLOR_TYPE)((val) & (0xFF & ~((1<<(8-COLOR_BITS_G))-1)))) >> (8-(COLOR_BITS_G+COLOR_SHIFT_G)))
+		#define GREEN_OF(c)			(((c) & (((1<<COLOR_BITS_G)-1) << COLOR_SHIFT_G)) << (8-(COLOR_BITS_G+COLOR_SHIFT_G)))
+		#define RGB2COLOR_G(g)		(((COLOR_TYPE)((g) & (0xFF & ~((1<<(8-COLOR_BITS_G))-1)))) >> (8-(COLOR_BITS_G+COLOR_SHIFT_G)))
 	#endif
 	#if COLOR_BITS_B + COLOR_SHIFT_B == 8
-		#define BLUE_OF(val)		((val) & (((1<<COLOR_BITS_B)-1) << COLOR_SHIFT_B))
-		#define RGB2COLOR_B(val)	((COLOR_TYPE)((val) & (0xFF & ~((1<<(8-COLOR_BITS_B))-1))))
+		#define BLUE_OF(c)			((c) & (((1<<COLOR_BITS_B)-1) << COLOR_SHIFT_B))
+		#define RGB2COLOR_B(b)		((COLOR_TYPE)((b) & (0xFF & ~((1<<(8-COLOR_BITS_B))-1))))
 	#elif COLOR_BITS_B + COLOR_SHIFT_B > 8
-		#define BLUE_OF(val)		(((val) & (((1<<COLOR_BITS_B)-1) << COLOR_SHIFT_B)) >> (COLOR_BITS_B+COLOR_SHIFT_B-8))
-		#define RGB2COLOR_B(val)	(((COLOR_TYPE)((val) & (0xFF & ~((1<<(8-COLOR_BITS_B))-1)))) << (COLOR_BITS_B+COLOR_SHIFT_B-8))
+		#define BLUE_OF(c)			(((c) & (((1<<COLOR_BITS_B)-1) << COLOR_SHIFT_B)) >> (COLOR_BITS_B+COLOR_SHIFT_B-8))
+		#define RGB2COLOR_B(b)		(((COLOR_TYPE)((b) & (0xFF & ~((1<<(8-COLOR_BITS_B))-1)))) << (COLOR_BITS_B+COLOR_SHIFT_B-8))
 	#else // COLOR_BITS_B + COLOR_SHIFT_B < 8
-		#define BLUE_OF(val)		(((val) & (((1<<COLOR_BITS_B)-1) << COLOR_SHIFT_B)) << (8-(COLOR_BITS_B+COLOR_SHIFT_B)))
-		#define RGB2COLOR_B(val)	(((COLOR_TYPE)((val) & (0xFF & ~((1<<(8-COLOR_BITS_B))-1)))) >> (8-(COLOR_BITS_B+COLOR_SHIFT_B)))
+		#define BLUE_OF(c)			(((c) & (((1<<COLOR_BITS_B)-1) << COLOR_SHIFT_B)) << (8-(COLOR_BITS_B+COLOR_SHIFT_B)))
+		#define RGB2COLOR_B(b)		(((COLOR_TYPE)((b) & (0xFF & ~((1<<(8-COLOR_BITS_B))-1)))) >> (8-(COLOR_BITS_B+COLOR_SHIFT_B)))
 	#endif
-	#define EXACT_RED_OF(val)		(((((val)>>COLOR_SHIFT_R)&((1<<COLOR_BITS_R)-1))*255)/((1<<COLOR_BITS_R)-1))
-	#define EXACT_GREEN_OF(val)		(((((val)>>COLOR_SHIFT_G)&((1<<COLOR_BITS_G)-1))*255)/((1<<COLOR_BITS_G)-1))
-	#define EXACT_BLUE_OF(val)		(((((val)>>COLOR_SHIFT_B)&((1<<COLOR_BITS_B)-1))*255)/((1<<COLOR_BITS_B)-1))
+	#define LUMA_OF(c)				((RED_OF(c)+((uint16_t)GREEN_OF(c)<<1)+BLUE_OF(c))>>2)
+	#define EXACT_RED_OF(c)			(((uint16_t)(((c)>>COLOR_SHIFT_R)&((1<<COLOR_BITS_R)-1))*255)/((1<<COLOR_BITS_R)-1))
+	#define EXACT_GREEN_OF(c)		(((uint16_t)(((c)>>COLOR_SHIFT_G)&((1<<COLOR_BITS_G)-1))*255)/((1<<COLOR_BITS_G)-1))
+	#define EXACT_BLUE_OF(c)		(((uint16_t)(((c)>>COLOR_SHIFT_B)&((1<<COLOR_BITS_B)-1))*255)/((1<<COLOR_BITS_B)-1))
+	#define EXACT_LUMA_OF(c)		((EXACT_RED_OF(c)+((uint16_t)EXACT_GREEN_OF(c)<<1)+EXACT_BLUE_OF(c))>>2)
+	#define LUMA2COLOR(l)			(RGB2COLOR_R(l) | RGB2COLOR_G(l) | RGB2COLOR_B(l))
 	#define RGB2COLOR(r,g,b)		(RGB2COLOR_R(r) | RGB2COLOR_G(g) | RGB2COLOR_B(b))
 
 	// Calculate HTML2COLOR
 	#if COLOR_BITS_R + COLOR_SHIFT_R == 24
-		#define HTML2COLOR_R(val)	((val) & ((0xFF & ~((1<<(8-COLOR_BITS_R))-1))<<16))
+		#define HTML2COLOR_R(h)		((h) & ((0xFF & ~((1<<(8-COLOR_BITS_R))-1))<<16))
 	#elif COLOR_BITS_R + COLOR_SHIFT_R > 24
-		#define HTML2COLOR_R(val)	(((val) & ((0xFF & ~((1<<(8-COLOR_BITS_R))-1))<<16)) << (COLOR_BITS_R+COLOR_SHIFT_R-24))
+		#define HTML2COLOR_R(h)		(((h) & ((0xFF & ~((1<<(8-COLOR_BITS_R))-1))<<16)) << (COLOR_BITS_R+COLOR_SHIFT_R-24))
 	#else // COLOR_BITS_R + COLOR_SHIFT_R < 24
-		#define HTML2COLOR_R(val)	(((val) & ((0xFF & ~((1<<(8-COLOR_BITS_R))-1))<<16)) >> (24-(COLOR_BITS_R+COLOR_SHIFT_R)))
+		#define HTML2COLOR_R(h)		(((h) & ((0xFF & ~((1<<(8-COLOR_BITS_R))-1))<<16)) >> (24-(COLOR_BITS_R+COLOR_SHIFT_R)))
 	#endif
 	#if COLOR_BITS_G + COLOR_SHIFT_G == 16
-		#define HTML2COLOR_G(val)	((val) & ((0xFF & ~((1<<(8-COLOR_BITS_G))-1))<<8))
+		#define HTML2COLOR_G(h)		((h) & ((0xFF & ~((1<<(8-COLOR_BITS_G))-1))<<8))
 	#elif COLOR_BITS_G + COLOR_SHIFT_G > 16
-		#define HTML2COLOR_G(val)	(((val) & ((0xFF & ~((1<<(8-COLOR_BITS_G))-1))<<8)) << (COLOR_BITS_G+COLOR_SHIFT_G-16))
+		#define HTML2COLOR_G(h)		(((h) & ((0xFF & ~((1<<(8-COLOR_BITS_G))-1))<<8)) << (COLOR_BITS_G+COLOR_SHIFT_G-16))
 	#else // COLOR_BITS_G + COLOR_SHIFT_G < 16
-		#define HTML2COLOR_G(val)	(((val) & ((0xFF & ~((1<<(8-COLOR_BITS_G))-1))<<8)) >> (16-(COLOR_BITS_G+COLOR_SHIFT_G)))
+		#define HTML2COLOR_G(h)		(((h) & ((0xFF & ~((1<<(8-COLOR_BITS_G))-1))<<8)) >> (16-(COLOR_BITS_G+COLOR_SHIFT_G)))
 	#endif
 	#if COLOR_BITS_B + COLOR_SHIFT_B == 8
-		#define HTML2COLOR_B(val)	((val) & (0xFF & ~((1<<(8-COLOR_BITS_B))-1)))
+		#define HTML2COLOR_B(h)		((h) & (0xFF & ~((1<<(8-COLOR_BITS_B))-1)))
 	#elif COLOR_BITS_B + COLOR_SHIFT_B > 8
-		#define HTML2COLOR_B(val)	(((val) & (0xFF & ~((1<<(8-COLOR_BITS_B))-1))) << (COLOR_BITS_B+COLOR_SHIFT_B-8))
+		#define HTML2COLOR_B(h)		(((h) & (0xFF & ~((1<<(8-COLOR_BITS_B))-1))) << (COLOR_BITS_B+COLOR_SHIFT_B-8))
 	#else // COLOR_BITS_B + COLOR_SHIFT_B < 8
-		#define HTML2COLOR_B(val)	(((val) & (0xFF & ~((1<<(8-COLOR_BITS_B))-1))) >> (8-(COLOR_BITS_B+COLOR_SHIFT_B)))
+		#define HTML2COLOR_B(h)		(((h) & (0xFF & ~((1<<(8-COLOR_BITS_B))-1))) >> (8-(COLOR_BITS_B+COLOR_SHIFT_B)))
 	#endif
 	#define HTML2COLOR(h)		((COLOR_TYPE)(HTML2COLOR_R(h) | HTML2COLOR_G(h) | HTML2COLOR_B(h)))
 
@@ -308,25 +331,26 @@
 
 	#if COLOR_BITS == 1
 		#define RGB2COLOR(r,g,b)	(((r)|(g)|(b)) ? 1 : 0)
+		#define LUMA2COLOR(l)		((l) ? 1 : 0)
 		#define HTML2COLOR(h)		((h) ? 1 : 0)
-		#define RED_OF(c)			((c) ? 255 : 0)
-		#define GREEN_OF(c)			RED_OF(c)
-		#define BLUE_OF(c)			RED_OF(c)
-		#define EXACT_RED_OF(val)	RED_OF(c)
-		#define EXACT_GREEN_OF(val)	RED_OF(c)
-		#define EXACT_BLUE_OF(val)	RED_OF(c)
+		#define LUMA_OF(c)			((c) ? 255 : 0)
+		#define EXACT_LUMA_OF(c)	LUMA_OF(c)
 	#else
 		// They eye is more sensitive to green
 		#define RGB2COLOR(r,g,b)	((COLOR_TYPE)(((uint16_t)(r)+(g)+(g)+(b)) >> (10-COLOR_BITS)))
+		#define LUMA2COLOR(l)		((COLOR_TYPE)((l)>>(8-COLOR_BITS)))
 		#define HTML2COLOR(h)		((COLOR_TYPE)(((((h)&0xFF0000)>>16)+(((h)&0x00FF00)>>7)+((h)&0x0000FF)) >> (10-COLOR_BITS)))
-		#define RED_OF(val)			(((val) & ((1<<COLOR_BITS)-1)) << (8-COLOR_BITS))
-		#define GREEN_OF(c)			RED_OF(c)
-		#define BLUE_OF(c)			RED_OF(c)
-		#define EXACT_RED_OF(val)	((((uint16_t)(val) & ((1<<COLOR_BITS)-1))*255)/((1<<COLOR_BITS)-1))
-		#define EXACT_GREEN_OF(val)	EXACT_RED_OF(c)
-		#define EXACT_BLUE_OF(val)	EXACT_RED_OF(c)
+		#define LUMA_OF(c)			(((c) & ((1<<COLOR_BITS)-1)) << (8-COLOR_BITS))
+		#define EXACT_LUMA_OF(c)	((((uint16_t)(c) & ((1<<COLOR_BITS)-1))*255)/((1<<COLOR_BITS)-1))
 	#endif
 
+	#define RED_OF(c)			LUMA_OF(c)
+	#define GREEN_OF(c)			LUMA_OF(c)
+	#define BLUE_OF(c)			LUMA_OF(c)
+	#define EXACT_RED_OF(c)		EXACT_LUMA_OF(c)
+	#define EXACT_GREEN_OF(c)	EXACT_LUMA_OF(c)
+	#define EXACT_BLUE_OF(c)	EXACT_LUMA_OF(c)
+
 //-------------------------
 //	Palette color system
 //-------------------------
diff --git a/include/gdisp/lld/gdisp_lld.h b/include/gdisp/lld/gdisp_lld.h
index 6f3a5e5f..d928d83d 100644
--- a/include/gdisp/lld/gdisp_lld.h
+++ b/include/gdisp/lld/gdisp_lld.h
@@ -651,6 +651,254 @@ struct GDisplay {
 	void gdispPackPixels(const pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color);
 #endif
 
+/* Low level driver pixel format information */
+//-------------------------
+//	True-Color color system
+//-------------------------
+#if GDISP_LLD_PIXELFORMAT & GDISP_COLORSYSTEM_TRUECOLOR
+	#define LLDCOLOR_SYSTEM			GDISP_COLORSYSTEM_TRUECOLOR
+
+	// Calculate the number of bits
+	#define LLDCOLOR_BITS_R			((GDISP_LLD_PIXELFORMAT>>8) & 0x0F)
+	#define LLDCOLOR_BITS_G			((GDISP_LLD_PIXELFORMAT>>4) & 0x0F)
+	#define LLDCOLOR_BITS_B			((GDISP_LLD_PIXELFORMAT>>0) & 0x0F)
+	#define LLDCOLOR_BITS			(LLDCOLOR_BITS_R + LLDCOLOR_BITS_G + LLDCOLOR_BITS_B)
+
+	// From the number of bits determine COLOR_TYPE, COLOR_TYPE_BITS and masking
+	#if LLDCOLOR_BITS <= 8
+		#define LLDCOLOR_TYPE			uint8_t
+		#define LLDCOLOR_TYPE_BITS		8
+	#elif LLDCOLOR_BITS <= 16
+		#define LLDCOLOR_TYPE			uint16_t
+		#define LLDCOLOR_TYPE_BITS		16
+	#elif LLDCOLOR_BITS <= 32
+		#define LLDCOLOR_TYPE			uint32_t
+		#define LLDCOLOR_TYPE_BITS		32
+	#else
+		#error "GDISP: Cannot define low level driver color types with more than 32 bits"
+	#endif
+	#if LLDCOLOR_TYPE_BITS == LLDCOLOR_BITS
+		#define LLDCOLOR_NEEDS_MASK	FALSE
+	#else
+		#define LLDCOLOR_NEEDS_MASK	TRUE
+	#endif
+	#define LLDCOLOR_MASK()			((1 << LLDCOLOR_BITS)-1)
+
+	// Calculate the component bit shifts
+	#if (GDISP_LLD_PIXELFORMAT & GDISP_COLORSYSTEM_MASK) == GDISP_COLORSYSTEM_RGB
+		#define LLDCOLOR_SHIFT_R		(LLDCOLOR_BITS_B+LLDCOLOR_BITS_G)
+		#define LLDCOLOR_SHIFT_G		LLDCOLOR_BITS_B
+		#define LLDCOLOR_SHIFT_B		0
+	#else
+		#define LLDCOLOR_SHIFT_B		(LLDCOLOR_BITS_R+LLDCOLOR_BITS_G)
+		#define LLDCOLOR_SHIFT_G		LLDCOLOR_BITS_R
+		#define LLDCOLOR_SHIFT_R		0
+	#endif
+
+	// Calculate LLDRED_OF, LLDGREEN_OF, LLDBLUE_OF and LLDRGB2COLOR
+	#if LLDCOLOR_BITS_R + LLDCOLOR_SHIFT_R == 8
+		#define LLDRED_OF(c)			((c) & (((1<<LLDCOLOR_BITS_R)-1) << LLDCOLOR_SHIFT_R))
+		#define LLDRGB2COLOR_R(r)		((LLDCOLOR_TYPE)((r) & (0xFF & ~((1<<(8-LLDCOLOR_BITS_R))-1))))
+	#elif LLDCOLOR_BITS_R + LLDCOLOR_SHIFT_R > 8
+		#define LLDRED_OF(c)			(((c) & (((1<<LLDCOLOR_BITS_R)-1) << LLDCOLOR_SHIFT_R)) >> (LLDCOLOR_BITS_R+LLDCOLOR_SHIFT_R-8))
+		#define LLDRGB2COLOR_R(r)		(((LLDCOLOR_TYPE)((r) & (0xFF & ~((1<<(8-LLDCOLOR_BITS_R))-1)))) << (LLDCOLOR_BITS_R+LLDCOLOR_SHIFT_R-8))
+	#else // LLDCOLOR_BITS_R + LLDCOLOR_SHIFT_R < 8
+		#define LLDRED_OF(c)			(((c) & (((1<<LLDCOLOR_BITS_R)-1) << LLDCOLOR_SHIFT_R)) << (8-(LLDCOLOR_BITS_R+LLDCOLOR_SHIFT_R)))
+		#define LLDRGB2COLOR_R(r)		(((LLDCOLOR_TYPE)((r) & (0xFF & ~((1<<(8-LLDCOLOR_BITS_R))-1)))) >> (8-(LLDCOLOR_BITS_R+LLDCOLOR_SHIFT_R)))
+	#endif
+	#if LLDCOLOR_BITS_G + LLDCOLOR_SHIFT_G == 8
+		#define LLDGREEN_OF(c)			((c) & (((1<<LLDCOLOR_BITS_G)-1) << LLDCOLOR_SHIFT_G))
+		#define LLDRGB2COLOR_G(g)		((LLDCOLOR_TYPE)((g) & (0xFF & ~((1<<(8-LLDCOLOR_BITS_G))-1))))
+	#elif LLDCOLOR_BITS_G + LLDCOLOR_SHIFT_G > 8
+		#define LLDGREEN_OF(c)			(((c) & (((1<<LLDCOLOR_BITS_G)-1) << LLDCOLOR_SHIFT_G)) >> (LLDCOLOR_BITS_G+LLDCOLOR_SHIFT_G-8))
+		#define LLDRGB2COLOR_G(g)		(((LLDCOLOR_TYPE)((g) & (0xFF & ~((1<<(8-LLDCOLOR_BITS_G))-1)))) << (LLDCOLOR_BITS_G+LLDCOLOR_SHIFT_G-8))
+	#else // LLDCOLOR_BITS_G + LLDCOLOR_SHIFT_G < 8
+		#define LLDGREEN_OF(c)			(((c) & (((1<<LLDCOLOR_BITS_G)-1) << LLDCOLOR_SHIFT_G)) << (8-(LLDCOLOR_BITS_G+LLDCOLOR_SHIFT_G)))
+		#define LLDRGB2COLOR_G(g)		(((LLDCOLOR_TYPE)((g) & (0xFF & ~((1<<(8-LLDCOLOR_BITS_G))-1)))) >> (8-(LLDCOLOR_BITS_LLDG+COLOR_SHIFT_G)))
+	#endif
+	#if LLDCOLOR_BITS_B + LLDCOLOR_SHIFT_B == 8
+		#define LLDBLUE_OF(c)			((c) & (((1<<LLDCOLOR_BITS_B)-1) << LLDCOLOR_SHIFT_B))
+		#define LLDRGB2COLOR_B(b)		((LLDCOLOR_TYPE)((b) & (0xFF & ~((1<<(8-LLDCOLOR_BITS_B))-1))))
+	#elif LLDCOLOR_BITS_B + LLDCOLOR_SHIFT_B > 8
+		#define LLDBLUE_OF(c)			(((c) & (((1<<LLDCOLOR_BITS_B)-1) << LLDCOLOR_SHIFT_B)) >> (LLDCOLOR_BITS_B+LLDCOLOR_SHIFT_B-8))
+		#define LLDRGB2COLOR_B(b)		(((LLDCOLOR_TYPE)((b) & (0xFF & ~((1<<(8-LLDCOLOR_BITS_B))-1)))) << (LLDCOLOR_BITS_B+LLDCOLOR_SHIFT_B-8))
+	#else // LLDCOLOR_BITS_B + LLDCOLOR_SHIFT_B < 8
+		#define LLDBLUE_OF(c)			(((c) & (((1<<LLDCOLOR_BITS_B)-1) << LLDCOLOR_SHIFT_B)) << (8-(LLDCOLOR_BITS_B+LLDCOLOR_SHIFT_B)))
+		#define LLDRGB2COLOR_B(b)		(((COLOR_TYPE)((b) & (0xFF & ~((1<<(8-LLDCOLOR_BITS_B))-1)))) >> (8-(LLDCOLOR_BITS_B+LLDCOLOR_SHIFT_B)))
+	#endif
+	#define LLDLUMA_OF(c)				((LLDRED_OF(c)+((uint16_t)LLDGREEN_OF(c)<<1)+LLDBLUE_OF(c))>>2)
+	#define LLDEXACT_RED_OF(c)			(((uint16_t)(((c)>>LLDCOLOR_SHIFT_R)&((1<<LLDCOLOR_BITS_R)-1))*255)/((1<<LLDCOLOR_BITS_R)-1))
+	#define LLDEXACT_GREEN_OF(c)		(((uint16_t)(((c)>>LLDCOLOR_SHIFT_G)&((1<<LLDCOLOR_BITS_G)-1))*255)/((1<<LLDCOLOR_BITS_G)-1))
+	#define LLDEXACT_BLUE_OF(c)			(((uint16_t)(((c)>>LLDCOLOR_SHIFT_B)&((1<<LLDCOLOR_BITS_B)-1))*255)/((1<<LLDCOLOR_BITS_B)-1))
+	#define LLDEXACT_LUMA_OF(c)			((LLDEXACT_RED_OF(c)+((uint16_t)LLDEXACT_GREEN_OF(c)<<1)+LLDEXACT_BLUE_OF(c))>>2)
+	#define LLDLUMA2COLOR(l)			(LLDRGB2COLOR_R(l) | LLDRGB2COLOR_G(l) | LLDRGB2COLOR_B(l))
+	#define LLDRGB2COLOR(r,g,b)			(LLDRGB2COLOR_R(r) | LLDRGB2COLOR_G(g) | LLDRGB2COLOR_B(b))
+
+	// Calculate LLDHTML2COLOR
+	#if LLDCOLOR_BITS_R + LLDCOLOR_SHIFT_R == 24
+		#define LLDHTML2COLOR_R(h)		((h) & ((0xFF & ~((1<<(8-LLDCOLOR_BITS_R))-1))<<16))
+	#elif COLOR_BITS_R + COLOR_SHIFT_R > 24
+		#define LLDHTML2COLOR_R(h)		(((h) & ((0xFF & ~((1<<(8-LLDCOLOR_BITS_R))-1))<<16)) << (LLDCOLOR_BITS_R+LLDCOLOR_SHIFT_R-24))
+	#else // COLOR_BITS_R + COLOR_SHIFT_R < 24
+		#define LLDHTML2COLOR_R(h)		(((h) & ((0xFF & ~((1<<(8-LLDCOLOR_BITS_R))-1))<<16)) >> (24-(LLDCOLOR_BITS_R+LLDCOLOR_SHIFT_R)))
+	#endif
+	#if LLDCOLOR_BITS_G + LLDCOLOR_SHIFT_G == 16
+		#define LLDHTML2COLOR_G(h)		((h) & ((0xFF & ~((1<<(8-LLDCOLOR_BITS_G))-1))<<8))
+	#elif LLDCOLOR_BITS_G + LLDCOLOR_SHIFT_G > 16
+		#define LLDHTML2COLOR_G(h)		(((h) & ((0xFF & ~((1<<(8-LLDCOLOR_BITS_G))-1))<<8)) << (LLDCOLOR_BITS_G+LLDCOLOR_SHIFT_G-16))
+	#else // LLDCOLOR_BITS_G + LLDCOLOR_SHIFT_G < 16
+		#define LLDHTML2COLOR_G(h)		(((h) & ((0xFF & ~((1<<(8-LLDCOLOR_BITS_G))-1))<<8)) >> (16-(LLDCOLOR_BITS_G+LLDCOLOR_SHIFT_G)))
+	#endif
+	#if LLDCOLOR_BITS_B + LLDCOLOR_SHIFT_B == 8
+		#define LLDHTML2COLOR_B(h)		((h) & (0xFF & ~((1<<(8-LLDCOLOR_BITS_B))-1)))
+	#elif LLDCOLOR_BITS_B + LLDCOLOR_SHIFT_B > 8
+		#define LLDHTML2COLOR_B(h)		(((h) & (0xFF & ~((1<<(8-LLDCOLOR_BITS_B))-1))) << (LLDCOLOR_BITS_B+LLDCOLOR_SHIFT_B-8))
+	#else // LLDCOLOR_BITS_B + LLDCOLOR_SHIFT_B < 8
+		#define LLDHTML2COLOR_B(h)		(((h) & (0xFF & ~((1<<(8-LLDCOLOR_BITS_B))-1))) >> (8-(LLDCOLOR_BITS_B+LLDCOLOR_SHIFT_B)))
+	#endif
+	#define LLDHTML2COLOR(h)		((LLDCOLOR_TYPE)(LLDHTML2COLOR_R(h) | LLDHTML2COLOR_G(h) | LLDHTML2COLOR_B(h)))
+
+//-------------------------
+//	Gray-scale color system
+//-------------------------
+#elif (GDISP_LLD_PIXELFORMAT & GDISP_COLORSYSTEM_MASK) == GDISP_COLORSYSTEM_GRAYSCALE
+	#define LLDCOLOR_SYSTEM			GDISP_COLORSYSTEM_GRAYSCALE
+
+	// Calculate the number of bits and shifts
+	#define LLDCOLOR_BITS			(GDISP_LLD_PIXELFORMAT & 0xFF)
+	#define LLDCOLOR_BITS_R			LLDCOLOR_BITS
+	#define LLDCOLOR_BITS_G			LLDCOLOR_BITS
+	#define LLDCOLOR_BITS_B			LLDCOLOR_BITS
+	#define LLDCOLOR_SHIFT_R		0
+	#define LLDCOLOR_SHIFT_G		0
+	#define LLDCOLOR_SHIFT_B		0
+
+	// From the number of bits determine COLOR_TYPE, COLOR_TYPE_BITS and masking
+	#if LLDCOLOR_BITS <= 8
+		#define LLDCOLOR_TYPE		uint8_t
+		#define LLDCOLOR_TYPE_BITS	8
+	#else
+		#error "GDISP: Cannot define gray-scale low level driver color types with more than 8 bits"
+	#endif
+	#if LLDCOLOR_TYPE_BITS == LLDCOLOR_BITS
+		#define LLDCOLOR_NEEDS_MASK	FALSE
+	#else
+		#define LLDCOLOR_NEEDS_MASK	TRUE
+	#endif
+	#define LLDCOLOR_MASK()			((1 << LLDCOLOR_BITS)-1)
+
+	#if COLOR_BITS == 1
+		#define LLDRGB2COLOR(r,g,b)		(((r)|(g)|(b)) ? 1 : 0)
+		#define LLDLUMA2COLOR(l)		((l) ? 1 : 0)
+		#define LLDHTML2COLOR(h)		((h) ? 1 : 0)
+		#define LLDLUMA_OF(c)			((c) ? 255 : 0)
+		#define LLDEXACT_LUMA_OF(c)		LLDLUMA_OF(c)
+	#else
+		// They eye is more sensitive to green
+		#define LLDRGB2COLOR(r,g,b)		((LLDCOLOR_TYPE)(((uint16_t)(r)+(g)+(g)+(b)) >> (10-LLDCOLOR_BITS)))
+		#define LLDLUMA2COLOR(l)		((LLDCOLOR_TYPE)((l)>>(8-LLDCOLOR_BITS)))
+		#define LLDHTML2COLOR(h)		((LLDCOLOR_TYPE)(((((h)&0xFF0000)>>16)+(((h)&0x00FF00)>>7)+((h)&0x0000FF)) >> (10-LLDCOLOR_BITS)))
+		#define LLDLUMA_OF(c)			(((c) & ((1<<LLDCOLOR_BITS)-1)) << (8-LLDCOLOR_BITS))
+		#define LLDEXACT_LUMA_OF(c)		((((uint16_t)(c) & ((1<<LLDCOLOR_BITS)-1))*255)/((1<<LLDCOLOR_BITS)-1))
+	#endif
+
+	#define LLDRED_OF(c)			LLDLUMA_OF(c)
+	#define LLDGREEN_OF(c)			LLDLUMA_OF(c)
+	#define LLDBLUE_OF(c)			LLDLUMA_OF(c)
+	#define LLDEXACT_RED_OF(c)		LLDEXACT_LUMA_OF(c)
+	#define LLDEXACT_GREEN_OF(c)	LLDEXACT_LUMA_OF(c)
+	#define LLDEXACT_BLUE_OF(c)		LLDEXACT_LUMA_OF(c)
+
+//-------------------------
+//	Palette color system
+//-------------------------
+#elif (GDISP_LLD_PIXELFORMAT & GDISP_COLORSYSTEM_MASK) == GDISP_COLORSYSTEM_PALETTE
+	#define LLDCOLOR_SYSTEM			GDISP_COLORSYSTEM_PALETTE
+
+	#error "GDISP: A palette color system for low level drivers is not currently supported"
+
+//-------------------------
+//	Some other color system
+//-------------------------
+#else
+	#error "GDISP: Unsupported color system for low level drivers"
+#endif
+
+/* Which is the larger color type */
+#if COLOR_BITS > LLDCOLOR_BITS
+	#define LARGER_COLOR_BITS	COLOR_BITS
+	#define LARGER_COLOR_TYPE	COLOR_TYPE
+#else
+	#define LARGER_COLOR_BITS	LLDCOLOR_BITS
+	#define LARGER_COLOR_TYPE	LLDCOLOR_TYPE
+#endif
+
+/**
+ * @brief	Controls color conversion accuracy for a low level driver
+ * @details	Should higher precision be used when converting colors.
+ * @note	Color conversion is only necessary if GDISP_PIXELFORMAT != GDISP_LLD_PIXELFORMAT
+ * @note	It only makes sense to turn this on if you have a high bit depth display but
+ * 			are running the application in low bit depths.
+ * @note	To achieve higher color accuracy bit shifting is replaced with multiplies and divides.
+ */
+#ifndef GDISP_HARDWARE_USE_EXACT_COLOR
+	#if LLDCOLOR_BITS_R - COLOR_BITS_R >= LLDCOLOR_BITS_R/2 || LLDCOLOR_BITS_G - COLOR_BITS_G >= LLDCOLOR_BITS_G/2 || LLDCOLOR_BITS_B - COLOR_BITS_B >= LLDCOLOR_BITS_B/2
+		#define GDISP_HARDWARE_USE_EXACT_COLOR	TRUE
+	#else
+		#define GDISP_HARDWARE_USE_EXACT_COLOR	FALSE
+	#endif
+#endif
+
+/* Low level driver pixel format conversion functions */
+#if GDISP_PIXELFORMAT == GDISP_LLD_PIXELFORMAT || defined(__DOXYGEN__)
+	/**
+	 * @brief	Convert from a standard color format to the low level driver pixel format
+	 * @note	For use only by low level drivers
+	 */
+	#define COLOR2NATIVE(c)	(c)
+	/**
+	 * @brief	Convert from a low level driver pixel format to the standard color format
+	 * @note	For use only by low level drivers
+	 */
+	#define NATIVE2COLOR(c)	(c)
+
+#else
+	#if COLOR_SYSTEM == GDISP_COLORSYSTEM_GRAYSCALE || LLDCOLOR_SYSTEM == GDISP_COLORSYSTEM_GRAYSCALE
+		#if GDISP_HARDWARE_USE_EXACT_COLOR
+			#define COLOR2NATIVE(c)	LLDLUMA2COLOR(EXACT_LUMA_OF(c))
+			#define NATIVE2COLOR(c)	LUMA2COLOR(LLDEXACT_LUMA_OF(c))
+		#else
+			#define COLOR2NATIVE(c)	LLDLUMA2COLOR(LUMA_OF(c))
+			#define NATIVE2COLOR(c)	LUMA2COLOR(LLDLUMA_OF(c))
+		#endif
+	#elif COLOR_SYSTEM == GDISP_COLORSYSTEM_TRUECOLOR && LLDCOLOR_SYSTEM == GDISP_COLORSYSTEM_TRUECOLOR
+		#if GDISP_HARDWARE_USE_EXACT_COLOR
+			#define COLOR2NATIVE(c)	LLDRGB2COLOR(EXACT_RED_OF(c), EXACT_GREEN_OF(c), EXACT_BLUE_OF(c))
+			#define NATIVE2COLOR(c)	RGB2COLOR(LLDEXACT_RED_OF(c), LLDEXACT_GREEN_OF(c), LLDEXACT_BLUE_OF(c))
+		#else
+			#define COLOR2NATIVE(c)	LLDRGB2COLOR(RED_OF(c), GREEN_OF(c), BLUE_OF(c))
+			#define NATIVE2COLOR(c)	RGB2COLOR(LLDRED_OF(c), LLDGREEN_OF(c), LLDBLUE_OF(c))
+		#endif
+
+	/*
+	#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB888 && GDISP_LLD_PIXELFORMAT == GDISP_PIXELFORMAT_BGR888
+		#define COLOR2NATIVE(c)	((LLDCOLOR_TYPE)(((c)&0xFF0000)>>16)|((c)&0x00FF00)|(((c)&0x0000FF)<<16))
+		#define NATIVE2COLOR(c)	((COLOR_TYPE)(((c)&0xFF0000)>>16)|((c)&0x00FF00)|(((c)&0x0000FF)<<16))
+	#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB565 && GDISP_LLD_PIXELFORMAT == GDISP_PIXELFORMAT_BGR888
+		#define COLOR2NATIVE(c)	((LLDCOLOR_TYPE)( \
+								((LARGER_COLOR_TYPE)((c)&(((1<<COLOR_BITS_R)-1)<<COLOR_SHIFT_R))>>(COLOR_BITS_R+COLOR_SHIFT_R-8))| \
+								((LARGER_COLOR_TYPE)((c)&(((1<<COLOR_BITS_G)-1)<<COLOR_SHIFT_G))<<(16-(COLOR_BITS_G+COLOR_SHIFT_G)))| \
+								((LARGER_COLOR_TYPE)((c)&(((1<<COLOR_BITS_B)-1)<<COLOR_SHIFT_B))<<(24-(COLOR_BITS_B+COLOR_SHIFT_B)))))
+		#define NATIVE2COLOR(c)	((COLOR_TYPE)( \
+								((LARGER_COLOR_TYPE)((c)&0x0000F8)<<COLOR_SHIFT_R)| \
+								((LARGER_COLOR_TYPE)((c)&0x00FC00)>>(16-(COLOR_BITS_G+COLOR_SHIFT_G)))| \
+								((LARGER_COLOR_TYPE)((c)&0xF80000)>>(24-(COLOR_BITS_B+COLOR_SHIFT_B)))))
+	*/
+	#else
+		#error "GDISP: This pixel format conversion is not supported yet"
+	#endif
+#endif
+
 #endif	/* GFX_USE_GDISP */
 
 #endif	/* _GDISP_LLD_H */