[OSS-Tools] [PATCH platsch V6 RESEND 5/5] Add spinner executable for boot animation and text show

[LI Qingwu <Qing-wu.Li@leica-geosystems.com.cn>]

This commit introduces a new executable, spinner,
    which supports two types of animations for boot sequences:
    1 static PNG and text support.
    2 rotates square PNG images per frame
    3 shows a sequence of square images from a strip of PNG images.

Signed-off-by: LI Qingwu <Qing-wu.Li@leica-geosystems.com.cn>
---
 README.rst        |  49 +++++++
 meson.build       |  20 +++
 meson_options.txt |   1 +
 spinner.c         | 323 ++++++++++++++++++++++++++++++++++++++++++++++
 spinner_conf.c    |  73 +++++++++++
 spinner_conf.h    |  39 ++++++
 6 files changed, 505 insertions(+)
 create mode 100644 meson_options.txt
 create mode 100644 spinner.c
 create mode 100644 spinner_conf.c
 create mode 100644 spinner_conf.h

diff --git a/README.rst b/README.rst
index e905437..27765ac 100644
--- a/README.rst
+++ b/README.rst
@@ -151,3 +151,52 @@ Compiling Instructions
     meson compile -C build
 
 To ensure fast startup, ``platsch`` prefers using static libraries.
+
+Spinner - Splash Screen with Animation
+======================================
+
+The ``spinner`` executable is designed to provide boot animations. It supports
+three types of animations:
+
+1. **Static PNG and Text Support**: Displays a static PNG image and text.
+2. **Square PNG Rotation Animation**: Rotates a square PNG image.
+3. **Sequence Move Rectangle Animation**: Displays a sequence of square images
+   from a strip of PNG images.
+
+To build the ``spinner`` executable, use the following commands:
+
+.. code-block:: shell
+
+    meson setup -Dspinner=true -Dprefer_static=true build
+    meson compile -C build
+
+Spinner Configuration
+---------------------
+
+The configuration for the ``spinner`` executable is read from a configuration
+file, with a default path of ``/usr/share/platsch/spinner.conf``. The directory
+of the configuration file can be set via the ``platsch_directory`` environment
+variable.
+
+Here is a sample configuration file (``spinner.conf``):
+
+.. code-block:: ini
+
+   symbol="/usr/share/platsch/Spinner.png"
+   fps=20
+   text=""
+   text_x=350
+   text_y=400
+   text_font="Sans"
+   text_size=30
+   text=qwqewrqr
+   symbol_x=-1
+   symbol_y=-1
+   rotate_step=0.1
+
+- Set ``text`` to empty if you don't want to display any text.
+- Set ``symbol`` to empty if you don't want to display any animation.
+- The background image is indicated by ``--directory`` and ``--basename``.
+- Set ``symbol_x`` and ``symbol_y`` to negative values for automatic centering.
+
+Please stop the spinner process after the system has booted, otherwise it keeps causing unnecessary CPU load.
diff --git a/meson.build b/meson.build
index ccc3d2d..c9c0e76 100644
--- a/meson.build
+++ b/meson.build
@@ -20,3 +20,23 @@ executable('platsch',
     install: true,
     install_dir: 'sbin'
 )
