[linux.git] / scripts / pnmtologo.c


/*
 *  Convert a logo in ASCII PNM format to C source suitable for inclusion in
 *  the Linux kernel
 *
 *  (C) Copyright 2001-2003 by Geert Uytterhoeven <[email protected]>
 *
 *  --------------------------------------------------------------------------
 *
 *  This file is subject to the terms and conditions of the GNU General Public
 *  License. See the file COPYING in the main directory of the Linux
 *  distribution for more details.
 */

#include <ctype.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>


static const char *programname;
static const char *filename;
static const char *logoname = "linux_logo";
static const char *outputname;
static FILE *out;


#define LINUX_LOGO_MONO		1	/* monochrome black/white */
#define LINUX_LOGO_VGA16	2	/* 16 colors VGA text palette */
#define LINUX_LOGO_CLUT224	3	/* 224 colors */
#define LINUX_LOGO_GRAY256	4	/* 256 levels grayscale */

static const char *logo_types[LINUX_LOGO_GRAY256+1] = {
    [LINUX_LOGO_MONO] = "LINUX_LOGO_MONO",
    [LINUX_LOGO_VGA16] = "LINUX_LOGO_VGA16",
    [LINUX_LOGO_CLUT224] = "LINUX_LOGO_CLUT224",
    [LINUX_LOGO_GRAY256] = "LINUX_LOGO_GRAY256"
};

#define MAX_LINUX_LOGO_COLORS	224

struct color {
    unsigned char red;
    unsigned char green;
    unsigned char blue;
};

static const struct color clut_vga16[16] = {
    { 0x00, 0x00, 0x00 },
    { 0x00, 0x00, 0xaa },
    { 0x00, 0xaa, 0x00 },
    { 0x00, 0xaa, 0xaa },
    { 0xaa, 0x00, 0x00 },
    { 0xaa, 0x00, 0xaa },
    { 0xaa, 0x55, 0x00 },
    { 0xaa, 0xaa, 0xaa },
    { 0x55, 0x55, 0x55 },
    { 0x55, 0x55, 0xff },
    { 0x55, 0xff, 0x55 },
    { 0x55, 0xff, 0xff },
    { 0xff, 0x55, 0x55 },
    { 0xff, 0x55, 0xff },
    { 0xff, 0xff, 0x55 },
    { 0xff, 0xff, 0xff },
};


static int logo_type = LINUX_LOGO_CLUT224;
static unsigned int logo_width;
static unsigned int logo_height;
static struct color **logo_data;
static struct color logo_clut[MAX_LINUX_LOGO_COLORS];
static unsigned int logo_clutsize;
static int is_plain_pbm = 0;

static void die(const char *fmt, ...)
    __attribute__ ((noreturn)) __attribute ((format (printf, 1, 2)));
static void usage(void) __attribute ((noreturn));


static unsigned int get_number(FILE *fp)
{
    int c, val;

    /* Skip leading whitespace */
    do {
	c = fgetc(fp);
	if (c == EOF)
	    die("%s: end of file\n", filename);
	if (c == '#') {
	    /* Ignore comments 'till end of line */
	    do {
		c = fgetc(fp);
		if (c == EOF)
		    die("%s: end of file\n", filename);
	    } while (c != '\n');
	}
    } while (isspace(c));

    /* Parse decimal number */
    val = 0;
    while (isdigit(c)) {
	val = 10*val+c-'0';
	/* some PBM are 'broken'; GiMP for example exports a PBM without space
	 * between the digits. This is Ok cause we know a PBM can only have a '1'
	 * or a '0' for the digit. */
	if (is_plain_pbm)
		break;
	c = fgetc(fp);
	if (c == EOF)
	    die("%s: end of file\n", filename);
    }
    return val;
}

static unsigned int get_number255(FILE *fp, unsigned int maxval)
{
    unsigned int val = get_number(fp);
    return (255*val+maxval/2)/maxval;
}

