This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_x11render.c
2361 lines (2164 loc) · 78.9 KB
1
/*
2
3
SDL - Simple DirectMedia Layer
4
Copyright (C) 1997-2010 Sam Lantinga
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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"
#if SDL_VIDEO_RENDER_X11
27
28
#include <limits.h> /* For INT_MIN and INT_MAX */
29
#include "SDL_x11video.h"
30
#include "SDL_x11render.h"
31
32
33
34
35
36
37
38
39
40
41
42
#include "../SDL_rect_c.h"
#include "../SDL_pixels_c.h"
#include "../SDL_yuv_sw_c.h"
/* X11 renderer implementation */
static SDL_Renderer *X11_CreateRenderer(SDL_Window * window, Uint32 flags);
static int X11_DisplayModeChanged(SDL_Renderer * renderer);
static int X11_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
static int X11_QueryTexturePixels(SDL_Renderer * renderer,
SDL_Texture * texture, void **pixels,
int *pitch);
43
44
static int X11_SetTextureRGBAMod(SDL_Renderer * renderer,
SDL_Texture * texture);
45
46
47
48
49
50
51
52
53
54
55
static int X11_SetTextureBlendMode(SDL_Renderer * renderer,
SDL_Texture * texture);
static int X11_SetTextureScaleMode(SDL_Renderer * renderer,
SDL_Texture * texture);
static int X11_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels,
int pitch);
static int X11_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, int markDirty,
void **pixels, int *pitch);
static void X11_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);
56
static int X11_SetDrawBlendMode(SDL_Renderer * renderer);
57
58
59
60
61
62
63
64
static int X11_RenderDrawPoints(SDL_Renderer * renderer,
const SDL_Point * points, int count);
static int X11_RenderDrawLines(SDL_Renderer * renderer,
const SDL_Point * points, int count);
static int X11_RenderDrawRects(SDL_Renderer * renderer,
const SDL_Rect ** rects, int count);
static int X11_RenderFillRects(SDL_Renderer * renderer,
const SDL_Rect ** rects, int count);
65
66
static int X11_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * srcrect, const SDL_Rect * dstrect);
67
68
69
70
static int X11_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 format, void * pixels, int pitch);
static int X11_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
Uint32 format, const void * pixels, int pitch);
71
72
73
74
75
76
77
78
79
80
81
82
83
84
static void X11_RenderPresent(SDL_Renderer * renderer);
static void X11_DestroyTexture(SDL_Renderer * renderer,
SDL_Texture * texture);
static void X11_DestroyRenderer(SDL_Renderer * renderer);
SDL_RenderDriver X11_RenderDriver = {
X11_CreateRenderer,
{
"x11",
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY |
SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |
SDL_RENDERER_PRESENTDISCARD | SDL_RENDERER_ACCELERATED),
SDL_TEXTUREMODULATE_NONE,
85
SDL_BLENDMODE_NONE,
86
SDL_SCALEMODE_NONE,
87
88
89
90
91
92
93
94
95
96
0,
{0},
0,
0}
};
typedef struct
{
Display *display;
int screen;
97
98
Visual *visual;
int depth;
99
int scanline_pad;
100
Window xwindow;
101
Pixmap pixmaps[3];
102
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
103
104
105
Pixmap stencil;
Pixmap brush;
Picture brush_pict;
106
Picture xwindow_pict;
107
Picture pixmap_picts[3];
108
Picture drawable_pict;
109
Picture stencil_pict;
110
int blend_op;
111
112
XRenderPictFormat *xwindow_pict_fmt;
XRenderPictFormat *drawable_pict_fmt;
113
GC stencil_gc;
114
SDL_bool use_xrender;
115
116
#ifdef SDL_VIDEO_DRIVER_X11_XDAMAGE
SDL_bool use_xdamage;
117
118
Damage stencil_damage;
XserverRegion stencil_parts;
119
#endif
120
#endif
121
122
int current_pixmap;
Drawable drawable;
123
SDL_PixelFormat format;
124
125
126
127
128
129
130
131
132
133
GC gc;
SDL_DirtyRectList dirty;
SDL_bool makedirty;
} X11_RenderData;
typedef struct
{
SDL_SW_YUVTexture *yuv;
Uint32 format;
Pixmap pixmap;
134
135
136
int depth;
Visual *visual;
GC gc;
137
138
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
Picture picture;
139
140
Pixmap modulated_pixmap;
Picture modulated_picture;
141
XRenderPictFormat* picture_fmt;
142
int blend_op;
143
const char* filter;
144
#endif
145
146
147
148
149
XImage *image;
#ifndef NO_SHARED_MEMORY
/* MIT shared memory extension information */
XShmSegmentInfo shminfo;
#endif
150
XImage *scaling_image;
151
152
153
154
155
156
157
void *pixels;
int pitch;
} X11_TextureData;
#ifndef NO_SHARED_MEMORY
/* Shared memory error handler routine */
static int shm_error;
158
159
160
static int (*X_handler) (Display *, XErrorEvent *) = NULL;
static int
shm_errhandler(Display * d, XErrorEvent * e)
161
{
162
163
164
165
166
167
if (e->error_code == BadAccess) {
shm_error = True;
return (0);
} else {
return (X_handler(d, e));
}
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
}
#endif /* ! NO_SHARED_MEMORY */
static void
UpdateYUVTextureData(SDL_Texture * texture)
{
X11_TextureData *data = (X11_TextureData *) texture->driverdata;
SDL_Rect rect;
rect.x = 0;
rect.y = 0;
rect.w = texture->w;
rect.h = texture->h;
SDL_SW_CopyYUVToRGB(data->yuv, &rect, data->format, texture->w,
texture->h, data->pixels, data->pitch);
}
185
186
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
static SDL_bool
187
188
CheckXRender(Display *display, int *major, int *minor)
{
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
const char *env;
*major = *minor = 0;
env = SDL_getenv("SDL_VIDEO_X11_XRENDER");
if (env && !SDL_atoi(env)) {
return SDL_FALSE;
}
if (!SDL_X11_HAVE_XRENDER) {
return SDL_FALSE;
}
if (!XRenderQueryVersion(display, major, minor)) {
return SDL_FALSE;
}
207
if (*major != 0 || *minor < 10) {
208
209
210
return SDL_FALSE;
}
211
212
213
214
215
216
return SDL_TRUE;
}
#endif
#ifdef SDL_VIDEO_DRIVER_X11_XFIXES
static SDL_bool
217
218
CheckXFixes(Display *display, int *major, int *minor)
{
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
const char *env;
*major = *minor = 0;
env = SDL_getenv("SDL_VIDEO_X11_XFIXES");
if (env && !SDL_atoi(env)) {
return SDL_FALSE;
}
if (!SDL_X11_HAVE_XFIXES) {
return SDL_FALSE;
}
if (!XFixesQueryVersion(display, major, minor)) {
return SDL_FALSE;
}
237
if (*major < 2) {
238
239
240
return SDL_FALSE;
}
241
242
243
244
245
246
return SDL_TRUE;
}
#endif
#ifdef SDL_VIDEO_DRIVER_X11_XDAMAGE
static SDL_bool
247
248
CheckXDamage(Display *display, int *major, int *minor)
{
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
const char *env;
*major = *minor = 0;
env = SDL_getenv("SDL_VIDEO_X11_XDAMAGE");
if (env && !SDL_atoi(env)) {
return SDL_FALSE;
}
if (!SDL_X11_HAVE_XDAMAGE) {
return SDL_FALSE;
}
if (!XDamageQueryVersion(display, major, minor)) {
return SDL_FALSE;
}
return SDL_TRUE;
}
#endif
271
272
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
static Uint32
273
274
XRenderPictFormatToSDLPixelFormatEnum(XRenderPictFormat *pict_format)
{
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
if (pict_format->type != PictTypeDirect) {
SDL_SetError("Indexed pict formats not supported ATM");
return 0;
}
Uint32 Amask, Rmask, Gmask, Bmask;
int bpp;
Rmask = pict_format->direct.redMask << pict_format->direct.red;
Gmask = pict_format->direct.greenMask << pict_format->direct.green;
Bmask = pict_format->direct.blueMask << pict_format->direct.blue;
Amask = pict_format->direct.alphaMask << pict_format->direct.alpha;
bpp = pict_format->depth;
Uint32 format;
format = SDL_MasksToPixelFormatEnum(bpp, Rmask, Gmask, Bmask, Amask);
return format;
}
#endif
294
295
296
297
void
X11_AddRenderDriver(_THIS)
{
SDL_RendererInfo *info = &X11_RenderDriver.info;
298
SDL_DisplayMode *mode = &SDL_CurrentDisplay->desktop_mode;
299
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
300
int i;
301
302
303
304
305
306
307
info->texture_formats[info->num_texture_formats++] = mode->format;
info->texture_formats[info->num_texture_formats++] = SDL_PIXELFORMAT_YV12;
info->texture_formats[info->num_texture_formats++] = SDL_PIXELFORMAT_IYUV;
info->texture_formats[info->num_texture_formats++] = SDL_PIXELFORMAT_YUY2;
info->texture_formats[info->num_texture_formats++] = SDL_PIXELFORMAT_UYVY;
info->texture_formats[info->num_texture_formats++] = SDL_PIXELFORMAT_YVYU;
308
309
310
311
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
int major, minor;
if (CheckXRender(data->display, &major, &minor)) {
312
313
314
315
316
XRenderPictFormat templ;
templ.type = PictTypeDirect;
XRenderPictFormat *pict_format;
Uint32 format;
int i = 0;
317
318
/* Convert each XRenderPictFormat into appropriate
* SDLPixelFormatEnum. */
319
320
321
322
323
324
325
326
327
328
329
330
while (info->num_texture_formats < 50) {
pict_format =
XRenderFindFormat(data->display, PictFormatType, &templ, i++);
if (pict_format) {
format = XRenderPictFormatToSDLPixelFormatEnum(pict_format);
if (format != SDL_PIXELTYPE_UNKNOWN) {
info->texture_formats[info->num_texture_formats++] = format;
}
}
else
break;
}
331
/* Update the capabilities of the renderer. */
332
info->blend_modes |= (SDL_BLENDMODE_BLEND | SDL_BLENDMODE_ADD |
333
SDL_BLENDMODE_MOD | SDL_BLENDMODE_MASK);
334
335
info->scale_modes |= (SDL_SCALEMODE_FAST | SDL_SCALEMODE_SLOW |
SDL_SCALEMODE_BEST);
336
info->mod_modes |= (SDL_TEXTUREMODULATE_COLOR | SDL_TEXTUREMODULATE_ALPHA);
337
338
}
#endif
339
340
341
342
for (i = 0; i < _this->num_displays; ++i) {
SDL_AddRenderDriver(&_this->displays[i], &X11_RenderDriver);
}
343
344
345
346
347
}
SDL_Renderer *
X11_CreateRenderer(SDL_Window * window, Uint32 flags)
{
348
SDL_VideoDisplay *display = window->display;
349
SDL_DisplayData *displaydata = (SDL_DisplayData *) display->driverdata;
350
351
352
353
SDL_WindowData *windowdata = (SDL_WindowData *) window->driverdata;
SDL_Renderer *renderer;
X11_RenderData *data;
XGCValues gcv;
354
gcv.graphics_exposures = False;
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
int i, n;
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
data = (X11_RenderData *) SDL_calloc(1, sizeof(*data));
if (!data) {
X11_DestroyRenderer(renderer);
SDL_OutOfMemory();
return NULL;
}
data->display = windowdata->videodata->display;
data->screen = displaydata->screen;
373
374
data->visual = displaydata->visual;
data->depth = displaydata->depth;
375
data->scanline_pad = displaydata->scanline_pad;
376
data->xwindow = windowdata->xwindow;
377
378
379
380
renderer->DisplayModeChanged = X11_DisplayModeChanged;
renderer->CreateTexture = X11_CreateTexture;
renderer->QueryTexturePixels = X11_QueryTexturePixels;
381
382
renderer->SetTextureAlphaMod = X11_SetTextureRGBAMod;
renderer->SetTextureColorMod = X11_SetTextureRGBAMod;
383
384
385
386
387
renderer->SetTextureBlendMode = X11_SetTextureBlendMode;
renderer->SetTextureScaleMode = X11_SetTextureScaleMode;
renderer->UpdateTexture = X11_UpdateTexture;
renderer->LockTexture = X11_LockTexture;
renderer->UnlockTexture = X11_UnlockTexture;
388
renderer->SetDrawBlendMode = X11_SetDrawBlendMode;
389
390
391
392
renderer->RenderDrawPoints = X11_RenderDrawPoints;
renderer->RenderDrawLines = X11_RenderDrawLines;
renderer->RenderDrawRects = X11_RenderDrawRects;
renderer->RenderFillRects = X11_RenderFillRects;
393
renderer->RenderCopy = X11_RenderCopy;
394
395
renderer->RenderReadPixels = X11_RenderReadPixels;
renderer->RenderWritePixels = X11_RenderWritePixels;
396
397
398
399
renderer->RenderPresent = X11_RenderPresent;
renderer->DestroyTexture = X11_DestroyTexture;
renderer->DestroyRenderer = X11_DestroyRenderer;
renderer->info = X11_RenderDriver.info;
400
renderer->window = window;
401
402
403
404
renderer->driverdata = data;
renderer->info.flags = SDL_RENDERER_ACCELERATED;
405
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
406
407
int major, minor;
data->use_xrender = CheckXRender(data->display, &major, &minor);
408
#ifdef SDL_VIDEO_DRIVER_X11_XDAMAGE
409
410
if (CheckXDamage(data->display, &major, &minor)) {
if (CheckXFixes(data->display, &major, &minor)) {
411
data->use_xdamage = SDL_TRUE;
412
}
413
}
414
#endif
415
if (data->use_xrender) {
416
417
/* Find the PictFormat from the visual.
* Should be an RGB PictFormat most of the time. */
418
419
data->xwindow_pict_fmt = XRenderFindVisualFormat(data->display,
data->visual);
420
421
422
423
if (!data->xwindow_pict_fmt) {
SDL_SetError("XRenderFindVisualFormat() failed");
return NULL;
}
424
425
426
data->xwindow_pict = XRenderCreatePicture(data->display,
data->xwindow,
data->xwindow_pict_fmt,
427
0, NULL);
428
429
430
431
432
if (!data->xwindow_pict) {
SDL_SetError("XRenderCreatePicture() failed");
return NULL;
}
// FIXME: Clear the window. Is this required?
433
434
435
436
437
438
439
440
441
XRenderComposite(data->display,
PictOpClear,
data->xwindow_pict,
None,
data->xwindow_pict,
0, 0,
0, 0,
0, 0,
window->w, window->h);
442
/* Create a clip mask that is used for rendering primitives. */
443
data->stencil = XCreatePixmap(data->display, data->xwindow,
444
window->w, window->h, 32);
445
446
447
448
if (!data->stencil) {
SDL_SetError("XCreatePixmap() failed.");
return NULL;
}
449
450
/* Create the GC for the clip mask. */
451
data->stencil_gc = XCreateGC(data->display, data->stencil,
452
GCGraphicsExposures, &gcv);
453
/* Set the GC parameters. */
454
455
XSetBackground(data->display, data->stencil_gc, 0);
XSetForeground(data->display, data->stencil_gc, 0);
456
457
XFillRectangle(data->display, data->stencil, data->stencil_gc,
0, 0, window->w, window->h);
458
XSetForeground(data->display, data->stencil_gc, 0xFFFFFFFF);
459
460
/* Create an XRender Picture for the clip mask. */
461
462
463
data->stencil_pict =
XRenderCreatePicture(data->display, data->stencil,
XRenderFindStandardFormat(data->display,
464
PictStandardARGB32),
465
0, NULL);
466
467
468
469
if (!data->stencil_pict) {
SDL_SetError("XRenderCreatePicture() failed.");
return NULL;
}
470
471
472
473
#ifdef SDL_VIDEO_DRIVER_X11_XDAMAGE
if (data->use_xdamage) {
data->stencil_damage =
XDamageCreate(data->display, data->stencil, XDamageReportNonEmpty);
474
475
476
477
if (!data->stencil_damage) {
SDL_SetError("XDamageCreate() failed.");
return NULL;
}
478
479
480
XDamageSubtract(data->display, data->stencil_damage, None, data->stencil_parts);
}
#endif
481
482
/* Create a brush pixmap for the color being
* drawn at any given time. */
483
484
data->brush =
XCreatePixmap(data->display, data->xwindow, 1, 1, 32);
485
486
487
488
489
490
if (!data->brush) {
SDL_SetError("XCreatePixmap() failed.");
return NULL;
}
/* Set some parameters for the brush. */
491
492
XRenderPictureAttributes brush_attr;
brush_attr.repeat = RepeatNormal;
493
494
/* Create an XRender Picture for the brush
* with the above parameters. */
495
496
497
498
499
data->brush_pict =
XRenderCreatePicture(data->display, data->brush,
XRenderFindStandardFormat(data->display,
PictStandardARGB32),
CPRepeat, &brush_attr);
500
501
502
503
504
505
if (!data->brush_pict) {
SDL_SetError("XRenderCreatePicture() failed.");
return NULL;
}
// FIXME: Is the following necessary?
/* Set the default blending mode. */
506
507
renderer->blendMode = SDL_BLENDMODE_BLEND;
data->blend_op = PictOpOver;
508
509
}
#endif
510
511
512
513
514
515
516
517
518
519
520
521
522
523
if (flags & SDL_RENDERER_SINGLEBUFFER) {
renderer->info.flags |=
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY);
n = 0;
} else 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;
}
524
525
526
527
528
529
530
531
532
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
if (data->use_xrender) {
if (n > 0)
data->drawable_pict_fmt =
XRenderFindStandardFormat(data->display, PictStandardARGB32);
else
data->drawable_pict_fmt = data->xwindow_pict_fmt;
}
#endif
533
for (i = 0; i < n; ++i) {
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
if (data->use_xrender) {
data->pixmaps[i] = XCreatePixmap(data->display,
data->xwindow,
window->w,
window->h,
32);
}
else
#endif
{
data->pixmaps[i] =
XCreatePixmap(data->display, data->xwindow, window->w, window->h,
displaydata->depth);
}
549
if (!data->pixmaps[i]) {
550
551
552
553
X11_DestroyRenderer(renderer);
SDL_SetError("XCreatePixmap() failed");
return NULL;
}
554
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
555
if (data->use_xrender) {
556
/* Create XRender pictures for each of the pixmaps
557
* and clear the pixmaps. */
558
data->pixmap_picts[i] =
559
560
561
562
XRenderCreatePicture(data->display,
data->pixmaps[i],
XRenderFindStandardFormat(data->display,
PictStandardARGB32),
563
0, None);
564
565
566
567
if (!data->pixmap_picts[i]) {
SDL_SetError("XRenderCreatePicture() failed");
return NULL;
}
568
569
570
571
572
573
574
575
576
577
XRenderComposite(data->display,
PictOpClear,
data->pixmap_picts[i],
None,
data->pixmap_picts[i],
0, 0,
0, 0,
0, 0,
window->w, window->h);
578
579
}
#endif
580
581
582
}
if (n > 0) {
data->drawable = data->pixmaps[0];
583
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
584
if(data->use_xrender == SDL_TRUE)
585
data->drawable_pict = data->pixmap_picts[0];
586
#endif
587
588
data->makedirty = SDL_TRUE;
} else {
589
data->drawable = data->xwindow;
590
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
591
if(data->use_xrender == SDL_TRUE)
592
data->drawable_pict = data->xwindow_pict;
593
#endif
594
595
596
597
data->makedirty = SDL_FALSE;
}
data->current_pixmap = 0;
598
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
599
600
/* When using XRender the drawable format
* is not the same as the screen format. */
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
if (data->use_xrender) {
bpp = data->drawable_pict_fmt->depth;
Rmask = ((data->drawable_pict_fmt->direct.redMask)
<< (data->drawable_pict_fmt->direct.red));
Gmask = ((data->drawable_pict_fmt->direct.greenMask)
<< (data->drawable_pict_fmt->direct.green));
Bmask = ((data->drawable_pict_fmt->direct.blueMask)
<< (data->drawable_pict_fmt->direct.blue));
Amask = ((data->drawable_pict_fmt->direct.alphaMask)
<< (data->drawable_pict_fmt->direct.alpha));
}
else
#endif
{
/* Get the format of the window */
if (!SDL_PixelFormatEnumToMasks
(display->current_mode.format, &bpp, &Rmask, &Gmask, &Bmask,
&Amask)) {
SDL_SetError("Unknown display format");
X11_DestroyRenderer(renderer);
return NULL;
}
623
}
624
SDL_InitFormat(&data->format, bpp, Rmask, Gmask, Bmask, Amask);
625
626
627
/* Create the drawing context */
gcv.graphics_exposures = False;
628
data->gc =
629
XCreateGC(data->display, data->drawable, GCGraphicsExposures, &gcv);
630
631
632
633
634
635
636
637
638
639
640
641
642
if (!data->gc) {
X11_DestroyRenderer(renderer);
SDL_SetError("XCreateGC() failed");
return NULL;
}
return renderer;
}
static int
X11_DisplayModeChanged(SDL_Renderer * renderer)
{
X11_RenderData *data = (X11_RenderData *) renderer->driverdata;
643
SDL_Window *window = renderer->window;
644
645
int i, n;
646
647
648
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
if (data->use_xrender) {
XRenderFreePicture(data->display, data->xwindow_pict);
649
650
651
data->xwindow_pict_fmt =
XRenderFindVisualFormat(data->display, data->visual);
652
653
654
655
656
if (!data->xwindow_pict_fmt) {
SDL_SetError("XRenderFindVisualFormat() failed.");
return -1;
}
657
658
659
data->xwindow_pict =
XRenderCreatePicture(data->display, data->xwindow,
data->xwindow_pict_fmt, 0, NULL);
660
661
662
663
664
if (!data->xwindow_pict) {
SDL_SetError("XRenderCreatePicture() failed.");
return -1;
}
665
666
667
668
669
670
671
672
673
674
675
676
677
XRenderComposite(data->display,
PictOpClear,
data->xwindow_pict,
None,
data->xwindow_pict,
0, 0,
0, 0,
0, 0,
window->w, window->h);
XFreePixmap(data->display, data->stencil);
data->stencil = XCreatePixmap(data->display, data->xwindow,
window->w, window->h, 32);
678
679
680
681
682
if (!data->stencil) {
SDL_SetError("XCreatePixmap() failed.");
return -1;
}
683
684
685
686
687
688
XRenderFreePicture(data->display, data->stencil_pict);
data->stencil_pict =
XRenderCreatePicture(data->display, data->stencil,
XRenderFindStandardFormat(data->display,
PictStandardARGB32),
0, NULL);
689
690
691
692
if (!data->stencil_pict) {
SDL_SetError("XRenderCreatePicture() failed.");
return -1;
}
693
694
#ifdef SDL_VIDEO_DRIVER_X11_XDAMAGE
if (data->use_xdamage) {
695
XDamageDestroy(data->display, data->stencil_damage);
696
697
data->stencil_damage =
XDamageCreate(data->display, data->stencil, XDamageReportNonEmpty);
698
699
700
701
if (!data->stencil_damage) {
SDL_SetError("XDamageCreate() failed.");
return -1;
}
702
703
704
XDamageSubtract(data->display, data->stencil_damage, None, data->stencil_parts);
}
#endif
705
706
}
#endif
707
708
709
710
711
712
713
714
715
716
717
718
719
if (renderer->info.flags & SDL_RENDERER_SINGLEBUFFER) {
n = 0;
} else 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->pixmaps[i] != None) {
XFreePixmap(data->display, data->pixmaps[i]);
data->pixmaps[i] = None;
720
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
721
XRenderFreePicture(data->display, data->pixmap_picts[i]);
722
data->pixmap_picts[i] = None;
723
#endif
724
725
726
}
}
for (i = 0; i < n; ++i) {
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
if (data->use_xrender) {
data->pixmaps[i] =
XCreatePixmap(data->display,
data->xwindow,
window->w,
window->h,
32);
}
else
#endif
{
data->pixmaps[i] =
XCreatePixmap(data->display, data->xwindow, window->w, window->h,
data->depth);
}
743
744
745
746
if (data->pixmaps[i] == None) {
SDL_SetError("XCreatePixmap() failed");
return -1;
}
747
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
748
if (data->use_xrender) {
749
data->pixmap_picts[i] =
750
751
752
753
XRenderCreatePicture(data->display,
data->pixmaps[i],
XRenderFindStandardFormat(data->display,
PictStandardARGB32),
754
0, None);
755
756
757
758
if (!data->pixmap_picts[i]) {
SDL_SetError("XRenderCreatePicture() failed");
return -1;
}
759
760
761
762
763
764
765
766
767
768
769
XRenderComposite(data->display,
PictOpClear,
data->pixmap_picts[i],
None,
data->pixmap_picts[i],
0, 0,
0, 0,
0, 0,
window->w, window->h);
}
770
#endif
771
772
773
}
if (n > 0) {
data->drawable = data->pixmaps[0];
774
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
775
data->drawable_pict = data->pixmap_picts[0];
776
#endif
777
778
779
780
781
782
}
data->current_pixmap = 0;
return 0;
}
783
784
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
static void
785
786
SDLMaskToXRenderMask(Uint32 sdl_mask, short *comp, short *compMask)
{
787
788
789
790
791
792
793
794
795
796
797
798
799
800
if (sdl_mask == 0) {
*comp = 0;
*compMask = 0;
} else {
(*comp) = 0;
(*compMask) = 0;
while(!(sdl_mask & 1)) {
(*comp)++;
sdl_mask >>= 1;
}
while(sdl_mask & 1) {
(*compMask) = ((*compMask) << 1) | 1;
sdl_mask >>= 1;
}
801
802
803
804
}
}
static XRenderPictFormat*
805
806
PixelFormatEnumToXRenderPictFormat(SDL_Renderer * renderer, Uint32 format)
{
807
808
XRenderPictFormat* pict_fmt = NULL;
X11_RenderData *data = (X11_RenderData *) renderer->driverdata;
809
810
811
812
813
if (data->use_xrender) {
int bpp;
Uint32 Amask, Rmask, Gmask, Bmask;
814
815
816
817
if(!SDL_PixelFormatEnumToMasks(format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
SDL_SetError("Unknown pixel format");
return NULL;
}
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
XRenderPictFormat templ;
unsigned long mask = (PictFormatType | PictFormatDepth | PictFormatRed |
PictFormatRedMask | PictFormatGreen | PictFormatGreenMask |
PictFormatBlue | PictFormatBlueMask | PictFormatAlpha |
PictFormatAlphaMask);
templ.type = PictTypeDirect;
templ.depth = bpp;
SDLMaskToXRenderMask(Amask, &(templ.direct.alpha), &(templ.direct.alphaMask));
SDLMaskToXRenderMask(Rmask, &(templ.direct.red), &(templ.direct.redMask));
SDLMaskToXRenderMask(Gmask, &(templ.direct.green), &(templ.direct.greenMask));
SDLMaskToXRenderMask(Bmask, &(templ.direct.blue), &(templ.direct.blueMask));
pict_fmt = XRenderFindFormat(data->display, mask, &templ, 0);
}
return pict_fmt;
}
static Visual*
837
838
PixelFormatEnumToVisual(SDL_Renderer * renderer, Uint32 format)
{
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
X11_RenderData *data = (X11_RenderData *) renderer->driverdata;
if (data->use_xrender) {
int bpp;
Uint32 Amask, Rmask, Gmask, Bmask;
SDL_PixelFormatEnumToMasks(format, &bpp, &Rmask, &Gmask, &Bmask, &Amask);
XVisualInfo vinfo_templ;
long vinfo_mask;
int nitems_return;
vinfo_mask = (VisualDepthMask | VisualRedMaskMask |
VisualGreenMaskMask | VisualBlueMaskMask);
vinfo_templ.depth = bpp;
vinfo_templ.red_mask = Rmask;
vinfo_templ.green_mask = Gmask;
vinfo_templ.blue_mask = Bmask;
XVisualInfo * ret = XGetVisualInfo(data->display, vinfo_mask,
&vinfo_templ, &nitems_return);
if (nitems_return) {
return ret[0].visual;
}
}
return NULL;
}
867
868
static XRenderColor
869
870
SDLColorToXRenderColor(Uint8 r, Uint8 g, Uint8 b, Uint8 a)
{
871
872
873
874
875
876
877
878
879
880
881
882
883
884
double rd, gd, bd, ad;
XRenderColor ret;
rd = r / 255.0;
gd = g / 255.0;
bd = b / 255.0;
ad = a / 255.0;
ret.red = (unsigned short) (rd * ad * 0xFFFF);
ret.green = (unsigned short) (gd * ad * 0xFFFF);
ret.blue = (unsigned short) (bd * ad * 0xFFFF);
ret.alpha = (unsigned short) (ad * 0xFFFF);
return ret;
}
885
886
#endif
887
888
889
890
static int
X11_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
X11_RenderData *renderdata = (X11_RenderData *) renderer->driverdata;
891
892
SDL_Window *window = renderer->window;
SDL_VideoDisplay *display = window->display;
893
X11_TextureData *data;
894
int pitch_alignmask = ((renderdata->scanline_pad / 8) - 1);
895
896
XGCValues gcv;
897
898
899
900
901
data = (X11_TextureData *) SDL_calloc(1, sizeof(*data));
if (!data) {
SDL_OutOfMemory();
return -1;
}
902
903
904
data->depth = renderdata->depth;
data->visual = renderdata->visual;
data->gc = renderdata->gc;
905
906
907
908
909
910
911
912
913
914
texture->driverdata = data;
if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
data->yuv =
SDL_SW_CreateYUVTexture(texture->format, texture->w, texture->h);
if (!data->yuv) {
return -1;
}
data->format = display->current_mode.format;
} else {
915
#ifdef SDL_VIDEO_DRIVER_X11_XRENDER
916
917
if (renderdata->use_xrender)
{
918
919
920
921
Uint32 Amask, Rmask, Gmask, Bmask;
SDL_PixelFormatEnumToMasks(texture->format, &(data->depth),
&Rmask, &Gmask, &Bmask, &Amask);
data->visual = PixelFormatEnumToVisual(renderer, texture->format);
922
}
923
else
924
#endif
925
926
927
928
929
930
{
if (texture->format != display->current_mode.format)
{
SDL_SetError("Texture format doesn't match window format");
return -1;
}
931
}
932
933
data->format = texture->format;
}
934
935
936
937
938
939
940
941
if (data->yuv || texture->access == SDL_TEXTUREACCESS_STREAMING) {
#ifndef NO_SHARED_MEMORY
XShmSegmentInfo *shminfo = &data->shminfo;
shm_error = True;
if (SDL_X11_HAVE_SHM) {
942
data->image =
943
XShmCreateImage(renderdata->display, data->visual,
944
data->depth, ZPixmap, NULL,
945
shminfo, texture->w, texture->h);
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
if (data->image) {
shminfo->shmid =
shmget(IPC_PRIVATE, texture->h * data->image->bytes_per_line,
IPC_CREAT | 0777);
if (shminfo->shmid >= 0) {
shminfo->shmaddr = (char *) shmat(shminfo->shmid, 0, 0);
shminfo->readOnly = False;
if (shminfo->shmaddr != (char *) -1) {
shm_error = False;
X_handler = XSetErrorHandler(shm_errhandler);
XShmAttach(renderdata->display, shminfo);
XSync(renderdata->display, False);
XSetErrorHandler(X_handler);
if (shm_error) {
XShmDetach(renderdata->display, shminfo);
shmdt(shminfo->shmaddr);
XDestroyImage(data->image);
XSync(renderdata->display, False);
}
else {
data->pixels = data->image->data = shminfo->shmaddr;
shmctl(shminfo->shmid, IPC_RMID, NULL);
data->pixmap =
XCreatePixmap(renderdata->display, renderdata->xwindow,
texture->w, texture->h, data->depth);
if (!data->pixmap) {
SDL_SetError("XCreatePixmap() failed");
return -1;
}
}
}
}
978
979
980
981
982
983
984
985
}
}
if (shm_error) {
shminfo->shmaddr = NULL;
}
if (!data->image)
#endif /* not NO_SHARED_MEMORY */
{
986
data->image =
987
988
XCreateImage(renderdata->display, data->visual,
data->depth, ZPixmap, 0, NULL,
989
990
texture->w, texture->h,
SDL_BYTESPERPIXEL(data->format) * 8,
991
0);
992
if (!data->image) {
993
X11_DestroyTexture(renderer, texture);
994
995
996
SDL_SetError("XCreateImage() failed");
return -1;
}
997
data->pixels = SDL_malloc(texture->h * data->image->bytes_per_line);
998
if (!data->pixels) {
999
X11_DestroyTexture(renderer, texture);
1000
SDL_OutOfMemory();