On Jan 23, 2008 6:36 PM, Marco Gerards <[EMAIL PROTECTED]> wrote:
> > static grub_uint32_t
> > grub_png_get_dword (struct grub_png_data *data)
> > {
> > grub_uint32_t r;
> >
> > r = 0;
>
> Why this?
just to make sure if grub_file_read fails, this function will return 0.
> Please follow our style of commenting. Personally I prefer putting a
> comment on a separate line.
ok.
> > color_type = grub_png_get_byte (data);
> > if (color_type == PNG_COLOR_TYPE_RGB)
> > {
> > if (grub_video_bitmap_create (data->bitmap, data->image_width,
> > data->image_height,
> > GRUB_VIDEO_BLIT_FORMAT_R8G8B8))
> > return grub_errno;
>
> I am not sure, is this indention correct?
it should be, i run it though indent, perhaps the tabs make it look funny.
> > else if (color_type == PNG_COLOR_TYPE_RGBA)
> > {
> > if (grub_video_bitmap_create (data->bitmap, data->image_width,
> > data->image_height,
> > GRUB_VIDEO_BLIT_FORMAT_R8G8B8A8))
> > return grub_errno;
> > data->bpp = 4;
> > }
> > else
> > return grub_error (GRUB_ERR_BAD_FILE_TYPE,
> > "png: color type not supported");
>
> YUV isn't used here?
png doesn't support YUV.
> > static grub_uint8_t 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
> > };
>
> You can make this constant. Please fix the comment. Same for the
> contants below.
ok.
> > static int
> > grub_png_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) + grub_png_get_bits (data, 1);
> > if (code < ht->maxval[i])
> > return ht->values[code + ht->offset[i]];
> > }
> > return 0;
> > }
>
> Can this code above be shared with jpeg somehow?
although they're all huff code, but the handling is a bit different.
> > case PNG_FILTER_VALUE_PAETH:
>
> PAETH?
png spec use this too, it refers to Alan W. Paeth.
> > grub_png_get_dword (data); /* skip adler checksum */
> > grub_png_get_dword (data); /* skip crc checksum */
>
> adler?
also a name, Mark Adler.
* conf/i386-pc.rmk (pkglib_MODULES): Add `png.mod'.
(png_mod_SOURCES): New variable.
(png_mod_CFLAGS): Likewise.
(png_mod_LDFLAGS): Likewise.
* video/readers/png.c : New file.
diff --git a/conf/i386-pc.rmk b/conf/i386-pc.rmk
index 30f2f6b..4a91e20 100644
--- a/conf/i386-pc.rmk
+++ b/conf/i386-pc.rmk
@@ -139,7 +139,7 @@ pkglib_MODULES = biosdisk.mod _chain.mod
_linux.mod linux.mod normal.mod \
_multiboot.mod chain.mod multiboot.mod reboot.mod halt.mod \
vbe.mod vbetest.mod vbeinfo.mod video.mod gfxterm.mod \
videotest.mod play.mod bitmap.mod tga.mod cpuid.mod serial.mod \
- ata.mod vga.mod memdisk.mod jpeg.mod
+ ata.mod vga.mod memdisk.mod jpeg.mod png.mod
# For biosdisk.mod.
biosdisk_mod_SOURCES = disk/i386/pc/biosdisk.c
@@ -277,4 +277,9 @@ jpeg_mod_SOURCES = video/readers/jpeg.c
jpeg_mod_CFLAGS = $(COMMON_CFLAGS)
jpeg_mod_LDFLAGS = $(COMMON_LDFLAGS)
+# For png.mod.
+png_mod_SOURCES = video/readers/png.c
+png_mod_CFLAGS = $(COMMON_CFLAGS)
+png_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
include $(srcdir)/conf/common.mk
diff --git a/video/readers/png.c b/video/readers/png.c
new file mode 100755
index 0000000..03d5f0a
--- /dev/null
+++ b/video/readers/png.c
@@ -0,0 +1,811 @@
+/*
+ * 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>
+
+/* 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
+
+#define DEFLATE_HCLEN_BASE 4
+#define DEFLATE_HCLEN_MAX 19
+#define DEFLATE_HLIT_BASE 257
+#define DEFLATE_HLIT_MAX 286
+#define DEFLATE_HDIST_BASE 1
+#define DEFLATE_HDIST_MAX 30
+
+#define DEFLATE_HUFF_LEN 16
+
+struct huff_table
+{
+ int *values, *maxval, *offset;
+ int num_values, max_length;
+};
+
+struct grub_png_data
+{
+ grub_file_t file;
+ struct grub_video_bitmap **bitmap;
+
+ int bit_count, bit_save;
+
+ int image_width, image_height;
+
+ int bpp;
+
+ int inside_idat, idat_remain;
+
+ int code_values[DEFLATE_HLIT_MAX];
+ int code_maxval[DEFLATE_HUFF_LEN];
+ int code_offset[DEFLATE_HUFF_LEN];
+
+ int dist_values[DEFLATE_HDIST_MAX];
+ int dist_maxval[DEFLATE_HUFF_LEN];
+ int dist_offset[DEFLATE_HUFF_LEN];
+
+ 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
+grub_png_get_dword (struct grub_png_data *data)
+{
+ grub_uint32_t r;
+
+ r = 0;
+ grub_file_read (data->file, (char *) &r, sizeof (grub_uint32_t));
+
+ return grub_be_to_cpu32 (r);
+}
+
+static grub_uint8_t
+grub_png_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
+ {
+ /* Skip crc checksum. */
+ grub_png_get_dword (data);
+ len = grub_png_get_dword (data);
+ type = grub_png_get_dword (data);
+ if (type != CHUNK_IDAT)
+ {
+ grub_error (GRUB_ERR_BAD_FILE_TYPE,
+ "png: unexpected end of data");
+ return 0;
+ }
+ }
+ while (len == 0);
+ data->idat_remain = len;
+ }
+
+ r = 0;
+ grub_file_read (data->file, (char *) &r, 1);
+
+ if (data->inside_idat)
+ data->idat_remain--;
+
+ return r;
+}
+
+static int
+grub_png_get_bits (struct grub_png_data *data, int num)
+{
+ int code, shift;
+
+ if (data->bit_count == 0)
+ {
+ data->bit_save = grub_png_get_byte (data);
+ data->bit_count = 8;
+ }
+
+ code = 0;
+ shift = 0;
+ while (grub_errno == 0)
+ {
+ 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 = grub_png_get_byte (data);
+ data->bit_count = 8;
+ }
+
+ return code;
+}
+
+static grub_err_t
+grub_png_decode_image_header (struct grub_png_data *data)
+{
+ int color_type;
+
+ data->image_width = grub_png_get_dword (data);
+ data->image_height = grub_png_get_dword (data);
+
+ if ((!data->image_height) || (!data->image_width))
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: invalid image size");
+
+ if (grub_png_get_byte (data) != 8)
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: bit depth must be 8");
+
+ color_type = grub_png_get_byte (data);
+ if (color_type == PNG_COLOR_TYPE_RGB)
+ {
+ if (grub_video_bitmap_create (data->bitmap, data->image_width,
+ data->image_height,
+ GRUB_VIDEO_BLIT_FORMAT_R8G8B8))
+ return grub_errno;
+ data->bpp = 3;
+ }
+ else if (color_type == PNG_COLOR_TYPE_RGBA)
+ {
+ if (grub_video_bitmap_create (data->bitmap, data->image_width,
+ data->image_height,
+ GRUB_VIDEO_BLIT_FORMAT_R8G8B8A8))
+ return grub_errno;
+ data->bpp = 4;
+ }
+ else
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE,
+ "png: color type not supported");
+
+ data->cur_rgb = (*data->bitmap)->data;
+ data->cur_colume = 0;
+ data->first_line = 1;
+
+ if (grub_png_get_byte (data) != PNG_COMPRESSION_TYPE_BASE)
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE,
+ "png: compression method not supported");
+
+ if (grub_png_get_byte (data) != PNG_FILTER_TYPE_BASE)
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE,
+ "png: filter method not supported");
+
+ if (grub_png_get_byte (data) != PNG_INTERLACE_NONE)
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE,
+ "png: interlace method not supported");
+
+ /* Skip crc checksum. */
+ grub_png_get_dword (data);
+
+ return grub_errno;
+}
+
+/* Order of the bit length code lengths. */
+static const grub_uint8_t bitorder[] = {
+ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
+};
+
+/* Copy lengths for literal codes 257..285. */
+static const int cplens[] = {
+ 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
+};
+
+/* Extra bits for literal codes 257..285. */
+static const grub_uint8_t cplext[] = {
+ 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 */
+
+/* Copy offsets for distance codes 0..29. */
+static const int cpdist[] = {
+ 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
+};
+
+/* Extra bits for distance codes. */
+static const grub_uint8_t cpdext[] = {
+ 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
+grub_png_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
+grub_png_insert_huff_item (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");
+ return;
+ }
+
+ 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
+grub_png_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
+grub_png_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) + grub_png_get_bits (data, 1);
+ if (code < ht->maxval[i])
+ return ht->values[code + ht->offset[i]];
+ }
+ return 0;
+}
+
+static grub_err_t
+grub_png_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];
+ grub_uint8_t lens[DEFLATE_HCLEN_MAX];
+
+ nl = DEFLATE_HLIT_BASE + grub_png_get_bits (data, 5);
+ nd = DEFLATE_HDIST_BASE + grub_png_get_bits (data, 5);
+ nb = DEFLATE_HCLEN_BASE + grub_png_get_bits (data, 4);
+
+ if ((nl > DEFLATE_HLIT_MAX) || (nd > DEFLATE_HDIST_MAX) ||
+ (nb > DEFLATE_HCLEN_MAX))
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: too much data");
+
+ grub_png_init_huff_table (&cl, 8, cl_values, cl_maxval, cl_offset);
+
+ for (i = 0; i < nb; i++)
+ lens[bitorder[i]] = grub_png_get_bits (data, 3);
+
+ for (; i < DEFLATE_HCLEN_MAX; i++)
+ lens[bitorder[i]] = 0;
+
+ for (i = 0; i < DEFLATE_HCLEN_MAX; i++)
+ grub_png_insert_huff_item (&cl, i, lens[i]);
+
+ grub_png_build_huff_table (&cl);
+
+ grub_png_init_huff_table (&data->code_table, DEFLATE_HUFF_LEN,
+ data->code_values, data->code_maxval,
+ data->code_offset);
+
+ grub_png_init_huff_table (&data->dist_table, DEFLATE_HUFF_LEN,
+ 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 (grub_errno)
+ return grub_errno;
+
+ if (i < nl)
+ {
+ ht = &data->code_table;
+ code = i;
+ }
+ else
+ {
+ ht = &data->dist_table;
+ code = i - nl;
+ }
+
+ n = grub_png_get_huff_code (data, &cl);
+ if (n < 16)
+ {
+ grub_png_insert_huff_item (ht, code, n);
+ prev = n;
+ }
+ else if (n == 16)
+ {
+ int c;
+
+ c = 3 + grub_png_get_bits (data, 2);
+ while (c > 0)
+ {
+ grub_png_insert_huff_item (ht, code++, prev);
+ i++;
+ c--;
+ }
+ i--;
+ }
+ else if (n == 17)
+ i += 3 + grub_png_get_bits (data, 3) - 1;
+ else
+ i += 11 + grub_png_get_bits (data, 7) - 1;
+ }
+
+ grub_png_build_huff_table (&data->code_table);
+ grub_png_build_huff_table (&data->dist_table);
+
+ return grub_errno;
+}
+
+static grub_err_t
+grub_png_output_byte (struct grub_png_data *data, grub_uint8_t n)
+{
+ int row_bytes;
+
+ if (data->cur_colume == 0)
+ {
+ if (n >= PNG_FILTER_VALUE_LAST)
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE, "invalid filter value");
+
+ data->cur_filter = n;
+ }
+ else
+ *(data->cur_rgb++) = n;
+
+ data->cur_colume++;
+ row_bytes = data->image_width * data->bpp;
+ if (data->cur_colume == row_bytes + 1)
+ {
+ grub_uint8_t *blank_line = NULL;
+ grub_uint8_t *cur = data->cur_rgb - row_bytes;
+ grub_uint8_t *left = cur;
+ grub_uint8_t *up;
+
+ if (data->first_line)
+ {
+ blank_line = grub_malloc (row_bytes);
+ if (blank_line == NULL)
+ return grub_errno;
+
+ grub_memset (blank_line, 0, row_bytes);
+ up = blank_line;
+ }
+ else
+ up = cur - row_bytes;
+
+ switch (data->cur_filter)
+ {
+ case PNG_FILTER_VALUE_SUB:
+ {
+ int i;
+
+ cur += data->bpp;
+ for (i = data->bpp; i < row_bytes; i++)
+ *(cur++) += *(left++);
+
+ break;
+ }
+ case PNG_FILTER_VALUE_UP:
+ {
+ int i;
+
+ for (i = 0; i < row_bytes; i++)
+ *(cur++) += *(up++);
+
+ break;
+ }
+ case PNG_FILTER_VALUE_AVG:
+ {
+ int i;
+
+ for (i = 0; i < data->bpp; i++)
+ *(cur++) += *(up++) >> 1;
+
+ for (; i < row_bytes; i++)
+ *(cur++) += ((int) *(up++) + (int) *(left++)) >> 1;
+
+ break;
+ }
+ case PNG_FILTER_VALUE_PAETH:
+ {
+ int i;
+ grub_uint8_t *upper_left = up;
+
+ for (i = 0; i < data->bpp; i++)
+ *(cur++) += *(up++);
+
+ for (; i < row_bytes; i++)
+ {
+ int a, b, c, pa, pb, pc, p;
+
+ a = *(left++);
+ b = *(up++);
+ c = *(upper_left++);
+
+ p = b - c;
+ pc = a - c;
+
+ pa = p < 0 ? -p : p;
+ pb = pc < 0 ? -pc : pc;
+ pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+
+ p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;
+
+ *(cur++) += p;
+ }
+ }
+ }
+
+ if (blank_line)
+ grub_free (blank_line);
+
+ data->cur_colume = 0;
+ data->first_line = 0;
+ }
+
+ return grub_errno;
+}
+
+static grub_err_t
+grub_png_read_dynamic_block (struct grub_png_data *data)
+{
+ while (grub_errno == 0)
+ {
+ int n;
+
+ n = grub_png_get_huff_code (data, &data->code_table);
+ if (n < 256)
+ {
+ data->slide[data->wp] = n;
+ grub_png_output_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 += grub_png_get_bits (data, cplext[n]);
+
+ n = grub_png_get_huff_code (data, &data->dist_table);
+ dist = cpdist[n];
+ if (cpdext[n])
+ dist += grub_png_get_bits (data, cpdext[n]);
+
+ pos = data->wp - dist;
+ if (pos < 0)
+ pos += WSIZE;
+
+ while (len > 0)
+ {
+ data->slide[data->wp] = data->slide[pos];
+ grub_png_output_byte (data, data->slide[data->wp]);
+
+ data->wp++;
+ if (data->wp >= WSIZE)
+ data->wp = 0;
+
+ pos++;
+ if (pos >= WSIZE)
+ pos = 0;
+
+ len--;
+ }
+ }
+ }
+
+ return grub_errno;
+}
+
+static grub_err_t
+grub_png_decode_image_data (struct grub_png_data *data)
+{
+ grub_uint8_t cmf, flg;
+ int final;
+
+ cmf = grub_png_get_byte (data);
+ flg = grub_png_get_byte (data);
+
+ if ((cmf & 0xF) != Z_DEFLATED)
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE,
+ "png: only support deflate compression method");
+
+ if (flg & Z_FLAG_DICT)
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE,
+ "png: dictionary not supported");
+
+ do
+ {
+ int block_type;
+
+ final = grub_png_get_bits (data, 1);
+ block_type = grub_png_get_bits (data, 2);
+
+ switch (block_type)
+ {
+ case INFLATE_STORED:
+ {
+ grub_uint16_t i, len;
+
+ data->bit_count = 0;
+ len = grub_png_get_byte (data);
+ len += ((grub_uint16_t) grub_png_get_byte (data)) << 8;
+
+ grub_png_get_byte (data); /* skip NLEN field */
+ grub_png_get_byte (data);
+
+ for (i = 0; i < len; i++)
+ grub_png_output_byte (data, grub_png_get_byte (data));
+
+ break;
+ }
+
+ case INFLATE_FIXED:
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE,
+ "png: block type fixed not supported");
+
+ case INFLATE_DYNAMIC:
+ grub_png_init_dynamic_block (data);
+ grub_png_read_dynamic_block (data);
+ break;
+
+ default:
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE,
+ "png: unknown block type");
+ }
+ }
+ while ((!final) && (grub_errno == 0));
+
+ /* Skip adler checksum. */
+ grub_png_get_dword (data);
+
+ /* Skip crc checksum. */
+ grub_png_get_dword (data);
+
+ return grub_errno;
+}
+
+static const grub_uint8_t png_magic[8] =
+ { 0x89, 0x50, 0x4e, 0x47, 0xd, 0xa, 0x1a, 0x0a };
+
+static grub_err_t
+grub_png_decode_png (struct grub_png_data *data)
+{
+ grub_uint8_t magic[8];
+
+ if (grub_file_read (data->file, (char *) &magic[0], 8) != 8)
+ return grub_errno;
+
+ if (grub_memcmp (magic, png_magic, sizeof (png_magic)))
+ return grub_error (GRUB_ERR_BAD_FILE_TYPE, "png: not a png file");
+
+ while (grub_errno == 0)
+ {
+ grub_uint32_t len, type;
+
+ len = grub_png_get_dword (data);
+ type = grub_png_get_dword (data);
+
+ switch (type)
+ {
+ case CHUNK_IHDR:
+ grub_png_decode_image_header (data);
+ break;
+
+ case CHUNK_IDAT:
+ data->inside_idat = 1;
+ data->idat_remain = len;
+ data->bit_count = 0;
+
+ grub_png_decode_image_data (data);
+
+ data->inside_idat = 0;
+ break;
+
+ case CHUNK_IEND:
+ return grub_errno;
+
+ default:
+ grub_file_seek (data->file, data->file->offset + len + 4);
+ }
+ }
+
+ return grub_errno;
+}
+
+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;
+
+ grub_png_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