static void read_image(void)
{
    FILE *fp;
    unsigned int i, j;
    int magic;
    unsigned int maxval;

    /* open image file */
    fp = fopen(filename, "r");
    if (!fp)
	die("Cannot open file %s: %s\n", filename, strerror(errno));

    /* check file type and read file header */
    magic = fgetc(fp);
    if (magic != 'P')
	die("%s is not a PNM file\n", filename);
    magic = fgetc(fp);
    switch (magic) {
	case '1':
	case '2':
	case '3':
	    /* Plain PBM/PGM/PPM */
	    break;

	case '4':
	case '5':
	case '6':
	    /* Binary PBM/PGM/PPM */
	    die("%s: Binary PNM is not supported\n"
		"Use pnmnoraw(1) to convert it to ASCII PNM\n", filename);

	default:
	    die("%s is not a PNM file\n", filename);
    }
    logo_width = get_number(fp);
    logo_height = get_number(fp);

    /* allocate image data */
    logo_data = (struct color **)malloc(logo_height*sizeof(struct color *));
    if (!logo_data)
	die("%s\n", strerror(errno));
    for (i = 0; i < logo_height; i++) {
	logo_data[i] = malloc(logo_width*sizeof(struct color));
	if (!logo_data[i])
	    die("%s\n", strerror(errno));
    }

    /* read image data */
    switch (magic) {
	case '1':
	    /* Plain PBM */
	    is_plain_pbm = 1;
	    for (i = 0; i < logo_height; i++)
		for (j = 0; j < logo_width; j++)
		    logo_data[i][j].red = logo_data[i][j].green =
			logo_data[i][j].blue = 255*(1-get_number(fp));
	    break;

	case '2':
	    /* Plain PGM */
	    maxval = get_number(fp);
	    for (i = 0; i < logo_height; i++)
		for (j = 0; j < logo_width; j++)
		    logo_data[i][j].red = logo_data[i][j].green =
			logo_data[i][j].blue = get_number255(fp, maxval);
	    break;

	case '3':
	    /* Plain PPM */
	    maxval = get_number(fp);
	    for (i = 0; i < logo_height; i++)
		for (j = 0; j < logo_width; j++) {
		    logo_data[i][j].red = get_number255(fp, maxval);
		    logo_data[i][j].green = get_number255(fp, maxval);
		    logo_data[i][j].blue = get_number255(fp, maxval);
		}
	    break;
    }

    /* close file */
    fclose(fp);
}

static inline int is_black(struct color c)
{
    return c.red == 0 && c.green == 0 && c.blue == 0;
}

static inline int is_white(struct color c)
{
    return c.red == 255 && c.green == 255 && c.blue == 255;
}

static inline int is_gray(struct color c)
{
    return c.red == c.green && c.red == c.blue;
}

static inline int is_equal(struct color c1, struct color c2)
{
    return c1.red == c2.red && c1.green == c2.green && c1.blue == c2.blue;
}

static void write_header(void)
{
    /* open logo file */
    if (outputname) {
	out = fopen(outputname, "w");
	if (!out)
	    die("Cannot create file %s: %s\n", outputname, strerror(errno));
    } else {
	out = stdout;
    }

    fputs("/*\n", out);
    fputs(" *  DO NOT EDIT THIS FILE!\n", out);
    fputs(" *\n", out);
    fprintf(out, " *  It was automatically generated from %s\n", filename);
    fputs(" *\n", out);
    fprintf(out, " *  Linux logo %s\n", logoname);
    fputs(" */\n\n", out);
    fputs("#include <linux/linux_logo.h>\n\n", out);
    fprintf(out, "static unsigned char %s_data[] __initdata = {\n",
	    logoname);
}

static void write_footer(void)
{
    fputs("\n};\n\n", out);
    fprintf(out, "const struct linux_logo %s __initconst = {\n", logoname);
    fprintf(out, "\t.type\t\t= %s,\n", logo_types[logo_type]);
    fprintf(out, "\t.width\t\t= %d,\n", logo_width);
    fprintf(out, "\t.height\t\t= %d,\n", logo_height);
    if (logo_type == LINUX_LOGO_CLUT224) {
	fprintf(out, "\t.clutsize\t= %d,\n", logo_clutsize);
	fprintf(out, "\t.clut\t\t= %s_clut,\n", logoname);
    }
    fprintf(out, "\t.data\t\t= %s_data\n", logoname);
    fputs("};\n\n", out);

    /* close logo file */
    if (outputname)
	fclose(out);
}

