Indexed Color support

Author: TomSaw

src/modm/driver/display/ili9341.hpp

@@ -53,6 +53,8 @@ class Ili9341 : public Interface,
 	using ColorType = Rgb565;
 	static constexpr Resolution resolution{320, 240};
 
+	ColorType* colormap;
+
 	using BufferLandscape = Buffer<Rgb565, resolution>;
 	using BufferPortrait = Buffer<Rgb565, resolution.swapped()>;
 
@@ -109,30 +111,19 @@ class Ili9341 : public Interface,
 	write(Rectangle rectangle, P pattern);
 
 	// Write BufferInterface
-	template<class C_>
-	modm::ResumableResult<void>
-	write(BufferInterface<C_> &buffer, Point origin = {0, 0}) {
-		RF_BEGIN();
-		RF_END_RETURN_CALL(writeImage(
-			ImageAccessor<C_, modm::accessor::Ram>(&buffer),
-			origin)
-		);
-	}
-
-	// Write BufferInterface
-	template<class C_>
+	template<class C>
 	modm::ResumableResult<void>
-	write(BufferInterface<C_> &buffer, ColorType* colormap, Point origin = {0, 0}) {
+	write(BufferInterface<C> &buffer, Point origin = {0, 0}) {
 		RF_BEGIN();
-		RF_END_RETURN_CALL(writeImage(ImageAccessor<C_, modm::accessor::Ram>(&buffer), colormap, origin));
+		RF_END_RETURN_CALL(writeImage(ImageAccessor<C, modm::accessor::Ram>(&buffer), origin));
 	}
 
 	// Write Flash Image
 	modm::ResumableResult<void>
 	write(const uint8_t *addr, Point origin = {0, 0}) {
 		RF_BEGIN();
 		RF_END_RETURN_CALL(writeImage(
-			ImageAccessor<Monochrome, modm::accessor::Flash>(addr),
+			ImageAccessor<Gray2, modm::accessor::Flash>(addr),
 			origin)
 		);
 	}
@@ -169,19 +160,19 @@ class Ili9341 : public Interface,
 	 * @param decoder		Image with Flash or Ram Accessor
 	 * @param origin	Placement for the image
 	 */
- 	template<Color C_, template<typename> class Accessor>
+ 	template<Color C, template<typename> class Accessor>
 	modm::ResumableResult<void>
-	writeImage(ImageAccessor<C_, Accessor> decoder, Point origin = {0, 0});
+	writeImage(ImageAccessor<C, Accessor> decoder, Point origin = {0, 0});
 
 	/**
 	 * Write ColorGrayBase2 Image using color-mapping
 	 *
 	 * @param decoder		Image with Flash or Ram Accessor
 	 * @param origin	Placement for the image
 	 */
-	template<template<typename> class Accessor>
+	template<ColorGrayBase2 G, template<typename> class Accessor>
 	modm::ResumableResult<void>
-	writeImage(ImageAccessor<Monochrome, Accessor> decoder, const ColorType colors[Monochrome::max + 1], Point origin = {0, 0});
+	writeImage(ImageAccessor<G, Accessor> decoder, Point origin = {0, 0});
 
 	inline void
 	initialize_write_monochrome(Point origin);
@@ -201,7 +192,7 @@ class Ili9341 : public Interface,
 
 private:
 	// Static variables for resumable functions
-	void scannerNextRow() {
+	void scannerincrementRow() {
 		p.scanner.x++;
 		p.scanner.y = this->clipping.topLeft.y;
 	}

src/modm/driver/display/ili9341_impl.hpp

@@ -10,6 +10,7 @@
  */
 
 #pragma once
+
 #include "ili9341.hpp"
 
 using namespace modm::shape;
@@ -262,7 +263,7 @@ modm::Ili9341<Interface, Reset, BC>::write(Rectangle rectangle, P pattern) {
 			p.buffer[p.i] = pattern(p.scanner);
 
 			if (++p.scanner.y == this->clipping.bottomRight.y) {
-				scannerNextRow();
+				scannerincrementRow();
 			}
 		}
 		// Transfer
@@ -300,7 +301,7 @@ modm::Ili9341<Interface, Reset, BC>::writeImage(ImageAccessor<Rgb565, Accessor>
 
 		while(p.pixels >= p.pixels_bulk) {
 			RF_CALL(this->writeData(d.getPointer() + 1, p.pixels_bulk));
-			d.nextRow();
+			d.incrementRow();
 			p.pixels -= p.pixels_bulk;
 		}
 	} else
@@ -339,8 +340,8 @@ modm::Ili9341<Interface, Reset, BC>::writeImage(ImageAccessor<C_, Accessor> deco
 			// difference to -- write monochrome Image -- below
 			p.buffer[p.i] = d.nextPixel();
 			if (++p.scanner.y == this->clipping.bottomRight.y) {
-				scannerNextRow();
-				d.nextRow();
+				scannerincrementRow();
+				d.incrementRow();
 			}
 		}
 		// Transfer
@@ -354,12 +355,12 @@ modm::Ili9341<Interface, Reset, BC>::writeImage(ImageAccessor<C_, Accessor> deco
 
 // -- Write Gray Image, this supports color-mapping
 template<class Interface, class Reset, size_t BC>
-template<template<typename> class Accessor>
+template<ColorGrayBase2 G, template<typename> class Accessor>
 modm::ResumableResult<void>
-modm::Ili9341<Interface, Reset, BC>::writeImage(ImageAccessor<Monochrome, Accessor> decoder, const ColorType colors[Monochrome::max + 1], Point origin) {
+modm::Ili9341<Interface, Reset, BC>::writeImage(ImageAccessor<G, Accessor> decoder, Point origin) {
 	// Found no cast for d share the memory between all of the writeImage()-methods.
 	// This waste of RAM will be history once Resumable Functions become history.
-	static ImageAccessor<Monochrome, Accessor> d;
+	static ImageAccessor<G, Accessor> d;
 
 	RF_BEGIN();
 
@@ -378,10 +379,10 @@ modm::Ili9341<Interface, Reset, BC>::writeImage(ImageAccessor<Monochrome, Access
 			// OPTIMIZE following Line is the only
 			// difference to -- write colored Image -- above
 			// IMPLEMENT color-mapping
-			p.buffer[p.i] = colors[d.nextPixel().getValue()];
+			p.buffer[p.i] = colormap[d.nextPixel().getValue()];
 			if (++p.scanner.y == this->clipping.bottomRight.y) {
-				scannerNextRow();
-				d.nextRow();
+				scannerincrementRow();
+				d.incrementRow();
 			}
 		}
 		// Transfer
@@ -418,6 +419,7 @@ modm::Ili9341<Interface, Reset, BC>::drawBlind(const VLine& vline)
 	RF_END_RETURN_CALL(drawBlind(Section(vline.start, {vline.start.x + 1, vline.end_y})));
 }
 
+#include <limits>
 template<class Interface, class Reset, size_t BC>
 modm::ResumableResult<void>
 modm::Ili9341<Interface, Reset, BC>::drawBlind(const Section& section)
@@ -426,20 +428,15 @@ modm::Ili9341<Interface, Reset, BC>::drawBlind(const Section& section)
 
 	this->clipping = section;
 	RF_CALL(updateClipping());
-
-	// OPTIMIZE Make this impossible fast through use of DMA
-	// See https://github.com/modm-io/modm/issues/666
-
-	// Without DMA, at least this could be parallelised to updateClipping(..) above
-	p.pixels_bulk = std::min<size_t>(BC, p.pixels);
-	std::fill(p.buffer, p.buffer + p.pixels_bulk, color);
-
-	while (p.pixels)
-	{
+	
+	// Respect DMAs max bulksize of 2^16-1
+	while(p.pixels) {
+		p.pixels_bulk = std::min<uint32_t>(p.pixels, std::numeric_limits<uint16_t>::max());
+		RF_CALL(this->writeData(color, p.pixels_bulk));
 		p.pixels -= p.pixels_bulk;
-		RF_CALL(this->writeData(p.buffer, p.pixels_bulk));
-		p.pixels_bulk = std::min<size_t>(BC, p.pixels);
 	}
+	// RF_CALL(this->writeData(color, p.pixels));
+
 	RF_END();
 }
 

src/modm/math/scaling_unsigned.hpp

@@ -65,7 +65,7 @@ class ScalingUnsigned {
 		: value(other.value * max / other.max)
 	{}
 
-	/* 	// Faster construction from monochrome
+	/* 	// Faster construction from from single digit
 	constexpr ScalingUnsigned(const ScalingUnsigned<1> &other) : value(other.value ? bitmask<D>() : 0){}
 
 	// constexpr ScalingUnsigned(ScalingUnsigned<1> &&other) : value(other.value ? bitmask<D>() : 0){}

src/modm/ui/color/rgb_stacked.hpp

@@ -57,15 +57,17 @@ class RgbStackedT
 		: RgbStackedT(rgb.getRed(), rgb.getGreen(), rgb.getBlue()) {}
 
 	void setRed(RedType red)
-	{ value = (value & ~(bitmask<DR>() << (DG + DB))) | red.value << (DG + DB); }
+	{ value = (value & ~(RedType::mask << (DG + DB))) | red.value << (DG + DB); }
 	void setGreen(GreenType green)
-	{ value = (value & ~(bitmask<DG>() << DB)) | green.value << DB; }
+	{ value = (value & ~(GreenType::mask << DB)) | green.value << DB; }
 	void setBlue(BlueType blue)
-	{ value = (value & ~bitmask<DB>()) | blue.value; }
+	{ value = (value & ~BlueType::mask) | blue.value; }
 
 	RedType getRed() const { return value >> (DG + DB); }
-	GreenType getGreen() const { return value >> DB & bitmask<DG>(); }
-	BlueType getBlue() const { return value & bitmask<DB>(); }
+	GreenType getGreen() const { return value >> DB & GreenType::max;}
+	BlueType getBlue() const { return value & BlueType::max; }
+	
+	ValueType getValue() const { return value; }
 
 	template <typename RgbStackedT_>
 	constexpr RgbStackedT operator+(RgbStackedT_ &other) {

src/modm/ui/graphic/accessor_image.hpp

@@ -80,7 +80,7 @@ class ImageAccessor<C, Accessor> : public Accessor<C>
 	}
 
 	void
-	nextRow()
+	incrementRow()
 	{
 		addr_top += size.y;
 		this->address = addr_top;

src/modm/ui/graphic/accessor_image_gray.hpp

@@ -54,46 +54,52 @@ class ImageAccessor<G, Accessor> : public Accessor<typename G::ValueType>
 	// # ImageAccessor for uncompressed monochrome images
 	// ####################################################
 
-	void
+	static constexpr int digits = numeric_limits<typename G::ValueType>::digits;
+
+	inline void
 	initialize(const modm::shape::Point origin)
 	{
 		const Point topLeft = {origin.x < 0 ? -origin.x : 0, origin.y < 0 ? -origin.y : 0};
 
-		addr_top = this->address + (topLeft.y / 8) * size.x + topLeft.x;
-		bitmask_top = std::rotl(Bit0, topLeft.y % 8 - 1);
-		nextRow();
+		addr_top = this->address + (topLeft.y * G::Digits / 8) * size.x + topLeft.x;
+		rotl_top = topLeft.y * G::Digits % 8;
+		incrementRow();
+	}
+
+	inline void
+	incrementRow()
+	{
+		rotl = rotl_top;
+		this->address = addr_top++;
+		// TODO I'm not sure about this but is propably required
+		// if (rotl_top == digits)
+		// 	this->address -= size.x;
+
+		byte = std::rotr(Accessor<uint8_t>::operator*(), rotl_top - G::Digits);
 	}
 
 	inline G
 	nextPixel()
 	{
-		bitmask = std::rotl(bitmask, 1);
-		if (bitmask == Bit0)
+		rotl += G::Digits;
+ 		if (rotl > digits)
 		{
 			this->address += size.x;
 			byte = Accessor<uint8_t>::operator*();
+			rotl = G::Digits;
+		} else {
+			byte = std::rotr(byte, G::Digits);
 		}
-		return byte & bitmask;
-	}
 
-	inline void
-	nextRow()
-	{
-		bitmask = bitmask_top;
-		this->address = addr_top++;
-		if (bitmask == Bit7)
-			this->address -= size.x;
-		else
-			byte = Accessor<uint8_t>::operator*();
+		return byte & G::max;
 	}
-
 private:
-	// config
+	// init state
 	const G::ValueType* addr_top;
-	G::ValueType bitmask_top;
+	int8_t rotl_top;
 
-	// cache
+	// reader state
 	G::ValueType byte;
-	G::ValueType bitmask;
+	int8_t rotl;
 };
 }  // namespace modm::graphic

src/modm/ui/graphic/buffer.hpp

@@ -134,27 +134,27 @@ class Buffer
 	/**
 	 * Write colored Image
 	 *
-	 * @param decoder		Image with Flash or Ram Accessor
+	 * @param accessor		Image with Flash or Ram Accessor
 	 * @param origin	Placement for the image
 	 */
 	template<Color C_, template<typename> class Accessor>
 	void
-	writeImage(ImageAccessor<C_, Accessor> decoder, Point origin = {0, 0});
+	writeImage(ImageAccessor<C_, Accessor> accessor, Point origin = {0, 0});
 
 	/**
 	 * Write monochrome Image
 	 *
-	 * @param decoder		Image with Flash or Ram Accessor
+	 * @param accessor		Image with Flash or Ram Accessor
 	 * @param origin	Placement for the image
 	 */
 	template<template<typename> class Accessor>
 	void
-	writeImage(ImageAccessor<Monochrome, Accessor> decoder, Point origin = {0, 0});
+	writeImage(ImageAccessor<Monochrome, Accessor> accessor, Point origin = {0, 0});
 
 	/**
 	 * Write monochrome Glyph
 	 *
-	 * @param decoder		Accessor for Image in Flash memory
+	 * @param accessor		Accessor for Image in Flash memory
 	 */
 	void
 	writeGlyph(ImageAccessor<Monochrome, modm::accessor::Flash> glyph) final {
@@ -184,4 +184,5 @@ class Buffer
 }  // namespace modm
 
 #include "buffer_impl.hpp"
+#include "buffer_draw_impl.hpp"
 #include "buffer_gray.hpp"