?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
make the linux-ppc packags be in synch with other platforms
[tangerine.git] / arch / common / boot / grub2 / video / readers / png.c
blob608fa5e4a849ac15d9d93fd0bab6df44d31bccd4
1 /*
2 * GRUB -- GRand Unified Bootloader
3 * Copyright (C) 2008 Free Software Foundation, Inc.
4 *
5 * GRUB is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, either version 3 of the License, or
8 * (at your option) any later version.
9 *
10 * GRUB is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with GRUB. If not, see <http://www.gnu.org/licenses/>.
17 */
18
19 #include <grub/bitmap.h>
20 #include <grub/types.h>
21 #include <grub/normal.h>
22 #include <grub/dl.h>
23 #include <grub/mm.h>
24 #include <grub/misc.h>
25 #include <grub/arg.h>
26 #include <grub/file.h>
27
28 /* Uncomment following define to enable PNG debug. */
29 //#define PNG_DEBUG
30
31 #define PNG_COLOR_MASK_PALETTE 1
32 #define PNG_COLOR_MASK_COLOR 2
33 #define PNG_COLOR_MASK_ALPHA 4
34
35 #define PNG_COLOR_TYPE_GRAY 0
36 #define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)
37 #define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR)
38 #define PNG_COLOR_TYPE_RGBA (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)
39 #define PNG_COLOR_TYPE_GRAYA (PNG_COLOR_MASK_ALPHA)
40
41 #define PNG_COMPRESSION_BASE 0
42
43 #define PNG_INTERLACE_NONE 0
44 #define PNG_INTERLACE_ADAM7 1
45
46 #define PNG_FILTER_TYPE_BASE 0
47
48 #define PNG_FILTER_VALUE_NONE 0
49 #define PNG_FILTER_VALUE_SUB 1
50 #define PNG_FILTER_VALUE_UP 2
51 #define PNG_FILTER_VALUE_AVG 3
52 #define PNG_FILTER_VALUE_PAETH 4
53 #define PNG_FILTER_VALUE_LAST 5
54
55 #define PNG_CHUNK_IHDR 0x49484452
56 #define PNG_CHUNK_IDAT 0x49444154
57 #define PNG_CHUNK_IEND 0x49454e44
58
59 #define Z_DEFLATED 8
60 #define Z_FLAG_DICT 32
61
62 #define INFLATE_STORED 0
63 #define INFLATE_FIXED 1
64 #define INFLATE_DYNAMIC 2
65
66 #define WSIZE 0x8000
67
68 #define DEFLATE_HCLEN_BASE 4
69 #define DEFLATE_HCLEN_MAX 19
70 #define DEFLATE_HLIT_BASE 257
71 #define DEFLATE_HLIT_MAX 286
72 #define DEFLATE_HDIST_BASE 1
73 #define DEFLATE_HDIST_MAX 30
74
75 #define DEFLATE_HUFF_LEN 16
76
77 struct huff_table
78 {
79 int *values, *maxval, *offset;
80 int num_values, max_length;
81 };
82
83 struct grub_png_data
84 {
85 grub_file_t file;
86 struct grub_video_bitmap **bitmap;
87
88 int bit_count, bit_save;
89
90 grub_uint32_t next_offset;
91
92 int image_width, image_height, bpp, is_16bit, raw_bytes;
93 grub_uint8_t *image_data;
94
95 int inside_idat, idat_remain;
96
97 int code_values[DEFLATE_HLIT_MAX];
98 int code_maxval[DEFLATE_HUFF_LEN];
99 int code_offset[DEFLATE_HUFF_LEN];
100
101 int dist_values[DEFLATE_HDIST_MAX];
102 int dist_maxval[DEFLATE_HUFF_LEN];
103 int dist_offset[DEFLATE_HUFF_LEN];
104
105 struct huff_table code_table;
106 struct huff_table dist_table;
107
108 grub_uint8_t slide[WSIZE];
109 int wp;
110
111 grub_uint8_t *cur_rgb;
112
113 int cur_colume, cur_filter, first_line;
114 };
115
116 static grub_uint32_t
117 grub_png_get_dword (struct grub_png_data *data)
118 {
119 grub_uint32_t r;
120
121 r = 0;
122 grub_file_read (data->file, (char *) &r, sizeof (grub_uint32_t));
123
124 return grub_be_to_cpu32 (r);
125 }
126
127 static grub_uint8_t
128 grub_png_get_byte (struct grub_png_data *data)
129 {
130 grub_uint8_t r;
131
132 if ((data->inside_idat) && (data->idat_remain == 0))
133 {
134 grub_uint32_t len, type;
135
136 do
137 {
138 /* Skip crc checksum. */
139 grub_png_get_dword (data);
140
141 if (data->file->offset != data->next_offset)
142 {
143 grub_error (GRUB_ERR_BAD_FILE_TYPE,
144 "png: chunk size error");
145 return 0;
146 }
147
148 len = grub_png_get_dword (data);
149 type = grub_png_get_dword (data);
150 if (type != PNG_CHUNK_IDAT)
151 {
152 grub_error (GRUB_ERR_BAD_FILE_TYPE,
153 "png: unexpected end of data");
154 return 0;
155 }
156
157 data->next_offset = data->file->offset + len + 4;
158 }
159 while (len == 0);
160 data->idat_remain = len;
161 }
162
163 r = 0;
164 grub_file_read (data->file, (char *) &r, 1);
165
166 if (data->inside_idat)
167 data->idat_remain--;
168
169 return r;
170 }
171
172 static int
173 grub_png_get_bits (struct grub_png_data *data, int num)
174 {
175 int code, shift;
176
177 if (data->bit_count == 0)
178 {
179 data->bit_save = grub_png_get_byte (data);
180 data->bit_count = 8;
181 }
182
183 code = 0;
184 shift = 0;
185 while (grub_errno == 0)
186 {
187 int n;
188
189 n = data->bit_count;
190 if (n > num)
191 n = num;
192
193 code += (int) (data->bit_save & ((1 << n) - 1)) << shift;
194 num -= n;
195 if (!num)
196 {
197 data->bit_count -= n;
198 data->bit_save >>= n;
199 break;
200 }
201
202 shift += n;
203
204 data->bit_save = grub_png_get_byte (data);
205 data->bit_count = 8;
206 }
207
208 return code;
209 }
210
211 static grub_err_t
212 grub_png_decode_image_header (struct grub_png_data *data)
213 {
214 int color_type;
215 int color_bits;
216
217 data->image_width = grub_png_get_dword (data);
218 data->image_height = grub_png_get_dword (data);
219
220 if ((!data->image_height) || (!data->image_width))
221 return grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: invalid image size");
222
223 color_bits = grub_png_get_byte (data);
224 if ((color_bits != 8) && (color_bits != 16))
225 return grub_error (GRUB_ERR_BAD_FILE_TYPE,
226 "png: bit depth must be 8 or 16");
227 data->is_16bit = (color_bits == 16);
228
229 color_type = grub_png_get_byte (data);
230 if (color_type == PNG_COLOR_TYPE_RGB)
231 {
232 if (grub_video_bitmap_create (data->bitmap, data->image_width,
233 data->image_height,
234 GRUB_VIDEO_BLIT_FORMAT_R8G8B8))
235 return grub_errno;
236 data->bpp = 3;
237 }
238 else if (color_type == PNG_COLOR_TYPE_RGBA)
239 {
240 if (grub_video_bitmap_create (data->bitmap, data->image_width,
241 data->image_height,
242 GRUB_VIDEO_BLIT_FORMAT_R8G8B8A8))
243 return grub_errno;
244 data->bpp = 4;
245 }
246 else
247 return grub_error (GRUB_ERR_BAD_FILE_TYPE,
248 "png: color type not supported");
249
250 if (data->is_16bit)
251 {
252 data->bpp <<= 1;
253
254 data->image_data = grub_malloc (data->image_height *
255 data->image_width * data->bpp);
256 if (grub_errno)
257 return grub_errno;
258
259 data->cur_rgb = data->image_data;
260 }
261 else
262 {
263 data->image_data = 0;
264 data->cur_rgb = (*data->bitmap)->data;
265 }
266
267 data->raw_bytes = data->image_height * (data->image_width + 1) * data->bpp;
268
269 data->cur_colume = 0;
270 data->first_line = 1;
271
272 if (grub_png_get_byte (data) != PNG_COMPRESSION_BASE)
273 return grub_error (GRUB_ERR_BAD_FILE_TYPE,
274 "png: compression method not supported");
275
276 if (grub_png_get_byte (data) != PNG_FILTER_TYPE_BASE)
277 return grub_error (GRUB_ERR_BAD_FILE_TYPE,
278 "png: filter method not supported");
279
280 if (grub_png_get_byte (data) != PNG_INTERLACE_NONE)
281 return grub_error (GRUB_ERR_BAD_FILE_TYPE,
282 "png: interlace method not supported");
283
284 /* Skip crc checksum. */
285 grub_png_get_dword (data);
286
287 return grub_errno;
288 }
289
290 /* Order of the bit length code lengths. */
291 static const grub_uint8_t bitorder[] = {
292 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
293 };
294
295 /* Copy lengths for literal codes 257..285. */
296 static const int cplens[] = {
297 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
298 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
299 };
300
301 /* Extra bits for literal codes 257..285. */
302 static const grub_uint8_t cplext[] = {
303 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
304 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99
305 }; /* 99==invalid */
306
307 /* Copy offsets for distance codes 0..29. */
308 static const int cpdist[] = {
309 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
310 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
311 8193, 12289, 16385, 24577
312 };
313
314 /* Extra bits for distance codes. */
315 static const grub_uint8_t cpdext[] = {
316 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
317 7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
318 12, 12, 13, 13
319 };
320
321 static void
322 grub_png_init_huff_table (struct huff_table *ht, int cur_maxlen,
323 int *cur_values, int *cur_maxval, int *cur_offset)
324 {
325 ht->values = cur_values;
326 ht->maxval = cur_maxval;
327 ht->offset = cur_offset;
328 ht->num_values = 0;
329 ht->max_length = cur_maxlen;
330 grub_memset (cur_maxval, 0, sizeof (int) * cur_maxlen);
331 }
332
333 static void
334 grub_png_insert_huff_item (struct huff_table *ht, int code, int len)
335 {
336 int i, n;
337
338 if (len == 0)
339 return;
340
341 if (len > ht->max_length)
342 {
343 grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: invalid code length");
344 return;
345 }
346
347 n = 0;
348 for (i = len; i < ht->max_length; i++)
349 n += ht->maxval[i];
350
351 for (i = 0; i < n; i++)
352 ht->values[ht->num_values - i] = ht->values[ht->num_values - i - 1];
353
354 ht->values[ht->num_values - n] = code;
355 ht->num_values++;
356 ht->maxval[len - 1]++;
357 }
358
359 static void
360 grub_png_build_huff_table (struct huff_table *ht)
361 {
362 int base, ofs, i;
363
364 base = 0;
365 ofs = 0;
366 for (i = 0; i < ht->max_length; i++)
367 {
368 base += ht->maxval[i];
369 ofs += ht->maxval[i];
370
371 ht->maxval[i] = base;
372 ht->offset[i] = ofs - base;
373
374 base <<= 1;
375 }
376 }
377
378 static int
379 grub_png_get_huff_code (struct grub_png_data *data, struct huff_table *ht)
380 {
381 int code, i;
382
383 code = 0;
384 for (i = 0; i < ht->max_length; i++)
385 {
386 code = (code << 1) + grub_png_get_bits (data, 1);
387 if (code < ht->maxval[i])
388 return ht->values[code + ht->offset[i]];
389 }
390 return 0;
391 }
392
393 static grub_err_t
394 grub_png_init_dynamic_block (struct grub_png_data *data)
395 {
396 int nl, nd, nb, i, prev;
397 struct huff_table cl;
398 int cl_values[sizeof (bitorder)];
399 int cl_maxval[8];
400 int cl_offset[8];
401 grub_uint8_t lens[DEFLATE_HCLEN_MAX];
402
403 nl = DEFLATE_HLIT_BASE + grub_png_get_bits (data, 5);
404 nd = DEFLATE_HDIST_BASE + grub_png_get_bits (data, 5);
405 nb = DEFLATE_HCLEN_BASE + grub_png_get_bits (data, 4);
406
407 if ((nl > DEFLATE_HLIT_MAX) || (nd > DEFLATE_HDIST_MAX) ||
408 (nb > DEFLATE_HCLEN_MAX))
409 return grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: too much data");
410
411 grub_png_init_huff_table (&cl, 8, cl_values, cl_maxval, cl_offset);
412
413 for (i = 0; i < nb; i++)
414 lens[bitorder[i]] = grub_png_get_bits (data, 3);
415
416 for (; i < DEFLATE_HCLEN_MAX; i++)
417 lens[bitorder[i]] = 0;
418
419 for (i = 0; i < DEFLATE_HCLEN_MAX; i++)
420 grub_png_insert_huff_item (&cl, i, lens[i]);
421
422 grub_png_build_huff_table (&cl);
423
424 grub_png_init_huff_table (&data->code_table, DEFLATE_HUFF_LEN,
425 data->code_values, data->code_maxval,
426 data->code_offset);
427
428 grub_png_init_huff_table (&data->dist_table, DEFLATE_HUFF_LEN,
429 data->dist_values, data->dist_maxval,
430 data->dist_offset);
431
432 prev = 0;
433 for (i = 0; i < nl + nd; i++)
434 {
435 int n, code;
436 struct huff_table *ht;
437
438 if (grub_errno)
439 return grub_errno;
440
441 if (i < nl)
442 {
443 ht = &data->code_table;
444 code = i;
445 }
446 else
447 {
448 ht = &data->dist_table;
449 code = i - nl;
450 }
451
452 n = grub_png_get_huff_code (data, &cl);
453 if (n < 16)
454 {
455 grub_png_insert_huff_item (ht, code, n);
456 prev = n;
457 }
458 else if (n == 16)
459 {
460 int c;
461
462 c = 3 + grub_png_get_bits (data, 2);
463 while (c > 0)
464 {
465 grub_png_insert_huff_item (ht, code++, prev);
466 i++;
467 c--;
468 }
469 i--;
470 }
471 else if (n == 17)
472 i += 3 + grub_png_get_bits (data, 3) - 1;
473 else
474 i += 11 + grub_png_get_bits (data, 7) - 1;
475 }
476
477 grub_png_build_huff_table (&data->code_table);
478 grub_png_build_huff_table (&data->dist_table);
479
480 return grub_errno;
481 }
482
483 static grub_err_t
484 grub_png_output_byte (struct grub_png_data *data, grub_uint8_t n)
485 {
486 int row_bytes;
487
488 if (--data->raw_bytes < 0)
489 return grub_error (GRUB_ERR_BAD_FILE_TYPE, "image size overflown");
490
491 if (data->cur_colume == 0)
492 {
493 if (n >= PNG_FILTER_VALUE_LAST)
494 return grub_error (GRUB_ERR_BAD_FILE_TYPE, "invalid filter value");
495
496 data->cur_filter = n;
497 }
498 else
499 *(data->cur_rgb++) = n;
500
501 data->cur_colume++;
502 row_bytes = data->image_width * data->bpp;
503 if (data->cur_colume == row_bytes + 1)
504 {
505 grub_uint8_t *blank_line = NULL;
506 grub_uint8_t *cur = data->cur_rgb - row_bytes;
507 grub_uint8_t *left = cur;
508 grub_uint8_t *up;
509
510 if (data->first_line)
511 {
512 blank_line = grub_malloc (row_bytes);
513 if (blank_line == NULL)
514 return grub_errno;
515
516 grub_memset (blank_line, 0, row_bytes);
517 up = blank_line;
518 }
519 else
520 up = cur - row_bytes;
521
522 switch (data->cur_filter)
523 {
524 case PNG_FILTER_VALUE_SUB:
525 {
526 int i;
527
528 cur += data->bpp;
529 for (i = data->bpp; i < row_bytes; i++, cur++, left++)
530 *cur += *left;
531
532 break;
533 }
534 case PNG_FILTER_VALUE_UP:
535 {
536 int i;
537
538 for (i = 0; i < row_bytes; i++, cur++, up++)
539 *cur += *up;
540
541 break;
542 }
543 case PNG_FILTER_VALUE_AVG:
544 {
545 int i;
546
547 for (i = 0; i < data->bpp; i++, cur++, up++)
548 *cur += *up >> 1;
549
550 for (; i < row_bytes; i++, cur++, up++, left++)
551 *cur += ((int) *up + (int) *left) >> 1;
552
553 break;
554 }
555 case PNG_FILTER_VALUE_PAETH:
556 {
557 int i;
558 grub_uint8_t *upper_left = up;
559
560 for (i = 0; i < data->bpp; i++, cur++, up++)
561 *cur += *up;
562
563 for (; i < row_bytes; i++, cur++, up++, left++, upper_left++)
564 {
565 int a, b, c, pa, pb, pc;
566
567 a = *left;
568 b = *up;
569 c = *upper_left;
570
571 pa = b - c;
572 pb = a - c;
573 pc = pa + pb;
574
575 if (pa < 0)
576 pa = -pa;
577
578 if (pb < 0)
579 pb = -pb;
580
581 if (pc < 0)
582 pc = -pc;
583
584 *cur += ((pa <= pb) && (pa <= pc)) ? a : (pb <= pc) ? b : c;
585 }
586 }
587 }
588
589 if (blank_line)
590 grub_free (blank_line);
591
592 data->cur_colume = 0;
593 data->first_line = 0;
594 }
595
596 return grub_errno;
597 }
598
599 static grub_err_t
600 grub_png_read_dynamic_block (struct grub_png_data *data)
601 {
602 while (grub_errno == 0)
603 {
604 int n;
605
606 n = grub_png_get_huff_code (data, &data->code_table);
607 if (n < 256)
608 {
609 data->slide[data->wp] = n;
610 grub_png_output_byte (data, n);
611
612 data->wp++;
613 if (data->wp >= WSIZE)
614 data->wp = 0;
615 }
616 else if (n == 256)
617 break;
618 else
619 {
620 int len, dist, pos;
621
622 n -= 257;
623 len = cplens[n];
624 if (cplext[n])
625 len += grub_png_get_bits (data, cplext[n]);
626
627 n = grub_png_get_huff_code (data, &data->dist_table);
628 dist = cpdist[n];
629 if (cpdext[n])
630 dist += grub_png_get_bits (data, cpdext[n]);
631
632 pos = data->wp - dist;
633 if (pos < 0)
634 pos += WSIZE;
635
636 while (len > 0)
637 {
638 data->slide[data->wp] = data->slide[pos];
639 grub_png_output_byte (data, data->slide[data->wp]);
640
641 data->wp++;
642 if (data->wp >= WSIZE)
643 data->wp = 0;
644
645 pos++;
646 if (pos >= WSIZE)
647 pos = 0;
648
649 len--;
650 }
651 }
652 }
653
654 return grub_errno;
655 }
656
657 static grub_err_t
658 grub_png_decode_image_data (struct grub_png_data *data)
659 {
660 grub_uint8_t cmf, flg;
661 int final;
662
663 cmf = grub_png_get_byte (data);
664 flg = grub_png_get_byte (data);
665
666 if ((cmf & 0xF) != Z_DEFLATED)
667 return grub_error (GRUB_ERR_BAD_FILE_TYPE,
668 "png: only support deflate compression method");
669
670 if (flg & Z_FLAG_DICT)
671 return grub_error (GRUB_ERR_BAD_FILE_TYPE,
672 "png: dictionary not supported");
673
674 do
675 {
676 int block_type;
677
678 final = grub_png_get_bits (data, 1);
679 block_type = grub_png_get_bits (data, 2);
680
681 switch (block_type)
682 {
683 case INFLATE_STORED:
684 {
685 grub_uint16_t i, len;
686
687 data->bit_count = 0;
688 len = grub_png_get_byte (data);
689 len += ((grub_uint16_t) grub_png_get_byte (data)) << 8;
690
691 /* Skip NLEN field. */
692 grub_png_get_byte (data);
693 grub_png_get_byte (data);
694
695 for (i = 0; i < len; i++)
696 grub_png_output_byte (data, grub_png_get_byte (data));
697
698 break;
699 }
700
701 case INFLATE_FIXED:
702 return grub_error (GRUB_ERR_BAD_FILE_TYPE,
703 "png: block type fixed not supported");
704
705 case INFLATE_DYNAMIC:
706 grub_png_init_dynamic_block (data);
707 grub_png_read_dynamic_block (data);
708 break;
709
710 default:
711 return grub_error (GRUB_ERR_BAD_FILE_TYPE,
712 "png: unknown block type");
713 }
714 }
715 while ((!final) && (grub_errno == 0));
716
717 /* Skip adler checksum. */
718 grub_png_get_dword (data);
719
720 /* Skip crc checksum. */
721 grub_png_get_dword (data);
722
723 return grub_errno;
724 }
725
726 static const grub_uint8_t png_magic[8] =
727 { 0x89, 0x50, 0x4e, 0x47, 0xd, 0xa, 0x1a, 0x0a };
728
729 static void
730 grub_png_convert_image (struct grub_png_data *data)
731 {
732 int i;
733 grub_uint8_t *d1, *d2;
734
735 d1 = (*data->bitmap)->data;
736 d2 = data->image_data + 1;
737
738 /* Only copy the upper 8 bit. */
739 for (i = 0; i < (data->image_width * data->image_height * data->bpp >> 1);
740 i++, d1++, d2+=2)
741 *d1 = *d2;
742 }
743
744 static grub_err_t
745 grub_png_decode_png (struct grub_png_data *data)
746 {
747 grub_uint8_t magic[8];
748
749 if (grub_file_read (data->file, (char *) &magic[0], 8) != 8)
750 return grub_errno;
751
752 if (grub_memcmp (magic, png_magic, sizeof (png_magic)))
753 return grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: not a png file");
754
755 while (1)
756 {
757 grub_uint32_t len, type;
758
759 len = grub_png_get_dword (data);
760 type = grub_png_get_dword (data);
761 data->next_offset = data->file->offset + len + 4;
762
763 switch (type)
764 {
765 case PNG_CHUNK_IHDR:
766 grub_png_decode_image_header (data);
767 break;
768
769 case PNG_CHUNK_IDAT:
770 data->inside_idat = 1;
771 data->idat_remain = len;
772 data->bit_count = 0;
773
774 grub_png_decode_image_data (data);
775
776 data->inside_idat = 0;
777 break;
778
779 case PNG_CHUNK_IEND:
780 if (data->is_16bit)
781 grub_png_convert_image (data);
782
783 return grub_errno;
784
785 default:
786 grub_file_seek (data->file, data->file->offset + len + 4);
787 }
788
789 if (grub_errno)
790 break;
791
792 if (data->file->offset != data->next_offset)
793 return grub_error (GRUB_ERR_BAD_FILE_TYPE,
794 "png: chunk size error");
795 }
796
797 return grub_errno;
798 }
799
800 static grub_err_t
801 grub_video_reader_png (struct grub_video_bitmap **bitmap,
802 const char *filename)
803 {
804 grub_file_t file;
805 struct grub_png_data *data;
806
807 file = grub_file_open (filename);
808 if (!file)
809 return grub_errno;
810
811 data = grub_malloc (sizeof (*data));
812 if (data != NULL)
813 {
814 grub_memset (data, 0, sizeof (*data));
815 data->file = file;
816 data->bitmap = bitmap;
817
818 grub_png_decode_png (data);
819
820 grub_free (data->image_data);
821 grub_free (data);
822 }
823
824 if (grub_errno != GRUB_ERR_NONE)
825 {
826 grub_video_bitmap_destroy (*bitmap);
827 *bitmap = 0;
828 }
829
830 grub_file_close (file);
831 return grub_errno;
832 }
833
834 #if defined(PNG_DEBUG)
835 static grub_err_t
836 grub_cmd_pngtest (struct grub_arg_list *state __attribute__ ((unused)),
837 int argc, char **args)
838 {
839 struct grub_video_bitmap *bitmap = 0;
840
841 if (argc != 1)
842 return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
843
844 grub_video_reader_png (&bitmap, args[0]);
845 if (grub_errno != GRUB_ERR_NONE)
846 return grub_errno;
847
848 grub_video_bitmap_destroy (bitmap);
849
850 return GRUB_ERR_NONE;
851 }
852 #endif
853
854 static struct grub_video_bitmap_reader png_reader = {
855 .extension = ".png",
856 .reader = grub_video_reader_png,
857 .next = 0
858 };
859
860 GRUB_MOD_INIT (video_reader_png)
861 {
862 grub_video_bitmap_reader_register (&png_reader);
863 #if defined(PNG_DEBUG)
864 grub_register_command ("pngtest", grub_cmd_pngtest,
865 GRUB_COMMAND_FLAG_BOTH, "pngtest FILE",
866 "Tests loading of PNG bitmap.", 0);
867 #endif
868 }
869
870 GRUB_MOD_FINI (video_reader_png)
871 {
872 #if defined(PNG_DEBUG)
873 grub_unregister_command ("pngtest");
874 #endif
875 grub_video_bitmap_reader_unregister (&png_reader);
876 }
A totally sweet operating system