sim/bfin/gui.c

   1 /* Blackfin GUI (SDL) helper code
   2
   3    Copyright (C) 2010-2019 Free Software Foundation, Inc.
   4    Contributed by Analog Devices, Inc.
   5
   6    This file is part of simulators.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22
  23 #ifdef HAVE_SDL
  24 # include <SDL.h>
  25 #endif
  26 #ifdef HAVE_DLFCN_H
  27 # include <dlfcn.h>
  28 #endif
  29
  30 #include "libiberty.h"
  31 #include "gui.h"
  32
  33 #ifdef HAVE_SDL
  34
  35 static struct {
  36   void *handle;
  37   int (*Init) (Uint32 flags);
  38   void (*Quit) (void);
  39   SDL_Surface *(*SetVideoMode) (int width, int height, int bpp, Uint32 flags);
  40   void (*WM_SetCaption) (const char *title, const char *icon);
  41   int (*ShowCursor) (int toggle);
  42   int (*LockSurface) (SDL_Surface *surface);
  43   void (*UnlockSurface) (SDL_Surface *surface);
  44   void (*GetRGB) (Uint32 pixel, const SDL_PixelFormat * const fmt, Uint8 *r, Uint8 *g, Uint8 *b);
  45   Uint32 (*MapRGB) (const SDL_PixelFormat * const format, const Uint8 r, const Uint8 g, const Uint8 b);
  46   void (*UpdateRect) (SDL_Surface *screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h);
  47 } sdl;
  48
  49 static const char * const sdl_syms[] =
  50 {
  51   "SDL_Init",
  52   "SDL_Quit",
  53   "SDL_SetVideoMode",
  54   "SDL_WM_SetCaption",
  55   "SDL_ShowCursor",
  56   "SDL_LockSurface",
  57   "SDL_UnlockSurface",
  58   "SDL_GetRGB",
  59   "SDL_MapRGB",
  60   "SDL_UpdateRect",
  61 };
  62
  63 struct gui_state {
  64   SDL_Surface *screen;
  65   const SDL_PixelFormat *format;
  66   int throttle, throttle_limit;
  67   enum gui_color color;
  68   int curr_line;
  69 };
  70
  71 /* Load the SDL lib on the fly to avoid hard linking against it.  */
  72 static int
  73 bfin_gui_sdl_setup (void)
  74 {
  75   int i;
  76   uintptr_t **funcs;
  77
  78   if (sdl.handle)
  79     return 0;
  80
  81   sdl.handle = dlopen ("libSDL-1.2.so.0", RTLD_LAZY);
  82   if (sdl.handle == NULL)
  83     return -1;
  84
  85   funcs = (void *) &sdl.Init;
  86   for (i = 0; i < ARRAY_SIZE (sdl_syms); ++i)
  87     {
  88       funcs[i] = dlsym (sdl.handle, sdl_syms[i]);
  89       if (funcs[i] == NULL)
  90         {
  91           dlclose (sdl.handle);
  92           sdl.handle = NULL;
  93           return -1;
  94         }
  95     }
  96
  97   return 0;
  98 }
  99
 100 static const SDL_PixelFormat *bfin_gui_color_format (enum gui_color color);
 101
 102 void *
 103 bfin_gui_setup (void *state, int enabled, int width, int height,
 104                 enum gui_color color)
 105 {
 106   if (bfin_gui_sdl_setup ())
 107     return NULL;
 108
 109   /* Create an SDL window if enabled and we don't have one yet.  */
 110   if (enabled && !state)
 111     {
 112       struct gui_state *gui = xmalloc (sizeof (*gui));
 113       if (!gui)
 114         return NULL;
 115
 116       if (sdl.Init (SDL_INIT_VIDEO))
 117         goto error;
 118
 119       gui->color = color;
 120       gui->format = bfin_gui_color_format (gui->color);
 121       gui->screen = sdl.SetVideoMode (width, height, 32,
 122                                       SDL_ANYFORMAT|SDL_HWSURFACE);
 123       if (!gui->screen)
 124         {
 125           sdl.Quit();
 126           goto error;
 127         }
 128
 129       sdl.WM_SetCaption ("GDB Blackfin Simulator", NULL);
 130       sdl.ShowCursor (0);
 131       gui->curr_line = 0;
 132       gui->throttle = 0;
 133       gui->throttle_limit = 0xf; /* XXX: let people control this ?  */
 134       return gui;
 135
 136  error:
 137       free (gui);
 138       return NULL;
 139     }
 140
 141   /* Else break down a window if disabled and we had one.  */
 142   else if (!enabled && state)
 143     {
 144       sdl.Quit();
 145       free (state);
 146       return NULL;
 147     }
 148
 149   /* Retain existing state, whatever that may be.  */
 150   return state;
 151 }
 152
 153 static int
 154 SDL_ConvertBlitLineFrom (const Uint8 *src, const SDL_PixelFormat * const format,
 155                          SDL_Surface *dst, int dsty)
 156 {
 157   Uint8 r, g, b;
 158   Uint32 *pixels;
 159   unsigned i, j;
 160
 161   if (SDL_MUSTLOCK (dst))
 162     if (sdl.LockSurface (dst))
 163       return 1;
 164
 165   pixels = dst->pixels;
 166   pixels += (dsty * dst->pitch / 4);
 167
 168   for (i = 0; i < dst->w; ++i)
 169     {
 170       /* Exract the packed source pixel; RGB or BGR.  */
 171       Uint32 pix = 0;
 172       for (j = 0; j < format->BytesPerPixel; ++j)
 173         if (format->Rshift)
 174           pix = (pix << 8) | src[j];
 175         else
 176           pix = pix | ((Uint32)src[j] << (j * 8));
 177
 178       /* Unpack the source pixel into its components.  */
 179       sdl.GetRGB (pix, format, &r, &g, &b);
 180       /* Translate into the screen pixel format.  */
 181       *pixels++ = sdl.MapRGB (dst->format, r, g, b);
 182
 183       src += format->BytesPerPixel;
 184     }
 185
 186   if (SDL_MUSTLOCK (dst))
 187     sdl.UnlockSurface (dst);
 188
 189   sdl.UpdateRect (dst, 0, dsty, dst->w, 1);
 190
 191   return 0;
 192 }
 193
 194 unsigned
 195 bfin_gui_update (void *state, const void *source, unsigned nr_bytes)
 196 {
 197   struct gui_state *gui = state;
 198   int ret;
 199
 200   if (!gui)
 201     return 0;
 202
 203   /* XXX: Make this an option ?  */
 204   gui->throttle = (gui->throttle + 1) & gui->throttle_limit;
 205   if (gui->throttle)
 206     return 0;
 207
 208   ret = SDL_ConvertBlitLineFrom (source, gui->format, gui->screen,
 209                                  gui->curr_line);
 210   if (ret)
 211     return 0;
 212
 213   gui->curr_line = (gui->curr_line + 1) % gui->screen->h;
 214
 215   return nr_bytes;
 216 }
 217
 218 #define FMASK(cnt, shift) (((1 << (cnt)) - 1) << (shift))
 219 #define _FORMAT(bpp, rcnt, gcnt, bcnt, acnt, rsh, gsh, bsh, ash) \
 220   NULL, bpp, (bpp)/8, 8-(rcnt), 8-(gcnt), 8-(bcnt), 8-(acnt), rsh, gsh, bsh, ash, \
 221   FMASK (rcnt, rsh), FMASK (gcnt, gsh), FMASK (bcnt, bsh), FMASK (acnt, ash),
 222 #define FORMAT(rcnt, gcnt, bcnt, acnt, rsh, gsh, bsh, ash) \
 223   _FORMAT(((((rcnt) + (gcnt) + (bcnt) + (acnt)) + 7) / 8) * 8, \
 224           rcnt, gcnt, bcnt, acnt, rsh, gsh, bsh, ash)
 225
 226 static const SDL_PixelFormat sdl_rgb_565 =
 227 {
 228   FORMAT (5, 6, 5, 0, 11, 5, 0, 0)
 229 };
 230 static const SDL_PixelFormat sdl_bgr_565 =
 231 {
 232   FORMAT (5, 6, 5, 0, 0, 5, 11, 0)
 233 };
 234 static const SDL_PixelFormat sdl_rgb_888 =
 235 {
 236   FORMAT (8, 8, 8, 0, 16, 8, 0, 0)
 237 };
 238 static const SDL_PixelFormat sdl_bgr_888 =
 239 {
 240   FORMAT (8, 8, 8, 0, 0, 8, 16, 0)
 241 };
 242 static const SDL_PixelFormat sdl_rgba_8888 =
 243 {
 244   FORMAT (8, 8, 8, 8, 24, 16, 8, 0)
 245 };
 246
 247 static const struct {
 248   const char *name;
 249   const SDL_PixelFormat *format;
 250   enum gui_color color;
 251 } color_spaces[] = {
 252   { "rgb565",   &sdl_rgb_565,   GUI_COLOR_RGB_565,   },
 253   { "bgr565",   &sdl_bgr_565,   GUI_COLOR_BGR_565,   },
 254   { "rgb888",   &sdl_rgb_888,   GUI_COLOR_RGB_888,   },
 255   { "bgr888",   &sdl_bgr_888,   GUI_COLOR_BGR_888,   },
 256   { "rgba8888", &sdl_rgba_8888, GUI_COLOR_RGBA_8888, },
 257 };
 258
 259 enum gui_color bfin_gui_color (const char *color)
 260 {
 261   int i;
 262
 263   if (!color)
 264     goto def;
 265
 266   for (i = 0; i < ARRAY_SIZE (color_spaces); ++i)
 267     if (!strcmp (color, color_spaces[i].name))
 268       return color_spaces[i].color;
 269
 270   /* Pick a random default.  */
 271  def:
 272   return GUI_COLOR_RGB_888;
 273 }
 274
 275 static const SDL_PixelFormat *bfin_gui_color_format (enum gui_color color)
 276 {
 277   int i;
 278
 279   for (i = 0; i < ARRAY_SIZE (color_spaces); ++i)
 280     if (color == color_spaces[i].color)
 281       return color_spaces[i].format;
 282
 283   return NULL;
 284 }
 285
 286 int bfin_gui_color_depth (enum gui_color color)
 287 {
 288   const SDL_PixelFormat *format = bfin_gui_color_format (color);
 289   return format ? format->BitsPerPixel : 0;
 290 }
 291
 292 #endif