Root/scripts/pnmtologo.c

Source at commit cdde9cf73945d547acd3e96f9508c79e84ad0bf1 created 9 years 4 months ago.
By Maarten ter Huurne, MMC: JZ4740: Added support for CPU frequency changing
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
24static const char *programname;
25static const char *filename;
26static const char *logoname = "linux_logo";
27static const char *outputname;
28static 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
36static 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
45struct color {
46    unsigned char red;
47    unsigned char green;
48    unsigned char blue;
49};
50
51static 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
71static int logo_type = LINUX_LOGO_CLUT224;
72static unsigned int logo_width;
73static unsigned int logo_height;
74static struct color **logo_data;
75static struct color logo_clut[MAX_LINUX_LOGO_COLORS];
76static unsigned int logo_clutsize;
77
78static void die(const char *fmt, ...)
79    __attribute__ ((noreturn)) __attribute ((format (printf, 1, 2)));
80static void usage(void) __attribute ((noreturn));
81
82
83static 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
113static 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
119static 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_height*sizeof(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
201static inline int is_black(struct color c)
202{
203    return c.red == 0 && c.green == 0 && c.blue == 0;
204}
205
206static inline int is_white(struct color c)
207{
208    return c.red == 255 && c.green == 255 && c.blue == 255;
209}
210
211static inline int is_gray(struct color c)
212{
213    return c.red == c.green && c.red == c.blue;
214}
215
216static 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
221static 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);
240    fprintf(out, "static unsigned char %s_data[] __initdata = {\n",
241        logoname);
242}
243
244static void write_footer(void)
245{
246    fputs("\n};\n\n", out);
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);
251    if (logo_type == LINUX_LOGO_CLUT224) {
252    fprintf(out, "\t.clutsize\t= %d,\n", logo_clutsize);
253    fprintf(out, "\t.clut\t\t= %s_clut,\n", logoname);
254    }
255    fprintf(out, "\t.data\t\t= %s_data\n", logoname);
256    fputs("};\n\n", out);
257
258    /* close logo file */
259    if (outputname)
260    fclose(out);
261}
262
263static int write_hex_cnt;
264
265static 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
276static 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
304static 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
344static 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 */
377    fprintf(out, "static unsigned char %s_clut[] __initdata = {\n",
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
390static 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
412static 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
423static 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
440int 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
509

Archive Download this file



interactive