aboutsummaryrefslogtreecommitdiff
path: root/sys/modules/splash
diff options
context:
space:
mode:
Diffstat (limited to 'sys/modules/splash')
-rw-r--r--sys/modules/splash/Makefile5
-rw-r--r--sys/modules/splash/Makefile.inc3
-rw-r--r--sys/modules/splash/bmp/Makefile8
-rw-r--r--sys/modules/splash/bmp/splash_bmp.c494
4 files changed, 510 insertions, 0 deletions
diff --git a/sys/modules/splash/Makefile b/sys/modules/splash/Makefile
new file mode 100644
index 000000000000..39a292e7c6bf
--- /dev/null
+++ b/sys/modules/splash/Makefile
@@ -0,0 +1,5 @@
+# $Id: $
+
+SUBDIR= bmp
+
+.include <bsd.subdir.mk>
diff --git a/sys/modules/splash/Makefile.inc b/sys/modules/splash/Makefile.inc
new file mode 100644
index 000000000000..64212f6bfa21
--- /dev/null
+++ b/sys/modules/splash/Makefile.inc
@@ -0,0 +1,3 @@
+# $Id: $
+
+.include "../Makefile.inc"
diff --git a/sys/modules/splash/bmp/Makefile b/sys/modules/splash/bmp/Makefile
new file mode 100644
index 000000000000..798e7e428389
--- /dev/null
+++ b/sys/modules/splash/bmp/Makefile
@@ -0,0 +1,8 @@
+# $Id: $
+
+KMOD= splash_bmp
+SRCS= splash_bmp.c
+
+NOMAN=
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/splash/bmp/splash_bmp.c b/sys/modules/splash/bmp/splash_bmp.c
new file mode 100644
index 000000000000..ebf007a50059
--- /dev/null
+++ b/sys/modules/splash/bmp/splash_bmp.c
@@ -0,0 +1,494 @@
+/*-
+ * Copyright (c) 1999 Michael Smith <msmith@freebsd.org>
+ * Copyright (c) 1999 Kazutaka YOKOTA <yokota@freebsd.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $Id:$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/linker.h>
+
+#include <machine/console.h>
+
+#include <dev/fb/fbreg.h>
+#include <dev/fb/splashreg.h>
+
+#define FADE_TIMEOUT 300 /* sec */
+
+static int splash_mode = -1;
+static int splash_on = FALSE;
+
+static int bmp_start(video_adapter_t *adp);
+static int bmp_end(video_adapter_t *adp);
+static int bmp_splash(video_adapter_t *adp, int on);
+static int bmp_Init(const char *data, int swidth, int sheight, int sdepth);
+static int bmp_Draw(video_adapter_t *adp);
+
+static splash_decoder_t bmp_decoder = {
+ "splash_bmp", bmp_start, bmp_end, bmp_splash, SPLASH_IMAGE,
+};
+
+SPLASH_DECODER(splash_bmp, bmp_decoder);
+
+static int
+bmp_start(video_adapter_t *adp)
+{
+ static int modes[] = {
+ M_VGA_CG320,
+ -1,
+ };
+ video_info_t info;
+ int i;
+
+ if ((bmp_decoder.data == NULL) || (bmp_decoder.data_size <= 0))
+ return ENODEV;
+ for (i = 0; modes[i] >= 0; ++i) {
+ if (((*vidsw[adp->va_index]->get_info)(adp, modes[i], &info) == 0)
+ && (bmp_Init((u_char *)bmp_decoder.data,
+ info.vi_width, info.vi_height, info.vi_depth) == 0))
+ break;
+ }
+ splash_mode = modes[i];
+ if (bootverbose)
+ printf("bmp_start(): splash_mode:%d\n", splash_mode);
+ return ((splash_mode < 0) ? ENODEV : 0);
+}
+
+static int
+bmp_end(video_adapter_t *adp)
+{
+ /* nothing to do */
+ return 0;
+}
+
+static int
+bmp_splash(video_adapter_t *adp, int on)
+{
+ static u_char pal[256*3];
+ static long time_stamp;
+ struct timeval tv;
+ int i;
+
+ if (on) {
+ if (!splash_on) {
+ /* set up the video mode and draw something */
+ if ((*vidsw[adp->va_index]->set_mode)(adp, splash_mode))
+ return 1;
+ if (bmp_Draw(adp))
+ return 1;
+ (*vidsw[adp->va_index]->save_palette)(adp, pal);
+ time_stamp = 0;
+ splash_on = TRUE;
+ }
+ /*
+ * This is a kludge to fade the image away. This section of the
+ * code takes effect only after the system is completely up.
+ */
+ if (!cold) {
+ getmicrotime(&tv);
+ if (time_stamp == 0)
+ time_stamp = tv.tv_sec;
+ if (tv.tv_sec > time_stamp + FADE_TIMEOUT) {
+ for (i = 0; i < sizeof(pal); ++i) {
+ if (pal[i] > 40)
+ pal[i] -= 4;
+ }
+ (*vidsw[adp->va_index]->load_palette)(adp, pal);
+ }
+ }
+ return 0;
+ } else {
+ /* the video mode will be restored by the caller */
+ splash_on = FALSE;
+ return 0;
+ }
+}
+
+/*
+** Code to handle Microsoft DIB (".BMP") format images.
+**
+** Blame me (msmith@freebsd.org) if this is broken, not Soren.
+*/
+
+typedef struct tagBITMAPFILEHEADER { /* bmfh */
+ u_short bfType __attribute__ ((packed));
+ int bfSize __attribute__ ((packed));
+ u_short bfReserved1 __attribute__ ((packed));
+ u_short bfReserved2 __attribute__ ((packed));
+ int bfOffBits __attribute__ ((packed));
+} BITMAPFILEHEADER;
+
+typedef struct tagBITMAPINFOHEADER { /* bmih */
+ int biSize __attribute__ ((packed));
+ int biWidth __attribute__ ((packed));
+ int biHeight __attribute__ ((packed));
+ short biPlanes __attribute__ ((packed));
+ short biBitCount __attribute__ ((packed));
+ int biCompression __attribute__ ((packed));
+ int biSizeImage __attribute__ ((packed));
+ int biXPelsPerMeter __attribute__ ((packed));
+ int biYPelsPerMeter __attribute__ ((packed));
+ int biClrUsed __attribute__ ((packed));
+ int biClrImportant __attribute__ ((packed));
+} BITMAPINFOHEADER;
+
+typedef struct tagRGBQUAD { /* rgbq */
+ u_char rgbBlue __attribute__ ((packed));
+ u_char rgbGreen __attribute__ ((packed));
+ u_char rgbRed __attribute__ ((packed));
+ u_char rgbReserved __attribute__ ((packed));
+} RGBQUAD;
+
+typedef struct tagBITMAPINFO { /* bmi */
+ BITMAPINFOHEADER bmiHeader __attribute__ ((packed));
+ RGBQUAD bmiColors[256] __attribute__ ((packed));
+} BITMAPINFO;
+
+typedef struct tagBITMAPF
+{
+ BITMAPFILEHEADER bmfh __attribute__ ((packed));
+ BITMAPINFO bmfi __attribute__ ((packed));
+} BITMAPF;
+
+#define BI_RGB 0
+#define BI_RLE8 1
+#define BI_RLE4 2
+
+/*
+** all we actually care about the image
+*/
+typedef struct
+{
+ int width,height; /* image dimensions */
+ int swidth,sheight; /* screen dimensions for the current mode */
+ u_char sdepth; /* screen depth (1, 4, 8 bpp) */
+ int ncols; /* number of colours */
+ u_char palette[256][3]; /* raw palette data */
+ u_char format; /* one of the BI_* constants above */
+ u_char *data; /* pointer to the raw data */
+ u_char *index; /* running pointer to the data while drawing */
+ u_char *vidmem; /* video memory allocated for drawing */
+} BMP_INFO;
+
+static BMP_INFO bmp_info;
+
+/*
+** bmp_SetPix
+**
+** Given (info), set the pixel at (x),(y) to (val)
+**
+*/
+static void
+bmp_SetPix(BMP_INFO *info, int x, int y, u_char val)
+{
+ int sofs, bofs;
+ u_char tpv, mask;
+
+ /*
+ * range check to avoid explosions
+ */
+ if ((x < 0) || (x >= info->swidth) || (y < 0) || (y >= info->sheight))
+ return;
+
+ /*
+ * calculate offset into video memory;
+ * because 0,0 is bottom-left for DIB, we have to convert.
+ */
+ sofs = ((info->height - (y+1) + (info->sheight - info->height) / 2)
+ * info->swidth) + x + (info->swidth - info->width) / 2;
+
+ switch(info->sdepth) {
+ case 1:
+ sofs = sofs >> 3; /* correct for depth */
+ bofs = x & 0x7; /* offset within byte */
+
+ val &= 1; /* mask pixel value */
+ mask = ~(0x80 >> bofs); /* calculate bit mask */
+ tpv = *(info->vidmem+sofs) & mask; /* get screen contents, excluding masked bit */
+ *(info->vidmem+sofs) = tpv | (val << (8-bofs)); /* write new bit */
+ break;
+
+ /* XXX only correct for non-interleaved modes */
+ case 4:
+ sofs = sofs >> 1; /* correct for depth */
+ bofs = x & 0x1; /* offset within byte */
+
+ val &= 0xf; /* mask pixel value */
+ mask = bofs ? 0x0f : 0xf0; /* calculate bit mask */
+ tpv = *(info->vidmem+sofs) & mask; /* get screen contents, excluding masked bits */
+ *(info->vidmem+sofs) = tpv | (val << (bofs ? 0 : 4)); /* write new bits */
+ break;
+
+ case 8:
+ *(info->vidmem+sofs) = val;
+ break;
+ }
+}
+
+/*
+** bmp_DecodeRLE4
+**
+** Given (data) pointing to a line of RLE4-format data and (line) being the starting
+** line onscreen, decode the line.
+*/
+static void
+bmp_DecodeRLE4(BMP_INFO *info, int line)
+{
+ int count; /* run count */
+ u_char val;
+ int x,y; /* screen position */
+
+ x = 0; /* starting position */
+ y = line;
+
+ /* loop reading data */
+ for (;;) {
+ /*
+ * encoded mode starts with a run length, and then a byte with
+ * two colour indexes to alternate between for the run
+ */
+ if (*info->index) {
+ for (count = 0; count < *info->index; count++, x++) {
+ if (count & 1) { /* odd count, low nybble */
+ bmp_SetPix(info, x, y, *(info->index+1) & 0x0f);
+ } else { /* even count, high nybble */
+ bmp_SetPix(info, x, y, (*(info->index+1) >>4) & 0x0f);
+ }
+ }
+ info->index += 2;
+ /*
+ * A leading zero is an escape; it may signal the end of the
+ * bitmap, a cursor move, or some absolute data.
+ */
+ } else { /* zero tag may be absolute mode or an escape */
+ switch (*(info->index+1)) {
+ case 0: /* end of line */
+ info->index += 2;
+ return;
+ case 1: /* end of bitmap */
+ info->index = NULL;
+ return;
+ case 2: /* move */
+ x += *(info->index + 2); /* new coords */
+ y += *(info->index + 3);
+ info->index += 4;
+ break;
+ default: /* literal bitmap data */
+ for (count = 0; count < *(info->index + 1); count++, x++) {
+ val = *(info->index + 2 + (count / 2)); /* byte with nybbles */
+ if (count & 1) {
+ val &= 0xf; /* get low nybble */
+ } else {
+ val = (val >> 4); /* get high nybble */
+ }
+ bmp_SetPix(info, x, y, val);
+ }
+ /* warning, this depends on integer truncation, do not hand-optimise! */
+ info->index += 2 + ((count + 3) / 4) * 2;
+ break;
+ }
+ }
+ }
+}
+
+/*
+** bmp_DecodeRLE8
+** Given (data) pointing to a line of RLE4-format data and (line) being the starting
+** line onscreen, decode the line.
+*/
+static void
+bmp_DecodeRLE8(BMP_INFO *info, int line)
+{
+ int count; /* run count */
+ int x,y; /* screen position */
+
+ x = 0; /* starting position */
+ y = line;
+
+ /* loop reading data */
+ for(;;) {
+ /*
+ * encoded mode starts with a run length, and then a byte with
+ * two colour indexes to alternate between for the run
+ */
+ if (*info->index) {
+ for (count = 0; count < *info->index; count++, x++)
+ bmp_SetPix(info, x, y, *(info->index+1));
+ info->index += 2;
+ /*
+ * A leading zero is an escape; it may signal the end of the
+ * bitmap, a cursor move, or some absolute data.
+ */
+ } else { /* zero tag may be absolute mode or an escape */
+ switch(*(info->index+1)) {
+ case 0: /* end of line */
+ info->index += 2;
+ return;
+ case 1: /* end of bitmap */
+ info->index = NULL;
+ return;
+ case 2: /* move */
+ x += *(info->index + 2); /* new coords */
+ y += *(info->index + 3);
+ info->index += 4;
+ break;
+ default: /* literal bitmap data */
+ for (count = 0; count < *(info->index + 1); count++, x++)
+ bmp_SetPix(info, x, y, *(info->index + 2 + count));
+ /* must be an even count */
+ info->index += 2 + count + (count & 1);
+ break;
+ }
+ }
+ }
+}
+
+/*
+** bmp_DecodeLine
+**
+** Given (info) pointing to an image being decoded, (line) being the line currently
+** being displayed, decode a line of data.
+*/
+static void
+bmp_DecodeLine(BMP_INFO *info, int line)
+{
+ int x;
+
+ switch(info->format) {
+ case BI_RGB:
+ for (x = 0; x < info->width; x++, info->index++)
+ bmp_SetPix(info, x, line, *info->index);
+ info->index += 4 - (x % 4);
+ break;
+ case BI_RLE4:
+ bmp_DecodeRLE4(info, line);
+ break;
+ case BI_RLE8:
+ bmp_DecodeRLE8(info, line);
+ break;
+ }
+}
+
+/*
+** bmp_Init
+**
+** Given a pointer (data) to the image of a BMP file, fill in bmp_info with what
+** can be learnt from it. Return nonzero if the file isn't usable.
+**
+** Take screen dimensions (swidth), (sheight) and (sdepth) and make sure we
+** can work with these.
+*/
+static int
+bmp_Init(const char *data, int swidth, int sheight, int sdepth)
+{
+ BITMAPF *bmf = (BITMAPF *)data;
+ int pind;
+
+ bmp_info.data = NULL; /* assume setup failed */
+#if 0
+ bmp_info.vidmem = vidmem; /* remember where */
+#endif
+
+ /* check file ID */
+ if (bmf->bmfh.bfType != 0x4d42) {
+ return(1); /* XXX check word ordering for big-endian ports? */
+ }
+
+ /* save what we know about the screen */
+ bmp_info.swidth = swidth;
+ bmp_info.sheight = sheight;
+ bmp_info.sdepth = sdepth;
+
+ /* where's the data? */
+ bmp_info.data = (u_char *)data + bmf->bmfh.bfOffBits;
+
+ /* image parameters */
+ bmp_info.width = bmf->bmfi.bmiHeader.biWidth;
+ bmp_info.height = bmf->bmfi.bmiHeader.biHeight;
+ bmp_info.format = bmf->bmfi.bmiHeader.biCompression;
+
+ switch(bmp_info.format) { /* check compression format */
+ case BI_RGB:
+ case BI_RLE4:
+ case BI_RLE8:
+ break;
+ default:
+ return(1); /* unsupported compression format */
+ }
+
+ /* palette details */
+ bmp_info.ncols = (bmf->bmfi.bmiHeader.biClrUsed);
+ bzero(bmp_info.palette,sizeof(bmp_info.palette));
+ if (bmp_info.ncols == 0) { /* uses all of them */
+ bmp_info.ncols = 2 << bmf->bmfi.bmiHeader.biBitCount;
+ }
+ if ((bmp_info.height > bmp_info.sheight) ||
+ (bmp_info.width > bmp_info.swidth) ||
+ (bmp_info.ncols > (1 << sdepth))) {
+ return(1); /* beyond screen capacity */
+ }
+
+ /* read palette */
+ for (pind = 0; pind < bmp_info.ncols; pind++) {
+ bmp_info.palette[pind][0] = bmf->bmfi.bmiColors[pind].rgbRed;
+ bmp_info.palette[pind][1] = bmf->bmfi.bmiColors[pind].rgbGreen;
+ bmp_info.palette[pind][2] = bmf->bmfi.bmiColors[pind].rgbBlue;
+ }
+ return(0);
+}
+
+/*
+** bmp_Draw
+**
+** Render the image. Return nonzero if that's not possible.
+**
+*/
+static int
+bmp_Draw(video_adapter_t *adp)
+{
+ int line;
+
+ if (bmp_info.data == NULL) { /* init failed, do nothing */
+ return(1);
+ }
+
+ /* clear the screen */
+ bmp_info.vidmem = (u_char *)adp->va_window;
+ /* XXX; the following line is correct only for 8bpp modes */
+ bzero(bmp_info.vidmem, bmp_info.swidth * bmp_info.sheight);
+
+ /* initialise the info structure for drawing */
+ bmp_info.index = bmp_info.data;
+
+ /* set the palette for our image */
+ (*vidsw[adp->va_index]->load_palette)(adp, (u_char *)&bmp_info.palette);
+
+ for (line = 0; (line < bmp_info.height) && bmp_info.index; line++) {
+ bmp_DecodeLine(&bmp_info, line);
+ }
+ return(0);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-03-13 16:05:25 +0000