Re: [PATCH] PNG image reader

[Marco Gerards]

Bean <address@hidden> writes:

> On Jan 23, 2008 6:36 PM, Marco Gerards <address@hidden> 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.

It would better to do proper error handling.  This error is never
picked up...  How about:

static grub_err_t
grub_png_get_dword (struct grub_png_data *data,  grub_uint32_t *val)


>> 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.

perhaps :)

>> >   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.

I see

>> > 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.

Ok

>> >       case PNG_FILTER_VALUE_PAETH:
>>
>> PAETH?
>
> png spec use this too, it refers to Alan W. Paeth.

I see.

>> >   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.

The patch below seems mostly right.  Especially the error handling is
important to me.

> 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);

Error handling?

> +     }
> +    }
> +
> +  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
> address@hidden
> http://lists.gnu.org/mailman/listinfo/grub-devel