splashdown

splashdown.c (7484B)

---

 
 /*
  * splashdown - minimal bootsplash program
  * Copyright (C) 2026 Pollux <pollux@pollux.codes>
  * 
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  * 
  * This program 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 General Public License for more details.
  * 
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 #include <errno.h>
 #include <stdarg.h>
 #include <linux/fb.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include <stdio.h>
 
 #include <fcntl.h>
 #include <unistd.h>
 
 #include <jpeglib.h>
 
 #include <freetype/freetype.h>
 #include FT_FREETYPE_H
 
 #define LENGTH(X) (sizeof (X) / sizeof (X)[0])
 #define MIN(A, B) ((A) < (B) ? (A) : (B))
 
 struct image_buffer {
 	uint32_t        width;
 	uint32_t        height;
 	uint32_t       *data;
 };
 
 void            die(const char *fmt, ...);
 void            draw_buffer(struct image_buffer src, uint32_t srcx,
                             uint32_t srcy, uint32_t srcw, uint32_t srch,
                             struct image_buffer dest, uint32_t destx,
                             uint32_t desty);
 void            draw_glyph(struct image_buffer buffer, FT_Bitmap bitmap, int x,
                            int y, uint32_t color);
 void            draw_text(struct image_buffer buffer, int x, int y,
                           FT_Face face, uint32_t color, const char *text,
                           size_t len);
 int             mmap_fb(struct image_buffer *fb);
 int             read_jpeg(const char *path, struct image_buffer *buffer);
 
 #include "config.h"
 
 void
 die(const char *fmt, ...) {
 	va_list         ap;
 	int             saved_errno;
 
 	saved_errno = errno;
 
 	va_start(ap, fmt);
 	vfprintf(stderr, fmt, ap);
 	va_end(ap);
 
 	if(fmt[0] && fmt[strlen(fmt) - 1] == ':')
 		fprintf(stderr, " %s", strerror(saved_errno));
 	fputc('\n', stderr);
 	exit(1);
 }
 
 void
 draw_buffer(struct image_buffer src, uint32_t srcx, uint32_t srcy,
 	    uint32_t srcw, uint32_t srch, struct image_buffer dest,
 	    uint32_t destx, uint32_t desty) {
 
 	srcw = MIN(srcw, src.width);
 	srch = MIN(srch, src.height);
 
 	srcw = MIN(srcw, dest.width - destx);
 	srch = MIN(srch, dest.height - desty);
 
 	int             row_bytes = srcw * sizeof(uint32_t);
 
 	for(uint32_t y = 0; y < srch; y++) {
 		memcpy(dest.data + dest.width * (desty + y) + destx,
 		       src.data + src.width * (y + srcy) + srcx, row_bytes);
 	}
 }
 
 void
 draw_glyph(struct image_buffer buffer, FT_Bitmap bitmap, int x, int y,
 	   uint32_t color) {
 	for(uint32_t py = 0; py < bitmap.rows; py++) {
 		for(uint32_t px = 0; px < bitmap.width; px++) {
 			uint8_t         a =
 			        bitmap.buffer[bitmap.pitch * py + px];
 			uint32_t        bg =
 			        buffer.data[(y + py) * buffer.width + x + px];
 
 			uint16_t        r = bg >> 16 & 0xff;
 			uint16_t        g = bg >> 8 & 0xff;
 			uint16_t        b = bg >> 0 & 0xff;
 
 			uint16_t        r_t = color >> 16 & 0xff;
 			uint16_t        g_t = color >> 8 & 0xff;
 			uint16_t        b_t = color >> 0 & 0xff;
 
 			r = (r * (255 - a) + r_t * a) / 255;
 			g = (g * (255 - a) + g_t * a) / 255;
 			b = (b * (255 - a) + b_t * a) / 255;
 
 			buffer.data[(y + py) * buffer.width + x + px] =
 			        b | g << 8 | r << 16;
 		}
 	}
 }
 
 void
 draw_text(struct image_buffer buffer, int x, int y, FT_Face face,
 	  uint32_t color, const char *text, size_t len) {
 
 	int             e, pen_x = x;
 
 	for(uint32_t n = 0; n < len; n++) {
 		e = FT_Load_Char(face, text[n], FT_LOAD_RENDER);
 		if(e)
 			continue;
 
 		draw_glyph(buffer, face->glyph->bitmap,
 		           pen_x + face->glyph->bitmap_left,
 		           y - face->glyph->bitmap_top, color);
 
 		pen_x += face->glyph->advance.x >> 6;
 	}
 }
 
 int
 mmap_fb(struct image_buffer *fb) {
 	int             fd = open(FB_DEV, O_RDWR);
 	struct fb_var_screeninfo fb_info;
 	int             e = ioctl(fd, FBIOGET_VSCREENINFO, &fb_info);
 
 	if(e)
 		return -1;
 	fb->width = fb_info.xres;
 	fb->height = fb_info.yres;
 	uint32_t        fb_size = fb->width * fb->height * 4;
 
 	fb->data =
 	        mmap(NULL, fb_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 	close(fd);
 	return 0;
 }
 
 int
 read_jpeg(const char *path, struct image_buffer *buffer) {
 	FILE           *fd;
 
 	fd = fopen(path, "rb");
 	if(fd == NULL)
 		return -1;
 
 	struct jpeg_error_mgr jerr;
 	struct jpeg_decompress_struct cinfo;
 
 	cinfo.err = jpeg_std_error(&jerr);
 
 	jpeg_create_decompress(&cinfo);
 	jpeg_stdio_src(&cinfo, fd);
 	if(jpeg_read_header(&cinfo, TRUE) != JPEG_HEADER_OK)
 		goto bail;
 	if(!jpeg_start_decompress(&cinfo))
 		goto bail;
 
 	buffer->width = cinfo.output_width;
 	buffer->height = cinfo.output_height;
 
 	int             pixels = buffer->width * buffer->height;
 
 	buffer->data = malloc(pixels * sizeof(uint32_t));
 
 	int             row_stride =
 	        cinfo.output_width * cinfo.output_components;
 
 	JSAMPARRAY      working_buffer =
 	        (cinfo.mem->alloc_sarray) ((j_common_ptr) & cinfo, JPOOL_IMAGE,
 	                                   row_stride, 1);
 
 	while(cinfo.output_scanline < cinfo.output_height) {
 		if(jpeg_read_scanlines(&cinfo, working_buffer, 1) != 1)
 			goto bail;
 		for(uint32_t x = 0; x < cinfo.output_width; x++)
 			buffer->data[buffer->width *
 		                     (cinfo.output_scanline - 1) + x] =
 		                (working_buffer[0][x * 3 + 2] & 0xff) |
 		                ((working_buffer[0][x * 3 + 1] & 0xff) << 8) |
 		                ((working_buffer[0][x * 3] & 0xff) << 16);
 	}
 
 	jpeg_finish_decompress(&cinfo);
 	jpeg_destroy_decompress(&cinfo);
 	return 0;
 
 	bail:
 	jpeg_destroy_decompress(&cinfo);
 	if(buffer->data)
 		free(buffer->data);
 	buffer->data = NULL;
 	return -1;
 }
 
 int
 main(const int argc, const char **argv) {
 
 	struct image_buffer splash_image = {.data = NULL };
 	struct image_buffer framebuffer = {.data = NULL };
 
 	const char     *err = NULL;
 
 	const char     *text = NULL;
 
 	if(argc > 1)
 		text = argv[1];
 
 	FT_Library      lib = NULL;
 	FT_Face         face = NULL;
 
 	if(FT_Init_FreeType(&lib))
 		die("Could not load freetype2.");
 	for(uint32_t i = 0; i < LENGTH(fonts); i++)
 		if(!FT_New_Face(lib, fonts[i], 0, &face))
 			break;
 	if(!face) {
 		err = "Could not locate font.";
 		goto cleanup;
 	}
 
 	if(FT_Set_Pixel_Sizes(face, 0, font_size)) {
 		err = "Could not set font properties.";
 		goto cleanup;
 	}
 
 	for(uint32_t i = 0; i < LENGTH(image_paths); i++)
 		if(read_jpeg(image_paths[i], &splash_image))
 			break;
 
 	if(!splash_image.data) {
 		err = "Could not open image.";
 		goto cleanup;
 	}
 
 	if(mmap_fb(&framebuffer)) {
 		err = "Could not open framebuffer.";
 		goto cleanup;
 	}
 
 	if(text)
 		draw_text(splash_image, margin_x, margin_y, face, font_color,
 	                  text, strlen(text));
 	draw_buffer(splash_image, 0, 0, splash_image.width, splash_image.height,
 	            framebuffer, 0, 0);
 
 	cleanup:
 	if(framebuffer.data)
 		munmap(framebuffer.data,
 	               framebuffer.width * framebuffer.height *
 	               sizeof(uint32_t));
 	if(splash_image.data)
 		free(splash_image.data);
 	if(face)
 		FT_Done_Face(face);
 	if(lib)
 		FT_Done_FreeType(lib);
 	if(err)
 		die(err);
 
 	return 0;
 }