SymbX/systemd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
97318131fd06a5bc35454da81dcbbc84f16d9940
systemd/src/boot/splash.c
T
Zbigniew Jędrzejewski-Szmek 97318131fd Rename src/boot/efi to just src/boot 
I very much dislike the approach in which we were mixing Linux and UEFI C code
in the same subdirectory. No code was shared between two environments. This
layout was created in e7dd673d1e, with the
justification of "being more consistent with the rest of systemd", but I don't
see how it's supposed to be so.

Originally, when the C code was just a single bootctl.c file, this wasn't so
bad. But over time the userspace code grew quite a bit. With the moves done in
previuos commits, the intermediate subdirectory is now empty except for the
efi/ subdir, and this additional subdirectory level doesn't have a good
justification. The components is called "systemd-boot", not "systemd-efi", and
we can remove one level of indentation.
2024-11-07 14:52:06 +01:00

335 lines
12 KiB
C
Raw Blame History

/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "graphics.h"
#include "logarithm.h"
#include "proto/graphics-output.h"
#include "splash.h"
#include "unaligned-fundamental.h"
#include "util.h"
struct bmp_file {
char signature[2];
uint32_t size;
uint16_t reserved[2];
uint32_t offset;
} _packed_;
/* we require at least BITMAPINFOHEADER, later versions are
accepted, but their features ignored */
struct bmp_dib {
uint32_t size;
uint32_t x;
uint32_t y;
uint16_t planes;
uint16_t depth;
uint32_t compression;
uint32_t image_size;
int32_t x_pixel_meter;
int32_t y_pixel_meter;
uint32_t colors_used;
uint32_t colors_important;
uint32_t channel_mask_r;
uint32_t channel_mask_g;
uint32_t channel_mask_b;
uint32_t channel_mask_a;
} _packed_;
#define SIZEOF_BMP_DIB offsetof(struct bmp_dib, channel_mask_r)
#define SIZEOF_BMP_DIB_RGB offsetof(struct bmp_dib, channel_mask_a)
#define SIZEOF_BMP_DIB_RGBA sizeof(struct bmp_dib)
struct bmp_map {
uint8_t blue;
uint8_t green;
uint8_t red;
uint8_t reserved;
} _packed_;
static EFI_STATUS bmp_parse_header(
const uint8_t *bmp,
size_t size,
struct bmp_dib **ret_dib,
struct bmp_map **ret_map,
const uint8_t **pixmap) {
assert(bmp);
assert(ret_dib);
assert(ret_map);
assert(pixmap);
if (size < sizeof(struct bmp_file) + SIZEOF_BMP_DIB)
return EFI_INVALID_PARAMETER;
/* check file header */
struct bmp_file *file = (struct bmp_file *) bmp;
if (file->signature[0] != 'B' || file->signature[1] != 'M')
return EFI_INVALID_PARAMETER;
if (file->size != size)
return EFI_INVALID_PARAMETER;
if (file->size < file->offset)
return EFI_INVALID_PARAMETER;
/* check device-independent bitmap */
struct bmp_dib *dib = (struct bmp_dib *) (bmp + sizeof(struct bmp_file));
if (dib->size < SIZEOF_BMP_DIB)
return EFI_UNSUPPORTED;
switch (dib->depth) {
case 1:
case 4:
case 8:
case 24:
if (dib->compression != 0)
return EFI_UNSUPPORTED;
break;
case 16:
case 32:
if (dib->compression != 0 && dib->compression != 3)
return EFI_UNSUPPORTED;
break;
default:
return EFI_UNSUPPORTED;
}
size_t row_size = ((size_t) dib->depth * dib->x + 31) / 32 * 4;
if (file->size - file->offset < dib->y * row_size)
return EFI_INVALID_PARAMETER;
if (row_size * dib->y > 64 * 1024 * 1024)
return EFI_INVALID_PARAMETER;
/* check color table */
struct bmp_map *map = (struct bmp_map *) (bmp + sizeof(struct bmp_file) + dib->size);
if (file->offset < sizeof(struct bmp_file) + dib->size)
return EFI_INVALID_PARAMETER;
if (file->offset > sizeof(struct bmp_file) + dib->size) {
uint32_t map_count = 0;
if (dib->colors_used)
map_count = dib->colors_used;
else if (IN_SET(dib->depth, 1, 4, 8))
map_count = 1 << dib->depth;
size_t map_size = file->offset - (sizeof(struct bmp_file) + dib->size);
if (map_size != sizeof(struct bmp_map) * map_count)
return EFI_INVALID_PARAMETER;
}
*ret_map = map;
*ret_dib = dib;
*pixmap = bmp + file->offset;
return EFI_SUCCESS;
}
enum Channels { R, G, B, A, _CHANNELS_MAX };
static void read_channel_maks(
const struct bmp_dib *dib,
uint32_t channel_mask[static _CHANNELS_MAX],
uint8_t channel_shift[static _CHANNELS_MAX],
uint8_t channel_scale[static _CHANNELS_MAX]) {
assert(dib);
if (IN_SET(dib->depth, 16, 32) && dib->size >= SIZEOF_BMP_DIB_RGB) {
channel_mask[R] = dib->channel_mask_r;
channel_mask[G] = dib->channel_mask_g;
channel_mask[B] = dib->channel_mask_b;
channel_shift[R] = __builtin_ctz(dib->channel_mask_r);
channel_shift[G] = __builtin_ctz(dib->channel_mask_g);
channel_shift[B] = __builtin_ctz(dib->channel_mask_b);
channel_scale[R] = 0xff / ((1 << popcount(dib->channel_mask_r)) - 1);
channel_scale[G] = 0xff / ((1 << popcount(dib->channel_mask_g)) - 1);
channel_scale[B] = 0xff / ((1 << popcount(dib->channel_mask_b)) - 1);
if (dib->size >= SIZEOF_BMP_DIB_RGBA && dib->channel_mask_a != 0) {
channel_mask[A] = dib->channel_mask_a;
channel_shift[A] = __builtin_ctz(dib->channel_mask_a);
channel_scale[A] = 0xff / ((1 << popcount(dib->channel_mask_a)) - 1);
} else {
channel_mask[A] = 0;
channel_shift[A] = 0;
channel_scale[A] = 0;
}
} else {
bool bpp16 = dib->depth == 16;
channel_mask[R] = bpp16 ? 0x7C00 : 0xFF0000;
channel_mask[G] = bpp16 ? 0x03E0 : 0x00FF00;
channel_mask[B] = bpp16 ? 0x001F : 0x0000FF;
channel_mask[A] = bpp16 ? 0x0000 : 0x000000;
channel_shift[R] = bpp16 ? 0xA : 0x10;
channel_shift[G] = bpp16 ? 0x5 : 0x08;
channel_shift[B] = bpp16 ? 0x0 : 0x00;
channel_shift[A] = bpp16 ? 0x0 : 0x00;
channel_scale[R] = bpp16 ? 0x08 : 0x1;
channel_scale[G] = bpp16 ? 0x08 : 0x1;
channel_scale[B] = bpp16 ? 0x08 : 0x1;
channel_scale[A] = bpp16 ? 0x00 : 0x0;
}
}
static EFI_STATUS bmp_to_blt(
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *buf,
struct bmp_dib *dib,
struct bmp_map *map,
const uint8_t *pixmap) {
const uint8_t *in;
assert(buf);
assert(dib);
assert(map);
assert(pixmap);
uint32_t channel_mask[_CHANNELS_MAX];
uint8_t channel_shift[_CHANNELS_MAX], channel_scale[_CHANNELS_MAX];
read_channel_maks(dib, channel_mask, channel_shift, channel_scale);
/* transform and copy pixels */
in = pixmap;
for (uint32_t y = 0; y < dib->y; y++) {
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *out = &buf[(dib->y - y - 1) * dib->x];
for (uint32_t x = 0; x < dib->x; x++, in++, out++) {
switch (dib->depth) {
case 1: {
for (unsigned i = 0; i < 8 && x < dib->x; i++) {
out->Red = map[((*in) >> (7 - i)) & 1].red;
out->Green = map[((*in) >> (7 - i)) & 1].green;
out->Blue = map[((*in) >> (7 - i)) & 1].blue;
out++;
x++;
}
out--;
x--;
break;
}
case 4: {
unsigned i = (*in) >> 4;
out->Red = map[i].red;
out->Green = map[i].green;
out->Blue = map[i].blue;
if (x < (dib->x - 1)) {
out++;
x++;
i = (*in) & 0x0f;
out->Red = map[i].red;
out->Green = map[i].green;
out->Blue = map[i].blue;
}
break;
}
case 8:
out->Red = map[*in].red;
out->Green = map[*in].green;
out->Blue = map[*in].blue;
break;
case 24:
out->Red = in[2];
out->Green = in[1];
out->Blue = in[0];
in += 2;
break;
case 16:
case 32: {
uint32_t i = dib->depth == 16 ? unaligned_read_ne16(in) :
unaligned_read_ne32(in);
uint8_t r = ((i & channel_mask[R]) >> channel_shift[R]) * channel_scale[R],
g = ((i & channel_mask[G]) >> channel_shift[G]) * channel_scale[G],
b = ((i & channel_mask[B]) >> channel_shift[B]) * channel_scale[B],
a = 0xFFu;
if (channel_mask[A] != 0)
a = ((i & channel_mask[A]) >> channel_shift[A]) * channel_scale[A];
out->Red = (out->Red * (0xFFu - a) + r * a) >> 8;
out->Green = (out->Green * (0xFFu - a) + g * a) >> 8;
out->Blue = (out->Blue * (0xFFu - a) + b * a) >> 8;
in += dib->depth == 16 ? 1 : 3;
break;
}
}
}
/* add row padding; new lines always start at 32 bit boundary */
size_t row_size = in - pixmap;
in += ((row_size + 3) & ~3) - row_size;
}
return EFI_SUCCESS;
}
EFI_STATUS graphics_splash(const uint8_t *content, size_t len) {
EFI_GRAPHICS_OUTPUT_BLT_PIXEL background = {};
EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput = NULL;
struct bmp_dib *dib;
struct bmp_map *map;
const uint8_t *pixmap;
size_t x_pos = 0, y_pos = 0;
EFI_STATUS err;
if (len == 0)
return EFI_SUCCESS;
assert(content);
if (strcaseeq16(ST->FirmwareVendor, u"Apple")) {
background.Red = 0xc0;
background.Green = 0xc0;
background.Blue = 0xc0;
}
err = BS->LocateProtocol(MAKE_GUID_PTR(EFI_GRAPHICS_OUTPUT_PROTOCOL), NULL, (void **) &GraphicsOutput);
if (err != EFI_SUCCESS)
return err;
err = bmp_parse_header(content, len, &dib, &map, &pixmap);
if (err != EFI_SUCCESS)
return err;
if (dib->x < GraphicsOutput->Mode->Info->HorizontalResolution)
x_pos = (GraphicsOutput->Mode->Info->HorizontalResolution - dib->x) / 2;
if (dib->y < GraphicsOutput->Mode->Info->VerticalResolution)
y_pos = (GraphicsOutput->Mode->Info->VerticalResolution - dib->y) / 2;
err = GraphicsOutput->Blt(
GraphicsOutput, &background,
EfiBltVideoFill, 0, 0, 0, 0,
GraphicsOutput->Mode->Info->HorizontalResolution,
GraphicsOutput->Mode->Info->VerticalResolution, 0);
if (err != EFI_SUCCESS)
return err;
/* Read in current screen content to perform proper alpha blending. */
_cleanup_free_ EFI_GRAPHICS_OUTPUT_BLT_PIXEL *blt = xnew(
EFI_GRAPHICS_OUTPUT_BLT_PIXEL, dib->x * dib->y);
err = GraphicsOutput->Blt(
GraphicsOutput, blt,
EfiBltVideoToBltBuffer, x_pos, y_pos, 0, 0,
dib->x, dib->y, 0);
if (err != EFI_SUCCESS)
return err;
err = bmp_to_blt(blt, dib, map, pixmap);
if (err != EFI_SUCCESS)
return err;
err = graphics_mode(true);
if (err != EFI_SUCCESS)
return err;
return GraphicsOutput->Blt(
GraphicsOutput, blt,
EfiBltBufferToVideo, 0, 0, x_pos, y_pos,
dib->x, dib->y, 0);
}
Reference in New Issue View Git Blame Copy Permalink