Remove PC98 support.
[dragonfly.git] / sys / dev / video / fb / bmp / splash_bmp.c
CommitLineData
984263bc
MD
1/*-
2 * Copyright (c) 1999 Michael Smith <msmith@freebsd.org>
3 * Copyright (c) 1999 Kazutaka YOKOTA <yokota@freebsd.org>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 * $FreeBSD: src/sys/modules/splash/bmp/splash_bmp.c,v 1.10.2.3 2000/10/31 08:00:06 nyan Exp $
92e585b8 28 * $DragonFly: src/sys/dev/video/fb/bmp/splash_bmp.c,v 1.7 2005/03/13 01:53:56 swildner Exp $
984263bc
MD
29 */
30
31#include <sys/param.h>
32#include <sys/systm.h>
33#include <sys/kernel.h>
34#include <sys/linker.h>
35#include <sys/fbio.h>
36
ac2e3f5e
MD
37#include <dev/video/fb/fbreg.h>
38#include <dev/video/fb/splashreg.h>
ac2e3f5e 39#include <dev/video/fb/vgareg.h>
984263bc 40
1f2de5d4 41#include <bus/isa/isareg.h>
984263bc
MD
42
43#define FADE_TIMEOUT 15 /* sec */
44#define FADE_LEVELS 10
45
46static int splash_mode = -1;
47static int splash_on = FALSE;
48
49static int bmp_start(video_adapter_t *adp);
50static int bmp_end(video_adapter_t *adp);
51static int bmp_splash(video_adapter_t *adp, int on);
52static int bmp_Init(const char *data, int swidth, int sheight, int sdepth);
53static int bmp_Draw(video_adapter_t *adp);
54
55static splash_decoder_t bmp_decoder = {
56 "splash_bmp", bmp_start, bmp_end, bmp_splash, SPLASH_IMAGE,
57};
58
59SPLASH_DECODER(splash_bmp, bmp_decoder);
60
61static int
62bmp_start(video_adapter_t *adp)
63{
64 /* currently only 256-color modes are supported XXX */
65 static int modes[] = {
984263bc
MD
66 M_VESA_CG640x480,
67 M_VESA_CG800x600,
68 M_VESA_CG1024x768,
69 M_CG640x480,
70 /*
71 * As 320x200 doesn't generally look great,
72 * it's least preferred here.
73 */
74 M_VGA_CG320,
984263bc
MD
75 -1,
76 };
77 video_info_t info;
78 int i;
79
80 if ((bmp_decoder.data == NULL) || (bmp_decoder.data_size <= 0)) {
81 printf("splash_bmp: No bitmap file found\n");
82 return ENODEV;
83 }
84 for (i = 0; modes[i] >= 0; ++i) {
85 if (((*vidsw[adp->va_index]->get_info)(adp, modes[i], &info) == 0)
86 && (bmp_Init((u_char *)bmp_decoder.data,
87 info.vi_width, info.vi_height, info.vi_depth) == 0))
88 break;
89 }
90 splash_mode = modes[i];
91 if (splash_mode < 0)
92 printf("splash_bmp: No appropriate video mode found\n");
93 if (bootverbose)
94 printf("bmp_start(): splash_mode:%d\n", splash_mode);
95 return ((splash_mode < 0) ? ENODEV : 0);
96}
97
98static int
99bmp_end(video_adapter_t *adp)
100{
101 /* nothing to do */
102 return 0;
103}
104
105static int
106bmp_splash(video_adapter_t *adp, int on)
107{
108 static u_char pal[256*3];
109 static long time_stamp;
110 u_char tpal[256*3];
111 static int fading = TRUE, brightness = FADE_LEVELS;
112 struct timeval tv;
113 int i;
114
115 if (on) {
116 if (!splash_on) {
117 /* set up the video mode and draw something */
118 if ((*vidsw[adp->va_index]->set_mode)(adp, splash_mode))
119 return 1;
120 if (bmp_Draw(adp))
121 return 1;
122 (*vidsw[adp->va_index]->save_palette)(adp, pal);
123 time_stamp = 0;
124 splash_on = TRUE;
125 }
126 /*
127 * This is a kludge to fade the image away. This section of the
128 * code takes effect only after the system is completely up.
129 * FADE_TIMEOUT should be configurable.
130 */
131 if (!cold) {
132 getmicrotime(&tv);
133 if (time_stamp == 0)
134 time_stamp = tv.tv_sec;
135 if (tv.tv_sec > time_stamp + FADE_TIMEOUT) {
136 if (fading)
137 if (brightness == 0) {
138 fading = FALSE;
139 brightness++;
140 }
141 else brightness--;
142 else
143 if (brightness == FADE_LEVELS) {
144 fading = TRUE;
145 brightness--;
146 }
147 else brightness++;
148 for (i = 0; i < sizeof(pal); ++i) {
149 tpal[i] = pal[i] * brightness / FADE_LEVELS;
150 }
151 (*vidsw[adp->va_index]->load_palette)(adp, tpal);
152 time_stamp = tv.tv_sec;
153 }
154 }
155 return 0;
156 } else {
157 /* the video mode will be restored by the caller */
158 splash_on = FALSE;
159 return 0;
160 }
161}
162
163/*
164** Code to handle Microsoft DIB (".BMP") format images.
165**
166** Blame me (msmith@freebsd.org) if this is broken, not Soren.
167*/
168
169typedef struct tagBITMAPFILEHEADER { /* bmfh */
170 u_short bfType __attribute__ ((packed));
171 int bfSize __attribute__ ((packed));
172 u_short bfReserved1 __attribute__ ((packed));
173 u_short bfReserved2 __attribute__ ((packed));
174 int bfOffBits __attribute__ ((packed));
175} BITMAPFILEHEADER;
176
177typedef struct tagBITMAPINFOHEADER { /* bmih */
178 int biSize __attribute__ ((packed));
179 int biWidth __attribute__ ((packed));
180 int biHeight __attribute__ ((packed));
181 short biPlanes __attribute__ ((packed));
182 short biBitCount __attribute__ ((packed));
183 int biCompression __attribute__ ((packed));
184 int biSizeImage __attribute__ ((packed));
185 int biXPelsPerMeter __attribute__ ((packed));
186 int biYPelsPerMeter __attribute__ ((packed));
187 int biClrUsed __attribute__ ((packed));
188 int biClrImportant __attribute__ ((packed));
189} BITMAPINFOHEADER;
190
191typedef struct tagRGBQUAD { /* rgbq */
192 u_char rgbBlue __attribute__ ((packed));
193 u_char rgbGreen __attribute__ ((packed));
194 u_char rgbRed __attribute__ ((packed));
195 u_char rgbReserved __attribute__ ((packed));
196} RGBQUAD;
197
198typedef struct tagBITMAPINFO { /* bmi */
199 BITMAPINFOHEADER bmiHeader __attribute__ ((packed));
200 RGBQUAD bmiColors[256] __attribute__ ((packed));
201} BITMAPINFO;
202
203typedef struct tagBITMAPF
204{
205 BITMAPFILEHEADER bmfh __attribute__ ((packed));
206 BITMAPINFO bmfi __attribute__ ((packed));
207} BITMAPF;
208
209#define BI_RGB 0
210#define BI_RLE8 1
211#define BI_RLE4 2
212
213/*
214** all we actually care about the image
215*/
216typedef struct
217{
218 int width,height; /* image dimensions */
219 int swidth,sheight; /* screen dimensions for the current mode */
220 u_char depth; /* image depth (1, 4, 8, 24 bits) */
221 u_char sdepth; /* screen depth (1, 4, 8 bpp) */
222 int ncols; /* number of colours */
223 u_char palette[256][3]; /* raw palette data */
224 u_char format; /* one of the BI_* constants above */
e7cb9e6a
JS
225 const u_char *data; /* pointer to the raw data */
226 const u_char *index; /* running pointer to the data while drawing */
984263bc
MD
227 u_char *vidmem; /* video memory allocated for drawing */
228 video_adapter_t *adp;
229 int bank;
984263bc
MD
230} BMP_INFO;
231
232static BMP_INFO bmp_info;
233
234/*
235** bmp_SetPix
236**
237** Given (info), set the pixel at (x),(y) to (val)
238**
239*/
240static void
241bmp_SetPix(BMP_INFO *info, int x, int y, u_char val)
242{
243 int sofs, bofs;
244 int newbank;
245
246 /*
247 * range check to avoid explosions
248 */
249 if ((x < 0) || (x >= info->swidth) || (y < 0) || (y >= info->sheight))
250 return;
251
252 /*
253 * calculate offset into video memory;
254 * because 0,0 is bottom-left for DIB, we have to convert.
255 */
256 sofs = ((info->height - (y+1) + (info->sheight - info->height) / 2)
257 * info->adp->va_line_width);
258 x += (info->swidth - info->width) / 2;
259
260 switch(info->sdepth) {
984263bc
MD
261 case 4:
262 case 1:
263 /* EGA/VGA planar modes */
264 sofs += (x >> 3);
265 newbank = sofs/info->adp->va_window_size;
266 if (info->bank != newbank) {
267 (*vidsw[info->adp->va_index]->set_win_org)(info->adp, newbank*info->adp->va_window_size);
268 info->bank = newbank;
269 }
270 sofs %= info->adp->va_window_size;
271 bofs = x & 0x7; /* offset within byte */
272 outw(GDCIDX, (0x8000 >> bofs) | 0x08); /* bit mask */
273 outw(GDCIDX, (val << 8) | 0x00); /* set/reset */
274 *(info->vidmem + sofs) ^= 0xff; /* read-modify-write */
275 break;
984263bc
MD
276
277 case 8:
278 sofs += x;
279 newbank = sofs/info->adp->va_window_size;
280 if (info->bank != newbank) {
281 (*vidsw[info->adp->va_index]->set_win_org)(info->adp, newbank*info->adp->va_window_size);
282 info->bank = newbank;
283 }
284 sofs %= info->adp->va_window_size;
285 *(info->vidmem+sofs) = val;
286 break;
287 }
288}
289
290/*
291** bmp_DecodeRLE4
292**
293** Given (data) pointing to a line of RLE4-format data and (line) being the starting
294** line onscreen, decode the line.
295*/
296static void
297bmp_DecodeRLE4(BMP_INFO *info, int line)
298{
299 int count; /* run count */
300 u_char val;
301 int x,y; /* screen position */
302
303 x = 0; /* starting position */
304 y = line;
305
306 /* loop reading data */
307 for (;;) {
308 /*
309 * encoded mode starts with a run length, and then a byte with
310 * two colour indexes to alternate between for the run
311 */
312 if (*info->index) {
313 for (count = 0; count < *info->index; count++, x++) {
314 if (count & 1) { /* odd count, low nybble */
315 bmp_SetPix(info, x, y, *(info->index+1) & 0x0f);
316 } else { /* even count, high nybble */
317 bmp_SetPix(info, x, y, (*(info->index+1) >>4) & 0x0f);
318 }
319 }
320 info->index += 2;
321 /*
322 * A leading zero is an escape; it may signal the end of the
323 * bitmap, a cursor move, or some absolute data.
324 */
325 } else { /* zero tag may be absolute mode or an escape */
326 switch (*(info->index+1)) {
327 case 0: /* end of line */
328 info->index += 2;
329 return;
330 case 1: /* end of bitmap */
331 info->index = NULL;
332 return;
333 case 2: /* move */
334 x += *(info->index + 2); /* new coords */
335 y += *(info->index + 3);
336 info->index += 4;
337 break;
338 default: /* literal bitmap data */
339 for (count = 0; count < *(info->index + 1); count++, x++) {
340 val = *(info->index + 2 + (count / 2)); /* byte with nybbles */
341 if (count & 1) {
342 val &= 0xf; /* get low nybble */
343 } else {
344 val = (val >> 4); /* get high nybble */
345 }
346 bmp_SetPix(info, x, y, val);
347 }
348 /* warning, this depends on integer truncation, do not hand-optimise! */
349 info->index += 2 + ((count + 3) / 4) * 2;
350 break;
351 }
352 }
353 }
354}
355
356/*
357** bmp_DecodeRLE8
358** Given (data) pointing to a line of RLE8-format data and (line) being the starting
359** line onscreen, decode the line.
360*/
361static void
362bmp_DecodeRLE8(BMP_INFO *info, int line)
363{
364 int count; /* run count */
365 int x,y; /* screen position */
366
367 x = 0; /* starting position */
368 y = line;
369
370 /* loop reading data */
371 for(;;) {
372 /*
373 * encoded mode starts with a run length, and then a byte with
374 * two colour indexes to alternate between for the run
375 */
376 if (*info->index) {
377 for (count = 0; count < *info->index; count++, x++)
378 bmp_SetPix(info, x, y, *(info->index+1));
379 info->index += 2;
380 /*
381 * A leading zero is an escape; it may signal the end of the
382 * bitmap, a cursor move, or some absolute data.
383 */
384 } else { /* zero tag may be absolute mode or an escape */
385 switch(*(info->index+1)) {
386 case 0: /* end of line */
387 info->index += 2;
388 return;
389 case 1: /* end of bitmap */
390 info->index = NULL;
391 return;
392 case 2: /* move */
393 x += *(info->index + 2); /* new coords */
394 y += *(info->index + 3);
395 info->index += 4;
396 break;
397 default: /* literal bitmap data */
398 for (count = 0; count < *(info->index + 1); count++, x++)
399 bmp_SetPix(info, x, y, *(info->index + 2 + count));
400 /* must be an even count */
401 info->index += 2 + count + (count & 1);
402 break;
403 }
404 }
405 }
406}
407
408/*
409** bmp_DecodeLine
410**
411** Given (info) pointing to an image being decoded, (line) being the line currently
412** being displayed, decode a line of data.
413*/
414static void
415bmp_DecodeLine(BMP_INFO *info, int line)
416{
417 int x;
e7cb9e6a
JS
418 u_char val, mask;
419 const u_char *p;
984263bc
MD
420
421 switch(info->format) {
422 case BI_RGB:
423 switch(info->depth) {
424 case 8:
425 for (x = 0; x < info->width; x++, info->index++)
426 bmp_SetPix(info, x, line, *info->index);
427 info->index += 3 - (--x % 4);
428 break;
429 case 4:
430 p = info->index;
431 for (x = 0; x < info->width; x++) {
432 if (x & 1) {
433 val = *p & 0xf; /* get low nybble */
434 p++;
435 } else {
436 val = *p >> 4; /* get high nybble */
437 }
438 bmp_SetPix(info, x, line, val);
439 }
440 /* warning, this depends on integer truncation, do not hand-optimise! */
441 info->index += ((x + 7) / 8) * 4;
442 break;
443 case 1:
444 p = info->index;
445 mask = 0x80;
446 for (x = 0; x < info->width; x++) {
447 val = (*p & mask) ? 1 : 0;
448 mask >>= 1;
449 if (mask == 0) {
450 mask = 0x80;
451 p++;
452 }
453 bmp_SetPix(info, x, line, val);
454 }
455 /* warning, this depends on integer truncation, do not hand-optimise! */
456 info->index += ((x + 31) / 32) * 4;
457 break;
458 }
459 break;
460 case BI_RLE4:
461 bmp_DecodeRLE4(info, line);
462 break;
463 case BI_RLE8:
464 bmp_DecodeRLE8(info, line);
465 break;
466 }
467}
468
469/*
470** bmp_Init
471**
472** Given a pointer (data) to the image of a BMP file, fill in bmp_info with what
473** can be learnt from it. Return nonzero if the file isn't usable.
474**
475** Take screen dimensions (swidth), (sheight) and (sdepth) and make sure we
476** can work with these.
477*/
478static int
479bmp_Init(const char *data, int swidth, int sheight, int sdepth)
480{
e7cb9e6a 481 const BITMAPF *bmf = (const BITMAPF *)data;
984263bc
MD
482 int pind;
483
484 bmp_info.data = NULL; /* assume setup failed */
485
486 /* check file ID */
487 if (bmf->bmfh.bfType != 0x4d42) {
488 printf("splash_bmp: not a BMP file\n");
489 return(1); /* XXX check word ordering for big-endian ports? */
490 }
491
492 /* do we understand this bitmap format? */
493 if (bmf->bmfi.bmiHeader.biSize > sizeof(bmf->bmfi.bmiHeader)) {
494 printf("splash_bmp: unsupported BMP format (size=%d)\n",
495 bmf->bmfi.bmiHeader.biSize);
496 return(1);
497 }
498
499 /* save what we know about the screen */
500 bmp_info.swidth = swidth;
501 bmp_info.sheight = sheight;
502 bmp_info.sdepth = sdepth;
503
504 /* where's the data? */
e7cb9e6a 505 bmp_info.data = (const u_char *)data + bmf->bmfh.bfOffBits;
984263bc
MD
506
507 /* image parameters */
508 bmp_info.width = bmf->bmfi.bmiHeader.biWidth;
509 bmp_info.height = bmf->bmfi.bmiHeader.biHeight;
510 bmp_info.depth = bmf->bmfi.bmiHeader.biBitCount;
511 bmp_info.format = bmf->bmfi.bmiHeader.biCompression;
512
513 switch(bmp_info.format) { /* check compression format */
514 case BI_RGB:
515 case BI_RLE4:
516 case BI_RLE8:
517 break;
518 default:
519 printf("splash_bmp: unsupported compression format\n");
520 return(1); /* unsupported compression format */
521 }
522
523 /* palette details */
524 bmp_info.ncols = (bmf->bmfi.bmiHeader.biClrUsed);
525 bzero(bmp_info.palette,sizeof(bmp_info.palette));
526 if (bmp_info.ncols == 0) { /* uses all of them */
527 bmp_info.ncols = 1 << bmf->bmfi.bmiHeader.biBitCount;
528 }
529 if ((bmp_info.height > bmp_info.sheight) ||
530 (bmp_info.width > bmp_info.swidth) ||
531 (bmp_info.ncols > (1 << sdepth))) {
532 if (bootverbose)
533 printf("splash_bmp: beyond screen capacity (%dx%d, %d colors)\n",
534 bmp_info.width, bmp_info.height, bmp_info.ncols);
535 return(1);
536 }
537
538 /* read palette */
539 for (pind = 0; pind < bmp_info.ncols; pind++) {
540 bmp_info.palette[pind][0] = bmf->bmfi.bmiColors[pind].rgbRed;
541 bmp_info.palette[pind][1] = bmf->bmfi.bmiColors[pind].rgbGreen;
542 bmp_info.palette[pind][2] = bmf->bmfi.bmiColors[pind].rgbBlue;
543 }
544 return(0);
545}
546
547/*
548** bmp_Draw
549**
550** Render the image. Return nonzero if that's not possible.
551**
552*/
553static int
554bmp_Draw(video_adapter_t *adp)
555{
556 int line;
6b08710e 557#if 0
984263bc 558 int i;
6b08710e 559#endif
984263bc
MD
560
561 if (bmp_info.data == NULL) { /* init failed, do nothing */
562 return(1);
563 }
564
565 /* clear the screen */
566 bmp_info.vidmem = (u_char *)adp->va_window;
567 bmp_info.adp = adp;
568 (*vidsw[adp->va_index]->clear)(adp);
569 (*vidsw[adp->va_index]->set_win_org)(adp, 0);
570 bmp_info.bank = 0;
571
572 /* initialise the info structure for drawing */
573 bmp_info.index = bmp_info.data;
984263bc
MD
574
575 /* set the palette for our image */
576 (*vidsw[adp->va_index]->load_palette)(adp, (u_char *)&bmp_info.palette);
577
578#if 0
984263bc
MD
579 /* XXX: this is ugly, but necessary for EGA/VGA 1bpp/4bpp modes */
580 if ((adp->va_type == KD_EGA) || (adp->va_type == KD_VGA)) {
581 inb(adp->va_crtc_addr + 6); /* reset flip-flop */
582 outb(ATC, 0x14);
583 outb(ATC, 0);
584 for (i = 0; i < 16; ++i) {
585 outb(ATC, i);
586 outb(ATC, i);
587 }
588 inb(adp->va_crtc_addr + 6); /* reset flip-flop */
589 outb(ATC, 0x20); /* enable palette */
590
591 outw(GDCIDX, 0x0f01); /* set/reset enable */
592
593 if (bmp_info.sdepth == 1)
594 outw(TSIDX, 0x0102); /* unmask plane #0 */
595 }
984263bc
MD
596#endif
597
598 for (line = 0; (line < bmp_info.height) && bmp_info.index; line++) {
599 bmp_DecodeLine(&bmp_info, line);
600 }
601 return(0);
602}