SOURCES: bootsplash-3.1.6-2.6.13.diff (NEW) - bootsplash for 2.6.1...

paszczus paszczus at pld-linux.org
Sun Sep 11 13:54:04 CEST 2005


Author: paszczus                     Date: Sun Sep 11 11:54:04 2005 GMT
Module: SOURCES                       Tag: HEAD
---- Log message:
- bootsplash for 2.6.13, www.bootsplash.de

---- Files affected:
SOURCES:
   bootsplash-3.1.6-2.6.13.diff (NONE -> 1.1)  (NEW)

---- Diffs:

================================================================
Index: SOURCES/bootsplash-3.1.6-2.6.13.diff
diff -u /dev/null SOURCES/bootsplash-3.1.6-2.6.13.diff:1.1
--- /dev/null	Sun Sep 11 13:54:04 2005
+++ SOURCES/bootsplash-3.1.6-2.6.13.diff	Sun Sep 11 13:53:59 2005
@@ -0,0 +1,2788 @@
+diff -urN linux-2.6.13/drivers/char/keyboard.c linux-2.6.13-bootsplash/drivers/char/keyboard.c
+--- linux-2.6.13/drivers/char/keyboard.c	2005-08-29 01:41:01.000000000 +0200
++++ linux-2.6.13-bootsplash/drivers/char/keyboard.c	2005-08-30 10:27:17.000000000 +0200
+@@ -1063,6 +1063,15 @@
+ 			if (keycode < BTN_MISC)
+ 				printk(KERN_WARNING "keyboard.c: can't emulate rawmode for keycode %d\n", keycode);
+ 
++#ifdef CONFIG_BOOTSPLASH
++	/* This code has to be redone for some non-x86 platforms */
++	if (down == 1 && (keycode == 0x3c || keycode == 0x01)) {        /* F2 and ESC on PC keyboard */
++		extern int splash_verbose(void);
++		if (splash_verbose())
++			return; 
++	}       
++#endif
++
+ #ifdef CONFIG_MAGIC_SYSRQ	       /* Handle the SysRq Hack */
+ 	if (keycode == KEY_SYSRQ && (sysrq_down || (down == 1 && sysrq_alt))) {
+ 		sysrq_down = down;
+diff -urN linux-2.6.13/drivers/char/n_tty.c linux-2.6.13-bootsplash/drivers/char/n_tty.c
+--- linux-2.6.13/drivers/char/n_tty.c	2005-08-29 01:41:01.000000000 +0200
++++ linux-2.6.13-bootsplash/drivers/char/n_tty.c	2005-08-30 10:27:17.000000000 +0200
+@@ -1292,6 +1292,15 @@
+ 			tty->minimum_to_wake = (minimum - (b - buf));
+ 		
+ 		if (!input_available_p(tty, 0)) {
++#ifdef CONFIG_BOOTSPLASH
++			if (file->f_dentry->d_inode->i_rdev == MKDEV(TTY_MAJOR,0) ||
++			    file->f_dentry->d_inode->i_rdev == MKDEV(TTY_MAJOR,1) ||
++			    file->f_dentry->d_inode->i_rdev == MKDEV(TTYAUX_MAJOR,0) ||
++			    file->f_dentry->d_inode->i_rdev == MKDEV(TTYAUX_MAJOR,1)) {
++				extern int splash_verbose(void);
++				(void)splash_verbose();
++			}
++#endif
+ 			if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
+ 				retval = -EIO;
+ 				break;
+diff -urN linux-2.6.13/drivers/char/vt.c linux-2.6.13-bootsplash/drivers/char/vt.c
+--- linux-2.6.13/drivers/char/vt.c	2005-08-29 01:41:01.000000000 +0200
++++ linux-2.6.13-bootsplash/drivers/char/vt.c	2005-08-30 10:27:17.000000000 +0200
+@@ -3225,6 +3225,31 @@
+ 	}
+ }
+ 
++#ifdef CONFIG_BOOTSPLASH
++void con_remap_def_color(struct vc_data *vc, int new_color)
++{
++       unsigned short *sbuf = vc->vc_screenbuf;
++       unsigned c, len = vc->vc_screenbuf_size >> 1;
++       int old_color;
++
++       if (sbuf) {
++	       old_color = vc->vc_def_color << 8;
++	       new_color <<= 8;
++	       while(len--) {
++		       c = *sbuf;
++		       if (((c ^ old_color) & 0xf000) == 0)
++			       *sbuf ^= (old_color ^ new_color) & 0xf000; 
++		       if (((c ^ old_color) & 0x0f00) == 0)
++			       *sbuf ^= (old_color ^ new_color) & 0x0f00;
++		       sbuf++;
++	       }
++	       new_color >>= 8;
++       }
++       vc->vc_def_color = vc->vc_color = new_color;
++       update_attr(vc);
++}
++#endif
++
+ /*
+  *	Visible symbols for modules
+  */
+diff -urN linux-2.6.13/drivers/video/bootsplash/bootsplash.c linux-2.6.13-bootsplash/drivers/video/bootsplash/bootsplash.c
+--- linux-2.6.13/drivers/video/bootsplash/bootsplash.c	1970-01-01 01:00:00.000000000 +0100
++++ linux-2.6.13-bootsplash/drivers/video/bootsplash/bootsplash.c	2005-08-30 10:27:17.000000000 +0200
+@@ -0,0 +1,984 @@
++/* 
++ *           linux/drivers/video/bootsplash/bootsplash.c - 
++ *                 splash screen handling functions.
++ *	
++ *	(w) 2001-2004 by Volker Poplawski, <volker at poplawski.de>,
++ * 		    Stefan Reinauer, <stepan at suse.de>,
++ * 		    Steffen Winterfeldt, <snwint at suse.de>,
++ *                  Michael Schroeder <mls at suse.de>
++ * 		    
++ *        Ideas & SuSE screen work by Ken Wimer, <wimer at suse.de>
++ *
++ *  For more information on this code check http://www.bootsplash.org/
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/types.h>
++#include <linux/fb.h>
++#include <linux/vt_kern.h>
++#include <linux/vmalloc.h>
++#include <linux/unistd.h>
++#include <linux/syscalls.h>
++
++#include <asm/irq.h>
++#include <asm/system.h>
++
++#include "../console/fbcon.h"
++#include "bootsplash.h"
++#include "decode-jpg.h"
++
++/* extern struct fb_ops vesafb_ops; */
++extern signed char con2fb_map[MAX_NR_CONSOLES];
++
++#define SPLASH_VERSION "3.1.6-2004/03/31"
++
++/* These errors have to match fbcon-jpegdec.h */
++static unsigned char *jpg_errors[] = {
++	"no SOI found", 
++	"not 8 bit", 
++	"height mismatch", 
++	"width mismatch",
++	"bad width or height", 
++	"too many COMPPs", 
++	"illegal HV", 
++	"quant table selector",
++	"picture is not YCBCR 221111",
++	"unknow CID in scan",
++	"dct not sequential",
++	"wrong marker",
++	"no EOI",
++	"bad tables",
++	"depth mismatch"
++};
++
++static struct jpeg_decdata *decdata = 0; /* private decoder data */
++
++static int splash_registered = 0;
++static int splash_usesilent = 0;	/* shall we display the silentjpeg? */
++int splash_default = 0xf01;
++
++static int splash_check_jpeg(unsigned char *jpeg, int width, int height, int depth);
++
++static int __init splash_setup(char *options)
++{
++	if(!strncmp("silent", options, 6)) {
++		printk(KERN_INFO "bootsplash: silent mode.\n");
++		splash_usesilent = 1;
++		/* skip "silent," */
++		if (strlen(options) == 6)
++			return 0;
++		options += 7;
++	}
++	if(!strncmp("verbose", options, 7)) {
++		printk(KERN_INFO "bootsplash: verbose mode.\n");
++		splash_usesilent = 0;
++		return 0;
++	}
++	splash_default = simple_strtoul(options, NULL, 0);
++	return 0;
++}
++
++__setup("splash=", splash_setup);
++
++
++static int splash_hasinter(unsigned char *buf, int num)
++{
++    unsigned char *bufend = buf + num * 12;
++    while(buf < bufend) {
++	if (buf[1] > 127)		/* inter? */
++	    return 1;
++	buf += buf[3] > 127 ? 24 : 12;	/* blend? */
++    }
++    return 0;
++}
++
++static int boxextract(unsigned char *buf, unsigned short *dp, unsigned char *cols, int *blendp)
++{
++    dp[0] = buf[0] | buf[1] << 8;
++    dp[1] = buf[2] | buf[3] << 8;
++    dp[2] = buf[4] | buf[5] << 8;
++    dp[3] = buf[6] | buf[7] << 8;
++    *(unsigned int *)(cols + 0) =
++	*(unsigned int *)(cols + 4) =
++	*(unsigned int *)(cols + 8) =
++	*(unsigned int *)(cols + 12) = *(unsigned int *)(buf + 8);
++    if (dp[1] > 32767) {
++	dp[1] = ~dp[1];
++	*(unsigned int *)(cols + 4) = *(unsigned int *)(buf + 12);
++	*(unsigned int *)(cols + 8) = *(unsigned int *)(buf + 16);
++	*(unsigned int *)(cols + 12) = *(unsigned int *)(buf + 20);
++	*blendp = 1;
++	return 24;
++    }
++    return 12;
++}
++
++static void boxit(unsigned char *pic, int bytes, unsigned char *buf, int num, int percent, int overpaint)
++{
++    int x, y, i, p, doblend, r, g, b, a, add;
++    unsigned short data1[4];
++    unsigned char cols1[16];
++    unsigned short data2[4];
++    unsigned char cols2[16];
++    unsigned char *bufend;
++    unsigned short *picp;
++    unsigned int stipple[32], sti, stin, stinn, stixs, stixe, stiys, stiye;
++    int xs, xe, ys, ye, xo, yo;
++
++    if (num == 0)
++	return;
++    bufend = buf + num * 12;
++    stipple[0] = 0xffffffff;
++    stin = 1;
++    stinn = 0;
++    stixs = stixe = 0;
++    stiys = stiye = 0;
++    while(buf < bufend) {
++	doblend = 0;
++	buf += boxextract(buf, data1, cols1, &doblend);
++	if (data1[0] == 32767 && data1[1] == 32767) {
++	    /* box stipple */
++	    if (stinn == 32)
++		continue;
++	    if (stinn == 0) {
++		stixs = data1[2];
++		stixe = data1[3];
++		stiys = stiye = 0;
++	    } else if (stinn == 4) {
++		stiys = data1[2];
++		stiye = data1[3];
++	    }
++	    stipple[stinn++] = (cols1[ 0] << 24) | (cols1[ 1] << 16) | (cols1[ 2] << 8) | cols1[ 3] ;
++	    stipple[stinn++] = (cols1[ 4] << 24) | (cols1[ 5] << 16) | (cols1[ 6] << 8) | cols1[ 7] ;
++	    stipple[stinn++] = (cols1[ 8] << 24) | (cols1[ 9] << 16) | (cols1[10] << 8) | cols1[11] ;
++	    stipple[stinn++] = (cols1[12] << 24) | (cols1[13] << 16) | (cols1[14] << 8) | cols1[15] ;
++	    stin = stinn;
++	    continue;
++	}
++	stinn = 0;
++	if (data1[0] > 32767)
++	    buf += boxextract(buf, data2, cols2, &doblend);
++	if (data1[0] == 32767 && data1[1] == 32766) {
++	    /* box copy */
++	    i = 12 * (short)data1[3];
++	    doblend = 0;
++	    i += boxextract(buf + i, data1, cols1, &doblend);
++	    if (data1[0] > 32767)
++		boxextract(buf + i, data2, cols2, &doblend);
++	}
++	if (data1[0] == 32767)
++	    continue;
++	if (data1[2] > 32767) {
++	    if (overpaint)
++		continue;
++	    data1[2] = ~data1[2];
++	}
++	if (data1[3] > 32767) {
++	    if (percent == 65536)
++		continue;
++	    data1[3] = ~data1[3];
++	}
++	if (data1[0] > 32767) {
++	    data1[0] = ~data1[0];
++	    for (i = 0; i < 4; i++)
++		data1[i] = (data1[i] * (65536 - percent) + data2[i] * percent) >> 16;
++	    for (i = 0; i < 16; i++)
++		cols1[i] = (cols1[i] * (65536 - percent) + cols2[i] * percent) >> 16;
++	}
++	*(unsigned int *)cols2 = *(unsigned int *)cols1;
++	a = cols2[3];
++	if (a == 0 && !doblend)
++	    continue;
++
++	if (stixs >= 32768) {
++	    xo = xs = (stixs ^ 65535) + data1[0];
++	    xe = stixe ? stixe + data1[0] : data1[2];
++	} else if (stixe >= 32768) {
++	    xs = stixs ? data1[2] - stixs : data1[0];
++	    xe = data1[2] - (stixe ^ 65535);
++	    xo = xe + 1;
++	} else {
++	    xo = xs = stixs;
++	    xe = stixe ? stixe : data1[2];
++	}
++	if (stiys >= 32768) {
++	    yo = ys = (stiys ^ 65535) + data1[1];
++	    ye = stiye ? stiye + data1[1] : data1[3];
++	} else if (stiye >= 32768) {
++	    ys = stiys ? data1[3] - stiys : data1[1];
++	    ye = data1[3] - (stiye ^ 65535);
++	    yo = ye + 1;
++	} else {
++	    yo = ys = stiys;
++	    ye = stiye ? stiye : data1[3];
++	}
++	xo = 32 - (xo & 31);
++	yo = stin - (yo % stin);
++	if (xs < data1[0])
++	    xs = data1[0];
++	if (xe > data1[2])
++	    xe = data1[2];
++	if (ys < data1[1])
++	    ys = data1[1];
++	if (ye > data1[3])
++	    ye = data1[3];
++
++	for (y = ys; y <= ye; y++) {
++	    sti = stipple[(y + yo) % stin];
++	    x = (xs + xo) & 31;
++	    if (x)
++		sti = (sti << x) | (sti >> (32 - x));
++	    if (doblend) {
++		if ((p = data1[3] - data1[1]) != 0)
++		    p = ((y - data1[1]) << 16) / p;
++		for (i = 0; i < 8; i++)
++		    cols2[i + 8] = (cols1[i] * (65536 - p) + cols1[i + 8] * p) >> 16;
++	    }
++	    add = (xs & 1);
++	    add ^= (add ^ y) & 1 ? 1 : 3;		/* 2x2 ordered dithering */
++	    picp = (unsigned short *)(pic + xs * 2 + y * bytes);
++	    for (x = xs; x <= xe; x++) {
++		if (!(sti & 0x80000000)) {
++		    sti <<= 1;
++		    picp++;
++		    add ^= 3;
++		    continue;
++		}
++		sti = (sti << 1) | 1;
++		if (doblend) {
++		    if ((p = data1[2] - data1[0]) != 0)
++			p = ((x - data1[0]) << 16) / p;
++		    for (i = 0; i < 4; i++)
++			cols2[i] = (cols2[i + 8] * (65536 - p) + cols2[i + 12] * p) >> 16;
++		    a = cols2[3];
++		}
++		r = cols2[0];
++		g = cols2[1];
++		b = cols2[2];
++		if (a != 255) {
++		    i = *picp;
++		    r = ((i >> 8 & 0xf8) * (255 - a) + r * a) / 255;
++		    g = ((i >> 3 & 0xfc) * (255 - a) + g * a) / 255;
++		    b = ((i << 3 & 0xf8) * (255 - a) + b * a) / 255;
++		}
++  #define CLAMP(x) ((x) >= 256 ? 255 : (x))
++		i = ((CLAMP(r + add*2+1) & 0xf8) <<  8) |
++		    ((CLAMP(g + add    ) & 0xfc) <<  3) |
++		    ((CLAMP(b + add*2+1)       ) >>  3);
++		*picp++ = i;
++		add ^= 3;
++	    }
++	}
++    }
++}
++
++static int splash_check_jpeg(unsigned char *jpeg, int width, int height, int depth)
++{
++    int size, err;
++    unsigned char *mem;
++
++    size = ((width + 15) & ~15) * ((height + 15) & ~15) * (depth >> 3);
++    mem = vmalloc(size);
++    if (!mem) {
++	printk(KERN_INFO "bootsplash: no memory for decoded picture.\n");
++	return -1;
++    }
++    if (!decdata)
++	decdata = vmalloc(sizeof(*decdata));
++    if ((err = jpeg_decode(jpeg, mem, ((width + 15) & ~15), ((height + 15) & ~15), depth, decdata)))
++	  printk(KERN_INFO "bootsplash: error while decompressing picture: %s (%d)\n",jpg_errors[err - 1], err);
++    vfree(mem);
++    return err ? -1 : 0;
++}
++
++static void splash_free(struct vc_data *vc, struct fb_info *info)
++{
++    if (!vc->vc_splash_data)
++	return;
++    if (info->silent_screen_base)
++	    info->screen_base = info->silent_screen_base;
++    info->silent_screen_base = 0;
++    if (vc->vc_splash_data->splash_silentjpeg)
++	    vfree(vc->vc_splash_data->splash_sboxes);
++    vfree(vc->vc_splash_data);
++    vc->vc_splash_data = 0;
++    info->splash_data = 0;
++}
++
++static int splash_mkpenguin(struct splash_data *data, int pxo, int pyo, int pwi, int phe, int pr, int pg, int pb)
++{
++    unsigned char *buf;
++    int i;
++
++    if (pwi ==0 || phe == 0)
++	return 0;
++    buf = (unsigned char *)data + sizeof(*data);
++    pwi += pxo - 1;
++    phe += pyo - 1;
++    *buf++ = pxo;
++    *buf++ = pxo >> 8;
++    *buf++ = pyo;
++    *buf++ = pyo >> 8;
++    *buf++ = pwi;
++    *buf++ = pwi >> 8;
++    *buf++ = phe;
++    *buf++ = phe >> 8;
++    *buf++ = pr;
++    *buf++ = pg;
++    *buf++ = pb;
++    *buf++ = 0;
++    for (i = 0; i < 12; i++, buf++)
++	*buf = buf[-12];
++    buf[-24] ^= 0xff;
++    buf[-23] ^= 0xff;
++    buf[-1] = 0xff;
++    return 2;
++}
++
++static const int splash_offsets[3][16] = {
++    /* len, unit, size, state, fgcol, col, xo, yo, wi, he
++       boxcnt, ssize, sboxcnt, percent, overok, palcnt */
++    /* V1 */
++    {   20,   -1,   16,    -1,    -1,  -1,  8, 10, 12, 14,
++           -1,    -1,      -1,      -1,     -1,     -1 },
++    /* V2 */
++    {   35,    8,   12,     9,    10,  11, 16, 18, 20, 22,
++           -1,    -1,      -1,      -1,     -1,     -1 },
++    /* V3 */
++    {   38,    8,   12,     9,    10,  11, 16, 18, 20, 22,
++           24,    28,      32,      34,     36,     37 },
++};
++
++#define SPLASH_OFF_LEN     offsets[0]
++#define SPLASH_OFF_UNIT    offsets[1]
++#define SPLASH_OFF_SIZE    offsets[2]
++#define SPLASH_OFF_STATE   offsets[3]
++#define SPLASH_OFF_FGCOL   offsets[4]
++#define SPLASH_OFF_COL     offsets[5]
++#define SPLASH_OFF_XO      offsets[6]
++#define SPLASH_OFF_YO      offsets[7]
++#define SPLASH_OFF_WI      offsets[8]
++#define SPLASH_OFF_HE      offsets[9]
++#define SPLASH_OFF_BOXCNT  offsets[10]
++#define SPLASH_OFF_SSIZE   offsets[11]
++#define SPLASH_OFF_SBOXCNT offsets[12]
++#define SPLASH_OFF_PERCENT offsets[13]
++#define SPLASH_OFF_OVEROK  offsets[14]
++#define SPLASH_OFF_PALCNT  offsets[15]
++
++static inline int splash_getb(unsigned char *pos, int off)
++{
++    return off == -1 ? 0 : pos[off];
++}
++
++static inline int splash_gets(unsigned char *pos, int off)
++{
++    return off == -1 ? 0 : pos[off] | pos[off + 1] << 8;
++}
++
++static inline int splash_geti(unsigned char *pos, int off)
++{
++    return off == -1 ? 0 :
++           pos[off] | pos[off + 1] << 8 | pos[off + 2] << 16 | pos[off + 3] << 24;
++}
++
++static int splash_getraw(unsigned char *start, unsigned char *end, int *update)
++{
++    unsigned char *ndata;
++    int version;
++    int splash_size;
++    int unit;
++    int width, height;
++    int silentsize;
++    int boxcnt;
++    int sboxcnt;
++    int palcnt;
++    int i, len;
++    const int *offsets;
++    struct vc_data *vc;
++    struct fb_info *info;
++    struct splash_data *sd;
++
++    if (update)
++	*update = -1;
++
++    if (!update || start[7] < '2' || start[7] > '3' || splash_geti(start, 12) != (int)0xffffffff)
++	printk(KERN_INFO "bootsplash %s: looking for picture...", SPLASH_VERSION);
++
++    for (ndata = start; ndata < end; ndata++) {
++	if (ndata[0] != 'B' || ndata[1] != 'O' || ndata[2] != 'O' || ndata[3] != 'T')
++	    continue;
++	if (ndata[4] != 'S' || ndata[5] != 'P' || ndata[6] != 'L' || ndata[7] < '1' || ndata[7] > '3')
++	    continue;
++	version = ndata[7] - '0';
++	offsets = splash_offsets[version - 1];
++	len = SPLASH_OFF_LEN;
++	unit = splash_getb(ndata, SPLASH_OFF_UNIT);
++	if (unit >= MAX_NR_CONSOLES)
++	    continue;
++	if (unit) {
++		vc_allocate(unit);
++	}
++	vc = vc_cons[unit].d;
++	info = registered_fb[(int)con2fb_map[unit]];
++	width = info->var.xres;
++	height = info->var.yres;
++	splash_size = splash_geti(ndata, SPLASH_OFF_SIZE);
++	if (splash_size == (int)0xffffffff && version > 1) {
++	    if ((sd = vc->vc_splash_data) != 0) {
++		int up = 0;
++		i = splash_getb(ndata, SPLASH_OFF_STATE);
++		if (i != 255) {
++		    sd->splash_state = i;
++		    up = -1;
++		}
++		i = splash_getb(ndata, SPLASH_OFF_FGCOL);
++		if (i != 255) {
++		    sd->splash_fg_color = i;
++		    up = -1;
++		}
++		i = splash_getb(ndata, SPLASH_OFF_COL);
++		if (i != 255) {
++		    sd->splash_color = i;
++		    up = -1;
++		}
++		boxcnt = sboxcnt = 0;
++		if (ndata + len <= end) {
++		    boxcnt = splash_gets(ndata, SPLASH_OFF_BOXCNT);
++		    sboxcnt = splash_gets(ndata, SPLASH_OFF_SBOXCNT);
++		}
++		if (boxcnt) {
++		    i = splash_gets(ndata, len);
++		    if (boxcnt + i <= sd->splash_boxcount && ndata + len + 2 + boxcnt * 12 <= end) {
++
++			if (splash_geti(ndata, len + 2) != 0x7ffd7fff || !memcmp(ndata + len + 2, sd->splash_boxes + i * 12, 8)) {
++
++			    memcpy(sd->splash_boxes + i * 12, ndata + len + 2, boxcnt * 12);
++			    up |= 1;
++			}
++		    }
++		    len += boxcnt * 12 + 2;
++		}
++		if (sboxcnt) {
++		    i = splash_gets(ndata, len);
++		    if (sboxcnt + i <= sd->splash_sboxcount && ndata + len + 2 + sboxcnt * 12 <= end) {
++			if (splash_geti(ndata, len + 2) != 0x7ffd7fff || !memcmp(ndata + len + 2, sd->splash_sboxes + i * 12, 8)) {
++			    memcpy(sd->splash_sboxes + i * 12, ndata + len + 2, sboxcnt * 12);
++			    up |= 2;
++			}
++		    }
++		}
++		if (update)
++		    *update = up;
++	    }
++	    return unit;
++	}
++	if (splash_size == 0) {
++	    printk(KERN_INFO"...found, freeing memory.\n");
++	    if (vc->vc_splash_data)
++		splash_free(vc, info);
++	    return unit;
++	}
++	boxcnt = splash_gets(ndata, SPLASH_OFF_BOXCNT);
++	palcnt = 3 * splash_getb(ndata, SPLASH_OFF_PALCNT);
++	if (ndata + len + splash_size > end) {
++	    printk(KERN_INFO "...found, but truncated!\n");
++	    return -1;
++	}
++	if (!jpeg_check_size(ndata + len + boxcnt * 12 + palcnt, width, height)) {
++	    ndata += len + splash_size - 1;
++	    continue;
++	}
++	if (splash_check_jpeg(ndata + len + boxcnt * 12 + palcnt, width, height, info->var.bits_per_pixel))
++	    return -1;
++	silentsize = splash_geti(ndata, SPLASH_OFF_SSIZE);
++	if (silentsize)
++	    printk(KERN_INFO" silentjpeg size %d bytes,", silentsize);
++	if (silentsize >= splash_size) {
++	    printk(KERN_INFO " bigger than splashsize!\n");
++	    return -1;
++	}
++	splash_size -= silentsize;
++	if (!splash_usesilent)
++	    silentsize = 0;
++	else if (height * 2 * info->fix.line_length > info->fix.smem_len) {
++	    printk(KERN_INFO " does not fit into framebuffer.\n");
++	    silentsize = 0;
++	}
++	sboxcnt = splash_gets(ndata, SPLASH_OFF_SBOXCNT);
++	if (silentsize) {
++	    unsigned char *simage = ndata + len + splash_size + 12 * sboxcnt;
++	    if (!jpeg_check_size(simage, width, height) ||
++		splash_check_jpeg(simage, width, height, info->var.bits_per_pixel)) {
++		    printk(KERN_INFO " error in silent jpeg.\n");
<<Diff was trimmed, longer than 597 lines>>



More information about the pld-cvs-commit mailing list