static int write_hex_cnt;

static void write_hex(unsigned char byte)
{
    if (write_hex_cnt % 12)
	fprintf(out, ", 0x%02x", byte);
    else if (write_hex_cnt)
	fprintf(out, ",\n\t0x%02x", byte);
    else
	fprintf(out, "\t0x%02x", byte);
    write_hex_cnt++;
}

static void write_logo_mono(void)
{
    unsigned int i, j;
    unsigned char val, bit;

    /* validate image */
    for (i = 0; i < logo_height; i++)
	for (j = 0; j < logo_width; j++)
	    if (!is_black(logo_data[i][j]) && !is_white(logo_data[i][j]))
		die("Image must be monochrome\n");

    /* write file header */
    write_header();

    /* write logo data */
    for (i = 0; i < logo_height; i++) {
	for (j = 0; j < logo_width;) {
	    for (val = 0, bit = 0x80; bit && j < logo_width; j++, bit >>= 1)
		if (logo_data[i][j].red)
		    val |= bit;
	    write_hex(val);
	}
    }

    /* write logo structure and file footer */
    write_footer();
}

static void write_logo_vga16(void)
{
    unsigned int i, j, k;
    unsigned char val;

    /* validate image */
    for (i = 0; i < logo_height; i++)
	for (j = 0; j < logo_width; j++) {
	    for (k = 0; k < 16; k++)
		if (is_equal(logo_data[i][j], clut_vga16[k]))
		    break;
	    if (k == 16)
		die("Image must use the 16 console colors only\n"
		    "Use ppmquant(1) -map clut_vga16.ppm to reduce the number "
		    "of colors\n");
	}

    /* write file header */
    write_header();

    /* write logo data */
    for (i = 0; i < logo_height; i++)
	for (j = 0; j < logo_width; j++) {
	    for (k = 0; k < 16; k++)
		if (is_equal(logo_data[i][j], clut_vga16[k]))
		    break;
	    val = k<<4;
	    if (++j < logo_width) {
		for (k = 0; k < 16; k++)
		    if (is_equal(logo_data[i][j], clut_vga16[k]))
			break;
		val |= k;
	    }
	    write_hex(val);
	}

    /* write logo structure and file footer */
    write_footer();
}

static void write_logo_clut224(void)
{
    unsigned int i, j, k;

    /* validate image */
    for (i = 0; i < logo_height; i++)
	for (j = 0; j < logo_width; j++) {
	    for (k = 0; k < logo_clutsize; k++)
		if (is_equal(logo_data[i][j], logo_clut[k]))
		    break;
	    if (k == logo_clutsize) {
		if (logo_clutsize == MAX_LINUX_LOGO_COLORS)
		    die("Image has more than %d colors\n"
			"Use ppmquant(1) to reduce the number of colors\n",
			MAX_LINUX_LOGO_COLORS);
		logo_clut[logo_clutsize++] = logo_data[i][j];
	    }
	}

    /* write file header */
    write_header();

    /* write logo data */
    for (i = 0; i < logo_height; i++)
	for (j = 0; j < logo_width; j++) {
	    for (k = 0; k < logo_clutsize; k++)
		if (is_equal(logo_data[i][j], logo_clut[k]))
		    break;
	    write_hex(k+32);
	}
    fputs("\n};\n\n", out);

    /* write logo clut */
    fprintf(out, "static unsigned char %s_clut[] __initdata = {\n",
	    logoname);
    write_hex_cnt = 0;
    for (i = 0; i < logo_clutsize; i++) {
	write_hex(logo_clut[i].red);
	write_hex(logo_clut[i].green);
	write_hex(logo_clut[i].blue);
    }

    /* write logo structure and file footer */
    write_footer();
}

