Hi, This is reader for png image file.
/* * GRUB -- GRand Unified Bootloader * Copyright (C) 2008 Free Software Foundation, Inc. * * GRUB is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * GRUB is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with GRUB. If not, see <http://www.gnu.org/licenses/>. */ #include <grub/bitmap.h> #include <grub/types.h> #include <grub/normal.h> #include <grub/dl.h> #include <grub/mm.h> #include <grub/misc.h> #include <grub/arg.h> #include <grub/file.h> #include <grub/setjmp.h> /* Uncomment following define to enable PNG debug. */ //#define PNG_DEBUG #define PNG_COLOR_MASK_PALETTE 1 #define PNG_COLOR_MASK_COLOR 2 #define PNG_COLOR_MASK_ALPHA 4 #define PNG_COLOR_TYPE_GRAY 0 #define PNG_COLOR_TYPE_PALETTE (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE) #define PNG_COLOR_TYPE_RGB (PNG_COLOR_MASK_COLOR) #define PNG_COLOR_TYPE_RGB_ALPHA (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA) #define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA) #define PNG_COLOR_TYPE_RGBA PNG_COLOR_TYPE_RGB_ALPHA #define PNG_COLOR_TYPE_GA PNG_COLOR_TYPE_GRAY_ALPHA #define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */ #define PNG_FILTER_TYPE_BASE 0 /* Single row per-byte filtering */ #define PNG_INTERLACE_NONE 0 /* Non-interlaced image */ #define PNG_INTERLACE_ADAM7 1 /* Adam7 interlacing */ #define PNG_FILTER_VALUE_NONE 0 #define PNG_FILTER_VALUE_SUB 1 #define PNG_FILTER_VALUE_UP 2 #define PNG_FILTER_VALUE_AVG 3 #define PNG_FILTER_VALUE_PAETH 4 #define PNG_FILTER_VALUE_LAST 5 #define Z_DEFLATED 8 #define Z_FLAG_DICT 32 #define INFLATE_STORED 0 #define INFLATE_FIXED 1 #define INFLATE_DYNAMIC 2 #define WSIZE 0x8000 #define CHUNK_IHDR 0x49484452 #define CHUNK_IDAT 0x49444154 #define CHUNK_IEND 0x49454e44 struct huff_table { int *values, *maxval, *offset; int num_values, max_length; }; struct grub_png_data { grub_file_t file; grub_jmp_buf jumper; struct grub_video_bitmap **bitmap; int bit_count, bit_save; int image_width, image_height; int inside_idat, idat_remain; int code_values[286]; int code_maxval[16]; int code_offset[16]; int dist_values[30]; int dist_maxval[16]; int dist_offset[16]; struct huff_table code_table; struct huff_table dist_table; grub_uint8_t slide[WSIZE]; int wp; grub_uint8_t *cur_rgb; int cur_colume, cur_filter, first_line; }; static grub_uint32_t get_dword (struct grub_png_data *data) { grub_uint32_t r; if (grub_file_read (data->file, (char *) &r, 4) != 4) grub_longjmp (data->jumper, 1); return grub_be_to_cpu32 (r); } static grub_uint8_t get_byte (struct grub_png_data *data) { grub_uint8_t r; if ((data->inside_idat) && (data->idat_remain == 0)) { grub_uint32_t len, type; do { get_dword (data); /* skip crc checksum */ len = get_dword (data); type = get_dword (data); if (type != CHUNK_IDAT) { grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: unexpected end of data"); grub_longjmp (data->jumper, 1); } } while (len == 0); data->idat_remain = len; } if (grub_file_read (data->file, (char *) &r, 1) != 1) grub_longjmp (data->jumper, 1); if (data->inside_idat) data->idat_remain--; return r; } static int get_bits (struct grub_png_data *data, int num) { int code, shift; if (data->bit_count == 0) { data->bit_save = get_byte (data); data->bit_count = 8; } code = 0; shift = 0; while (1) { int n; n = data->bit_count; if (n > num) n = num; code += (int) (data->bit_save & ((1 << n) - 1)) << shift; num -= n; if (!num) { data->bit_count -= n; data->bit_save >>= n; break; } shift += n; data->bit_save = get_byte (data); data->bit_count = 8; } return code; } static void decode_image_header (struct grub_png_data *data) { data->image_width = get_dword (data); data->image_height = get_dword (data); if ((!data->image_height) || (!data->image_width)) { grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: invalid image size"); grub_longjmp (data->jumper, 1); } if (get_byte (data) != 8) { grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: bit depth must be 8"); grub_longjmp (data->jumper, 1); } if (get_byte (data) != PNG_COLOR_TYPE_RGB) { grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: color type not supported"); grub_longjmp (data->jumper, 1); } if (get_byte (data) != PNG_COMPRESSION_TYPE_BASE) { grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: compression method not supported"); grub_longjmp (data->jumper, 1); } if (get_byte (data) != PNG_FILTER_TYPE_BASE) { grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: filter method not supported"); grub_longjmp (data->jumper, 1); } if (get_byte (data) != PNG_INTERLACE_NONE) { grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: interlace method not supported"); grub_longjmp (data->jumper, 1); } if (grub_video_bitmap_create (data->bitmap, data->image_width, data->image_height, GRUB_VIDEO_BLIT_FORMAT_R8G8B8)) grub_longjmp (data->jumper, 1); data->cur_rgb = (*data->bitmap)->data; data->cur_colume = 0; data->first_line = 1; get_dword (data); /* skip crc checksum */ } static unsigned char bitorder[] = { /* Order of the bit length code lengths */ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 }; static int cplens[] = { /* Copy lengths for literal codes 257..285 */ 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 }; static unsigned char cplext[] = { /* Extra bits for literal codes 257..285 */ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99 }; /* 99==invalid */ static int cpdist[] = { /* Copy offsets for distance codes 0..29 */ 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577 }; static unsigned char cpdext[] = { /* Extra bits for distance codes */ 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 }; static void init_huff_table (struct huff_table *ht, int cur_maxlen, int *cur_values, int *cur_maxval, int *cur_offset) { ht->values = cur_values; ht->maxval = cur_maxval; ht->offset = cur_offset; ht->num_values = 0; ht->max_length = cur_maxlen; grub_memset (cur_maxval, 0, sizeof (int) * cur_maxlen); } static void insert_huff_item (struct grub_png_data *data, struct huff_table *ht, int code, int len) { int i, n; if (len == 0) return; if (len > ht->max_length) { grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: invalid code length"); grub_longjmp (data->jumper, 1); } n = 0; for (i = len; i < ht->max_length; i++) n += ht->maxval[i]; for (i = 0; i < n; i++) ht->values[ht->num_values - i] = ht->values[ht->num_values - i - 1]; ht->values[ht->num_values - n] = code; ht->num_values++; ht->maxval[len - 1]++; } static void build_huff_table (struct huff_table *ht) { int base, ofs, i; base = 0; ofs = 0; for (i = 0; i < ht->max_length; i++) { base += ht->maxval[i]; ofs += ht->maxval[i]; ht->maxval[i] = base; ht->offset[i] = ofs - base; base <<= 1; } } static int get_huff_code (struct grub_png_data *data, struct huff_table *ht) { int code, i; code = 0; for (i = 0; i < ht->max_length; i++) { code = (code << 1) + get_bits (data, 1); if (code < ht->maxval[i]) return ht->values[code + ht->offset[i]]; } return 0; } static void init_dynamic_block (struct grub_png_data *data) { int nl, nd, nb, i, prev; struct huff_table cl; int cl_values[sizeof (bitorder)]; int cl_maxval[8]; int cl_offset[8]; unsigned char lens[20]; nl = 257 + get_bits (data, 5); nd = 1 + get_bits (data, 5); nb = 4 + get_bits (data, 4); if ((nl > 286) || (nd > 30) || (nb > 19)) { grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: too much data"); grub_longjmp (data->jumper, 1); } init_huff_table (&cl, 8, cl_values, cl_maxval, cl_offset); for (i = 0; i < nb; i++) lens[bitorder[i]] = get_bits (data, 3); for (; i < 19; i++) lens[bitorder[i]] = 0; for (i = 0; i < 19; i++) insert_huff_item (data, &cl, i, lens[i]); build_huff_table (&cl); init_huff_table (&data->code_table, 16, data->code_values, data->code_maxval, data->code_offset); init_huff_table (&data->dist_table, 16, data->dist_values, data->dist_maxval, data->dist_offset); prev = 0; for (i = 0; i < nl + nd; i++) { int n, code; struct huff_table *ht; if (i < nl) { ht = &data->code_table; code = i; } else { ht = &data->dist_table; code = i - nl; } n = get_huff_code (data, &cl); if (n < 16) { insert_huff_item (data, ht, code, n); prev = n; } else if (n == 16) { int c; c = 3 + get_bits (data, 2); while (c > 0) { insert_huff_item (data, ht, code++, prev); i++; c--; } i--; } else if (n == 17) i += 3 + get_bits (data, 3) - 1; else i += 11 + get_bits (data, 7) - 1; } build_huff_table (&data->code_table); build_huff_table (&data->dist_table); } static void input_byte (struct grub_png_data *data, grub_uint8_t n) { if (data->cur_colume == 0) { if (n >= PNG_FILTER_VALUE_LAST) { grub_error (GRUB_ERR_BAD_FILE_TYPE, "invalid filter value"); grub_longjmp (data->jumper, 1); } data->cur_filter = n; } else { unsigned char left, up; left = (data->cur_colume <= 3) ? 0 : *(data->cur_rgb - 3); up = (data->first_line) ? 0 : *(data->cur_rgb - 3 * data->image_width); switch (data->cur_filter) { case PNG_FILTER_VALUE_NONE: *data->cur_rgb = n; break; case PNG_FILTER_VALUE_SUB: *data->cur_rgb = n + left; break; case PNG_FILTER_VALUE_UP: *data->cur_rgb = n + up; break; case PNG_FILTER_VALUE_AVG: *data->cur_rgb = n + (((int) left + (int) up) >> 1); break; case PNG_FILTER_VALUE_PAETH: { unsigned char upper_left, r; int p, pa, pb, pc; upper_left = ((data->cur_colume <= 3) || (data->first_line)) ? 0 : *(data->cur_rgb - 3 * data->image_width - 3); p = (int) left + (int) up - (int) upper_left; pa = p - (int) left; if (pa < 0) pa = -pa; pb = p - (int) up; if (pb < 0) pb = -pb; pc = p - (int) upper_left; if (pc < 0) pc = -pc; if ((pa <= pb) && (pa <= pc)) r = left; else if (pb <= pc) r = up; else r = upper_left; *data->cur_rgb = n + r; } } data->cur_rgb++; } data->cur_colume++; if (data->cur_colume == data->image_width * 3 + 1) { data->cur_colume = 0; data->first_line = 0; } } static void read_dynamic_block (struct grub_png_data *data) { while (1) { int n; n = get_huff_code (data, &data->code_table); if (n < 256) { data->slide[data->wp] = n; input_byte (data, n); data->wp++; if (data->wp >= WSIZE) data->wp = 0; } else if (n == 256) break; else { int len, dist, pos; n -= 257; len = cplens[n]; if (cplext[n]) len += get_bits (data, cplext[n]); n = get_huff_code (data, &data->dist_table); dist = cpdist[n]; if (cpdext[n]) dist += get_bits (data, cpdext[n]); pos = data->wp - dist; if (pos < 0) pos += WSIZE; while (len > 0) { data->slide[data->wp] = data->slide[pos]; input_byte (data, data->slide[data->wp]); data->wp++; if (data->wp >= WSIZE) data->wp = 0; pos++; if (pos >= WSIZE) pos = 0; len--; } } } } static void decode_image_data (struct grub_png_data *data) { grub_uint8_t cmf, flg; int final; cmf = get_byte (data); flg = get_byte (data); if ((cmf & 0xF) != Z_DEFLATED) { grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: only support deflate compression method"); grub_longjmp (data->jumper, 1); } if (flg & Z_FLAG_DICT) { grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: dictionary not supported"); grub_longjmp (data->jumper, 1); } do { int block_type; final = get_bits (data, 1); block_type = get_bits (data, 2); switch (block_type) { case INFLATE_STORED: grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: block type stored not supported"); grub_longjmp (data->jumper, 1); case INFLATE_FIXED: grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: block type fixed not supported"); grub_longjmp (data->jumper, 1); case INFLATE_DYNAMIC: init_dynamic_block (data); read_dynamic_block (data); break; default: grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: unknown block type"); grub_longjmp (data->jumper, 1); } } while (!final); get_dword (data); /* skip adler checksum */ get_dword (data); /* skip crc checksum */ } static grub_uint8_t png_magic[8] = { 0x89, 0x50, 0x4e, 0x47, 0xd, 0xa, 0x1a, 0x0a }; static void decode_png (struct grub_png_data *data) { grub_uint8_t magic[8]; if (grub_file_read (data->file, (char *) &magic[0], 8) != 8) grub_longjmp (data->jumper, 1); if (grub_memcmp (magic, png_magic, sizeof (png_magic))) { grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: not a png file"); grub_longjmp (data->jumper, 1); } while (1) { grub_uint32_t len, type; len = get_dword (data); type = get_dword (data); switch (type) { case CHUNK_IHDR: decode_image_header (data); break; case CHUNK_IDAT: data->inside_idat = 1; data->idat_remain = len; data->bit_count = 0; decode_image_data (data); data->inside_idat = 0; break; case CHUNK_IEND: return; default: grub_file_seek (data->file, data->file->offset + len + 4); } } } static grub_err_t grub_video_reader_png (struct grub_video_bitmap **bitmap, const char *filename) { grub_file_t file; struct grub_png_data *data; file = grub_file_open (filename); if (!file) return grub_errno; data = grub_malloc (sizeof (*data)); if (data != NULL) { grub_memset (data, 0, sizeof (*data)); data->file = file; data->bitmap = bitmap; if (!grub_setjmp (data->jumper)) decode_png (data); grub_free (data); } if (grub_errno != GRUB_ERR_NONE) { grub_video_bitmap_destroy (*bitmap); *bitmap = 0; } grub_file_close (file); return grub_errno; } #if defined(PNG_DEBUG) static grub_err_t grub_cmd_pngtest (struct grub_arg_list *state __attribute__ ((unused)), int argc, char **args) { struct grub_video_bitmap *bitmap = 0; if (argc != 1) return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required"); grub_video_reader_png (&bitmap, args[0]); if (grub_errno != GRUB_ERR_NONE) return grub_errno; grub_video_bitmap_destroy (bitmap); return GRUB_ERR_NONE; } #endif static struct grub_video_bitmap_reader png_reader = { .extension = ".png", .reader = grub_video_reader_png, .next = 0 }; GRUB_MOD_INIT (video_reader_png) { grub_video_bitmap_reader_register (&png_reader); #if defined(PNG_DEBUG) grub_register_command ("pngtest", grub_cmd_pngtest, GRUB_COMMAND_FLAG_BOTH, "pngtest FILE", "Tests loading of PNG bitmap.", 0); #endif } GRUB_MOD_FINI (video_reader_png) { #if defined(PNG_DEBUG) grub_unregister_command ("pngtest"); #endif grub_video_bitmap_reader_unregister (&png_reader); } -- Bean _______________________________________________ Grub-devel mailing list Grub-devel@gnu.org http://lists.gnu.org/mailman/listinfo/grub-devel
