libs/backends/GP_SDL.c

   1 /*****************************************************************************
   2  * This file is part of gfxprim library.                                     *
   3  *                                                                           *
   4  * Gfxprim is free software; you can redistribute it and/or                  *
   5  * modify it under the terms of the GNU Lesser General Public                *
   6  * License as published by the Free Software Foundation; either              *
   7  * version 2.1 of the License, or (at your option) any later version.        *
   8  *                                                                           *
   9  * Gfxprim is distributed in the hope that it will be useful,                *
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  12  * Lesser General Public License for more details.                           *
  13  *                                                                           *
  14  * You should have received a copy of the GNU Lesser General Public          *
  15  * License along with gfxprim; if not, write to the Free Software            *
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor,                        *
  17  * Boston, MA  02110-1301  USA                                               *
  18  *                                                                           *
  19  * Copyright (C) 2009-2010 Jiri "BlueBear" Dluhos                            *
  20  *                         <jiri.bluebear.dluhos@gmail.com>                  *
  21  *                                                                           *
  22  * Copyright (C) 2009-2012 Cyril Hrubis <metan@ucw.cz>                       *
  23  *                                                                           *
  24  *****************************************************************************/
  25
  26 #include "../../config.h"
  27
  28 #ifdef HAVE_LIBSDL
  29
  30 #include "core/GP_Debug.h"
  31 #include "input/GP_InputDriverSDL.h"
  32 #include "GP_Backend.h"
  33 #include "GP_SDL.h"
  34
  35 #include <SDL/SDL.h>
  36 #include <SDL/SDL_mutex.h>
  37
  38 static SDL_Surface *sdl_surface;
  39 static SDL_mutex *mutex;
  40 static GP_Context context;
  41
  42 static uint32_t sdl_flags = SDL_SWSURFACE;
  43
  44 /* Backend API funcitons */
  45
  46 static void sdl_flip(struct GP_Backend *self __attribute__((unused)))
  47 {
  48         SDL_mutexP(mutex);
  49
  50         SDL_Flip(sdl_surface);
  51         context.pixels = sdl_surface->pixels;
  52
  53         SDL_mutexV(mutex);
  54 }
  55
  56 static void sdl_update_rect(struct GP_Backend *self __attribute__((unused)),
  57                             GP_Coord x0, GP_Coord y0, GP_Coord x1, GP_Coord y1)
  58 {
  59         SDL_mutexP(mutex);
  60
  61         /*
  62          * SDL_UpdateRect() with all x0, y0, x1 and y1 zero updates whole
  63          * screen we avoid such behavior as it will break other backends.
  64          */
  65         if (x1 != 0 && y1 != 0)
  66                 SDL_UpdateRect(sdl_surface, x0, y0,
  67                                GP_ABS(x1 - x0) + 1, GP_ABS(y1 - y0) + 1);
  68
  69         SDL_mutexV(mutex);
  70 }
  71
  72 static void sdl_poll(struct GP_Backend *self __attribute__((unused)))
  73 {
  74         SDL_Event ev;
  75
  76         SDL_mutexP(mutex);
  77
  78         while (SDL_PollEvent(&ev))
  79                 GP_InputDriverSDLEventPut(&ev);
  80
  81         SDL_mutexV(mutex);
  82 }
  83
  84 int context_from_surface(GP_Context *context, SDL_Surface *surf)
  85 {
  86         /* sanity checks on the SDL surface */
  87         if (surf->format->BytesPerPixel == 0) {
  88                 GP_DEBUG(1, "ERROR: Surface->BytesPerPixel == 0");
  89                 return 1;
  90         }
  91
  92         if (surf->format->BytesPerPixel > 4) {
  93                 GP_DEBUG(1, "ERROR: Surface->BytesPerPixel > 4");
  94                 return 1;
  95         }
  96
  97         enum GP_PixelType pixeltype = GP_PixelRGBMatch(surf->format->Rmask,
  98                                                        surf->format->Gmask,
  99                                                        surf->format->Bmask,
 100                                                        surf->format->Ashift,
 101                                                        surf->format->BitsPerPixel);
 102
 103         if (pixeltype == GP_PIXEL_UNKNOWN)
 104                 return 1;
 105
 106         /* basic structure and size */
 107         context->pixels = surf->pixels;
 108         context->bpp = 8 * surf->format->BytesPerPixel;
 109         context->pixel_type = pixeltype;
 110         context->bytes_per_row = surf->pitch;
 111         context->w = surf->w;
 112         context->h = surf->h;
 113
 114         return 0;
 115 }
 116
 117 static int sdl_set_attributes(struct GP_Backend *self __attribute__((unused)),
 118                               uint32_t w, uint32_t h,
 119                               const char *caption)
 120 {
 121         SDL_mutexP(mutex);
 122
 123         if (caption != NULL)
 124                 SDL_WM_SetCaption(caption, caption);
 125
 126         if (w != 0 && h != 0) {
 127                 sdl_surface = SDL_SetVideoMode(w, h, 0, sdl_flags);
 128                 context_from_surface(&context, sdl_surface);
 129         }
 130
 131         SDL_mutexV(mutex);
 132
 133         return 0;
 134 }
 135
 136 static void sdl_exit(struct GP_Backend *self __attribute__((unused)));
 137
 138 static struct GP_Backend backend = {
 139         .name          = "SDL",
 140         .context       = NULL,
 141         .Flip          = sdl_flip,
 142         .UpdateRect    = sdl_update_rect,
 143         .SetAttributes = sdl_set_attributes,
 144         .Exit          = sdl_exit,
 145         .fd_list       = NULL,
 146         .Poll          = sdl_poll,
 147 };
 148
 149 static void sdl_exit(struct GP_Backend *self __attribute__((unused)))
 150 {
 151         SDL_mutexP(mutex);
 152
 153         SDL_Quit();
 154
 155         SDL_DestroyMutex(mutex);
 156
 157         backend.context = NULL;
 158 }
 159
 160 GP_Backend *GP_BackendSDLInit(GP_Size w, GP_Size h, uint8_t bpp, uint8_t flags,
 161                               const char *caption)
 162 {
 163         /* SDL not yet initalized */
 164         if (backend.context == NULL) {
 165                 if (SDL_Init(SDL_INIT_VIDEO)) {
 166                         GP_DEBUG(1, "ERROR: SDL_Init: %s", SDL_GetError());
 167                         return NULL;
 168                 }
 169
 170                 if (flags & GP_SDL_FULLSCREEN)
 171                         sdl_flags |= SDL_FULLSCREEN;
 172
 173                 if (flags & GP_SDL_RESIZABLE)
 174                         sdl_flags |= SDL_RESIZABLE;
 175
 176                 sdl_surface = SDL_SetVideoMode(w, h, bpp, sdl_flags);
 177
 178                 if (caption != NULL)
 179                         SDL_WM_SetCaption(caption, caption);
 180
 181                 if (sdl_surface == NULL) {
 182                         GP_DEBUG(1, "ERROR: SDL_SetVideoMode: %s", SDL_GetError());
 183                         SDL_Quit();
 184                         return NULL;
 185                 }
 186
 187                 mutex = SDL_CreateMutex();
 188
 189                 if (context_from_surface(&context, sdl_surface)) {
 190                         GP_DEBUG(1, "ERROR: Failed to match pixel_type");
 191                         SDL_Quit();
 192                         return NULL;
 193                 }
 194
 195                 backend.context = &context;
 196         }
 197
 198         return &backend;
 199 }
 200
 201 #else
 202
 203 #include "GP_Backend.h"
 204
 205 GP_Backend *GP_BackendSDLInit(GP_Size w __attribute__((unused)),
 206                               GP_Size h __attribute__((unused)),
 207                               uint8_t bpp __attribute__((unused)),
 208                               uint8_t flags __attribute__((unused)),
 209                               const char *caption __attribute__((unused)))
 210 {
 211         return NULL;
 212 }
 213
 214 #endif /* HAVE_LIBSDL */