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