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