+
+if get_option('spinner')
+    spinner_dep = [
+        dependency('cairo', version: '>= 1.0'),
+        dep_libdrm
+    ]
+
+    spinner_src = [
+        'spinner.c',
+        'spinner_conf.c'
+    ]
+
+    executable('spinner',
+        spinner_src,
+        dependencies: spinner_dep,
+        link_with: libplatsch,
+        install: true,
+        install_dir:'sbin'
+    )
+endif
diff --git a/meson_options.txt b/meson_options.txt
new file mode 100644
index 0000000..607ecaf
--- /dev/null
+++ b/meson_options.txt
@@ -0,0 +1 @@
+option('spinner', type: 'boolean', value: false, description: 'Enable spinner build')
diff --git a/spinner.c b/spinner.c
new file mode 100644
index 0000000..dc4a191
--- /dev/null
+++ b/spinner.c
@@ -0,0 +1,323 @@
+
+#include <cairo.h>
+#include <math.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "libplatsch.h"
+#include "spinner_conf.h"
+
+typedef struct spinner {
+	cairo_format_t format;
+	cairo_surface_t *background_surface;
+	cairo_surface_t *symbol_surface;
+	cairo_t *disp_cr;
+	int display_height;
+	int display_width;
+	int symbol_frames;
+	int symbol_height;
+	int symbol_width;
+	int symbol_x;
+	int symbol_y;
+	float rotate_step;
+	struct modeset_dev *dev;
+	struct spinner *next;
+} spinner_t;
+
+void draw_background(cairo_t *cr, spinner_t *data)
+{
+	cairo_set_source_surface(cr, data->background_surface, -data->symbol_x, -data->symbol_y);
+	cairo_paint(cr);
+	cairo_save(cr);
+}
+
+void on_draw_sequence_animation(cairo_t *cr, spinner_t *data)
+{
+	static int frame;
+
+	int x = -data->symbol_width / 2;
+	int y = -data->symbol_height / 2;
+
+	int width = cairo_image_surface_get_width(data->symbol_surface);
+	int height = cairo_image_surface_get_height(data->symbol_surface);
+
+	if (width > height)
+		x = -data->symbol_width / 2 - frame * data->symbol_width;
+	else
+		y = -data->symbol_height / 2 - frame * data->symbol_height;
+
+	draw_background(cr, data);
+	cairo_translate(cr, data->symbol_width / 2, data->symbol_height / 2);
+	cairo_set_source_surface(cr, data->symbol_surface, x, y);
+	cairo_paint(cr);
+	cairo_restore(cr);
+	frame = (frame + 1) % data->symbol_frames;
+}
+
+void on_draw_rotation_animation(cairo_t *cr, spinner_t *data)
+{
+	static float angle = 0.0;
+
+	draw_background(cr, data);
+	cairo_translate(cr, data->symbol_width / 2, data->symbol_height / 2);
+	cairo_rotate(cr, angle);
+	cairo_set_source_surface(cr, data->symbol_surface, -data->symbol_width / 2,
+				 -data->symbol_height / 2);
+	cairo_paint(cr);
+	cairo_restore(cr);
+	angle += data->rotate_step;
+	if (angle > 2 * M_PI)
+		angle = 0.0;
+}
+
+static uint32_t convert_to_cairo_format(uint32_t format)
+{
+	switch (format) {
+	case DRM_FORMAT_RGB565:
+		return CAIRO_FORMAT_RGB16_565;
+	case DRM_FORMAT_XRGB8888:
+		return CAIRO_FORMAT_ARGB32;
+	}
+	return CAIRO_FORMAT_INVALID;
+}
+
+static void cairo_draw_text(cairo_t *cr, Config config)
+{
+	if (strlen(config.text) > 0) {
+		cairo_select_font_face(cr, config.text_font, CAIRO_FONT_SLANT_NORMAL,
+				       CAIRO_FONT_WEIGHT_NORMAL);
+		cairo_set_font_size(cr, (double)config.text_size);
+		cairo_move_to(cr, config.text_x, config.text_y);
+		cairo_set_source_rgb(cr, 0, 0, 0);
+		cairo_show_text(cr, config.text);
+	}
+}
+
+static int cairo_create_display_surface(struct modeset_dev *dev, spinner_t *data)
+{
+	cairo_surface_t *disp_surface = cairo_image_surface_create_for_data(
+	    dev->map, convert_to_cairo_format(dev->format->format), dev->width, dev->height,
+	    dev->stride);
+	if (cairo_surface_status(disp_surface)) {
+		platsch_error("Failed to create cairo surface\n");
+		return EXIT_FAILURE;
+	}
+	data->display_width = cairo_image_surface_get_width(disp_surface);
+	data->display_height = cairo_image_surface_get_height(disp_surface);
+	data->format = cairo_image_surface_get_format(disp_surface);
+	data->disp_cr = cairo_create(disp_surface);
+	return EXIT_SUCCESS;
+}
+
+// create a surface and paint background image
+static int cairo_create_background_surface(spinner_t *data, Config config, const char *dir,
+					   const char *base)
+{
+	char file_name[PLATSCH_MAX_FILENAME_LENGTH];
+	int ret;
+
+	ret = snprintf(file_name, sizeof(file_name), "%s/%s.png", dir, base);
+	if (ret >= sizeof(file_name)) {
+		platsch_error("Failed to fit file_name into buffer\n");
+		return EXIT_FAILURE;
+	}
+
+	data->background_surface =
+	    cairo_image_surface_create(data->format, data->display_width, data->display_height);
+	if (cairo_surface_status(data->background_surface)) {
+		platsch_error("Failed to create background surface\n");
+		return EXIT_FAILURE;
+	}
+
+	cairo_surface_t *bk_img_surface = cairo_image_surface_create_from_png(file_name);
+
+	if (cairo_surface_status(bk_img_surface)) {
+		platsch_error("Failed to create cairo surface from %s\n", file_name);
+		return EXIT_FAILURE;
+	}
+
+	int image_width = cairo_image_surface_get_width(bk_img_surface);
+	int image_height = cairo_image_surface_get_height(bk_img_surface);
+	double scale_x = (double)data->display_width / image_width;
+	double scale_y = (double)data->display_height / image_height;
+
+	cairo_t *cr_background = cairo_create(data->background_surface);
+	cairo_scale(cr_background, scale_x, scale_y);
+	cairo_set_source_surface(cr_background, bk_img_surface, 0, 0);
+
+	cairo_paint(cr_background);
+	cairo_draw_text(cr_background, config);
+	return EXIT_SUCCESS;
+}
+
+static int cairo_create_symbol_surface(spinner_t *data, Config config)
+{
+	if (strlen(config.symbol) == 0)
+		return EXIT_FAILURE;
+
+	data->symbol_surface = cairo_image_surface_create_from_png(config.symbol);
+	if (cairo_surface_status(data->symbol_surface)) {
+		platsch_error("Failed loading %s\n", config.symbol);
+		data->symbol_surface = NULL;
+		return EXIT_FAILURE;
+	}
+	data->symbol_width = cairo_image_surface_get_width(data->symbol_surface);
+	data->symbol_height = cairo_image_surface_get_height(data->symbol_surface);
+
+	if (data->symbol_width > data->symbol_height) {
+		data->symbol_frames = data->symbol_width / data->symbol_height;
+		data->symbol_width = data->symbol_height;
+	} else {
+		data->symbol_frames = data->symbol_height / data->symbol_width;
+		data->symbol_height = data->symbol_width;
+	}
+
+	data->rotate_step = config.rotate_step;
+
+	if (config.symbol_x <0)
+		data->symbol_x = data->display_width / 2 - data->symbol_width / 2;
+	else
+		data->symbol_x = config.symbol_x;
+
+	if(config.symbol_y <0)
+		data->symbol_y = data->display_height / 2 - data->symbol_height / 2;
+	else
+		data->symbol_y = config.symbol_y;
+
+	return EXIT_SUCCESS;
+}
+
+int main(int argc, char *argv[])
+{
+	bool pid1 = getpid() == 1;
+	char **initsargv;
+	char file_name[PLATSCH_MAX_FILENAME_LENGTH];
+	Config config = DEFAULT_CONFIG;
+	const char *base = "splash";
+	const char *dir = "/usr/share/platsch";
+	const char *env;
+	int ret;
+
+	spinner_t *spinner_list = NULL, *spinner_node = NULL, *spinner_iter = NULL;
+	struct modeset_dev *iter;
+	struct timespec start, end;
+
+	env = getenv("platsch_directory");
+	if (env)
+		dir = env;
+
+	env = getenv("platsch_basename");
+	if (env)
+		base = env;
+
+	ret = snprintf(file_name, sizeof(file_name), "%s/spinner.conf", dir);
+	if (ret >= sizeof(file_name)) {
+		platsch_error("Failed to fit file_name\n");
+		return EXIT_FAILURE;
+	}
+
+	parseConfig(file_name, &config);
+
+	struct modeset_dev *modeset_list = platsch_init();
+
+	if (!modeset_list) {
+		platsch_error("Failed to initialize modeset\n");
+		return EXIT_FAILURE;
+	}
+
+	for (iter = modeset_list; iter; iter = iter->next) {
+		spinner_node = (spinner_t *)malloc(sizeof(spinner_t));
+		if (!spinner_node) {
+			platsch_error("Failed to allocate memory for spinner_node\n");
+			return EXIT_FAILURE;
+		}
+		memset(spinner_node, 0, sizeof(*spinner_node));
+
+		if (cairo_create_display_surface(iter, spinner_node))
+			return EXIT_FAILURE;
+
+		if (cairo_create_background_surface(spinner_node, config, dir, base))
+			return EXIT_FAILURE;
+
+		cairo_create_symbol_surface(spinner_node, config);
+
+		cairo_set_source_surface(spinner_node->disp_cr, spinner_node->background_surface, 0,
+					 0);
+
+		cairo_paint(spinner_node->disp_cr);
+		platsch_setup_display(iter);
+
+		spinner_node->next = spinner_list;
+		spinner_list = spinner_node;
+	}
+
+	platsch_drmDropMaster();
+
+	ret = fork();
+	if (ret < 0)
+		platsch_error("failed to fork for init: %m\n");
+	else if (ret == 0)
+		/*
+		 * Always fork to make sure we got the required
+		 * resources for drawing the animation in the child.
+		 */
+		goto drawing;
+
+	if (pid1) {
+		initsargv = calloc(sizeof(argv[0]), argc + 1);
+
+		if (!initsargv) {
+			platsch_error("failed to allocate argv for init\n");
+			return EXIT_FAILURE;
+		}
+		memcpy(initsargv, argv, argc * sizeof(argv[0]));
+		initsargv[0] = "/sbin/init";
+		initsargv[argc] = NULL;
+
+		execv("/sbin/init", initsargv);
+
+		platsch_error("failed to exec init: %m\n");
+
+		return EXIT_FAILURE;
+	}
+	return EXIT_SUCCESS;
+
+drawing:
+	// create cairo surface for drawing symbol to avoid frlickering.
+	cairo_surface_t *drawing_surface = cairo_image_surface_create(
+	    spinner_node->format, spinner_node->symbol_width, spinner_node->symbol_height);
+	if (cairo_surface_status(drawing_surface)) {
+		platsch_error("Failed to create drawing surface\n");
+		return EXIT_FAILURE;
+	}
+
+	cairo_t *cr_drawing = cairo_create(drawing_surface);
+
+	while (true) {
+		clock_gettime(CLOCK_MONOTONIC, &start);
+
+		for (spinner_iter = spinner_list; spinner_iter; spinner_iter = spinner_iter->next) {
+			if (spinner_node->symbol_surface == NULL) {
+				sleep(10);
+				continue;
+			}
+
+			if (spinner_node->symbol_frames > 1)
+				on_draw_sequence_animation(cr_drawing, spinner_iter);
+			else
+				on_draw_rotation_animation(cr_drawing, spinner_iter);
+
+			cairo_set_source_surface(spinner_iter->disp_cr, drawing_surface,
+						 spinner_iter->symbol_x, spinner_iter->symbol_y);
+			cairo_paint(spinner_iter->disp_cr);
+		}
+
+		clock_gettime(CLOCK_MONOTONIC, &end);
+		long elapsed_time =
+		    (end.tv_sec - start.tv_sec) * 1000000L + (end.tv_nsec - start.tv_nsec) / 1000;
+		long sleep_time = (1000000 / config.fps) - elapsed_time;
+
+		if (sleep_time > 0)
+			usleep(sleep_time);
+	}
+}
diff --git a/spinner_conf.c b/spinner_conf.c
new file mode 100644
index 0000000..b867811
--- /dev/null
+++ b/spinner_conf.c
@@ -0,0 +1,73 @@
+#include "spinner_conf.h"
+#include <errno.h>
+
+int parseConfig(const char *filename, Config *config)
+{
+	char *value_end;
+	char *value_start;
+	char key[MAX_LINE_LENGTH];
+	char line[MAX_LINE_LENGTH];
+	char value[MAX_LINE_LENGTH];
+	FILE *file;
+
+	file = fopen(filename, "r");
+	if (file == NULL) {
+		fprintf(stderr, "Unable to open file: %s\n", filename);
+		return -EFAULT;
+	}
+
+	while (fgets(line, sizeof(line), file)) {
+		if (strlen(line) > MAX_LINE_LENGTH) {
+			fprintf(stderr, "conf string too long\n");
+			continue;
+		}
+		if (line[0] != '#' && sscanf(line, "%[^=]=%[^\n]", key, value) == 2) {
+			value_start = strchr(line, '=') + 1;
+			value_end = line + strlen(line) - 1;
+
+			while (isspace(*value_start))
+				value_start++;
+			while (isspace(*value_end) || *value_end == '"')
+				value_end--;
+
+			if (*value_start == '"')
+				value_start++;
+			if (*value_end == '"')
+					value_end--;
+
+			if (value_end < value_start) {
+				memset(value, 0, sizeof(value));
+				continue;
+			} else {
+				strncpy(value, value_start, value_end - value_start + 1);
+				value[value_end - value_start + 1] = '\0';
+				value[sizeof(value) - 1] = '\0';
+			}
+			value[MAX_LINE_LENGTH - 1] = '\0';
+
+			if (strcmp(key, "symbol") == 0) {
+				strncpy(config->symbol, value, MAX_LINE_LENGTH);
+			} else if (strcmp(key, "text") == 0) {
+				strncpy(config->text, value, MAX_LINE_LENGTH);
+			} else if (strcmp(key, "fps") == 0) {
+				config->fps = atoi(value);
+			} else if (strcmp(key, "text_x") == 0) {
+				config->text_x = atoi(value);
+			} else if (strcmp(key, "text_y") == 0) {
+				config->text_y = atoi(value);
+			} else if (strcmp(key, "text_font") == 0) {
+				strncpy(config->text_font, value, MAX_LINE_LENGTH);
+			} else if (strcmp(key, "text_size") == 0) {
+				config->text_size = atoi(value);
+			} else if (strcmp(key, "rotate_step") == 0) {
+				config->rotate_step = atof(value);
+			} else if (strcmp(key, "symbol_x") == 0) {
+				config->symbol_x = atoi(value);
+			} else if (strcmp(key, "symbol_y") == 0) {
+				config->symbol_y = atoi(value);
+			}
+		}
+	}
+	fclose(file);
+	return 0;
+}
diff --git a/spinner_conf.h b/spinner_conf.h
new file mode 100644
index 0000000..c397b9a
--- /dev/null
+++ b/spinner_conf.h
@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#ifndef __SPINNER_CONF_H__
+#define __SPINNER_CONF_H__
+
+
+#define MAX_LINE_LENGTH 128
+
+typedef struct {
+	char symbol[MAX_LINE_LENGTH];
+	char text_font[MAX_LINE_LENGTH];
+	char text[MAX_LINE_LENGTH];
+	float rotate_step;
+	int fps;
+	int symbol_x;
+	int symbol_y;
+	int text_size;
+	int text_x;
+	int text_y;
+} Config;
+
+int parseConfig(const char *filename, Config *config);
+
+#define DEFAULT_CONFIG { \
+	.symbol = "", \
+	.fps = 20, \
+	.text_x = 0, \
+	.text_y = 0, \
+	.text_font = "Sans", \
+	.text_size = 30, \
+	.text = "", \
+	.rotate_step = 0.1, \
+	.symbol_x = -1, \
+	.symbol_y = -1 \
+}
+#endif
-- 
2.34.1