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_pixels_c.h"
27
28
29
30
31
32
#include "SDL_rect_c.h"
#include "SDL_yuv_sw_c.h"
/* SDL surface based renderer implementation */
33
static SDL_Renderer *SW_CreateRenderer(SDL_Window * window, Uint32 flags);
34
35
static int SW_ActivateRenderer(SDL_Renderer * renderer);
static int SW_DisplayModeChanged(SDL_Renderer * renderer);
36
37
38
39
40
41
42
43
44
45
46
static int SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
static int SW_QueryTexturePixels(SDL_Renderer * renderer,
SDL_Texture * texture, void **pixels,
int *pitch);
static int SW_SetTexturePalette(SDL_Renderer * renderer,
SDL_Texture * texture,
const SDL_Color * colors, int firstcolor,
int ncolors);
static int SW_GetTexturePalette(SDL_Renderer * renderer,
SDL_Texture * texture, SDL_Color * colors,
int firstcolor, int ncolors);
47
48
49
50
51
52
53
54
55
56
57
static int SW_SetTextureColorMod(SDL_Renderer * renderer,
SDL_Texture * texture);
static int SW_SetTextureAlphaMod(SDL_Renderer * renderer,
SDL_Texture * texture);
static int SW_SetTextureBlendMode(SDL_Renderer * renderer,
SDL_Texture * texture);
static int SW_SetTextureScaleMode(SDL_Renderer * renderer,
SDL_Texture * texture);
static int SW_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels,
int pitch);
58
static int SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
59
60
const SDL_Rect * rect, int markDirty, void **pixels,
int *pitch);
61
static void SW_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);
62
63
static int SW_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g, Uint8 b,
Uint8 a, const SDL_Rect * rect);
64
static int SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
65
const SDL_Rect * srcrect, const SDL_Rect * dstrect);
66
67
68
69
70
71
72
static void SW_RenderPresent(SDL_Renderer * renderer);
static void SW_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture);
static void SW_DestroyRenderer(SDL_Renderer * renderer);
SDL_RenderDriver SW_RenderDriver = {
SW_CreateRenderer,
73
74
{
"software",
75
76
77
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY |
SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |
SDL_RENDERER_PRESENTDISCARD | SDL_RENDERER_PRESENTVSYNC),
78
79
(SDL_TEXTUREMODULATE_NONE | SDL_TEXTUREMODULATE_COLOR |
SDL_TEXTUREMODULATE_ALPHA),
80
(SDL_TEXTUREBLENDMODE_NONE | SDL_TEXTUREBLENDMODE_MASK |
81
82
SDL_TEXTUREBLENDMODE_BLEND | SDL_TEXTUREBLENDMODE_ADD |
SDL_TEXTUREBLENDMODE_MOD),
83
(SDL_TEXTURESCALEMODE_NONE | SDL_TEXTURESCALEMODE_FAST),
86
87
88
89
90
91
92
93
94
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,
95
96
SDL_PIXELFORMAT_YV12,
SDL_PIXELFORMAT_IYUV,
97
SDL_PIXELFORMAT_YUY2,
98
99
SDL_PIXELFORMAT_UYVY,
SDL_PIXELFORMAT_YVYU},
100
101
102
103
104
105
0,
0}
};
typedef struct
{
106
Uint32 format;
107
SDL_bool updateSize;
108
109
110
int current_texture;
SDL_Texture *texture[3];
SDL_Surface surface;
111
112
SDL_Renderer *renderer;
SDL_DirtyRectList dirty;
113
} SW_RenderData;
115
116
117
118
119
static SDL_Texture *
CreateTexture(SDL_Renderer * renderer, Uint32 format, int w, int h)
{
SDL_Texture *texture;
120
texture = (SDL_Texture *) SDL_calloc(1, sizeof(*texture));
121
122
123
124
125
126
if (!texture) {
SDL_OutOfMemory();
return NULL;
}
texture->format = format;
127
texture->access = SDL_TEXTUREACCESS_STREAMING;
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
texture->w = w;
texture->h = h;
texture->renderer = renderer;
if (renderer->CreateTexture(renderer, texture) < 0) {
SDL_free(texture);
return NULL;
}
return texture;
}
static void
DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
renderer->DestroyTexture(renderer, texture);
SDL_free(texture);
}
static int
DisplayPaletteChanged(void *userdata, SDL_Palette * palette)
{
149
SW_RenderData *data = (SW_RenderData *) userdata;
150
151
152
153
154
155
156
157
158
159
160
161
162
int i;
for (i = 0; i < SDL_arraysize(data->texture); ++i) {
if (data->texture[i] && data->renderer->SetTexturePalette) {
data->renderer->SetTexturePalette(data->renderer,
data->texture[i],
palette->colors, 0,
palette->ncolors);
}
}
return 0;
}
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
void
Setup_SoftwareRenderer(SDL_Renderer * renderer)
{
renderer->CreateTexture = SW_CreateTexture;
renderer->QueryTexturePixels = SW_QueryTexturePixels;
renderer->SetTexturePalette = SW_SetTexturePalette;
renderer->GetTexturePalette = SW_GetTexturePalette;
renderer->SetTextureColorMod = SW_SetTextureColorMod;
renderer->SetTextureAlphaMod = SW_SetTextureAlphaMod;
renderer->SetTextureBlendMode = SW_SetTextureBlendMode;
renderer->SetTextureScaleMode = SW_SetTextureScaleMode;
renderer->UpdateTexture = SW_UpdateTexture;
renderer->LockTexture = SW_LockTexture;
renderer->UnlockTexture = SW_UnlockTexture;
renderer->DestroyTexture = SW_DestroyTexture;
renderer->info.mod_modes = SW_RenderDriver.info.mod_modes;
renderer->info.blend_modes = SW_RenderDriver.info.blend_modes;
renderer->info.scale_modes = SW_RenderDriver.info.scale_modes;
renderer->info.num_texture_formats =
SW_RenderDriver.info.num_texture_formats;
SDL_memcpy(renderer->info.texture_formats,
SW_RenderDriver.info.texture_formats,
sizeof(renderer->info.texture_formats));;
renderer->info.max_texture_width = SW_RenderDriver.info.max_texture_width;
renderer->info.max_texture_height =
SW_RenderDriver.info.max_texture_height;
}
192
SDL_Renderer *
193
SW_CreateRenderer(SDL_Window * window, Uint32 flags)
194
195
196
197
{
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
SDL_DisplayMode *displayMode = &display->current_mode;
SDL_Renderer *renderer;
198
SW_RenderData *data;
199
200
201
int i, n;
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
202
Uint32 renderer_flags;
203
const char *desired_driver;
204
205
206
207
208
209
210
211
212
213
214
215
216
if (!SDL_PixelFormatEnumToMasks
(displayMode->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
SDL_SetError("Unknown display format");
return NULL;
}
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
217
data = (SW_RenderData *) SDL_calloc(1, sizeof(*data));
218
if (!data) {
219
SW_DestroyRenderer(renderer);
220
221
222
SDL_OutOfMemory();
return NULL;
}
223
224
renderer->ActivateRenderer = SW_ActivateRenderer;
renderer->DisplayModeChanged = SW_DisplayModeChanged;
225
226
227
228
renderer->RenderFill = SW_RenderFill;
renderer->RenderCopy = SW_RenderCopy;
renderer->RenderPresent = SW_RenderPresent;
renderer->DestroyRenderer = SW_DestroyRenderer;
229
230
renderer->info.name = SW_RenderDriver.info.name;
renderer->info.flags = 0;
231
232
renderer->window = window->id;
renderer->driverdata = data;
233
Setup_SoftwareRenderer(renderer);
235
236
if (flags & SDL_RENDERER_PRESENTFLIP2) {
renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2;
238
239
} else if (flags & SDL_RENDERER_PRESENTFLIP3) {
renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3;
240
241
n = 3;
} else {
242
renderer->info.flags |= SDL_RENDERER_PRESENTCOPY;
245
data->format = displayMode->format;
246
247
/* Find a render driver that we can use to display data */
248
249
250
251
renderer_flags = (SDL_RENDERER_SINGLEBUFFER |
SDL_RENDERER_PRESENTDISCARD);
if (flags & SDL_RENDERER_PRESENTVSYNC) {
renderer_flags |= SDL_RENDERER_PRESENTVSYNC;
253
desired_driver = SDL_getenv("SDL_VIDEO_RENDERER_SWDRIVER");
254
255
for (i = 0; i < display->num_render_drivers; ++i) {
SDL_RenderDriver *driver = &display->render_drivers[i];
256
257
258
259
260
261
262
263
264
265
if (driver->info.name == SW_RenderDriver.info.name) {
continue;
}
if (desired_driver
&& SDL_strcasecmp(desired_driver, driver->info.name) != 0) {
continue;
}
data->renderer = driver->CreateRenderer(window, renderer_flags);
if (data->renderer) {
break;
266
267
268
}
}
if (i == display->num_render_drivers) {
269
SW_DestroyRenderer(renderer);
270
271
272
SDL_SetError("Couldn't find display render driver");
return NULL;
}
273
274
if (data->renderer->info.flags & SDL_RENDERER_PRESENTVSYNC) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
275
276
277
278
279
280
281
}
/* Create the textures we'll use for display */
for (i = 0; i < n; ++i) {
data->texture[i] =
CreateTexture(data->renderer, data->format, window->w, window->h);
if (!data->texture[i]) {
282
SW_DestroyRenderer(renderer);
283
284
285
286
287
288
289
290
291
return NULL;
}
}
data->current_texture = 0;
/* Create a surface we'll use for rendering */
data->surface.flags = SDL_PREALLOC;
data->surface.format = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask);
if (!data->surface.format) {
292
SW_DestroyRenderer(renderer);
293
294
295
296
297
298
299
300
301
return NULL;
}
SDL_SetSurfacePalette(&data->surface, display->palette);
/* Set up a palette watch on the display palette */
if (display->palette) {
SDL_AddPaletteWatch(display->palette, DisplayPaletteChanged, data);
}
302
303
304
return renderer;
}
305
306
307
308
static int
SW_ActivateRenderer(SDL_Renderer * renderer)
{
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
309
310
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
int i, n;
311
312
313
314
315
316
if (data->renderer && data->renderer->ActivateRenderer) {
if (data->renderer->ActivateRenderer(data->renderer) < 0) {
return -1;
}
}
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
if (data->updateSize) {
/* Recreate the textures for the new window size */
if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP2) {
n = 2;
} else if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP3) {
n = 3;
} else {
n = 1;
}
for (i = 0; i < n; ++i) {
if (data->texture[i]) {
DestroyTexture(data->renderer, data->texture[i]);
data->texture[i] = 0;
}
}
for (i = 0; i < n; ++i) {
data->texture[i] =
CreateTexture(data->renderer, data->format, window->w,
window->h);
if (!data->texture[i]) {
return -1;
}
}
data->updateSize = SDL_FALSE;
}
342
343
344
345
346
347
348
349
350
351
352
353
354
return 0;
}
static int
SW_DisplayModeChanged(SDL_Renderer * renderer)
{
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
if (data->renderer && data->renderer->DisplayModeChanged) {
if (data->renderer->DisplayModeChanged(data->renderer) < 0) {
return -1;
}
}
355
data->updateSize = SDL_TRUE;
356
357
358
return 0;
}
360
SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
361
362
{
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
363
364
texture->driverdata =
SDL_SW_CreateYUVTexture(texture->format, texture->w, texture->h);
365
366
367
368
369
370
371
372
373
374
375
376
377
} else {
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
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);
378
379
380
if (texture->access == SDL_TEXTUREACCESS_STATIC) {
SDL_SetSurfaceRLE(texture->driverdata, 1);
}
381
382
383
384
385
386
387
388
389
}
if (!texture->driverdata) {
return -1;
}
return 0;
}
static int
390
391
SW_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture,
void **pixels, int *pitch)
392
393
{
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
394
395
396
return SDL_SW_QueryYUVTexturePixels((SDL_SW_YUVTexture *)
texture->driverdata, pixels,
pitch);
397
398
399
400
401
402
403
404
405
406
} else {
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
*pixels = surface->pixels;
*pitch = surface->pitch;
return 0;
}
}
static int
407
408
SW_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Color * colors, int firstcolor, int ncolors)
409
410
411
412
413
414
415
416
417
418
419
420
421
{
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;
return SDL_SetPaletteColors(surface->format->palette, colors,
firstcolor, ncolors);
}
}
static int
422
423
SW_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
SDL_Color * colors, int firstcolor, int ncolors)
424
425
426
427
428
429
430
431
432
433
434
435
436
{
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;
SDL_memcpy(colors, &surface->format->palette->colors[firstcolor],
ncolors * sizeof(*colors));
return 0;
}
}
437
438
439
static int
SW_SetTextureColorMod(SDL_Renderer * renderer, SDL_Texture * texture)
{
440
441
442
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
return SDL_SetSurfaceColorMod(surface, texture->r, texture->g,
texture->b);
443
444
445
446
447
}
static int
SW_SetTextureAlphaMod(SDL_Renderer * renderer, SDL_Texture * texture)
{
448
449
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
return SDL_SetSurfaceAlphaMod(surface, texture->a);
450
451
452
453
454
}
static int
SW_SetTextureBlendMode(SDL_Renderer * renderer, SDL_Texture * texture)
{
455
456
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
return SDL_SetSurfaceBlendMode(surface, texture->blendMode);
457
458
459
460
461
}
static int
SW_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture)
{
462
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
463
return SDL_SetSurfaceScaleMode(surface, texture->scaleMode);
467
468
SW_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels, int pitch)
469
470
{
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
471
472
473
return SDL_SW_UpdateYUVTexture((SDL_SW_YUVTexture *)
texture->driverdata, rect, pixels,
pitch);
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
} 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;
}
}
static int
495
496
497
SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, int markDirty, void **pixels,
int *pitch)
498
499
{
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
500
501
502
return SDL_SW_LockYUVTexture((SDL_SW_YUVTexture *)
texture->driverdata, rect, markDirty,
pixels, pitch);
503
504
505
506
507
508
509
510
511
512
513
514
} else {
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
*pixels =
(void *) ((Uint8 *) surface->pixels + rect->y * surface->pitch +
rect->x * surface->format->BytesPerPixel);
*pitch = surface->pitch;
return 0;
}
}
static void
515
SW_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
516
517
518
519
520
521
522
{
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
SDL_SW_UnlockYUVTexture((SDL_SW_YUVTexture *) texture->driverdata);
}
}
static int
523
524
SW_RenderFill(SDL_Renderer * renderer, Uint8 r, Uint8 g, Uint8 b, Uint8 a,
const SDL_Rect * rect)
526
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
527
Uint32 color;
528
529
SDL_Rect real_rect;
int status;
531
if (data->renderer->info.flags & SDL_RENDERER_PRESENTCOPY) {
532
533
SDL_AddDirtyRect(&data->dirty, rect);
}
535
536
color = SDL_MapRGBA(data->surface.format, r, g, b, a);
537
538
539
540
if (data->renderer->LockTexture(data->renderer,
data->texture[data->current_texture],
rect, 1, &data->surface.pixels,
&data->surface.pitch) < 0) {
541
542
543
544
545
546
547
548
549
return -1;
}
data->surface.w = rect->w;
data->surface.h = rect->h;
data->surface.clip_rect.w = rect->w;
data->surface.clip_rect.h = rect->h;
real_rect = data->surface.clip_rect;
status = SDL_FillRect(&data->surface, &real_rect, color);
551
552
553
data->renderer->UnlockTexture(data->renderer,
data->texture[data->current_texture]);
return status;
554
555
556
}
static int
557
SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
558
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
560
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
561
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
564
if (data->renderer->info.flags & SDL_RENDERER_PRESENTCOPY) {
565
566
SDL_AddDirtyRect(&data->dirty, dstrect);
}
568
569
570
571
if (data->renderer->LockTexture(data->renderer,
data->texture[data->current_texture],
dstrect, 1, &data->surface.pixels,
&data->surface.pitch) < 0) {
572
573
574
return -1;
}
575
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
576
577
578
579
status =
SDL_SW_CopyYUVToRGB((SDL_SW_YUVTexture *) texture->driverdata,
srcrect, data->format, dstrect->w, dstrect->h,
data->surface.pixels, data->surface.pitch);
580
581
} else {
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
582
583
584
585
586
587
588
589
590
591
592
593
SDL_Rect real_srcrect = *srcrect;
SDL_Rect real_dstrect;
data->surface.w = dstrect->w;
data->surface.h = dstrect->h;
data->surface.clip_rect.w = dstrect->w;
data->surface.clip_rect.h = dstrect->h;
real_dstrect = data->surface.clip_rect;
status =
SDL_LowerBlit(surface, &real_srcrect, &data->surface,
&real_dstrect);
595
596
597
data->renderer->UnlockTexture(data->renderer,
data->texture[data->current_texture]);
return status;
598
599
600
}
static void
601
SW_RenderPresent(SDL_Renderer * renderer)
603
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
604
SDL_Texture *texture = data->texture[data->current_texture];
605
606
/* Send the data to the display */
607
if (data->renderer->info.flags & SDL_RENDERER_PRESENTCOPY) {
608
609
610
SDL_DirtyRect *dirty;
for (dirty = data->dirty.list; dirty; dirty = dirty->next) {
data->renderer->RenderCopy(data->renderer, texture, &dirty->rect,
611
&dirty->rect);
612
613
614
615
616
617
618
619
}
SDL_ClearDirtyRects(&data->dirty);
} else {
SDL_Rect rect;
rect.x = 0;
rect.y = 0;
rect.w = texture->w;
rect.h = texture->h;
620
data->renderer->RenderCopy(data->renderer, texture, &rect, &rect);
621
622
623
624
}
data->renderer->RenderPresent(data->renderer);
/* Update the flipping chain, if any */
625
if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP2) {
626
data->current_texture = (data->current_texture + 1) % 2;
627
} else if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP3) {
628
data->current_texture = (data->current_texture + 1) % 3;
629
630
631
632
}
}
static void
633
SW_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
634
635
636
637
638
639
640
641
642
643
644
{
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
SDL_SW_DestroyYUVTexture((SDL_SW_YUVTexture *) texture->driverdata);
} else {
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
SDL_FreeSurface(surface);
}
}
static void
645
SW_DestroyRenderer(SDL_Renderer * renderer)
647
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
648
649
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
650
651
652
int i;
if (data) {
653
654
655
for (i = 0; i < SDL_arraysize(data->texture); ++i) {
if (data->texture[i]) {
DestroyTexture(data->renderer, data->texture[i]);
658
659
660
661
662
663
664
665
666
667
668
if (data->surface.format) {
SDL_SetSurfacePalette(&data->surface, NULL);
SDL_FreeFormat(data->surface.format);
}
if (display->palette) {
SDL_DelPaletteWatch(display->palette, DisplayPaletteChanged,
data);
}
if (data->renderer) {
data->renderer->DestroyRenderer(data->renderer);
}
669
670
671
672
673
674
675
SDL_FreeDirtyRects(&data->dirty);
SDL_free(data);
}
SDL_free(renderer);
}
/* vi: set ts=4 sw=4 expandtab: */