Add splash screen module. This version has rather limited

capabilities, but should be a good start... Well, sort of.

It can handle W*ndows 256 color BMP file.  (Other color depth probably
won't work.) The size of the image must be 320x200 or less.  *sigh*

4 files changed, 510 insertions, 0 deletions

diff --git a/sys/modules/splash/Makefile b/sys/modules/splash/Makefile
new file mode 100644
index 0000000..39a292e
--- /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 0000000..64212f6
--- /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 0000000..798e7e4
--- /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 0000000..ebf007a
--- /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);
+}