static void write_logo_gray256(void)
{
    unsigned int i, j;

    /* validate image */
    for (i = 0; i < logo_height; i++)
	for (j = 0; j < logo_width; j++)
	    if (!is_gray(logo_data[i][j]))
		die("Image must be grayscale\n");

    /* write file header */
    write_header();

    /* write logo data */
    for (i = 0; i < logo_height; i++)
	for (j = 0; j < logo_width; j++)
	    write_hex(logo_data[i][j].red);

    /* write logo structure and file footer */
    write_footer();
}

static void die(const char *fmt, ...)
{
    va_list ap;

    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    va_end(ap);

    exit(1);
}

static void usage(void)
{
    die("\n"
	"Usage: %s [options] <filename>\n"
	"\n"
	"Valid options:\n"
	"    -h          : display this usage information\n"
	"    -n <name>   : specify logo name (default: linux_logo)\n"
	"    -o <output> : output to file <output> instead of stdout\n"
	"    -t <type>   : specify logo type, one of\n"
	"                      mono    : monochrome black/white\n"
	"                      vga16   : 16 colors VGA text palette\n"
	"                      clut224 : 224 colors (default)\n"
	"                      gray256 : 256 levels grayscale\n"
	"\n", programname);
}

int main(int argc, char *argv[])
{
    int opt;

    programname = argv[0];

    opterr = 0;
    while (1) {
	opt = getopt(argc, argv, "hn:o:t:");
	if (opt == -1)
	    break;

	switch (opt) {
	    case 'h':
		usage();
		break;

	    case 'n':
		logoname = optarg;
		break;

	    case 'o':
		outputname = optarg;
		break;

	    case 't':
		if (!strcmp(optarg, "mono"))
		    logo_type = LINUX_LOGO_MONO;
		else if (!strcmp(optarg, "vga16"))
		    logo_type = LINUX_LOGO_VGA16;
		else if (!strcmp(optarg, "clut224"))
		    logo_type = LINUX_LOGO_CLUT224;
		else if (!strcmp(optarg, "gray256"))
		    logo_type = LINUX_LOGO_GRAY256;
		else
		    usage();
		break;

	    default:
		usage();
		break;
	}
    }
    if (optind != argc-1)
	usage();

    filename = argv[optind];

    read_image();
    switch (logo_type) {
	case LINUX_LOGO_MONO:
	    write_logo_mono();
	    break;

	case LINUX_LOGO_VGA16:
	    write_logo_vga16();
	    break;

	case LINUX_LOGO_CLUT224:
	    write_logo_clut224();
	    break;

	case LINUX_LOGO_GRAY256:
	    write_logo_gray256();
	    break;
    }
    exit(0);
}
Commit	Line	Data
1da177e4 LT	1
	2	/*
	3	* Convert a logo in ASCII PNM format to C source suitable for inclusion in
	4	* the Linux kernel
	5	*
	6	* (C) Copyright 2001-2003 by Geert Uytterhoeven <[email protected]>
	7	*
	8	* --------------------------------------------------------------------------
	9	*
	10	* This file is subject to the terms and conditions of the GNU General Public
	11	* License. See the file COPYING in the main directory of the Linux
	12	* distribution for more details.
	13	*/
	14
	15	#include <ctype.h>
	16	#include <errno.h>
	17	#include <stdarg.h>
	18	#include <stdio.h>
	19	#include <stdlib.h>
	20	#include <string.h>
	21	#include <unistd.h>
	22
	23
	24	static const char *programname;
	25	static const char *filename;
	26	static const char *logoname = "linux_logo";
	27	static const char *outputname;
	28	static FILE *out;
	29
	30
	31	#define LINUX_LOGO_MONO 1 /* monochrome black/white */
	32	#define LINUX_LOGO_VGA16 2 /* 16 colors VGA text palette */
	33	#define LINUX_LOGO_CLUT224 3 /* 224 colors */
	34	#define LINUX_LOGO_GRAY256 4 /* 256 levels grayscale */
	35
	36	static const char *logo_types[LINUX_LOGO_GRAY256+1] = {
	37	[LINUX_LOGO_MONO] = "LINUX_LOGO_MONO",
	38	[LINUX_LOGO_VGA16] = "LINUX_LOGO_VGA16",
	39	[LINUX_LOGO_CLUT224] = "LINUX_LOGO_CLUT224",
	40	[LINUX_LOGO_GRAY256] = "LINUX_LOGO_GRAY256"
	41	};
	42
	43	#define MAX_LINUX_LOGO_COLORS 224
	44
	45	struct color {
	46	unsigned char red;
	47	unsigned char green;
	48	unsigned char blue;
	49	};
	50
	51	static const struct color clut_vga16[16] = {
	52	{ 0x00, 0x00, 0x00 },
	53	{ 0x00, 0x00, 0xaa },
	54	{ 0x00, 0xaa, 0x00 },
	55	{ 0x00, 0xaa, 0xaa },
	56	{ 0xaa, 0x00, 0x00 },
	57	{ 0xaa, 0x00, 0xaa },
	58	{ 0xaa, 0x55, 0x00 },
	59	{ 0xaa, 0xaa, 0xaa },
	60	{ 0x55, 0x55, 0x55 },
	61	{ 0x55, 0x55, 0xff },
	62	{ 0x55, 0xff, 0x55 },
	63	{ 0x55, 0xff, 0xff },
	64	{ 0xff, 0x55, 0x55 },
65	{ 0xff, 0x55, 0xff },
66	{ 0xff, 0xff, 0x55 },
67	{ 0xff, 0xff, 0xff },
68	};
69
70
71	static int logo_type = LINUX_LOGO_CLUT224;
72	static unsigned int logo_width;
73	static unsigned int logo_height;
74	static struct color **logo_data;
75	static struct color logo_clut[MAX_LINUX_LOGO_COLORS];
76	static unsigned int logo_clutsize;
fc96b211	77	static int is_plain_pbm = 0;
1da177e4 LT	78
	79	static void die(const char *fmt, ...)
	80	__attribute__ ((noreturn)) __attribute ((format (printf, 1, 2)));
	81	static void usage(void) __attribute ((noreturn));
	82
	83
	84	static unsigned int get_number(FILE *fp)
	85	{
	86	int c, val;
	87
	88	/* Skip leading whitespace */
	89	do {
	90	c = fgetc(fp);
	91	if (c == EOF)
	92	die("%s: end of file\n", filename);
	93	if (c == '#') {
	94	/* Ignore comments 'till end of line */
	95	do {
	96	c = fgetc(fp);
	97	if (c == EOF)
	98	die("%s: end of file\n", filename);
	99	} while (c != '\n');
	100	}
	101	} while (isspace(c));
	102
	103	/* Parse decimal number */
	104	val = 0;
	105	while (isdigit(c)) {
	106	val = 10*val+c-'0';
fc96b211 AB	107	/* some PBM are 'broken'; GiMP for example exports a PBM without space
	108	* between the digits. This is Ok cause we know a PBM can only have a '1'
	109	* or a '0' for the digit. */
	110	if (is_plain_pbm)
	111	break;
1da177e4 LT	112	c = fgetc(fp);
	113	if (c == EOF)
	114	die("%s: end of file\n", filename);
	115	}
	116	return val;
	117	}
	118
	119	static unsigned int get_number255(FILE *fp, unsigned int maxval)
	120	{
	121	unsigned int val = get_number(fp);
	122	return (255*val+maxval/2)/maxval;
	123	}
	124
	125	static void read_image(void)
	126	{
	127	FILE *fp;
	128	unsigned int i, j;
	129	int magic;
	130	unsigned int maxval;
	131
	132	/* open image file */
	133	fp = fopen(filename, "r");
	134	if (!fp)
	135	die("Cannot open file %s: %s\n", filename, strerror(errno));
	136
	137	/* check file type and read file header */
	138	magic = fgetc(fp);
	139	if (magic != 'P')
	140	die("%s is not a PNM file\n", filename);
	141	magic = fgetc(fp);
	142	switch (magic) {
	143	case '1':
	144	case '2':
	145	case '3':
	146	/* Plain PBM/PGM/PPM */
	147	break;
	148
	149	case '4':
	150	case '5':
	151	case '6':
	152	/* Binary PBM/PGM/PPM */
	153	die("%s: Binary PNM is not supported\n"
	154	"Use pnmnoraw(1) to convert it to ASCII PNM\n", filename);
	155
	156	default:
	157	die("%s is not a PNM file\n", filename);
	158	}
	159	logo_width = get_number(fp);
	160	logo_height = get_number(fp);
	161
	162	/* allocate image data */
	163	logo_data = (struct color *)malloc(logo_heightsizeof(struct color *));
	164	if (!logo_data)
	165	die("%s\n", strerror(errno));
	166	for (i = 0; i < logo_height; i++) {
	167	logo_data[i] = malloc(logo_width*sizeof(struct color));
	168	if (!logo_data[i])
	169	die("%s\n", strerror(errno));
	170	}
	171
	172	/* read image data */
	173	switch (magic) {
	174	case '1':
	175	/* Plain PBM */
fc96b211	176	is_plain_pbm = 1;
1da177e4 LT	177	for (i = 0; i < logo_height; i++)
	178	for (j = 0; j < logo_width; j++)
	179	logo_data[i][j].red = logo_data[i][j].green =
	180	logo_data[i][j].blue = 255*(1-get_number(fp));
	181	break;
	182
	183	case '2':
	184	/* Plain PGM */
	185	maxval = get_number(fp);
	186	for (i = 0; i < logo_height; i++)
	187	for (j = 0; j < logo_width; j++)
	188	logo_data[i][j].red = logo_data[i][j].green =
	189	logo_data[i][j].blue = get_number255(fp, maxval);
	190	break;
	191
	192	case '3':
	193	/* Plain PPM */
	194	maxval = get_number(fp);
	195	for (i = 0; i < logo_height; i++)
	196	for (j = 0; j < logo_width; j++) {
	197	logo_data[i][j].red = get_number255(fp, maxval);
	198	logo_data[i][j].green = get_number255(fp, maxval);
	199	logo_data[i][j].blue = get_number255(fp, maxval);
	200	}
	201	break;
	202	}
	203
	204	/* close file */
	205	fclose(fp);
	206	}
	207
	208	static inline int is_black(struct color c)
	209	{
	210	return c.red == 0 && c.green == 0 && c.blue == 0;
	211	}
	212
	213	static inline int is_white(struct color c)
	214	{
	215	return c.red == 255 && c.green == 255 && c.blue == 255;
	216	}
	217
	218	static inline int is_gray(struct color c)
	219	{
	220	return c.red == c.green && c.red == c.blue;
	221	}
	222
	223	static inline int is_equal(struct color c1, struct color c2)
	224	{
	225	return c1.red == c2.red && c1.green == c2.green && c1.blue == c2.blue;
	226	}
	227
	228	static void write_header(void)
	229	{
	230	/* open logo file */
	231	if (outputname) {
	232	out = fopen(outputname, "w");
	233	if (!out)
	234	die("Cannot create file %s: %s\n", outputname, strerror(errno));
	235	} else {
	236	out = stdout;
	237	}
	238
	239	fputs("/*\n", out);
	240	fputs(" * DO NOT EDIT THIS FILE!\n", out);
241	fputs(" *\n", out);
242	fprintf(out, " * It was automatically generated from %s\n", filename);
243	fputs(" *\n", out);
244	fprintf(out, " * Linux logo %s\n", logoname);
245	fputs(" */\n\n", out);
246	fputs("#include <linux/linux_logo.h>\n\n", out);
15e32524	247	fprintf(out, "static unsigned char %s_data[] __initdata = {\n",
1da177e4 LT	248	logoname);
	249	}
	250
	251	static void write_footer(void)
	252	{
	253	fputs("\n};\n\n", out);
ae52bb23 GU	254	fprintf(out, "const struct linux_logo %s __initconst = {\n", logoname);
	255	fprintf(out, "\t.type\t\t= %s,\n", logo_types[logo_type]);
	256	fprintf(out, "\t.width\t\t= %d,\n", logo_width);
	257	fprintf(out, "\t.height\t\t= %d,\n", logo_height);
1da177e4	258	if (logo_type == LINUX_LOGO_CLUT224) {
ae52bb23 GU	259	fprintf(out, "\t.clutsize\t= %d,\n", logo_clutsize);
ae52bb23 GU	260	fprintf(out, "\t.clut\t\t= %s_clut,\n", logoname);
1da177e4	261	}
ae52bb23	262	fprintf(out, "\t.data\t\t= %s_data\n", logoname);
1da177e4 LT	263	fputs("};\n\n", out);
	264
	265	/* close logo file */
	266	if (outputname)
	267	fclose(out);
	268	}
	269
	270	static int write_hex_cnt;
	271
	272	static void write_hex(unsigned char byte)
	273	{
	274	if (write_hex_cnt % 12)
	275	fprintf(out, ", 0x%02x", byte);
	276	else if (write_hex_cnt)
	277	fprintf(out, ",\n\t0x%02x", byte);
	278	else
	279	fprintf(out, "\t0x%02x", byte);
	280	write_hex_cnt++;
	281	}
	282
	283	static void write_logo_mono(void)
	284	{
	285	unsigned int i, j;
	286	unsigned char val, bit;
	287
	288	/* validate image */
	289	for (i = 0; i < logo_height; i++)
	290	for (j = 0; j < logo_width; j++)
	291	if (!is_black(logo_data[i][j]) && !is_white(logo_data[i][j]))
	292	die("Image must be monochrome\n");
	293
	294	/* write file header */
	295	write_header();
	296
	297	/* write logo data */
	298	for (i = 0; i < logo_height; i++) {
	299	for (j = 0; j < logo_width;) {
	300	for (val = 0, bit = 0x80; bit && j < logo_width; j++, bit >>= 1)
	301	if (logo_data[i][j].red)
	302	val \|= bit;
	303	write_hex(val);
	304	}
	305	}
	306
	307	/* write logo structure and file footer */
	308	write_footer();
	309	}
	310
	311	static void write_logo_vga16(void)
	312	{
	313	unsigned int i, j, k;
	314	unsigned char val;
	315
	316	/* validate image */
	317	for (i = 0; i < logo_height; i++)
	318	for (j = 0; j < logo_width; j++) {
	319	for (k = 0; k < 16; k++)
	320	if (is_equal(logo_data[i][j], clut_vga16[k]))
	321	break;
	322	if (k == 16)
	323	die("Image must use the 16 console colors only\n"
	324	"Use ppmquant(1) -map clut_vga16.ppm to reduce the number "
	325	"of colors\n");
	326	}
327
328	/* write file header */
329	write_header();
330
331	/* write logo data */
332	for (i = 0; i < logo_height; i++)
333	for (j = 0; j < logo_width; j++) {
334	for (k = 0; k < 16; k++)
335	if (is_equal(logo_data[i][j], clut_vga16[k]))
336	break;
337	val = k<<4;
338	if (++j < logo_width) {
339	for (k = 0; k < 16; k++)
340	if (is_equal(logo_data[i][j], clut_vga16[k]))
341	break;
342	val \|= k;
343	}
344	write_hex(val);
345	}
346
347	/* write logo structure and file footer */
348	write_footer();
349	}
350
351	static void write_logo_clut224(void)
352	{
353	unsigned int i, j, k;
354
355	/* validate image */
356	for (i = 0; i < logo_height; i++)
357	for (j = 0; j < logo_width; j++) {
358	for (k = 0; k < logo_clutsize; k++)
359	if (is_equal(logo_data[i][j], logo_clut[k]))
360	break;
361	if (k == logo_clutsize) {
362	if (logo_clutsize == MAX_LINUX_LOGO_COLORS)
363	die("Image has more than %d colors\n"
364	"Use ppmquant(1) to reduce the number of colors\n",
365	MAX_LINUX_LOGO_COLORS);
366	logo_clut[logo_clutsize++] = logo_data[i][j];
367	}
368	}
369
370	/* write file header */
371	write_header();
372
373	/* write logo data */
374	for (i = 0; i < logo_height; i++)
375	for (j = 0; j < logo_width; j++) {
376	for (k = 0; k < logo_clutsize; k++)
377	if (is_equal(logo_data[i][j], logo_clut[k]))
378	break;
379	write_hex(k+32);
380	}
381	fputs("\n};\n\n", out);
382
383	/* write logo clut */
15e32524	384	fprintf(out, "static unsigned char %s_clut[] __initdata = {\n",
1da177e4 LT	385	logoname);
	386	write_hex_cnt = 0;
	387	for (i = 0; i < logo_clutsize; i++) {
	388	write_hex(logo_clut[i].red);
	389	write_hex(logo_clut[i].green);
	390	write_hex(logo_clut[i].blue);
	391	}
	392
	393	/* write logo structure and file footer */
	394	write_footer();
	395	}
	396
	397	static void write_logo_gray256(void)
	398	{
	399	unsigned int i, j;
	400
	401	/* validate image */
	402	for (i = 0; i < logo_height; i++)
	403	for (j = 0; j < logo_width; j++)
	404	if (!is_gray(logo_data[i][j]))
	405	die("Image must be grayscale\n");
	406
	407	/* write file header */
	408	write_header();
	409
	410	/* write logo data */
	411	for (i = 0; i < logo_height; i++)
	412	for (j = 0; j < logo_width; j++)
	413	write_hex(logo_data[i][j].red);
	414
	415	/* write logo structure and file footer */
	416	write_footer();
	417	}
	418
	419	static void die(const char *fmt, ...)
	420	{
	421	va_list ap;
	422
	423	va_start(ap, fmt);
	424	vfprintf(stderr, fmt, ap);
	425	va_end(ap);
	426
	427	exit(1);
	428	}
	429
	430	static void usage(void)
	431	{
	432	die("\n"
	433	"Usage: %s [options] <filename>\n"
	434	"\n"
	435	"Valid options:\n"
	436	" -h : display this usage information\n"
	437	" -n <name> : specify logo name (default: linux_logo)\n"
	438	" -o <output> : output to file <output> instead of stdout\n"
	439	" -t <type> : specify logo type, one of\n"
	440	" mono : monochrome black/white\n"
	441	" vga16 : 16 colors VGA text palette\n"
	442	" clut224 : 224 colors (default)\n"
	443	" gray256 : 256 levels grayscale\n"
	444	"\n", programname);
	445	}
	446
	447	int main(int argc, char *argv[])
	448	{
449	int opt;
450
451	programname = argv[0];
452
453	opterr = 0;
454	while (1) {
455	opt = getopt(argc, argv, "hn:o:t:");
456	if (opt == -1)
457	break;
458
459	switch (opt) {
460	case 'h':
461	usage();
462	break;
463
464	case 'n':
465	logoname = optarg;
466	break;
467
468	case 'o':
469	outputname = optarg;
470	break;
471
472	case 't':
473	if (!strcmp(optarg, "mono"))
474	logo_type = LINUX_LOGO_MONO;
475	else if (!strcmp(optarg, "vga16"))
476	logo_type = LINUX_LOGO_VGA16;
477	else if (!strcmp(optarg, "clut224"))
478	logo_type = LINUX_LOGO_CLUT224;
479	else if (!strcmp(optarg, "gray256"))
480	logo_type = LINUX_LOGO_GRAY256;
481	else
482	usage();
483	break;
484
485	default:
486	usage();
487	break;
488	}
489	}
490	if (optind != argc-1)
491	usage();
492
493	filename = argv[optind];
494
495	read_image();
496	switch (logo_type) {
497	case LINUX_LOGO_MONO:
498	write_logo_mono();
499	break;
500
501	case LINUX_LOGO_VGA16:
502	write_logo_vga16();
503	break;
504
505	case LINUX_LOGO_CLUT224:
506	write_logo_clut224();
507	break;
508
509	case LINUX_LOGO_GRAY256:
510	write_logo_gray256();
511	break;
512	}
513	exit(0);
514	}