This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
SDL_renderer_sw.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
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
*/
#include "SDL_config.h"
#include "SDL_video.h"
#include "SDL_sysvideo.h"
26
#include "SDL_yuv_sw_c.h"
27
28
29
30
31
32
33
/* SDL surface based renderer implementation */
static SDL_Renderer *SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags);
static int SDL_SW_CreateTexture(SDL_Renderer * renderer,
SDL_Texture * texture);
34
35
36
static int SDL_SW_QueryTexturePixels(SDL_Renderer * renderer,
SDL_Texture * texture, void **pixels,
int *pitch);
37
static int SDL_SW_SetTexturePalette(SDL_Renderer * renderer,
38
39
40
41
SDL_Texture * texture,
const SDL_Color * colors, int firstcolor,
int ncolors);
static int SDL_SW_GetTexturePalette(SDL_Renderer * renderer,
42
43
SDL_Texture * texture, SDL_Color * colors,
int firstcolor, int ncolors);
44
static int SDL_SW_UpdateTexture(SDL_Renderer * renderer,
45
SDL_Texture * texture, const SDL_Rect * rect,
46
47
const void *pixels, int pitch);
static int SDL_SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
48
49
const SDL_Rect * rect, int markDirty,
void **pixels, int *pitch);
50
51
52
53
static void SDL_SW_UnlockTexture(SDL_Renderer * renderer,
SDL_Texture * texture);
static void SDL_SW_DirtyTexture(SDL_Renderer * renderer,
SDL_Texture * texture, int numrects,
54
const SDL_Rect * rects);
55
56
static void SDL_SW_SelectRenderTexture(SDL_Renderer * renderer,
SDL_Texture * texture);
57
static void SDL_SW_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect,
58
59
Uint32 color);
static int SDL_SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
60
61
62
63
64
65
66
67
68
const SDL_Rect * srcrect,
const SDL_Rect * dstrect, int blendMode,
int scaleMode);
static int SDL_SW_RenderReadPixels(SDL_Renderer * renderer,
const SDL_Rect * rect, void *pixels,
int pitch);
static int SDL_SW_RenderWritePixels(SDL_Renderer * renderer,
const SDL_Rect * rect, const void *pixels,
int pitch);
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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
static void SDL_SW_RenderPresent(SDL_Renderer * renderer);
static void SDL_SW_DestroyTexture(SDL_Renderer * renderer,
SDL_Texture * texture);
static void SDL_SW_DestroyRenderer(SDL_Renderer * renderer);
SDL_RenderDriver SDL_SW_RenderDriver = {
SDL_SW_CreateRenderer,
{
"software",
(SDL_Renderer_PresentDiscard |
SDL_Renderer_PresentCopy |
SDL_Renderer_PresentFlip2 |
SDL_Renderer_PresentFlip3 | SDL_Renderer_RenderTarget),
(SDL_TextureBlendMode_None |
SDL_TextureBlendMode_Mask | SDL_TextureBlendMode_Blend),
(SDL_TextureScaleMode_None | SDL_TextureScaleMode_Fast),
11,
{
SDL_PixelFormat_Index8,
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_YUY2,
SDL_PixelFormat_UYVY},
32768,
32768}
};
typedef struct
{
int current_screen;
SDL_Surface *screens[3];
SDL_Surface *target;
SDL_Renderer *renderer;
} SDL_SW_RenderData;
SDL_Renderer *
SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_DisplayMode *displayMode = &window->display->current_mode;
SDL_Renderer *renderer;
SDL_SW_RenderData *data;
int i, n;
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
if (!SDL_PixelFormatEnumToMasks
(displayMode->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
SDL_SetError("Unknown display format");
return NULL;
}
renderer = (SDL_Renderer *) SDL_malloc(sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
SDL_zerop(renderer);
data = (SDL_SW_RenderData *) SDL_malloc(sizeof(*data));
if (!data) {
SDL_SW_DestroyRenderer(renderer);
SDL_OutOfMemory();
return NULL;
}
SDL_zerop(data);
renderer->CreateTexture = SDL_SW_CreateTexture;
143
renderer->QueryTexturePixels = SDL_SW_QueryTexturePixels;
144
renderer->SetTexturePalette = SDL_SW_SetTexturePalette;
145
renderer->GetTexturePalette = SDL_SW_GetTexturePalette;
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
renderer->UpdateTexture = SDL_SW_UpdateTexture;
renderer->LockTexture = SDL_SW_LockTexture;
renderer->UnlockTexture = SDL_SW_UnlockTexture;
renderer->DirtyTexture = SDL_SW_DirtyTexture;
renderer->SelectRenderTexture = SDL_SW_SelectRenderTexture;
renderer->RenderFill = SDL_SW_RenderFill;
renderer->RenderCopy = SDL_SW_RenderCopy;
renderer->RenderReadPixels = SDL_SW_RenderReadPixels;
renderer->RenderWritePixels = SDL_SW_RenderWritePixels;
renderer->RenderPresent = SDL_SW_RenderPresent;
renderer->DestroyTexture = SDL_SW_DestroyTexture;
renderer->DestroyRenderer = SDL_SW_DestroyRenderer;
renderer->info = SDL_SW_RenderDriver.info;
renderer->window = window;
renderer->driverdata = data;
renderer->info.flags = SDL_Renderer_RenderTarget;
if (flags & SDL_Renderer_PresentFlip2) {
renderer->info.flags |= SDL_Renderer_PresentFlip2;
n = 2;
} else if (flags & SDL_Renderer_PresentFlip3) {
renderer->info.flags |= SDL_Renderer_PresentFlip3;
n = 3;
} else {
renderer->info.flags |= SDL_Renderer_PresentCopy;
n = 1;
}
for (i = 0; i < n; ++i) {
data->screens[i] =
SDL_CreateRGBSurface(0, window->w, window->h, bpp, Rmask, Gmask,
Bmask, Amask);
if (!data->screens[i]) {
SDL_SW_DestroyRenderer(renderer);
return NULL;
}
182
SDL_SetSurfacePalette(data->screens[i], window->display->palette);
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
}
data->current_screen = 0;
data->target = data->screens[0];
/* Find a render driver that we can use to display data */
for (i = 0; i < window->display->num_render_drivers; ++i) {
SDL_RenderDriver *driver = &window->display->render_drivers[i];
if (driver->info.name != SDL_SW_RenderDriver.info.name) {
data->renderer =
driver->CreateRenderer(window, SDL_Renderer_PresentDiscard);
if (data->renderer) {
break;
}
}
}
if (i == window->display->num_render_drivers) {
SDL_SW_DestroyRenderer(renderer);
SDL_SetError("Couldn't find display render driver");
return NULL;
}
return renderer;
}
207
208
209
SDL_SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
210
211
212
213
214
215
216
217
if (texture->access == SDL_TextureAccess_Render) {
SDL_SetError("Rendering to YUV format textures is not supported");
return -1;
}
texture->driverdata = SDL_SW_CreateYUVTexture(texture);
} else {
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
219
220
221
222
223
224
225
226
227
if (!SDL_PixelFormatEnumToMasks
(texture->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
SDL_SetError("Unknown texture format");
return -1;
}
texture->driverdata =
SDL_CreateRGBSurface(0, texture->w, texture->h, bpp, Rmask, Gmask,
Bmask, Amask);
230
if (!texture->driverdata) {
231
232
233
234
235
return -1;
}
return 0;
}
237
238
239
SDL_SW_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture,
void **pixels, int *pitch)
{
240
241
242
243
244
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
return SDL_SW_QueryYUVTexturePixels((SDL_SW_YUVTexture *) texture->
driverdata, pixels, pitch);
} else {
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
246
247
248
249
*pixels = surface->pixels;
*pitch = surface->pitch;
return 0;
}
252
253
static int
SDL_SW_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
254
255
const SDL_Color * colors, int firstcolor,
int ncolors)
257
258
259
260
261
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
SDL_SetError("YUV textures don't have a palette");
return -1;
} else {
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
263
264
265
return SDL_SetPaletteColors(surface->format->palette, colors,
firstcolor, ncolors);
}
268
269
270
271
static int
SDL_SW_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
SDL_Color * colors, int firstcolor, int ncolors)
{
272
273
274
275
276
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
SDL_SetError("YUV textures don't have a palette");
return -1;
} else {
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
278
279
280
281
SDL_memcpy(colors, &surface->format->palette->colors[firstcolor],
ncolors * sizeof(*colors));
return 0;
}
285
SDL_SW_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
286
const SDL_Rect * rect, const void *pixels, int pitch)
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
return SDL_SW_UpdateYUVTexture((SDL_SW_YUVTexture *) texture->
driverdata, rect, pixels, pitch);
} else {
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
Uint8 *src, *dst;
int row;
size_t length;
src = (Uint8 *) pixels;
dst =
(Uint8 *) surface->pixels + rect->y * surface->pitch +
rect->x * surface->format->BytesPerPixel;
length = rect->w * surface->format->BytesPerPixel;
for (row = 0; row < rect->h; ++row) {
SDL_memcpy(dst, src, length);
src += pitch;
dst += surface->pitch;
}
return 0;
308
309
310
}
}
312
SDL_SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
313
314
const SDL_Rect * rect, int markDirty, void **pixels,
int *pitch)
316
317
318
319
320
321
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
return SDL_SW_LockYUVTexture((SDL_SW_YUVTexture *) texture->
driverdata, rect, markDirty, pixels,
pitch);
} else {
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
323
324
325
326
327
328
*pixels =
(void *) ((Uint8 *) surface->pixels + rect->y * surface->pitch +
rect->x * surface->format->BytesPerPixel);
*pitch = surface->pitch;
return 0;
}
332
333
SDL_SW_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
334
335
336
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
SDL_SW_UnlockYUVTexture((SDL_SW_YUVTexture *) texture->driverdata);
}
340
SDL_SW_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture,
341
int numrects, const SDL_Rect * rects)
342
343
344
{
}
346
347
348
SDL_SW_SelectRenderTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata;
349
350
351
352
353
354
if (texture) {
data->target = (SDL_Surface *) texture->driverdata;
} else {
data->target = data->screens[data->current_screen];
}
358
359
SDL_SW_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 color)
360
361
{
SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata;
362
SDL_Rect real_rect = *rect;
363
364
365
366
367
368
369
370
Uint8 r, g, b, a;
a = (Uint8) ((color >> 24) & 0xFF);
r = (Uint8) ((color >> 16) & 0xFF);
g = (Uint8) ((color >> 8) & 0xFF);
b = (Uint8) (color & 0xFF);
color = SDL_MapRGBA(data->target->format, r, g, b, a);
371
SDL_FillRect(data->target, &real_rect, color);
375
SDL_SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
376
377
const SDL_Rect * srcrect, const SDL_Rect * dstrect,
int blendMode, int scaleMode)
378
379
380
{
SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata;
381
382
383
384
385
386
387
388
389
390
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
SDL_Surface *target = data->target;
void *pixels =
(Uint8 *) target->pixels + dstrect->y * target->pitch +
dstrect->x * target->format->BytesPerPixel;
return SDL_SW_CopyYUVToRGB((SDL_SW_YUVTexture *) texture->driverdata,
srcrect,
renderer->window->display->current_mode.
format, dstrect->w, dstrect->h, pixels,
target->pitch);
391
} else {
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
SDL_Rect real_srcrect = *srcrect;
SDL_Rect real_dstrect = *dstrect;
if (blendMode &
(SDL_TextureBlendMode_Mask | SDL_TextureBlendMode_Blend)) {
SDL_SetAlpha(surface, SDL_SRCALPHA, 0);
} else {
SDL_SetAlpha(surface, 0, 0);
}
if (scaleMode != SDL_TextureScaleMode_None &&
(srcrect->w != dstrect->w || srcrect->h != dstrect->h)) {
return SDL_SoftStretch(surface, &real_srcrect, data->target,
&real_dstrect);
} else {
return SDL_LowerBlit(surface, &real_srcrect, data->target,
&real_dstrect);
}
410
411
412
}
}
414
SDL_SW_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
void *pixels, int pitch)
{
SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata;
SDL_Surface *surface = data->target;
Uint8 *src, *dst;
int row;
size_t length;
src =
(Uint8 *) surface->pixels + rect->y * surface->pitch +
rect->x * surface->format->BytesPerPixel;
dst = (Uint8 *) pixels;
length = rect->w * surface->format->BytesPerPixel;
for (row = 0; row < rect->h; ++row) {
SDL_memcpy(dst, src, length);
src += surface->pitch;
dst += pitch;
}
return 0;
}
437
SDL_SW_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
const void *pixels, int pitch)
{
SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata;
SDL_Surface *surface = data->target;
Uint8 *src, *dst;
int row;
size_t length;
src = (Uint8 *) pixels;
dst =
(Uint8 *) surface->pixels + rect->y * surface->pitch +
rect->x * surface->format->BytesPerPixel;
length = rect->w * surface->format->BytesPerPixel;
for (row = 0; row < rect->h; ++row) {
SDL_memcpy(dst, src, length);
src += pitch;
dst += surface->pitch;
}
return 0;
}
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
SDL_SW_RenderPresent(SDL_Renderer * renderer)
{
SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata;
SDL_Surface *surface = data->screens[data->current_screen];
SDL_Rect rect;
int new_screen;
/* Send the data to the display */
/* FIXME: implement dirty rect updates */
rect.x = 0;
rect.y = 0;
rect.w = surface->w;
rect.h = surface->h;
data->renderer->RenderWritePixels(data->renderer, &rect, surface->pixels,
surface->pitch);
data->renderer->RenderPresent(data->renderer);
/* Update the flipping chain, if any */
if (renderer->info.flags & SDL_Renderer_PresentFlip2) {
new_screen = (data->current_screen + 1) % 2;
} else if (renderer->info.flags & SDL_Renderer_PresentFlip3) {
new_screen = (data->current_screen + 1) % 3;
} else {
new_screen = 0;
}
if (data->target == data->screens[data->current_screen]) {
data->target = data->screens[new_screen];
}
data->current_screen = new_screen;
}
492
493
SDL_SW_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
494
495
496
497
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
SDL_SW_DestroyYUVTexture((SDL_SW_YUVTexture *) texture->driverdata);
} else {
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
499
500
SDL_FreeSurface(surface);
}
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
SDL_SW_DestroyRenderer(SDL_Renderer * renderer)
{
SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata;
int i;
if (data) {
for (i = 0; i < SDL_arraysize(data->screens); ++i) {
if (data->screens[i]) {
SDL_FreeSurface(data->screens[i]);
}
}
SDL_free(data);
}
SDL_free(renderer);
}
/* vi: set ts=4 sw=4 expandtab: */