This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
SDL_renderer_sw.c
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
21
22
23
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"
24
25
26
#include "../SDL_sysrender.h"
#include "../../video/SDL_pixels_c.h"
#include "../../video/SDL_yuv_sw_c.h"
27
28
29
30
/* SDL surface based renderer implementation */
31
static SDL_Renderer *SW_CreateRenderer(SDL_Window * window, Uint32 flags);
32
33
static void SW_WindowEvent(SDL_Renderer * renderer,
const SDL_WindowEvent *event);
34
35
36
37
static int SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
static int SW_QueryTexturePixels(SDL_Renderer * renderer,
SDL_Texture * texture, void **pixels,
int *pitch);
38
39
40
41
static int SW_SetTextureColorMod(SDL_Renderer * renderer,
SDL_Texture * texture);
static int SW_SetTextureAlphaMod(SDL_Renderer * renderer,
SDL_Texture * texture);
42
43
static int SW_SetTextureBlendMode(SDL_Renderer * renderer,
SDL_Texture * texture);
44
45
46
static int SW_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels,
int pitch);
47
static int SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
48
49
const SDL_Rect * rect, int markDirty, void **pixels,
int *pitch);
50
static void SW_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);
51
52
53
54
55
56
static int SW_RenderDrawPoints(SDL_Renderer * renderer,
const SDL_Point * points, int count);
static int SW_RenderDrawLines(SDL_Renderer * renderer,
const SDL_Point * points, int count);
static int SW_RenderFillRects(SDL_Renderer * renderer,
const SDL_Rect ** rects, int count);
57
static int SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
58
const SDL_Rect * srcrect, const SDL_Rect * dstrect);
59
static int SW_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
60
Uint32 format, void * pixels, int pitch);
61
static int SW_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
62
Uint32 format, const void * pixels, int pitch);
63
64
65
66
67
68
69
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,
70
71
{
"software",
72
(SDL_RENDERER_PRESENTVSYNC),
75
76
77
78
79
80
81
82
SDL_PIXELFORMAT_RGB555,
SDL_PIXELFORMAT_RGB565,
SDL_PIXELFORMAT_RGB888,
SDL_PIXELFORMAT_BGR888,
SDL_PIXELFORMAT_ARGB8888,
SDL_PIXELFORMAT_RGBA8888,
SDL_PIXELFORMAT_ABGR8888,
SDL_PIXELFORMAT_BGRA8888,
83
84
SDL_PIXELFORMAT_YV12,
SDL_PIXELFORMAT_IYUV,
85
SDL_PIXELFORMAT_YUY2,
86
87
SDL_PIXELFORMAT_UYVY,
SDL_PIXELFORMAT_YVYU},
88
89
90
91
92
93
0,
0}
};
typedef struct
{
94
Uint32 format;
95
SDL_bool updateSize;
96
SDL_Texture *texture;
97
SDL_Surface surface;
98
99
SDL_Renderer *renderer;
SDL_DirtyRectList dirty;
100
} SW_RenderData;
102
103
104
105
106
static SDL_Texture *
CreateTexture(SDL_Renderer * renderer, Uint32 format, int w, int h)
{
SDL_Texture *texture;
107
texture = (SDL_Texture *) SDL_calloc(1, sizeof(*texture));
108
109
110
111
112
113
if (!texture) {
SDL_OutOfMemory();
return NULL;
}
texture->format = format;
114
texture->access = SDL_TEXTUREACCESS_STREAMING;
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
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);
}
133
SDL_Renderer *
134
SW_CreateRenderer(SDL_Window * window, Uint32 flags)
135
136
{
SDL_Renderer *renderer;
137
SW_RenderData *data;
138
139
int i;
Uint32 format;
140
141
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
142
Uint32 renderer_flags;
143
const char *desired_driver;
145
format = SDL_GetWindowPixelFormat(window);
146
if (!SDL_PixelFormatEnumToMasks
147
(format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
148
149
150
151
152
153
154
155
156
157
SDL_SetError("Unknown display format");
return NULL;
}
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
158
data = (SW_RenderData *) SDL_calloc(1, sizeof(*data));
159
if (!data) {
160
SW_DestroyRenderer(renderer);
161
162
163
SDL_OutOfMemory();
return NULL;
}
164
renderer->WindowEvent = SW_WindowEvent;
165
166
167
168
169
170
171
172
173
renderer->CreateTexture = SW_CreateTexture;
renderer->QueryTexturePixels = SW_QueryTexturePixels;
renderer->SetTextureColorMod = SW_SetTextureColorMod;
renderer->SetTextureAlphaMod = SW_SetTextureAlphaMod;
renderer->SetTextureBlendMode = SW_SetTextureBlendMode;
renderer->UpdateTexture = SW_UpdateTexture;
renderer->LockTexture = SW_LockTexture;
renderer->UnlockTexture = SW_UnlockTexture;
renderer->DestroyTexture = SW_DestroyTexture;
174
175
176
renderer->RenderDrawPoints = SW_RenderDrawPoints;
renderer->RenderDrawLines = SW_RenderDrawLines;
renderer->RenderFillRects = SW_RenderFillRects;
177
renderer->RenderCopy = SW_RenderCopy;
178
179
renderer->RenderReadPixels = SW_RenderReadPixels;
renderer->RenderWritePixels = SW_RenderWritePixels;
180
181
renderer->RenderPresent = SW_RenderPresent;
renderer->DestroyRenderer = SW_DestroyRenderer;
182
renderer->info = SW_RenderDriver.info;
183
renderer->info.flags = 0;
184
renderer->window = window;
185
186
renderer->driverdata = data;
187
data->format = format;
188
189
/* Find a render driver that we can use to display data */
190
renderer_flags = 0;
191
192
if (flags & SDL_RENDERER_PRESENTVSYNC) {
renderer_flags |= SDL_RENDERER_PRESENTVSYNC;
194
desired_driver = SDL_getenv("SDL_VIDEO_RENDERER_SWDRIVER");
195
196
197
198
for (i = 0; i < SDL_GetNumRenderDrivers(); ++i) {
SDL_RendererInfo info;
SDL_GetRenderDriverInfo(i, &info);
if (SDL_strcmp(info.name, SW_RenderDriver.info.name) == 0) {
199
200
201
continue;
}
if (desired_driver
202
&& SDL_strcasecmp(desired_driver, info.name) != 0) {
203
204
continue;
}
205
data->renderer = SDL_CreateRenderer(window, i, renderer_flags);
206
207
if (data->renderer) {
break;
210
if (i == SDL_GetNumRenderDrivers()) {
211
SW_DestroyRenderer(renderer);
212
213
214
SDL_SetError("Couldn't find display render driver");
return NULL;
}
215
216
if (data->renderer->info.flags & SDL_RENDERER_PRESENTVSYNC) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
217
218
219
}
/* Create the textures we'll use for display */
220
221
222
223
224
data->texture =
CreateTexture(data->renderer, data->format, window->w, window->h);
if (!data->texture) {
SW_DestroyRenderer(renderer);
return NULL;
225
226
227
228
229
230
}
/* 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) {
231
SW_DestroyRenderer(renderer);
232
233
234
return NULL;
}
235
236
237
return renderer;
}
238
static SDL_Texture *
239
240
241
SW_ActivateRenderer(SDL_Renderer * renderer)
{
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
242
SDL_Window *window = renderer->window;
244
245
if (data->updateSize) {
/* Recreate the textures for the new window size */
246
247
if (data->texture) {
DestroyTexture(data->renderer, data->texture);
249
250
data->texture = CreateTexture(data->renderer, data->format,
window->w, window->h);
251
252
if (data->texture) {
data->updateSize = SDL_FALSE;
255
return data->texture;
258
259
static void
SW_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
260
261
262
{
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
263
264
if (event->event == SDL_WINDOWEVENT_RESIZED) {
data->updateSize = SDL_TRUE;
269
SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
270
271
{
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
272
273
texture->driverdata =
SDL_SW_CreateYUVTexture(texture->format, texture->w, texture->h);
274
275
276
277
278
279
280
281
282
283
284
285
286
} 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);
287
288
289
290
291
SDL_SetSurfaceColorMod(texture->driverdata, texture->r, texture->g,
texture->b);
SDL_SetSurfaceAlphaMod(texture->driverdata, texture->a);
SDL_SetSurfaceBlendMode(texture->driverdata, texture->blendMode);
292
293
294
if (texture->access == SDL_TEXTUREACCESS_STATIC) {
SDL_SetSurfaceRLE(texture->driverdata, 1);
}
295
296
297
298
299
300
301
302
303
}
if (!texture->driverdata) {
return -1;
}
return 0;
}
static int
304
305
SW_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture,
void **pixels, int *pitch)
306
307
{
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
308
309
310
return SDL_SW_QueryYUVTexturePixels((SDL_SW_YUVTexture *)
texture->driverdata, pixels,
pitch);
311
312
313
314
315
316
317
318
319
} else {
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
*pixels = surface->pixels;
*pitch = surface->pitch;
return 0;
}
}
320
321
322
static int
SW_SetTextureColorMod(SDL_Renderer * renderer, SDL_Texture * texture)
{
323
324
325
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
return SDL_SetSurfaceColorMod(surface, texture->r, texture->g,
texture->b);
326
327
328
329
330
}
static int
SW_SetTextureAlphaMod(SDL_Renderer * renderer, SDL_Texture * texture)
{
331
332
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
return SDL_SetSurfaceAlphaMod(surface, texture->a);
333
334
335
336
337
}
static int
SW_SetTextureBlendMode(SDL_Renderer * renderer, SDL_Texture * texture)
{
338
339
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
return SDL_SetSurfaceBlendMode(surface, texture->blendMode);
343
344
SW_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels, int pitch)
345
346
{
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
347
348
349
return SDL_SW_UpdateYUVTexture((SDL_SW_YUVTexture *)
texture->driverdata, rect, pixels,
pitch);
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
} 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
371
372
373
SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, int markDirty, void **pixels,
int *pitch)
374
375
{
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
376
377
378
return SDL_SW_LockYUVTexture((SDL_SW_YUVTexture *)
texture->driverdata, rect, markDirty,
pixels, pitch);
379
380
381
382
383
384
385
386
387
388
389
390
} 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
391
SW_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
392
393
394
395
396
397
{
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
SDL_SW_UnlockYUVTexture((SDL_SW_YUVTexture *) texture->driverdata);
}
}
398
static int
399
400
SW_RenderDrawPoints(SDL_Renderer * renderer, const SDL_Point * points,
int count)
401
402
{
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
403
SDL_Texture *texture = SW_ActivateRenderer(renderer);
404
SDL_Rect rect;
405
406
407
408
int i;
int x, y;
int status = 0;
409
410
411
412
if (!texture) {
return -1;
}
413
414
415
416
417
418
419
420
421
/* Get the smallest rectangle that contains everything */
rect.x = 0;
rect.y = 0;
rect.w = texture->w;
rect.h = texture->h;
if (!SDL_EnclosePoints(points, count, &rect, &rect)) {
/* Nothing to draw */
return 0;
}
423
if (data->renderer->LockTexture(data->renderer, texture, &rect, 1,
424
425
426
427
428
&data->surface.pixels,
&data->surface.pitch) < 0) {
return -1;
}
429
430
data->surface.clip_rect.w = data->surface.w = rect.w;
data->surface.clip_rect.h = data->surface.h = rect.h;
432
/* Draw the points! */
433
if (renderer->blendMode == SDL_BLENDMODE_NONE) {
434
435
436
437
438
439
440
Uint32 color = SDL_MapRGBA(data->surface.format,
renderer->r, renderer->g, renderer->b,
renderer->a);
for (i = 0; i < count; ++i) {
x = points[i].x - rect.x;
y = points[i].y - rect.y;
442
443
status = SDL_DrawPoint(&data->surface, x, y, color);
}
444
} else {
445
446
447
448
449
450
451
452
453
for (i = 0; i < count; ++i) {
x = points[i].x - rect.x;
y = points[i].y - rect.y;
status = SDL_BlendPoint(&data->surface, x, y,
renderer->blendMode,
renderer->r, renderer->g, renderer->b,
renderer->a);
}
454
455
}
456
457
data->renderer->UnlockTexture(data->renderer, texture);
458
459
460
return status;
}
462
463
SW_RenderDrawLines(SDL_Renderer * renderer, const SDL_Point * points,
int count)
464
465
{
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
466
SDL_Texture *texture = SW_ActivateRenderer(renderer);
467
468
469
470
471
SDL_Rect clip, rect;
int i;
int x1, y1, x2, y2;
int status = 0;
472
473
474
475
if (!texture) {
return -1;
}
476
477
478
479
480
481
482
483
484
/* Get the smallest rectangle that contains everything */
clip.x = 0;
clip.y = 0;
clip.w = texture->w;
clip.h = texture->h;
SDL_EnclosePoints(points, count, NULL, &rect);
if (!SDL_IntersectRect(&rect, &clip, &rect)) {
/* Nothing to draw */
return 0;
487
if (data->renderer->LockTexture(data->renderer, texture, &rect, 1,
488
&data->surface.pixels,
489
490
491
492
&data->surface.pitch) < 0) {
return -1;
}
493
494
data->surface.clip_rect.w = data->surface.w = rect.w;
data->surface.clip_rect.h = data->surface.h = rect.h;
496
/* Draw the points! */
497
if (renderer->blendMode == SDL_BLENDMODE_NONE) {
498
499
500
501
502
503
504
505
506
Uint32 color = SDL_MapRGBA(data->surface.format,
renderer->r, renderer->g, renderer->b,
renderer->a);
for (i = 1; i < count; ++i) {
x1 = points[i-1].x - rect.x;
y1 = points[i-1].y - rect.y;
x2 = points[i].x - rect.x;
y2 = points[i].y - rect.y;
508
509
status = SDL_DrawLine(&data->surface, x1, y1, x2, y2, color);
}
511
512
513
514
515
516
517
518
519
520
521
for (i = 1; i < count; ++i) {
x1 = points[i-1].x - rect.x;
y1 = points[i-1].y - rect.y;
x2 = points[i].x - rect.x;
y2 = points[i].y - rect.y;
status = SDL_BlendLine(&data->surface, x1, y1, x2, y2,
renderer->blendMode,
renderer->r, renderer->g, renderer->b,
renderer->a);
}
524
525
data->renderer->UnlockTexture(data->renderer, texture);
526
527
528
return status;
}
529
530
531
532
533
static int
SW_RenderFillRects(SDL_Renderer * renderer, const SDL_Rect ** rects,
int count)
{
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
534
SDL_Texture *texture = SW_ActivateRenderer(renderer);
535
536
537
538
539
SDL_Rect clip, rect;
Uint32 color = 0;
int i;
int status = 0;
540
541
542
543
if (!texture) {
return -1;
}
544
545
546
547
548
clip.x = 0;
clip.y = 0;
clip.w = texture->w;
clip.h = texture->h;
549
if (renderer->blendMode == SDL_BLENDMODE_NONE) {
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
color = SDL_MapRGBA(data->surface.format,
renderer->r, renderer->g, renderer->b,
renderer->a);
}
for (i = 0; i < count; ++i) {
if (!SDL_IntersectRect(rects[i], &clip, &rect)) {
/* Nothing to draw */
continue;
}
if (data->renderer->LockTexture(data->renderer, texture, &rect, 1,
&data->surface.pixels,
&data->surface.pitch) < 0) {
return -1;
}
data->surface.clip_rect.w = data->surface.w = rect.w;
data->surface.clip_rect.h = data->surface.h = rect.h;
570
if (renderer->blendMode == SDL_BLENDMODE_NONE) {
571
572
573
574
575
576
577
578
579
580
581
582
583
status = SDL_FillRect(&data->surface, NULL, color);
} else {
status = SDL_BlendFillRect(&data->surface, NULL,
renderer->blendMode,
renderer->r, renderer->g, renderer->b,
renderer->a);
}
data->renderer->UnlockTexture(data->renderer, texture);
}
return status;
}
585
SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
586
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
588
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
591
592
593
594
if (!SW_ActivateRenderer(renderer)) {
return -1;
}
595
if (data->renderer->LockTexture(data->renderer, data->texture,
596
597
dstrect, 1, &data->surface.pixels,
&data->surface.pitch) < 0) {
598
599
600
return -1;
}
601
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
602
603
604
605
status =
SDL_SW_CopyYUVToRGB((SDL_SW_YUVTexture *) texture->driverdata,
srcrect, data->format, dstrect->w, dstrect->h,
data->surface.pixels, data->surface.pitch);
606
607
} else {
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
608
609
610
611
612
613
614
615
616
617
618
619
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);
621
data->renderer->UnlockTexture(data->renderer, data->texture);
622
return status;
625
626
static int
SW_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
627
Uint32 format, void * pixels, int pitch)
628
629
630
{
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
631
632
633
634
if (!SW_ActivateRenderer(renderer)) {
return -1;
}
635
if (data->renderer->LockTexture(data->renderer, data->texture,
636
637
638
639
640
rect, 0, &data->surface.pixels,
&data->surface.pitch) < 0) {
return -1;
}
641
642
643
SDL_ConvertPixels(rect->w, rect->h,
data->format, data->surface.pixels, data->surface.pitch,
format, pixels, pitch);
645
data->renderer->UnlockTexture(data->renderer, data->texture);
646
647
648
649
650
return 0;
}
static int
SW_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
651
Uint32 format, const void * pixels, int pitch)
652
653
654
{
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
655
656
657
658
if (!SW_ActivateRenderer(renderer)) {
return -1;
}
659
if (data->renderer->LockTexture(data->renderer, data->texture,
660
661
662
663
664
rect, 1, &data->surface.pixels,
&data->surface.pitch) < 0) {
return -1;
}
665
666
SDL_ConvertPixels(rect->w, rect->h, format, pixels, pitch,
data->format, data->surface.pixels, data->surface.pitch);
668
data->renderer->UnlockTexture(data->renderer, data->texture);
669
670
671
return 0;
}
673
SW_RenderPresent(SDL_Renderer * renderer)
675
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
676
SDL_Texture *texture = SW_ActivateRenderer(renderer);
677
SDL_Rect rect;
679
680
681
682
if (!texture) {
return;
}
683
/* Send the data to the display */
684
685
686
687
688
rect.x = 0;
rect.y = 0;
rect.w = texture->w;
rect.h = texture->h;
data->renderer->RenderCopy(data->renderer, texture, &rect, &rect);
689
690
691
692
data->renderer->RenderPresent(data->renderer);
}
static void
693
SW_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
694
695
696
697
698
699
700
701
702
703
704
{
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
705
SW_DestroyRenderer(SDL_Renderer * renderer)
707
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
708
SDL_Window *window = renderer->window;
709
710
if (data) {
711
712
if (data->texture) {
DestroyTexture(data->renderer, data->texture);
714
715
716
717
718
719
if (data->surface.format) {
SDL_FreeFormat(data->surface.format);
}
if (data->renderer) {
data->renderer->DestroyRenderer(data->renderer);
}
720
721
722
723
724
725
726
SDL_FreeDirtyRects(&data->dirty);
SDL_free(data);
}
SDL_free(renderer);
}
/* vi: set ts=4 sw=4 expandtab: */