Remove PC98 support.
[dragonfly.git] / sys / dev / video / fb / bmp / splash_bmp.c
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 $
28  * $DragonFly: src/sys/dev/video/fb/bmp/splash_bmp.c,v 1.7 2005/03/13 01:53:56 swildner Exp $
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
37 #include <dev/video/fb/fbreg.h>
38 #include <dev/video/fb/splashreg.h>
39 #include <dev/video/fb/vgareg.h>
40
41 #include <bus/isa/isareg.h>
42
43 #define FADE_TIMEOUT    15      /* sec */
44 #define FADE_LEVELS     10
45
46 static int splash_mode = -1;
47 static int splash_on = FALSE;
48
49 static int bmp_start(video_adapter_t *adp);
50 static int bmp_end(video_adapter_t *adp);
51 static int bmp_splash(video_adapter_t *adp, int on);
52 static int bmp_Init(const char *data, int swidth, int sheight, int sdepth);
53 static int bmp_Draw(video_adapter_t *adp);
54
55 static splash_decoder_t bmp_decoder = {
56     "splash_bmp", bmp_start, bmp_end, bmp_splash, SPLASH_IMAGE,
57 };
58
59 SPLASH_DECODER(splash_bmp, bmp_decoder);
60
61 static int 
62 bmp_start(video_adapter_t *adp)
63 {
64     /* currently only 256-color modes are supported XXX */
65     static int          modes[] = {
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,
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
98 static int
99 bmp_end(video_adapter_t *adp)
100 {
101     /* nothing to do */
102     return 0;
103 }
104
105 static int
106 bmp_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
169 typedef 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
177 typedef 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
191 typedef 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
198 typedef struct tagBITMAPINFO {  /* bmi */
199     BITMAPINFOHEADER    bmiHeader       __attribute__ ((packed));
200     RGBQUAD             bmiColors[256]  __attribute__ ((packed));
201 } BITMAPINFO;
202
203 typedef 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 */
216 typedef 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 */
225     const u_char *data;                 /* pointer to the raw data */
226     const u_char *index;                        /* running pointer to the data while drawing */
227     u_char      *vidmem;                /* video memory allocated for drawing */
228     video_adapter_t *adp;
229     int         bank;
230 } BMP_INFO;
231
232 static BMP_INFO bmp_info;
233
234 /*
235 ** bmp_SetPix
236 **
237 ** Given (info), set the pixel at (x),(y) to (val) 
238 **
239 */
240 static void
241 bmp_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) {
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;
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 */
296 static void
297 bmp_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 */
361 static void
362 bmp_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 */
414 static void
415 bmp_DecodeLine(BMP_INFO *info, int line)
416 {
417     int         x;
418     u_char      val, mask;
419     const u_char *p;
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 */
478 static int
479 bmp_Init(const char *data, int swidth, int sheight, int sdepth)
480 {
481     const BITMAPF *bmf = (const BITMAPF *)data;
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? */
505     bmp_info.data = (const u_char *)data + bmf->bmfh.bfOffBits;
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 */
553 static int
554 bmp_Draw(video_adapter_t *adp)
555 {
556     int         line;
557 #if 0
558     int         i;
559 #endif
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;
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
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     }
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 }