util/sdl.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2005,2006,2007,2008,2009  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 #define grub_video_render_target grub_video_fbrender_target
  20
  21 #include <grub/err.h>
  22 #include <grub/types.h>
  23 #include <grub/dl.h>
  24 #include <grub/misc.h>
  25 #include <grub/mm.h>
  26 #include <grub/video.h>
  27 #include <grub/video_fb.h>
  28 #include <SDL/SDL.h>
  29
  30 static SDL_Surface *window = 0;
  31 static struct grub_video_render_target sdl_render_target;
  32
  33 static grub_err_t
  34 grub_video_sdl_set_palette (unsigned int start, unsigned int count,
  35                             struct grub_video_palette_data *palette_data);
  36
  37 static grub_err_t
  38 grub_video_sdl_init (void)
  39 {
  40   window = 0;
  41   grub_memset (&sdl_render_target, 0, sizeof(sdl_render_target));
  42
  43   if (SDL_Init (SDL_INIT_VIDEO) < 0)
  44     return grub_error (GRUB_ERR_BAD_DEVICE, "Couldn't init SDL: %s",
  45                        SDL_GetError ());
  46   /* Reset frame buffer and render target variables.  */
  47   grub_memset (&sdl_render_target, 0, sizeof(sdl_render_target));
  48   return grub_video_fb_init ();
  49 }
  50
  51 static grub_err_t
  52 grub_video_sdl_fini (void)
  53 {
  54   SDL_Quit ();
  55   window = 0;
  56   grub_memset (&sdl_render_target, 0, sizeof(sdl_render_target));
  57
  58   return grub_video_fb_fini ();
  59 }
  60
  61 static inline unsigned int
  62 get_mask_size (grub_uint32_t mask)
  63 {
  64   unsigned i;
  65   for (i = 0; mask > 1U << i; i++);
  66   return i;
  67 }
  68
  69 static grub_err_t
  70 grub_video_sdl_setup (unsigned int width, unsigned int height,
  71                       unsigned int mode_type)
  72 {
  73   int depth;
  74   int flags = 0;
  75   /* Decode depth from mode_type.  If it is zero, then autodetect.  */
  76   depth = (mode_type & GRUB_VIDEO_MODE_TYPE_DEPTH_MASK)
  77           >> GRUB_VIDEO_MODE_TYPE_DEPTH_POS;
  78
  79   if (mode_type & GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED)
  80     flags |= SDL_DOUBLEBUF;
  81
  82   window = SDL_SetVideoMode (width, height, depth, flags | SDL_HWSURFACE);
  83   if (! window)
  84     window = SDL_SetVideoMode (width, height, depth, flags | SDL_SWSURFACE);
  85   if (! window)
  86     return grub_error (GRUB_ERR_BAD_DEVICE, "Couldn't open window: %s",
  87                        SDL_GetError ());
  88
  89   grub_memset (&sdl_render_target, 0, sizeof (sdl_render_target));
  90
  91   sdl_render_target.mode_info.width = window->w;
  92   sdl_render_target.mode_info.height = window->h;
  93   sdl_render_target.mode_info.mode_type = 0;
  94   if (window->flags & SDL_DOUBLEBUF)
  95     sdl_render_target.mode_info.mode_type
  96       |= GRUB_VIDEO_MODE_TYPE_DOUBLE_BUFFERED;
  97   if (window->format->palette)
  98     sdl_render_target.mode_info.mode_type |= GRUB_VIDEO_MODE_TYPE_INDEX_COLOR;
  99   else
 100     sdl_render_target.mode_info.mode_type |= GRUB_VIDEO_MODE_TYPE_RGB;
 101
 102   sdl_render_target.mode_info.bpp = window->format->BitsPerPixel;
 103   sdl_render_target.mode_info.bytes_per_pixel = window->format->BytesPerPixel;
 104   sdl_render_target.mode_info.pitch = window->pitch;
 105
 106   /* In index color mode, number of colors.  In RGB mode this is 256.  */
 107   if (window->format->palette)
 108     sdl_render_target.mode_info.number_of_colors
 109       = 1 << window->format->BitsPerPixel;
 110   else
 111     sdl_render_target.mode_info.number_of_colors = 256;
 112
 113   if (! window->format->palette)
 114     {
 115       sdl_render_target.mode_info.red_mask_size
 116         = get_mask_size (window->format->Rmask >> window->format->Rshift);
 117       sdl_render_target.mode_info.red_field_pos = window->format->Rshift;
 118       sdl_render_target.mode_info.green_mask_size
 119         = get_mask_size (window->format->Gmask >> window->format->Gshift);
 120       sdl_render_target.mode_info.green_field_pos = window->format->Gshift;
 121       sdl_render_target.mode_info.blue_mask_size
 122         = get_mask_size (window->format->Bmask >> window->format->Bshift);
 123       sdl_render_target.mode_info.blue_field_pos = window->format->Bshift;
 124       sdl_render_target.mode_info.reserved_mask_size
 125         = get_mask_size (window->format->Amask >> window->format->Ashift);
 126       sdl_render_target.mode_info.reserved_field_pos = window->format->Ashift;
 127       sdl_render_target.mode_info.blit_format
 128         = grub_video_get_blit_format (&sdl_render_target.mode_info);
 129     }
 130
 131   sdl_render_target.viewport.x = sdl_render_target.viewport.y = 0;
 132   sdl_render_target.viewport.width = window->w;
 133   sdl_render_target.viewport.height = window->h;
 134   sdl_render_target.is_allocated = 0;
 135   sdl_render_target.data = window->pixels;
 136
 137   /* Copy default palette to initialize emulated palette.  */
 138   grub_video_sdl_set_palette (0, (sizeof (grub_video_fbstd_colors)
 139                                   / sizeof (grub_video_fbstd_colors[0])),
 140                               grub_video_fbstd_colors);
 141
 142   /* Reset render target to SDL one.  */
 143   return grub_video_fb_set_active_render_target (&sdl_render_target);
 144 }
 145
 146 static grub_err_t
 147 grub_video_sdl_set_palette (unsigned int start, unsigned int count,
 148                             struct grub_video_palette_data *palette_data)
 149 {
 150   unsigned i;
 151   if (window->format->palette)
 152     {
 153       SDL_Color *tmp = grub_malloc (count * sizeof (tmp[0]));
 154       for (i = 0; i < count; i++)
 155         {
 156           tmp[i].r = palette_data[i].r;
 157           tmp[i].g = palette_data[i].g;
 158           tmp[i].b = palette_data[i].b;
 159           tmp[i].unused = palette_data[i].a;
 160         }
 161       SDL_SetColors (window, tmp, start, count);
 162       grub_free (tmp);
 163     }
 164
 165   return grub_video_fb_set_palette (start, count, palette_data);
 166 }
 167
 168 grub_err_t
 169 grub_video_sdl_set_viewport (unsigned int x, unsigned int y,
 170                              unsigned int width, unsigned int height)
 171 {
 172   /* Make sure viewport is withing screen dimensions.  If viewport was set
 173      to be out of the region, mark its size as zero.  */
 174   if (x > (unsigned) window->w)
 175     {
 176       x = 0;
 177       width = 0;
 178     }
 179
 180   if (y > (unsigned) window->h)
 181     {
 182       y = 0;
 183       height = 0;
 184     }
 185
 186   if (x + width > (unsigned) window->w)
 187     width = window->w - x;
 188
 189   if (y + height > (unsigned) window->h)
 190     height = window->h - y;
 191   return grub_video_fb_set_viewport (x, y, width, height);
 192 }
 193
 194 static grub_err_t
 195 grub_video_sdl_swap_buffers (void)
 196 {
 197   if (SDL_Flip (window) < 0)
 198     return grub_error (GRUB_ERR_BAD_DEVICE, "couldn't swap buffers: %s",
 199                        SDL_GetError ());
 200   return GRUB_ERR_NONE;
 201 }
 202
 203 static grub_err_t
 204 grub_video_sdl_set_active_render_target (struct grub_video_render_target *target)
 205 {
 206   if (target == GRUB_VIDEO_RENDER_TARGET_DISPLAY)
 207     return grub_video_fb_set_active_render_target (&sdl_render_target);
 208
 209   return grub_video_fb_set_active_render_target (target);
 210 }
 211
 212 static grub_err_t grub_video_sdl_enable_double_buffering (int enable)
 213 {
 214   return GRUB_ERR_NONE;
 215 }
 216
 217 static struct grub_video_adapter grub_video_sdl_adapter =
 218   {
 219     .name = "SDL Video Driver",
 220
 221     .init = grub_video_sdl_init,
 222     .fini = grub_video_sdl_fini,
 223     .setup = grub_video_sdl_setup,
 224     .get_info = grub_video_fb_get_info,
 225     .set_palette = grub_video_sdl_set_palette,
 226     .get_palette = grub_video_fb_get_palette,
 227     .set_viewport = grub_video_fb_set_viewport,
 228     .get_viewport = grub_video_fb_get_viewport,
 229     .map_color = grub_video_fb_map_color,
 230     .map_rgb = grub_video_fb_map_rgb,
 231     .map_rgba = grub_video_fb_map_rgba,
 232     .unmap_color = grub_video_fb_unmap_color,
 233     .fill_rect = grub_video_fb_fill_rect,
 234     .blit_bitmap = grub_video_fb_blit_bitmap,
 235     .blit_render_target = grub_video_fb_blit_render_target,
 236     .scroll = grub_video_fb_scroll,
 237     .swap_buffers = grub_video_sdl_swap_buffers,
 238     .create_render_target = grub_video_fb_create_render_target,
 239     .delete_render_target = grub_video_fb_delete_render_target,
 240     .set_active_render_target = grub_video_sdl_set_active_render_target,
 241     .get_active_render_target = grub_video_fb_get_active_render_target,
 242     .enable_double_buffering = grub_video_sdl_enable_double_buffering,
 243     .next = 0
 244   };
 245
 246 GRUB_MOD_INIT(sdl)
 247 {
 248   grub_video_register (&grub_video_sdl_adapter);
 249 }
 250
 251 GRUB_MOD_FINI(sdl)
 252 {
 253   grub_video_unregister (&grub_video_sdl_adapter);
 254 }