This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_DirectFB_render.c
865 lines (761 loc) · 28.5 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
21
22
23
24
25
26
27
28
29
30
31
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
SDL1.3 implementation by couriersud@arcor.de
*/
#include "SDL_config.h"
#include "SDL_DirectFB_video.h"
#include "SDL_DirectFB_render.h"
#include "../SDL_rect_c.h"
#include "../SDL_yuv_sw_c.h"
32
33
34
/* the following is not yet tested ... */
#define USE_DISPLAY_PALETTE (0)
35
36
37
38
39
/* GDI renderer implementation */
static SDL_Renderer *DirectFB_CreateRenderer(SDL_Window * window,
Uint32 flags);
static int DirectFB_DisplayModeChanged(SDL_Renderer * renderer);
40
static int DirectFB_ActivateRenderer(SDL_Renderer * renderer);
41
42
43
static int DirectFB_CreateTexture(SDL_Renderer * renderer,
SDL_Texture * texture);
static int DirectFB_QueryTexturePixels(SDL_Renderer * renderer,
44
45
SDL_Texture * texture,
void **pixels, int *pitch);
46
47
static int DirectFB_UpdateTexture(SDL_Renderer * renderer,
SDL_Texture * texture,
48
49
const SDL_Rect * rect,
const void *pixels, int pitch);
50
static int DirectFB_LockTexture(SDL_Renderer * renderer,
51
52
53
SDL_Texture * texture,
const SDL_Rect * rect, int markDirty,
void **pixels, int *pitch);
54
55
56
57
58
static void DirectFB_UnlockTexture(SDL_Renderer * renderer,
SDL_Texture * texture);
static void DirectFB_DirtyTexture(SDL_Renderer * renderer,
SDL_Texture * texture, int numrects,
const SDL_Rect * rects);
59
60
61
62
63
64
static int DirectFB_RenderDrawPoints(SDL_Renderer * renderer,
const SDL_Point * points, int count);
static int DirectFB_RenderDrawLines(SDL_Renderer * renderer,
const SDL_Point * points, int count);
static int DirectFB_RenderFillRects(SDL_Renderer * renderer,
const SDL_Rect ** rects, int count);
65
66
static int DirectFB_RenderCopy(SDL_Renderer * renderer,
SDL_Texture * texture,
67
68
69
70
71
72
73
const SDL_Rect * srcrect,
const SDL_Rect * dstrect);
static void DirectFB_RenderPresent(SDL_Renderer * renderer);
static void DirectFB_DestroyTexture(SDL_Renderer * renderer,
SDL_Texture * texture);
static void DirectFB_DestroyRenderer(SDL_Renderer * renderer);
74
75
#define SDL_DFB_WINDOWSURFACE(win) IDirectFBSurface *destsurf = ((DFB_WindowData *) ((win)->driverdata))->surface;
76
77
78
79
SDL_RenderDriver DirectFB_RenderDriver = {
DirectFB_CreateRenderer,
{
"directfb",
80
(SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_ACCELERATED),
81
12,
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
{
SDL_PIXELFORMAT_RGB332,
SDL_PIXELFORMAT_RGB555,
SDL_PIXELFORMAT_RGB565,
SDL_PIXELFORMAT_RGB888,
SDL_PIXELFORMAT_ARGB8888,
SDL_PIXELFORMAT_ARGB4444,
SDL_PIXELFORMAT_ARGB1555,
SDL_PIXELFORMAT_RGB24,
SDL_PIXELFORMAT_YV12,
SDL_PIXELFORMAT_IYUV,
SDL_PIXELFORMAT_YUY2,
SDL_PIXELFORMAT_UYVY},
0,
0}
};
typedef struct
{
101
SDL_Window *window;
102
103
DFBSurfaceFlipFlags flipflags;
int isyuvdirect;
104
int size_changed;
105
106
107
int lastBlendMode;
DFBSurfaceBlittingFlags blitFlags;
DFBSurfaceDrawingFlags drawFlags;
108
109
110
111
112
113
114
115
} DirectFB_RenderData;
typedef struct
{
IDirectFBSurface *surface;
Uint32 format;
void *pixels;
int pitch;
116
117
SDL_VideoDisplay *display;
SDL_DirtyRectList dirty;
118
#if (DFB_VERSION_ATLEAST(1,2,0))
119
120
DFBSurfaceRenderOptions render_options;
#endif
121
122
} DirectFB_TextureData;
123
124
125
126
127
128
129
130
131
static __inline__ void
SDLtoDFBRect(const SDL_Rect * sr, DFBRectangle * dr)
{
dr->x = sr->x;
dr->y = sr->y;
dr->h = sr->h;
dr->w = sr->w;
}
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
static int
TextureHasAlpha(DirectFB_TextureData * data)
{
/* Drawing primitive ? */
if (!data)
return 0;
switch (data->format) {
case SDL_PIXELFORMAT_ARGB4444:
case SDL_PIXELFORMAT_ARGB1555:
case SDL_PIXELFORMAT_ARGB8888:
case SDL_PIXELFORMAT_RGBA8888:
case SDL_PIXELFORMAT_ABGR8888:
case SDL_PIXELFORMAT_BGRA8888:
case SDL_PIXELFORMAT_ARGB2101010:
return 1;
default:
return 0;
}
}
static void
SetBlendMode(DirectFB_RenderData * data, int blendMode,
DirectFB_TextureData * source)
{
157
158
159
SDL_DFB_WINDOWSURFACE(data->window);
//FIXME: check for format change
160
161
162
163
164
165
if (1 || data->lastBlendMode != blendMode) {
switch (blendMode) {
case SDL_BLENDMODE_NONE:
/**< No blending */
data->blitFlags = DSBLIT_NOFX;
data->drawFlags = DSDRAW_NOFX;
166
167
SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_ONE));
SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_ZERO));
168
169
170
171
break;
case SDL_BLENDMODE_BLEND:
data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
data->drawFlags = DSDRAW_BLEND;
172
173
SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_SRCALPHA));
SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_INVSRCALPHA));
174
175
176
177
break;
case SDL_BLENDMODE_ADD:
data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
data->drawFlags = DSDRAW_BLEND;
178
179
180
181
// FIXME: SRCALPHA kills performance on radeon ...
// It will be cheaper to copy the surface to
// a temporay surface and premultiply
if (source && TextureHasAlpha(source))
182
SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_SRCALPHA));
183
else
184
185
SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_ONE));
SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_ONE));
186
187
188
189
190
191
break;
}
data->lastBlendMode = blendMode;
}
}
192
193
194
195
void
DirectFB_AddRenderDriver(_THIS)
{
int i;
196
197
for (i = 0; i < _this->num_displays; ++i) {
198
SDL_AddRenderDriver(&_this->displays[i], &DirectFB_RenderDriver);
199
}
200
201
202
203
204
205
}
SDL_Renderer *
DirectFB_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_DFB_WINDOWDATA(window);
206
SDL_VideoDisplay *display = window->display;
207
208
209
210
211
212
213
214
SDL_Renderer *renderer = NULL;
DirectFB_RenderData *data = NULL;
char *p;
SDL_DFB_CALLOC(renderer, 1, sizeof(*renderer));
SDL_DFB_CALLOC(data, 1, sizeof(*data));
renderer->DisplayModeChanged = DirectFB_DisplayModeChanged;
215
renderer->ActivateRenderer = DirectFB_ActivateRenderer;
216
217
218
219
220
221
renderer->CreateTexture = DirectFB_CreateTexture;
renderer->QueryTexturePixels = DirectFB_QueryTexturePixels;
renderer->UpdateTexture = DirectFB_UpdateTexture;
renderer->LockTexture = DirectFB_LockTexture;
renderer->UnlockTexture = DirectFB_UnlockTexture;
renderer->DirtyTexture = DirectFB_DirtyTexture;
222
223
224
renderer->RenderDrawPoints = DirectFB_RenderDrawPoints;
renderer->RenderDrawLines = DirectFB_RenderDrawLines;
renderer->RenderFillRects = DirectFB_RenderFillRects;
225
226
/* RenderDrawEllipse - no reference implementation yet */
/* RenderFillEllipse - no reference implementation yet */
227
228
renderer->RenderCopy = DirectFB_RenderCopy;
renderer->RenderPresent = DirectFB_RenderPresent;
229
230
/* RenderReadPixels is difficult to implement */
/* RenderWritePixels is difficult to implement */
231
232
233
renderer->DestroyTexture = DirectFB_DestroyTexture;
renderer->DestroyRenderer = DirectFB_DestroyRenderer;
renderer->info = DirectFB_RenderDriver.info;
234
renderer->window = window; /* SDL window */
235
236
renderer->driverdata = data;
237
renderer->info.flags = SDL_RENDERER_ACCELERATED;
238
239
data->window = window;
240
241
data->flipflags = DSFLIP_PIPELINE | DSFLIP_BLIT;
242
243
if (flags & SDL_RENDERER_PRESENTVSYNC) {
244
data->flipflags |= DSFLIP_WAITFORSYNC | DSFLIP_ONSYNC;
245
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
246
247
} else
data->flipflags |= DSFLIP_ONSYNC;
248
249
data->isyuvdirect = 0; /* default is off! */
250
p = SDL_getenv(DFBENV_USE_YUV_DIRECT);
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
if (p)
data->isyuvdirect = atoi(p);
return renderer;
error:
SDL_DFB_FREE(renderer);
SDL_DFB_FREE(data);
return NULL;
}
static DFBSurfacePixelFormat
SDLToDFBPixelFormat(Uint32 format)
{
switch (format) {
case SDL_PIXELFORMAT_RGB332:
return DSPF_RGB332;
case SDL_PIXELFORMAT_RGB555:
return DSPF_ARGB1555;
case SDL_PIXELFORMAT_ARGB4444:
return DSPF_ARGB4444;
case SDL_PIXELFORMAT_ARGB1555:
return DSPF_ARGB1555;
case SDL_PIXELFORMAT_RGB565:
return DSPF_RGB16;
case SDL_PIXELFORMAT_RGB24:
return DSPF_RGB24;
case SDL_PIXELFORMAT_RGB888:
return DSPF_RGB32;
case SDL_PIXELFORMAT_ARGB8888:
return DSPF_ARGB;
case SDL_PIXELFORMAT_YV12:
return DSPF_YV12; /* Planar mode: Y + V + U (3 planes) */
case SDL_PIXELFORMAT_IYUV:
return DSPF_I420; /* Planar mode: Y + U + V (3 planes) */
case SDL_PIXELFORMAT_YUY2:
return DSPF_YUY2; /* Packed mode: Y0+U0+Y1+V0 (1 plane) */
case SDL_PIXELFORMAT_UYVY:
return DSPF_UYVY; /* Packed mode: U0+Y0+V0+Y1 (1 plane) */
case SDL_PIXELFORMAT_YVYU:
return DSPF_UNKNOWN; /* Packed mode: Y0+V0+Y1+U0 (1 plane) */
292
#if (DFB_VERSION_ATLEAST(1,2,0))
293
case SDL_PIXELFORMAT_RGB444:
294
295
return DSPF_RGB444;
#endif
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
case SDL_PIXELFORMAT_BGR24:
return DSPF_UNKNOWN;
case SDL_PIXELFORMAT_BGR888:
return DSPF_UNKNOWN;
case SDL_PIXELFORMAT_RGBA8888:
return DSPF_UNKNOWN;
case SDL_PIXELFORMAT_ABGR8888:
return DSPF_UNKNOWN;
case SDL_PIXELFORMAT_BGRA8888:
return DSPF_UNKNOWN;
case SDL_PIXELFORMAT_ARGB2101010:
return DSPF_UNKNOWN;
default:
return DSPF_UNKNOWN;
}
}
static int
314
DirectFB_ActivateRenderer(SDL_Renderer * renderer)
315
316
{
SDL_DFB_RENDERERDATA(renderer);
317
SDL_Window *window = renderer->window;
318
319
SDL_DFB_WINDOWDATA(window);
320
if (renddata->size_changed || windata->wm_needs_redraw) {
321
// DirectFB_AdjustWindowSurface(window);
322
}
323
324
325
return 0;
}
326
327
328
329
330
331
332
333
334
static int
DirectFB_DisplayModeChanged(SDL_Renderer * renderer)
{
SDL_DFB_RENDERERDATA(renderer);
renddata->size_changed = SDL_TRUE;
return 0;
}
335
static int
336
DirectFB_AcquireVidLayer(SDL_Renderer * renderer, SDL_Texture * texture)
337
338
{
SDL_DFB_RENDERERDATA(renderer);
339
SDL_Window *window = renderer->window;
340
SDL_VideoDisplay *display = window->display;
341
342
SDL_DFB_DEVICEDATA(display->device);
DFB_DisplayData *dispdata = (DFB_DisplayData *) display->driverdata;
343
DirectFB_TextureData *data = texture->driverdata;
344
DFBDisplayLayerConfig layconf;
345
DFBResult ret;
346
347
if (renddata->isyuvdirect && (dispdata->vidID >= 0)
348
&& (!dispdata->vidIDinuse)
349
&& SDL_ISPIXELFORMAT_FOURCC(data->format)) {
350
351
352
layconf.flags =
DLCONF_WIDTH | DLCONF_HEIGHT | DLCONF_PIXELFORMAT |
DLCONF_SURFACE_CAPS;
353
354
355
layconf.width = texture->w;
layconf.height = texture->h;
layconf.pixelformat = SDLToDFBPixelFormat(data->format);
356
layconf.surface_caps = DSCAPS_VIDEOONLY | DSCAPS_DOUBLE;
357
358
359
360
361
362
363
SDL_DFB_CHECKERR(devdata->dfb->GetDisplayLayer(devdata->dfb,
dispdata->vidID,
&dispdata->vidlayer));
SDL_DFB_CHECKERR(dispdata->
vidlayer->SetCooperativeLevel(dispdata->vidlayer,
DLSCL_EXCLUSIVE));
364
365
if (devdata->use_yuv_underlays) {
366
ret = SDL_DFB_CHECK(dispdata->vidlayer->SetLevel(dispdata->vidlayer, -1));
367
368
369
if (ret != DFB_OK)
SDL_DFB_DEBUG("Underlay Setlevel not supported\n");
}
370
371
372
373
374
375
SDL_DFB_CHECKERR(dispdata->
vidlayer->SetConfiguration(dispdata->vidlayer,
&layconf));
SDL_DFB_CHECKERR(dispdata->
vidlayer->GetSurface(dispdata->vidlayer,
&data->surface));
376
377
dispdata->vidIDinuse = 1;
data->display = display;
378
return 0;
379
}
380
381
return 1;
error:
382
if (dispdata->vidlayer) {
383
SDL_DFB_RELEASE(data->surface);
384
385
386
SDL_DFB_CHECKERR(dispdata->
vidlayer->SetCooperativeLevel(dispdata->vidlayer,
DLSCL_ADMINISTRATIVE));
387
SDL_DFB_RELEASE(dispdata->vidlayer);
388
389
390
391
392
393
394
}
return 1;
}
static int
DirectFB_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
395
SDL_Window *window = renderer->window;
396
SDL_VideoDisplay *display = window->display;
397
398
399
SDL_DFB_DEVICEDATA(display->device);
DirectFB_TextureData *data;
DFBSurfaceDescription dsc;
400
DFBSurfacePixelFormat pixelformat;
401
402
403
404
SDL_DFB_CALLOC(data, 1, sizeof(*data));
texture->driverdata = data;
405
406
407
408
409
410
411
/* find the right pixelformat */
pixelformat = SDLToDFBPixelFormat(texture->format);
if (pixelformat == DSPF_UNKNOWN) {
SDL_SetError("Unknown pixel format %d\n", data->format);
goto error;
}
412
data->format = texture->format;
413
data->pitch = texture->w * DFB_BYTES_PER_PIXEL(pixelformat);
414
415
if (DirectFB_AcquireVidLayer(renderer, texture) != 0) {
416
417
418
419
420
/* fill surface description */
dsc.flags =
DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS;
dsc.width = texture->w;
dsc.height = texture->h;
421
/* <1.2 Never use DSCAPS_VIDEOONLY here. It kills performance
422
* No DSCAPS_SYSTEMONLY either - let dfb decide
423
* 1.2: DSCAPS_SYSTEMONLY boosts performance by factor ~8
424
* Depends on other settings as well. Let dfb decide.
425
*/
426
dsc.caps = DSCAPS_PREMULTIPLIED;
427
#if 0
428
429
430
431
if (texture->access == SDL_TEXTUREACCESS_STREAMING)
dsc.caps |= DSCAPS_SYSTEMONLY;
else
dsc.caps |= DSCAPS_VIDEOONLY;
432
#endif
433
434
dsc.pixelformat = pixelformat;
435
436
437
data->pixels = NULL;
/* Create the surface */
438
439
SDL_DFB_CHECKERR(devdata->dfb->CreateSurface(devdata->dfb, &dsc,
&data->surface));
440
}
441
#if (DFB_VERSION_ATLEAST(1,2,0))
442
443
444
445
data->render_options = DSRO_NONE;
#endif
if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
446
447
448
449
450
451
452
/* 3 plane YUVs return 1 bpp, but we need more space for other planes */
if(texture->format == SDL_PIXELFORMAT_YV12 ||
texture->format == SDL_PIXELFORMAT_IYUV) {
SDL_DFB_CALLOC(data->pixels, 1, (texture->h * data->pitch * 3 + texture->h * data->pitch * 3 % 2) / 2);
} else {
SDL_DFB_CALLOC(data->pixels, 1, texture->h * data->pitch);
}
453
454
}
455
456
457
458
459
460
461
462
463
464
return 0;
error:
SDL_DFB_RELEASE(data->palette);
SDL_DFB_RELEASE(data->surface);
SDL_DFB_FREE(texture->driverdata);
return -1;
}
static int
465
466
DirectFB_QueryTexturePixels(SDL_Renderer * renderer,
SDL_Texture * texture, void **pixels, int *pitch)
467
{
468
469
DirectFB_TextureData *texturedata =
(DirectFB_TextureData *) texture->driverdata;
470
471
472
473
474
475
476
477
if (texturedata->display) {
return -1;
} else {
*pixels = texturedata->pixels;
*pitch = texturedata->pitch;
}
return 0;
478
479
480
481
482
}
static int
DirectFB_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture)
{
483
#if (DFB_VERSION_ATLEAST(1,2,0))
484
485
486
DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata;
487
switch (texture->scaleMode) {
488
489
case SDL_SCALEMODE_NONE:
case SDL_SCALEMODE_FAST:
490
491
data->render_options = DSRO_NONE;
break;
492
case SDL_SCALEMODE_SLOW:
493
494
data->render_options = DSRO_SMOOTH_UPSCALE | DSRO_SMOOTH_DOWNSCALE;
break;
495
case SDL_SCALEMODE_BEST:
496
497
498
data->render_options =
DSRO_SMOOTH_UPSCALE | DSRO_SMOOTH_DOWNSCALE | DSRO_ANTIALIAS;
break;
499
500
default:
SDL_Unsupported();
501
data->render_options = DSRO_NONE;
502
texture->scaleMode = SDL_SCALEMODE_NONE;
503
504
return -1;
}
505
#endif
506
507
508
509
510
511
512
513
return 0;
}
static int
DirectFB_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * rect, const void *pixels, int pitch)
{
DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata;
514
Uint8 *dpixels;
515
int dpitch;
516
517
518
Uint8 *src, *dst;
int row;
size_t length;
519
520
int bpp = DFB_BYTES_PER_PIXEL(SDLToDFBPixelFormat(texture->format));
// FIXME: SDL_BYTESPERPIXEL(texture->format) broken for yuv yv12 3 planes
521
522
SDL_DFB_CHECKERR(data->surface->Lock(data->surface,
523
524
DSLF_WRITE | DSLF_READ,
((void **) &dpixels), &dpitch));
525
src = (Uint8 *) pixels;
526
527
dst = (Uint8 *) dpixels + rect->y * dpitch + rect->x * bpp;
length = rect->w * bpp;
528
529
530
531
for (row = 0; row < rect->h; ++row) {
SDL_memcpy(dst, src, length);
src += pitch;
dst += dpitch;
532
}
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
/* copy other planes for 3 plane formats */
if (texture->format == SDL_PIXELFORMAT_YV12 ||
texture->format == SDL_PIXELFORMAT_IYUV) {
src = (Uint8 *) pixels + texture->h * pitch;
dst = (Uint8 *) dpixels + texture->h * dpitch + rect->y * dpitch / 4 + rect->x * bpp / 2;
for (row = 0; row < rect->h / 2; ++row) {
SDL_memcpy(dst, src, length / 2);
src += pitch / 2;
dst += dpitch / 2;
}
src = (Uint8 *) pixels + texture->h * pitch + texture->h * pitch / 4;
dst = (Uint8 *) dpixels + texture->h * dpitch + texture->h * dpitch / 4 + rect->y * dpitch / 4 + rect->x * bpp / 2;
for (row = 0; row < rect->h / 2; ++row) {
SDL_memcpy(dst, src, length / 2);
src += pitch / 2;
dst += dpitch / 2;
}
}
551
SDL_DFB_CHECKERR(data->surface->Unlock(data->surface));
552
return 0;
553
554
error:
return 1;
555
556
557
558
559
}
static int
DirectFB_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
560
561
const SDL_Rect * rect, int markDirty,
void **pixels, int *pitch)
562
{
563
564
DirectFB_TextureData *texturedata =
(DirectFB_TextureData *) texture->driverdata;
565
566
567
if (markDirty) {
SDL_AddDirtyRect(&texturedata->dirty, rect);
568
569
}
570
571
572
if (texturedata->display) {
void *fdata;
int fpitch;
573
574
575
576
577
578
579
580
581
582
SDL_DFB_CHECKERR(texturedata->surface->Lock(texturedata->surface,
DSLF_WRITE | DSLF_READ,
&fdata, &fpitch));
*pitch = fpitch;
*pixels = fdata;
} else {
*pixels =
(void *) ((Uint8 *) texturedata->pixels +
rect->y * texturedata->pitch +
583
rect->x * DFB_BYTES_PER_PIXEL(SDLToDFBPixelFormat(texture->format)));
584
585
*pitch = texturedata->pitch;
}
586
return 0;
587
588
589
590
591
592
593
594
error:
return -1;
}
static void
DirectFB_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
595
596
DirectFB_TextureData *texturedata =
(DirectFB_TextureData *) texture->driverdata;
597
598
if (texturedata->display) {
599
SDL_DFB_CHECK(texturedata->surface->Unlock(texturedata->surface));
600
601
texturedata->pixels = NULL;
}
602
603
604
605
606
607
}
static void
DirectFB_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture,
int numrects, const SDL_Rect * rects)
{
608
609
610
611
612
613
DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata;
int i;
for (i = 0; i < numrects; ++i) {
SDL_AddDirtyRect(&data->dirty, &rects[i]);
}
614
615
}
616
617
static int
PrepareDraw(SDL_Renderer * renderer)
618
619
{
DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
620
SDL_DFB_WINDOWSURFACE(data->window);
621
622
623
624
625
626
627
628
629
Uint8 r, g, b, a;
r = renderer->r;
g = renderer->g;
b = renderer->b;
a = renderer->a;
SetBlendMode(data, renderer->blendMode, NULL);
630
SDL_DFB_CHECKERR(destsurf->SetDrawingFlags(destsurf, data->drawFlags));
631
632
633
634
635
636
637
638
639
640
641
642
switch (renderer->blendMode) {
case SDL_BLENDMODE_NONE:
case SDL_BLENDMODE_BLEND:
break;
case SDL_BLENDMODE_ADD:
r = ((int) r * (int) a) / 255;
g = ((int) g * (int) a) / 255;
b = ((int) b * (int) a) / 255;
a = 255;
break;
}
643
644
SDL_DFB_CHECKERR(destsurf->SetColor(destsurf, r, g, b, a));
645
646
647
648
649
return 0;
error:
return -1;
}
650
651
static int DirectFB_RenderDrawPoints(SDL_Renderer * renderer,
const SDL_Point * points, int count)
652
653
{
DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
654
SDL_DFB_WINDOWSURFACE(data->window);
655
int i;
656
657
PrepareDraw(renderer);
658
659
for (i=0; i < count; i++)
SDL_DFB_CHECKERR(destsurf->DrawLine(destsurf, points[i].x, points[i].y, points[i].x, points[i].y));
660
661
662
663
664
return 0;
error:
return -1;
}
665
666
static int DirectFB_RenderDrawLines(SDL_Renderer * renderer,
const SDL_Point * points, int count)
667
668
{
DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
669
SDL_DFB_WINDOWSURFACE(data->window);
670
int i;
671
672
PrepareDraw(renderer);
673
/* Use antialiasing when available */
674
#if (DFB_VERSION_ATLEAST(1,2,0))
675
SDL_DFB_CHECKERR(destsurf->SetRenderOptions(destsurf, DSRO_ANTIALIAS));
676
#endif
677
678
679
680
for (i=0; i < count - 1; i++)
SDL_DFB_CHECKERR(destsurf->DrawLine(destsurf, points[i].x, points[i].y, points[i+1].x, points[i+1].y));
681
682
683
684
685
return 0;
error:
return -1;
}
686
687
688
689
690
691
692
693
694
695
696
697
static int
DirectFB_RenderFillRects(SDL_Renderer * renderer, const SDL_Rect ** rects, int count)
{
DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
SDL_DFB_WINDOWSURFACE(data->window);
int i;
PrepareDraw(renderer);
for (i=0; i<count; i++)
SDL_DFB_CHECKERR(destsurf->FillRectangle(destsurf, rects[i]->x, rects[i]->y,
rects[i]->w, rects[i]->h));
698
699
700
701
702
703
704
705
706
707
708
return 0;
error:
return -1;
}
static int
DirectFB_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
{
DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
709
SDL_DFB_WINDOWSURFACE(data->window);
710
711
DirectFB_TextureData *texturedata =
(DirectFB_TextureData *) texture->driverdata;
712
Uint8 alpha = 0xFF;
713
714
if (texturedata->display) {
715
int px, py;
716
SDL_Window *window = renderer->window;
717
SDL_DFB_WINDOWDATA(window);
718
719
SDL_VideoDisplay *display = texturedata->display;
DFB_DisplayData *dispdata = (DFB_DisplayData *) display->driverdata;
720
721
722
723
724
725
SDL_DFB_CHECKERR(dispdata->
vidlayer->SetSourceRectangle(dispdata->vidlayer,
srcrect->x, srcrect->y,
srcrect->w,
srcrect->h));
726
SDL_DFB_CHECK(windata->window->GetPosition(windata->window, &px, &py));
727
728
729
730
731
732
733
734
px += windata->client.x;
py += windata->client.y;
SDL_DFB_CHECKERR(dispdata->
vidlayer->SetScreenRectangle(dispdata->vidlayer,
px + dstrect->x,
py + dstrect->y,
dstrect->w,
dstrect->h));
735
736
737
738
} else {
DFBRectangle sr, dr;
DFBSurfaceBlittingFlags flags = 0;
739
740
741
if (texturedata->dirty.list) {
SDL_DirtyRect *dirty;
void *pixels;
742
int bpp = DFB_BYTES_PER_PIXEL(SDLToDFBPixelFormat(texture->format));
743
744
745
746
747
748
749
750
751
752
753
754
755
int pitch = texturedata->pitch;
for (dirty = texturedata->dirty.list; dirty; dirty = dirty->next) {
SDL_Rect *rect = &dirty->rect;
pixels =
(void *) ((Uint8 *) texturedata->pixels +
rect->y * pitch + rect->x * bpp);
DirectFB_UpdateTexture(renderer, texture, rect,
texturedata->pixels,
texturedata->pitch);
}
SDL_ClearDirtyRects(&texturedata->dirty);
}
756
757
758
SDLtoDFBRect(srcrect, &sr);
SDLtoDFBRect(dstrect, &dr);
759
760
761
762
763
764
SDL_DFB_CHECKERR(destsurf->
SetColor(destsurf, 0xFF, 0xFF, 0xFF, 0xFF));
if (texture->
modMode & (SDL_TEXTUREMODULATE_COLOR | SDL_TEXTUREMODULATE_ALPHA))
{
765
if (texture->modMode & SDL_TEXTUREMODULATE_ALPHA) {
766
alpha = texture->a;
767
SDL_DFB_CHECKERR(destsurf->SetColor(destsurf, 0xFF, 0xFF,
768
0xFF, alpha));
769
770
}
if (texture->modMode & SDL_TEXTUREMODULATE_COLOR) {
771
772
SDL_DFB_CHECKERR(destsurf->SetColor(destsurf,
773
774
775
texture->r,
texture->g,
texture->b, alpha));
776
flags |= DSBLIT_COLORIZE;
777
}
778
779
780
if (alpha < 0xFF)
flags |= DSBLIT_SRC_PREMULTCOLOR;
} else
781
SDL_DFB_CHECKERR(destsurf->SetColor(destsurf, 0xFF, 0xFF,
782
0xFF, 0xFF));
783
784
SetBlendMode(data, texture->blendMode, texturedata);
785
786
SDL_DFB_CHECKERR(destsurf->SetBlittingFlags(destsurf,
787
data->blitFlags | flags));
788
789
#if (DFB_VERSION_ATLEAST(1,2,0))
790
SDL_DFB_CHECKERR(destsurf->SetRenderOptions(destsurf,
791
792
texturedata->
render_options));
793
#endif
794
795
if (srcrect->w == dstrect->w && srcrect->h == dstrect->h) {
796
SDL_DFB_CHECKERR(destsurf->Blit(destsurf,
797
798
texturedata->surface,
&sr, dr.x, dr.y));
799
} else {
800
SDL_DFB_CHECKERR(destsurf->StretchBlit(destsurf,
801
802
texturedata->surface,
&sr, &dr));
803
804
805
806
807
808
809
810
811
812
813
}
}
return 0;
error:
return -1;
}
static void
DirectFB_RenderPresent(SDL_Renderer * renderer)
{
DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
814
SDL_Window *window = renderer->window;
815
SDL_DFB_WINDOWDATA(window);
816
817
818
819
820
821
822
823
824
DFBRectangle sr;
sr.x = 0;
sr.y = 0;
sr.w = window->w;
sr.h = window->h;
/* Send the data to the display */
825
826
SDL_DFB_CHECK(windata->window_surface->Flip(windata->window_surface, NULL,
data->flipflags));
827
828
829
830
831
832
833
834
835
836
837
838
}
static void
DirectFB_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata;
if (!data) {
return;
}
SDL_DFB_RELEASE(data->palette);
SDL_DFB_RELEASE(data->surface);
839
if (data->display) {
840
841
842
DFB_DisplayData *dispdata =
(DFB_DisplayData *) data->display->driverdata;
dispdata->vidIDinuse = 0;
843
844
845
/* FIXME: Shouldn't we reset the cooperative level */
SDL_DFB_CHECK(dispdata->vidlayer->SetCooperativeLevel(dispdata->vidlayer,
DLSCL_ADMINISTRATIVE));
846
SDL_DFB_RELEASE(dispdata->vidlayer);
847
}
848
849
SDL_FreeDirtyRects(&data->dirty);
SDL_DFB_FREE(data->pixels);
850
851
852
853
854
855
856
857
SDL_free(data);
texture->driverdata = NULL;
}
static void
DirectFB_DestroyRenderer(SDL_Renderer * renderer)
{
DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
858
859
860
861
862
863
864
865
if (data) {
SDL_free(data);
}
SDL_free(renderer);
}
/* vi: set ts=4 sw=4 expandtab: */