grub-devel
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[PATCH] PNG image reader


From: Bean
Subject: [PATCH] PNG image reader
Date: Sat, 12 Jan 2008 07:14:38 +0800

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




reply via email to

[Prev in Thread] Current Thread [Next in Thread]