video/bitmap.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2006,2007  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/video.h>
  20 #include <grub/bitmap.h>
  21 #include <grub/types.h>
  22 #include <grub/dl.h>
  23 #include <grub/mm.h>
  24 #include <grub/misc.h>
  25
  26 /* List of bitmap readers registered to system.  */
  27 static grub_video_bitmap_reader_t bitmap_readers_list;
  28
  29 /* Register bitmap reader.  */
  30 void
  31 grub_video_bitmap_reader_register (grub_video_bitmap_reader_t reader)
  32 {
  33   reader->next = bitmap_readers_list;
  34   bitmap_readers_list = reader;
  35 }
  36
  37 /* Unregister bitmap reader.  */
  38 void
  39 grub_video_bitmap_reader_unregister (grub_video_bitmap_reader_t reader)
  40 {
  41   grub_video_bitmap_reader_t *p, q;
  42
  43   for (p = &bitmap_readers_list, q = *p; q; p = &(q->next), q = q->next)
  44     if (q == reader)
  45       {
  46         *p = q->next;
  47         break;
  48       }
  49 }
  50
  51 /* Creates new bitmap, saves created bitmap on success to *bitmap.  */
  52 grub_err_t
  53 grub_video_bitmap_create (struct grub_video_bitmap **bitmap,
  54                           unsigned int width, unsigned int height,
  55                           enum grub_video_blit_format blit_format)
  56 {
  57   struct grub_video_mode_info *mode_info;
  58   unsigned int size;
  59
  60   if (!bitmap)
  61     return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid argument.");
  62
  63   *bitmap = 0;
  64
  65   if (width == 0 || height == 0)
  66     return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid argument.");
  67
  68   *bitmap = (struct grub_video_bitmap *)grub_malloc (sizeof (struct grub_video_bitmap));
  69   if (! *bitmap)
  70     return grub_errno;
  71
  72   mode_info = &((*bitmap)->mode_info);
  73
  74   /* Populate mode_info.  */
  75   mode_info->width = width;
  76   mode_info->height = height;
  77   mode_info->blit_format = blit_format;
  78
  79   switch (blit_format)
  80     {
  81       case GRUB_VIDEO_BLIT_FORMAT_RGBA_8888:
  82         mode_info->mode_type = GRUB_VIDEO_MODE_TYPE_RGB
  83                                | GRUB_VIDEO_MODE_TYPE_ALPHA;
  84         mode_info->bpp = 32;
  85         mode_info->bytes_per_pixel = 4;
  86         mode_info->number_of_colors = 256;
  87         mode_info->red_mask_size = 8;
  88         mode_info->red_field_pos = 0;
  89         mode_info->green_mask_size = 8;
  90         mode_info->green_field_pos = 8;
  91         mode_info->blue_mask_size = 8;
  92         mode_info->blue_field_pos = 16;
  93         mode_info->reserved_mask_size = 8;
  94         mode_info->reserved_field_pos = 24;
  95         break;
  96
  97       case GRUB_VIDEO_BLIT_FORMAT_RGB_888:
  98         mode_info->mode_type = GRUB_VIDEO_MODE_TYPE_RGB;
  99         mode_info->bpp = 24;
 100         mode_info->bytes_per_pixel = 3;
 101         mode_info->number_of_colors = 256;
 102         mode_info->red_mask_size = 8;
 103         mode_info->red_field_pos = 0;
 104         mode_info->green_mask_size = 8;
 105         mode_info->green_field_pos = 8;
 106         mode_info->blue_mask_size = 8;
 107         mode_info->blue_field_pos = 16;
 108         mode_info->reserved_mask_size = 0;
 109         mode_info->reserved_field_pos = 0;
 110         break;
 111
 112       case GRUB_VIDEO_BLIT_FORMAT_INDEXCOLOR:
 113         mode_info->mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
 114         mode_info->bpp = 8;
 115         mode_info->bytes_per_pixel = 1;
 116         mode_info->number_of_colors = 256;
 117         mode_info->red_mask_size = 0;
 118         mode_info->red_field_pos = 0;
 119         mode_info->green_mask_size = 0;
 120         mode_info->green_field_pos = 0;
 121         mode_info->blue_mask_size = 0;
 122         mode_info->blue_field_pos = 0;
 123         mode_info->reserved_mask_size = 0;
 124         mode_info->reserved_field_pos = 0;
 125         break;
 126
 127       default:
 128         grub_free (*bitmap);
 129         *bitmap = 0;
 130
 131         return grub_error (GRUB_ERR_BAD_ARGUMENT,
 132                            "Unsupported bitmap format");
 133     }
 134
 135   mode_info->pitch = width * mode_info->bytes_per_pixel;
 136
 137   /* Calculate size needed for the data.  */
 138   size = (width * mode_info->bytes_per_pixel) * height;
 139
 140   (*bitmap)->data = grub_malloc (size);
 141   if (! (*bitmap)->data)
 142     {
 143       grub_free (*bitmap);
 144       *bitmap = 0;
 145
 146       return grub_errno;
 147     }
 148
 149   /* Clear bitmap.  */
 150   grub_memset ((*bitmap)->data, 0, size);
 151
 152   return GRUB_ERR_NONE;
 153 }
 154
 155 /* Frees all resources allocated by bitmap.  */
 156 grub_err_t
 157 grub_video_bitmap_destroy (struct grub_video_bitmap *bitmap)
 158 {
 159   if (! bitmap)
 160     return GRUB_ERR_NONE;
 161
 162   grub_free (bitmap->data);
 163   grub_free (bitmap);
 164
 165   return GRUB_ERR_NONE;
 166 }
 167
 168 /* Match extension to filename.  */
 169 static int
 170 match_extension (const char *filename, const char *ext)
 171 {
 172   int pos;
 173   int ext_len;
 174
 175   pos = grub_strlen (filename);
 176   ext_len = grub_strlen (ext);
 177
 178   if (! pos || ! ext_len || ext_len > pos)
 179     return 0;
 180
 181   pos -= ext_len;
 182
 183   return grub_strcmp (filename + pos, ext) == 0;
 184 }
 185
 186 /* Loads bitmap using registered bitmap readers.  */
 187 grub_err_t
 188 grub_video_bitmap_load (struct grub_video_bitmap **bitmap,
 189                         const char *filename)
 190 {
 191   grub_video_bitmap_reader_t reader = bitmap_readers_list;
 192
 193   if (!bitmap)
 194     return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid argument.");
 195
 196   *bitmap = 0;
 197
 198   while (reader)
 199     {
 200       if (match_extension (filename, reader->extension))
 201         return reader->reader (bitmap, filename);
 202
 203       reader = reader->next;
 204     }
 205
 206   return grub_error(GRUB_ERR_BAD_FILE_TYPE, "unsupported bitmap format");
 207 }
 208
 209 /* Return bitmap width.  */
 210 unsigned int
 211 grub_video_bitmap_get_width (struct grub_video_bitmap *bitmap)
 212 {
 213   if (!bitmap)
 214     return 0;
 215
 216   return bitmap->mode_info.width;
 217 }
 218
 219 /* Return bitmap height.  */
 220 unsigned int
 221 grub_video_bitmap_get_height (struct grub_video_bitmap *bitmap)
 222 {
 223   if (!bitmap)
 224     return 0;
 225
 226   return bitmap->mode_info.height;
 227 }
 228
 229 /* Return mode info for bitmap.  */
 230 void grub_video_bitmap_get_mode_info (struct grub_video_bitmap *bitmap,
 231                                       struct grub_video_mode_info *mode_info)
 232 {
 233   if (!bitmap)
 234     return;
 235
 236   *mode_info = bitmap->mode_info;
 237 }
 238
 239 /* Return pointer to bitmap's raw data.  */
 240 void *grub_video_bitmap_get_data (struct grub_video_bitmap *bitmap)
 241 {
 242   if (!bitmap)
 243     return 0;
 244
 245   return bitmap->data;
 246 }
 247
 248 /* Initialize bitmap module.  */
 249 GRUB_MOD_INIT(video_bitmap)
 250 {
 251 }
 252
 253 /* Finalize bitmap module.  */
 254 GRUB_MOD_FINI(video_bitmap)
 255 {
 256 }