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