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