Merge branch 'schneider/lodepng' into 'master'

PNG support

See merge request !457

.gitmodules

@@ -10,3 +10,6 @@
 [submodule "lib/crypto/SHA256"]
 	path = lib/crypto/SHA256
 	url = https://github.com/ilvn/SHA256
+[submodule "lib/lodepng/lodepng"]
+	path = lib/lodepng/lodepng
+	url = https://github.com/lvandeve/lodepng

Documentation/conf.py

@@ -124,6 +124,7 @@ autodoc_mock_imports = [
     "sys_leds",
     "sys_max30001",
     "sys_max86150",
+    "sys_png",
     "sys_config",
     "ucollections",
     "uerrno",

Documentation/index.rst

@@ -36,6 +36,7 @@ Last but not least, if you want to start hacking the lower-level firmware, the
    pycardium/light-sensor
    pycardium/os
    pycardium/personal_state
+   pycardium/png
    pycardium/power
    pycardium/pride
    pycardium/simple_menu

Documentation/pycardium/png.rst

+``png`` - PNG Decoder
+===============
+The ``png`` module provides functions to decode PNG files into raw pixel data
+which can be displayed using the card10's display or its LEDs.
+
+.. automodule:: png
+   :members:

bootloader/bootloader-display.c

@@ -8,13 +8,12 @@
 
 static void bootloader_display_splash(void)
 {
-	gfx_copy_region(
+	gfx_copy_region_rle_mono(
 		&display_screen,
 		0,
 		0,
 		160,
 		80,
-		GFX_RLE_MONO,
 		sizeof(splash),
 		(const void *)(splash)
 	);

epicardium/epicardium.h

@@ -1652,6 +1652,16 @@ enum disp_font_name {
 	DISP_FONT24 = 4,
 };
 
+/*
+ * Image data type
+ */
+enum epic_rgb_format {
+	EPIC_RGB8     = 0,
+	EPIC_RGBA8    = 1,
+	EPIC_RGB565   = 2,
+	EPIC_RGBA5551 = 3,
+ };
+
 /**
  * Prints a string into the display framebuffer with font type selectable
  *
@@ -1699,22 +1709,22 @@ API(API_DISP_PIXEL, int epic_disp_pixel(
 ));
 
 /**
- * Blit an image buffer to display
+ * Blits an image buffer to the display
  *
  * :param x: x position
  * :param y: y position
- * :param w: image width
- * :param h: image height
- * :param img: image data (rgb565)
- * :param alpha: 8 bit alpha channel. Currently unused.
+ * :param w: Image width
+ * :param h: Image height
+ * :param img: Image data
+ * :param format: Format of the image data. One of :c:type:`epic_rgb_format`.
  */
 API(API_DISP_BLIT, int epic_disp_blit(
 	int16_t x,
 	int16_t y,
 	int16_t w,
 	int16_t h,
-	uint16_t *img,
-	uint8_t *alpha
+	void *img,
+	enum epic_rgb_format format
 ));
 
 /**

epicardium/main.c

@@ -48,14 +48,7 @@ int main(void)
 	epic_disp_clear(0x0000);
 
 	gfx_copy_region(
-		&display_screen,
-		0,
-		0,
-		160,
-		80,
-		GFX_RAW,
-		sizeof(version_splash),
-		version_splash
+		&display_screen, 0, 0, 160, 80, GFX_RGB565, version_splash
 	);
 
 	if (strcmp(CARD10_VERSION, "v1.16") != 0) {

epicardium/modules/display.c

@@ -92,61 +92,81 @@ int epic_disp_blit(
 	int16_t pos_y,
 	int16_t width,
 	int16_t height,
-	uint16_t *img,
-	uint8_t *alpha
+	void *img,
+	enum epic_rgb_format format
 ) {
-	/* TODO: alpha is not supported yet */
 	int cl = check_lock();
 	if (cl < 0) {
 		return cl;
-	} else {
-		int16_t offset_x = (pos_x < 0) ? -pos_x : 0;
-		int16_t count_x  = width - offset_x;
-		int16_t offset_y = (pos_y < 0) ? -pos_y : 0;
-		int16_t count_y  = height - offset_y;
+	}
 
-		if (pos_x + width >= 160) {
-			count_x -= (pos_x + width) % 160;
-		}
-		if (pos_y + height >= 80) {
-			count_y -= (pos_y + height) % 80;
-		}
+	int16_t offset_x = (pos_x < 0) ? -pos_x : 0;
+	int16_t count_x  = width - offset_x;
+	int16_t offset_y = (pos_y < 0) ? -pos_y : 0;
+	int16_t count_y  = height - offset_y;
+
+	if (pos_x + width >= 160) {
+		count_x -= (pos_x + width) % 160;
+	}
+	if (pos_y + height >= 80) {
+		count_y -= (pos_y + height) % 80;
+	}
+
+	size_t bpp;
+	enum gfx_encoding encoding;
+
+	switch (format) {
+	case EPIC_RGB565:
+		bpp      = 2;
+		encoding = GFX_RGB565;
+		break;
+	case EPIC_RGBA5551:
+		bpp      = 2;
+		encoding = GFX_RGBA5551;
+		break;
+	case EPIC_RGB8:
+		bpp      = 3;
+		encoding = GFX_RGB8;
+		break;
+	case EPIC_RGBA8:
+		bpp      = 4;
+		encoding = GFX_RGBA8;
+		break;
+	default:
+		return -1;
+		break;
+	}
 
-		if (offset_x == 0 && offset_y == 0 && count_x == width &&
-		    count_y == height) {
-			/* Simply copy full image, no cropping or alpha blending */
+	if (offset_x == 0 && offset_y == 0 && count_x == width &&
+	    count_y == height) {
+		/* Copy full image. No cropping.*/
+		gfx_copy_region(
+			&display_screen,
+			pos_x,
+			pos_y,
+			width,
+			height,
+			encoding,
+			img
+		);
+	} else {
+		/* Copy cropped image line by line. */
+		int16_t curr_y;
+		for (curr_y = offset_y; curr_y < offset_y + count_y; curr_y++) {
+			uint8_t *line = img + (curr_y * width + offset_x) * bpp;
 			gfx_copy_region(
 				&display_screen,
-				pos_x,
-				pos_y,
-				width,
-				height,
-				GFX_RAW,
-				width * height * 2,
-				img
+				pos_x + offset_x,
+				pos_y + curr_y,
+				count_x,
+				1,
+				encoding,
+				line
 			);
-		} else {
-			/* Copy cropped image line by line */
-			for (int16_t curr_y = offset_y;
-			     curr_y < offset_y + count_y;
-			     curr_y++) {
-				uint16_t *curr_img =
-					img + (curr_y * width + offset_x);
-				gfx_copy_region(
-					&display_screen,
-					pos_x + offset_x,
-					pos_y + curr_y,
-					count_x,
-					1,
-					GFX_RAW,
-					count_x * 2,
-					curr_img
-				);
-			}
 		}
-
-		return 0;
 	}
+
+	return 0;
 }
 
 int epic_disp_line(

epicardium/modules/panic.c

@@ -120,13 +120,12 @@ static void faultsplash(const char *msg)
 {
 	LCD_SetBacklight(100);
 
-	gfx_copy_region(
+	gfx_copy_region_rle_mono(
 		&display_screen,
 		0,
 		0,
 		160,
 		80,
-		GFX_RLE_MONO,
 		sizeof(faultsplash_rle),
 		faultsplash_rle
 	);

hw-tests/dual-core/main.c

@@ -28,8 +28,7 @@ int main(void)
 		0,
 		160,
 		80,
-		GFX_RAW,
-		sizeof(Heart),
+		GFX_RGB565,
 		(const void *)(Heart)
 	);
 	gfx_update(&display_screen);

hw-tests/hello-world/main.c

@@ -36,8 +36,7 @@ int main(void)
 		0,
 		160,
 		80,
-		GFX_RAW,
-		sizeof(Heart),
+		GFX_RGB565,
 		(const void *)(Heart)
 	);
 	gfx_update(&display_screen);

hw-tests/ips/main.c

@@ -43,8 +43,7 @@ int main(void)
 		0,
 		40,
 		40,
-		GFX_RAW,
-		40 * 40 * 2,
+		GFX_RGB565,
 		(const void *)(gImage_40X40)
 	);
 	gfx_copy_region(
@@ -53,8 +52,7 @@ int main(void)
 		0,
 		160,
 		80,
-		GFX_RAW,
-		160 * 80 * 2,
+		GFX_RGB565,
 		(const void *)(gImage_160X80)
 	);
 	gfx_update(&display_screen);

lib/gfx/framebuffer.c

@@ -99,3 +99,21 @@ void fb_setpixel(struct framebuffer *fb, int x, int y, Color c)
 		pixel[0] = color[1];
 	}
 }
+
+Color fb_getpixel(struct framebuffer *fb, int x, int y)
+{
+	uint8_t *pixel = fb_pixel(fb, x, y);
+	if (pixel == NULL)
+		return 0;
+
+	Color c;
+	uint8_t *color   = (uint8_t *)(&c);
+	const size_t bpp = fb_bytes_per_pixel(fb);
+	switch (bpp) {
+	default:
+	case 2:
+		color[0] = pixel[1];
+		color[1] = pixel[0];
+	}
+	return c;
+}

lib/gfx/framebuffer.h

@@ -27,6 +27,7 @@ struct framebuffer {
 size_t fb_bytes_per_pixel(const struct framebuffer *fb);
 void *fb_pixel(struct framebuffer *fb, int x, int y);
 void fb_setpixel(struct framebuffer *fb, int x, int y, Color c);
+Color fb_getpixel(struct framebuffer *fb, int x, int y);
 void fb_clear_to_color(struct framebuffer *fb, Color c);
 void fb_clear(struct framebuffer *fb);
 Color fb_encode_color_rgb(struct framebuffer *fb, int r, int g, int b);

lib/gfx/gfx.c

@@ -13,6 +13,42 @@ const struct gfx_color_rgb gfx_colors_rgb[COLORS] = {
 	{ 255, 255, 0 }    /* YELLOW */
 };
 
+static inline uint16_t rgb8_to_rgb565(const uint8_t *bytes)
+{
+	return ((bytes[0] & 0b11111000) << 8) | ((bytes[1] & 0b11111100) << 3) |
+	       (bytes[2] >> 3);
+}
+
+static inline void rgb565_to_rgb8(uint16_t c, uint8_t *bytes)
+{
+	bytes[0] = (c & 0b1111100000000000) >> 8;
+	bytes[1] = (c & 0b0000011111100000) >> 3;
+	bytes[2] = (c & 0b0000000000011111) << 3;
+}
+
+static inline uint16_t rgba5551_to_rgb565(const uint8_t *bytes)
+{
+	return (bytes[1] << 8) | (bytes[0] & 0b11000000) |
+	       ((bytes[0] & 0b00111110) >> 1);
+}
+
+static inline uint8_t apply_alpha(uint8_t in, uint8_t bg, uint8_t alpha)
+{
+	/* Not sure if it is worth (or even a good idea) to have
+	 * the special cases here. */
+	if (bg == 0) {
+		return (in * alpha) / 255;
+	}
+
+	uint8_t beta = 255 - alpha;
+
+	if (bg == 255) {
+		return ((in * alpha) / 255) + beta;
+	}
+
+	return (in * alpha + bg * beta) / 255;
+}
+
 void gfx_setpixel(struct gfx_region *r, int x, int y, Color c)
 {
 	if (x < 0 || y < 0)
@@ -23,6 +59,25 @@ void gfx_setpixel(struct gfx_region *r, int x, int y, Color c)
 	fb_setpixel(r->fb, r->x + x, r->y + y, c);
 }
 
+void gfx_setpixel_rgba(struct gfx_region *r, int x, int y, const uint8_t *c)
+{
+	if (x < 0 || y < 0)
+		return;
+	if ((size_t)x >= r->width || (size_t)y >= r->height)
+		return;
+
+	uint8_t pixel[3];
+	Color p = fb_getpixel(r->fb, r->x + x, r->y + y);
+	rgb565_to_rgb8(p, pixel);
+
+	uint8_t alpha = c[3];
+	pixel[0]      = apply_alpha(c[0], pixel[0], alpha);
+	pixel[1]      = apply_alpha(c[1], pixel[1], alpha);
+	pixel[2]      = apply_alpha(c[2], pixel[2], alpha);
+
+	fb_setpixel(r->fb, r->x + x, r->y + y, rgb8_to_rgb565(pixel));
+}
+
 struct gfx_region gfx_screen(struct framebuffer *fb)
 {
 	struct gfx_region r = { .fb     = fb,
@@ -270,61 +325,48 @@ Color gfx_color(struct gfx_region *reg, enum gfx_color color)
 	return gfx_color_rgb(reg, c->r, c->g, c->b);
 }
 
-static void gfx_copy_region_raw(
+void gfx_copy_region(
 	struct gfx_region *reg,
 	int x,
 	int y,
 	int w,
 	int h,
-	size_t size,
-	const void *p
+	enum gfx_encoding encoding,
+	const uint8_t *p
 ) {
-	size_t bpp = size / (w * h);
-
 	for (int y_ = 0; y_ < h; y_++) {
 		for (int x_ = 0; x_ < w; x_++) {
 			Color c;
+			uint8_t alpha;
 
-			switch (bpp) {
-			default:
-			case 2:
+			switch (encoding) {
+			case GFX_RGB565:
+				/* Assuming alignment here */
 				c = *(const uint16_t *)(p);
+				gfx_setpixel(reg, x + x_, y + y_, c);
+				p += 2;
+				break;
+			case GFX_RGB8:
+				c = rgb8_to_rgb565(p);
+				gfx_setpixel(reg, x + x_, y + y_, c);
+				p += 3;
+				break;
+			case GFX_RGBA5551:
+				c     = rgba5551_to_rgb565(p);
+				alpha = (*p) & 1;
+				if (alpha) {
+					gfx_setpixel(reg, x + x_, y + y_, c);
+				}
+				p += 2;
+				break;
+			case GFX_RGBA8:
+				gfx_setpixel_rgba(reg, x + x_, y + y_, p);
+				p += 4;
+				break;
+			default:
+				return;
 				break;
 			}
-
-			gfx_setpixel(reg, x + x_, y + y_, c);
-			p += bpp;
-		}
-	}
-}
-
-static void gfx_copy_region_mono(
-	struct gfx_region *reg,
-	int x,
-	int y,
-	int w,
-	int h,
-	size_t size,
-	const void *p
-) {
-	const char *bp = p;
-	int bit        = 0;
-	Color white    = gfx_color(reg, WHITE);
-	Color black    = gfx_color(reg, BLACK);
-
-	for (int y_ = 0; y_ < h; y_++) {
-		for (int x_ = 0; x_ < w; x_++) {
-			int value = *bp & (1 << bit);
-			if (++bit >= 8) {
-				bp++;
-				bit %= 8;
-
-				if ((const void *)(bp) >= (p + size))
-					return;
-			}
-
-			Color c = value ? white : black;
-			gfx_setpixel(reg, x + x_, y + y_, c);
 		}
 	}
 }
@@ -336,7 +378,7 @@ static void gfx_copy_region_mono(
  * significant bit determines the color, the remaining 7 bits determine the
  * amount.
  */
-static void gfx_copy_region_rle_mono(
+void gfx_copy_region_rle_mono(
 	struct gfx_region *reg,
 	int x,
 	int y,
@@ -363,31 +405,6 @@ static void gfx_copy_region_rle_mono(
 	}
 }
 
-void gfx_copy_region(
-	struct gfx_region *reg,
-	int x,
-	int y,
-	int w,
-	int h,
-	enum gfx_encoding encoding,
-	size_t size,
-	const void *p
-) {
-	switch (encoding) {
-	case GFX_RAW:
-		gfx_copy_region_raw(reg, x, y, w, h, size, p);
-		break;
-	case GFX_MONO:
-		gfx_copy_region_mono(reg, x, y, w, h, size, p);
-		break;
-	case GFX_RLE_MONO:
-		gfx_copy_region_rle_mono(reg, x, y, w, h, size, p);
-		break;
-	default:
-		break;
-	}
-}
-
 void gfx_copy_raw(struct gfx_region *reg, const void *p, size_t size)
 {
 	fb_copy_raw(reg->fb, p, size);

lib/gfx/gfx.h

@@ -44,9 +44,12 @@ enum gfx_color {
 };
 
 enum gfx_encoding {
-	GFX_RAW,
+	GFX_RGB565,
 	GFX_MONO,
-	GFX_RLE_MONO
+	GFX_RLE_MONO,
+	GFX_RGB8,
+	GFX_RGBA8,
+	GFX_RGBA5551
 };
 
 struct gfx_color_rgb {
@@ -57,9 +60,10 @@ struct gfx_color_rgb {
 
 Color gfx_color(struct gfx_region *reg, enum gfx_color color);
 
-void gfx_copy_region(struct gfx_region *reg, int x, int y, int w, int h,
-				enum gfx_encoding encoding, size_t size,
-							 const void *p);
+void gfx_copy_region_rle_mono(struct gfx_region *reg, int x, int y, int w, int h,
+						size_t size, const void *p);
+void gfx_copy_region( struct gfx_region *reg, int x, int y, int w, int h,
+						enum gfx_encoding encoding, const uint8_t *p);
 void gfx_copy_raw(struct gfx_region *reg, const void *p, size_t size);
 
 #endif

lodepng @ 7fdcc96a

+Subproject commit 7fdcc96a5e5864eee72911c3ca79b1d9f0d12292

lib/lodepng/lodepng.c

+lodepng/lodepng.cpp
\ No newline at end of file

lib/lodepng/meson.build

+includes = include_directories(
+  './lodepng',
+)
+
+sources = files(
+  './lodepng.c',
+)
+
+lib = static_library(
+  'lodepng',
+  sources,
+  include_directories: includes,
+  c_args: ['-O3', '-w', '-DLODEPNG_NO_COMPILE_ENCODER', '-DLODEPNG_NO_COMPILE_DISK', '-DLODEPNG_NO_COMPILE_ALLOCATORS'],
+)
+
+lodepng = declare_dependency(
+  include_directories: includes,
+  link_with: lib,
+)

lib/meson.build

@@ -17,3 +17,4 @@ subdir('./crypto/')
 subdir('./card10/')
 subdir('./mx25lba/')
 subdir('./ff13/')
+subdir('./lodepng/')