src/video/qnxgf/SDL_gf_render.c
author Sam Lantinga <slouken@libsdl.org>
Sun, 12 Dec 2010 15:19:05 -0800
changeset 4929 aa8888658021
parent 3697 f7b03b6838cb
child 5138 da10636e5eca
permissions -rw-r--r--
Use the enumerated type for blend and scale mode instead of int
Renamed SDL_TextureScaleMode to SDL_ScaleMode
     1 /*
     2     SDL - Simple DirectMedia Layer
     3     Copyright (C) 1997-2010 Sam Lantinga
     4 
     5     This library is free software; you can redistribute it and/or
     6     modify it under the terms of the GNU Lesser General Public
     7     License as published by the Free Software Foundation; either
     8     version 2.1 of the License, or (at your option) any later version.
     9 
    10     This library 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 GNU
    13     Lesser General Public License for more details.
    14 
    15     You should have received a copy of the GNU Lesser General Public
    16     License along with this library; if not, write to the Free Software
    17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    18 
    19     Sam Lantinga
    20     slouken@libsdl.org
    21 
    22     QNX Graphics Framework SDL driver
    23     Copyright (C) 2009 Mike Gorchak
    24     (mike@malva.ua, lestat@i.com.ua)
    25 */
    26 
    27 #include "SDL_config.h"
    28 
    29 #include "../SDL_pixels_c.h"
    30 #include "../SDL_yuv_sw_c.h"
    31 
    32 #include "SDL_video.h"
    33 
    34 #include "SDL_gf_render.h"
    35 #include "SDL_qnxgf.h"
    36 
    37 static SDL_Renderer *gf_createrenderer(SDL_Window * window, Uint32 flags);
    38 static int gf_displaymodechanged(SDL_Renderer * renderer);
    39 static int gf_activaterenderer(SDL_Renderer * renderer);
    40 static int gf_createtexture(SDL_Renderer * renderer, SDL_Texture * texture);
    41 static int gf_querytexturepixels(SDL_Renderer * renderer,
    42                                  SDL_Texture * texture, void **pixels,
    43                                  int *pitch);
    44 static int gf_settexturepalette(SDL_Renderer * renderer,
    45                                 SDL_Texture * texture,
    46                                 const SDL_Color * colors, int firstcolor,
    47                                 int ncolors);
    48 static int gf_gettexturepalette(SDL_Renderer * renderer,
    49                                 SDL_Texture * texture, SDL_Color * colors,
    50                                 int firstcolor, int ncolors);
    51 static int gf_settexturecolormod(SDL_Renderer * renderer,
    52                                  SDL_Texture * texture);
    53 static int gf_settexturealphamod(SDL_Renderer * renderer,
    54                                  SDL_Texture * texture);
    55 static int gf_settextureblendmode(SDL_Renderer * renderer,
    56                                   SDL_Texture * texture);
    57 static int gf_settexturescalemode(SDL_Renderer * renderer,
    58                                   SDL_Texture * texture);
    59 static int gf_updatetexture(SDL_Renderer * renderer, SDL_Texture * texture,
    60                             const SDL_Rect * rect, const void *pixels,
    61                             int pitch);
    62 static int gf_locktexture(SDL_Renderer * renderer, SDL_Texture * texture,
    63                           const SDL_Rect * rect, int markDirty, void **pixels,
    64                           int *pitch);
    65 static void gf_unlocktexture(SDL_Renderer * renderer, SDL_Texture * texture);
    66 static void gf_dirtytexture(SDL_Renderer * renderer, SDL_Texture * texture,
    67                             int numrects, const SDL_Rect * rects);
    68 static int gf_renderpoint(SDL_Renderer * renderer, int x, int y);
    69 static int gf_renderline(SDL_Renderer * renderer, int x1, int y1, int x2,
    70                          int y2);
    71 static int gf_renderfill(SDL_Renderer * renderer, const SDL_Rect * rect);
    72 static int gf_rendercopy(SDL_Renderer * renderer, SDL_Texture * texture,
    73                          const SDL_Rect * srcrect, const SDL_Rect * dstrect);
    74 static void gf_renderpresent(SDL_Renderer * renderer);
    75 static void gf_destroytexture(SDL_Renderer * renderer, SDL_Texture * texture);
    76 static void gf_destroyrenderer(SDL_Renderer * renderer);
    77 
    78 SDL_RenderDriver gf_renderdriver = {
    79     gf_createrenderer,
    80     {
    81      "qnxgf",
    82      (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY |
    83       SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |
    84       SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_PRESENTDISCARD |
    85       SDL_RENDERER_ACCELERATED),
    86      (SDL_TEXTUREMODULATE_NONE | SDL_TEXTUREMODULATE_COLOR |
    87       SDL_TEXTUREMODULATE_ALPHA),
    88      (SDL_BLENDMODE_NONE | SDL_BLENDMODE_MASK |
    89       SDL_BLENDMODE_BLEND | SDL_BLENDMODE_ADD | SDL_BLENDMODE_MOD),
    90      (SDL_SCALEMODE_NONE | SDL_SCALEMODE_SLOW),
    91      13,
    92      {
    93       SDL_PIXELFORMAT_INDEX8,
    94       SDL_PIXELFORMAT_RGB555,
    95       SDL_PIXELFORMAT_RGB565,
    96       SDL_PIXELFORMAT_RGB888,
    97       SDL_PIXELFORMAT_BGR888,
    98       SDL_PIXELFORMAT_ARGB8888,
    99       SDL_PIXELFORMAT_RGBA8888,
   100       SDL_PIXELFORMAT_ABGR8888,
   101       SDL_PIXELFORMAT_BGRA8888,
   102       SDL_PIXELFORMAT_YV12,
   103       SDL_PIXELFORMAT_YUY2,
   104       SDL_PIXELFORMAT_UYVY,
   105       SDL_PIXELFORMAT_YVYU},
   106      0,
   107      0}
   108 };
   109 
   110 static SDL_Renderer *
   111 gf_createrenderer(SDL_Window * window, Uint32 flags)
   112 {
   113     SDL_VideoDisplay *display = window->display;
   114     SDL_DisplayData *didata = (SDL_DisplayData *) display->driverdata;
   115     SDL_WindowData *wdata = (SDL_WindowData *) window->driverdata;
   116     SDL_Renderer *renderer = NULL;
   117     SDL_RenderData *rdata = NULL;
   118     uint32_t it;
   119     int32_t jt;
   120     int32_t status;
   121 
   122     /* Check if it is OpenGL ES window */
   123     if ((window->flags & SDL_WINDOW_OPENGL) == SDL_WINDOW_OPENGL) {
   124         /* No error, just no need to create 2D renderer for OpenGL ES window */
   125         return NULL;
   126     }
   127 
   128     /* Allocate new renderer structure */
   129     renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(SDL_Renderer));
   130     if (renderer == NULL) {
   131         SDL_OutOfMemory();
   132         return NULL;
   133     }
   134 
   135     /* Allocate renderer data */
   136     rdata = (SDL_RenderData *) SDL_calloc(1, sizeof(SDL_RenderData));
   137     if (rdata == NULL) {
   138         SDL_free(renderer);
   139         SDL_OutOfMemory();
   140         return NULL;
   141     }
   142 
   143     renderer->DisplayModeChanged = gf_displaymodechanged;
   144     renderer->ActivateRenderer = gf_activaterenderer;
   145     renderer->CreateTexture = gf_createtexture;
   146     renderer->QueryTexturePixels = gf_querytexturepixels;
   147     renderer->SetTexturePalette = gf_settexturepalette;
   148     renderer->GetTexturePalette = gf_gettexturepalette;
   149     renderer->SetTextureAlphaMod = gf_settexturealphamod;
   150     renderer->SetTextureColorMod = gf_settexturecolormod;
   151     renderer->SetTextureBlendMode = gf_settextureblendmode;
   152     renderer->SetTextureScaleMode = gf_settexturescalemode;
   153     renderer->UpdateTexture = gf_updatetexture;
   154     renderer->LockTexture = gf_locktexture;
   155     renderer->UnlockTexture = gf_unlocktexture;
   156     renderer->DirtyTexture = gf_dirtytexture;
   157     renderer->RenderPoint = gf_renderpoint;
   158     renderer->RenderLine = gf_renderline;
   159     renderer->RenderFill = gf_renderfill;
   160     renderer->RenderCopy = gf_rendercopy;
   161     renderer->RenderPresent = gf_renderpresent;
   162     renderer->DestroyTexture = gf_destroytexture;
   163     renderer->DestroyRenderer = gf_destroyrenderer;
   164     renderer->info = gf_renderdriver.info;
   165     renderer->window = window;
   166     renderer->driverdata = rdata;
   167 
   168     /* Set render acceleration flag in case it is accelerated */
   169     if ((didata->caps & SDL_GF_ACCELERATED) == SDL_GF_ACCELERATED) {
   170         renderer->info.flags = SDL_RENDERER_ACCELERATED;
   171     } else {
   172         renderer->info.flags &= ~(SDL_RENDERER_ACCELERATED);
   173     }
   174 
   175     rdata->window = window;
   176 
   177     /* Check if upper level requested synchronization on vsync signal */
   178     if ((flags & SDL_RENDERER_PRESENTVSYNC) == SDL_RENDERER_PRESENTVSYNC) {
   179         rdata->enable_vsync = SDL_TRUE;
   180     } else {
   181         rdata->enable_vsync = SDL_FALSE;
   182     }
   183 
   184     /* Check what buffer copy/flip scheme is requested */
   185     rdata->surfaces_count = 0;
   186     if ((flags & SDL_RENDERER_SINGLEBUFFER) == SDL_RENDERER_SINGLEBUFFER) {
   187         if ((flags & SDL_RENDERER_PRESENTDISCARD) ==
   188             SDL_RENDERER_PRESENTDISCARD) {
   189             renderer->info.flags |=
   190                 SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD;
   191         } else {
   192             renderer->info.flags |=
   193                 SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY;
   194         }
   195         rdata->surfaces_count = 1;
   196         rdata->surface_visible_idx = 0;
   197         rdata->surface_render_idx = 0;
   198     } else {
   199         if ((flags & SDL_RENDERER_PRESENTFLIP2) == SDL_RENDERER_PRESENTFLIP2) {
   200             renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2;
   201             rdata->surfaces_count = 2;
   202             rdata->surface_visible_idx = 0;
   203             rdata->surface_render_idx = 1;
   204         } else {
   205             if ((flags & SDL_RENDERER_PRESENTFLIP3) ==
   206                 SDL_RENDERER_PRESENTFLIP3) {
   207                 renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3;
   208                 rdata->surfaces_count = 3;
   209                 rdata->surface_visible_idx = 0;
   210                 rdata->surface_render_idx = 1;
   211             } else {
   212                 renderer->info.flags |=
   213                     SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY;
   214                 rdata->surfaces_count = 1;
   215                 rdata->surface_visible_idx = 0;
   216                 rdata->surface_render_idx = 0;
   217             }
   218         }
   219     }
   220 
   221     /* Create layer surfaces, which could be visible */
   222     for (it = 0; it < rdata->surfaces_count; it++) {
   223         /* TODO: add palette creation */
   224 
   225         /* Create displayable surfaces */
   226         status =
   227             gf_surface_create_layer(&rdata->surface[it], &didata->layer, 1, 0,
   228                                     didata->current_mode.w,
   229                                     didata->current_mode.h,
   230                                     qnxgf_sdl_to_gf_pixelformat(didata->
   231                                                                 current_mode.
   232                                                                 format), NULL,
   233                                     GF_SURFACE_CREATE_2D_ACCESSIBLE);
   234 
   235         if (status != GF_ERR_OK) {
   236             /* Free already allocated surfaces */
   237             for (jt = it - 1; jt > 0; jt--) {
   238                 gf_surface_free(rdata->surface[jt]);
   239                 rdata->surface[jt] = NULL;
   240             }
   241             SDL_free(rdata);
   242             SDL_free(renderer);
   243             if (status == GF_ERR_MEM) {
   244                 SDL_SetError("unsufficient free video memory");
   245             } else {
   246                 SDL_SetError("error during displayable surface creation");
   247             }
   248             return NULL;
   249         }
   250 
   251         /* Get detailed information about allocated surface */
   252         gf_surface_get_info(rdata->surface[it], &rdata->surface_info[it]);
   253     }
   254 
   255     return renderer;
   256 }
   257 
   258 void
   259 gf_addrenderdriver(_THIS)
   260 {
   261     uint32_t it;
   262 
   263     for (it = 0; it < _this->num_displays; it++) {
   264         SDL_AddRenderDriver(&_this->displays[it], &gf_renderdriver);
   265     }
   266 }
   267 
   268 /****************************************************************************/
   269 /* SDL render interface                                                     */
   270 /****************************************************************************/
   271 static int
   272 gf_displaymodechanged(SDL_Renderer * renderer)
   273 {
   274     SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
   275 
   276     /* Remove all allocated surfaces, they are no more valid */
   277 
   278     /* TODO: Add video mode change detection and new parameters detection */
   279 
   280     return 0;
   281 }
   282 
   283 static int
   284 gf_activaterenderer(SDL_Renderer * renderer)
   285 {
   286     SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
   287     SDL_VideoDisplay *display = rdata->window->display;
   288     SDL_DisplayData *didata = (SDL_DisplayData *) display->driverdata;
   289 
   290     /* Setup current surface as visible */
   291 //   gf_layer_set_surfaces(didata->layer, &rdata->surface[rdata->surface_visible_idx], 1);
   292 
   293     /* Set visible surface when hardware in idle state */
   294 //   gf_layer_update(didata->layer, GF_LAYER_UPDATE_NO_WAIT_IDLE);
   295 
   296     return 0;
   297 }
   298 
   299 static int
   300 gf_createtexture(SDL_Renderer * renderer, SDL_Texture * texture)
   301 {
   302     SDL_RenderData *renderdata = (SDL_RenderData *) renderer->driverdata;
   303     SDL_Window *window = SDL_GetWindowFromID(renderer->window);
   304     SDL_VideoDisplay *display = window->display;
   305     SDL_TextureData *tdata = NULL;
   306 
   307     /* Allocate texture driver data */
   308     tdata = (SDL_TextureData *) SDL_calloc(1, sizeof(SDL_TextureData));
   309     if (tdata == NULL) {
   310         SDL_OutOfMemory();
   311         return -1;
   312     }
   313 
   314     /* Set texture driver data */
   315     texture->driverdata = tdata;
   316 
   317 }
   318 
   319 static int
   320 gf_querytexturepixels(SDL_Renderer * renderer, SDL_Texture * texture,
   321                       void **pixels, int *pitch)
   322 {
   323 }
   324 
   325 static int
   326 gf_settexturepalette(SDL_Renderer * renderer, SDL_Texture * texture,
   327                      const SDL_Color * colors, int firstcolor, int ncolors)
   328 {
   329 }
   330 
   331 static int
   332 gf_gettexturepalette(SDL_Renderer * renderer, SDL_Texture * texture,
   333                      SDL_Color * colors, int firstcolor, int ncolors)
   334 {
   335 }
   336 
   337 static int
   338 gf_settexturecolormod(SDL_Renderer * renderer, SDL_Texture * texture)
   339 {
   340 }
   341 
   342 static int
   343 gf_settexturealphamod(SDL_Renderer * renderer, SDL_Texture * texture)
   344 {
   345 }
   346 
   347 static int
   348 gf_settextureblendmode(SDL_Renderer * renderer, SDL_Texture * texture)
   349 {
   350 }
   351 
   352 static int
   353 gf_settexturescalemode(SDL_Renderer * renderer, SDL_Texture * texture)
   354 {
   355 }
   356 
   357 static int
   358 gf_updatetexture(SDL_Renderer * renderer, SDL_Texture * texture,
   359                  const SDL_Rect * rect, const void *pixels, int pitch)
   360 {
   361 }
   362 
   363 static int
   364 gf_locktexture(SDL_Renderer * renderer, SDL_Texture * texture,
   365                const SDL_Rect * rect, int markDirty, void **pixels,
   366                int *pitch)
   367 {
   368 }
   369 
   370 static void
   371 gf_unlocktexture(SDL_Renderer * renderer, SDL_Texture * texture)
   372 {
   373 }
   374 
   375 static void
   376 gf_dirtytexture(SDL_Renderer * renderer, SDL_Texture * texture, int numrects,
   377                 const SDL_Rect * rects)
   378 {
   379 }
   380 
   381 static int
   382 gf_renderpoint(SDL_Renderer * renderer, int x, int y)
   383 {
   384 }
   385 
   386 static int
   387 gf_renderline(SDL_Renderer * renderer, int x1, int y1, int x2, int y2)
   388 {
   389 }
   390 
   391 static int
   392 gf_renderfill(SDL_Renderer * renderer, const SDL_Rect * rect)
   393 {
   394 }
   395 
   396 static int
   397 gf_rendercopy(SDL_Renderer * renderer, SDL_Texture * texture,
   398               const SDL_Rect * srcrect, const SDL_Rect * dstrect)
   399 {
   400 }
   401 
   402 static void
   403 gf_renderpresent(SDL_Renderer * renderer)
   404 {
   405 }
   406 
   407 static void
   408 gf_destroytexture(SDL_Renderer * renderer, SDL_Texture * texture)
   409 {
   410 }
   411 
   412 static void
   413 gf_destroyrenderer(SDL_Renderer * renderer)
   414 {
   415     SDL_RenderData *rdata = (SDL_RenderData *) renderer->driverdata;
   416     uint32_t it;
   417 
   418     for (it = 0; it < rdata->surfaces_count; it++) {
   419         if (rdata->surface[it] != NULL) {
   420             gf_surface_free(rdata->surface[it]);
   421         }
   422     }
   423 }
   424 
   425 /* vi: set ts=4 sw=4 expandtab: */