This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_DirectFB_render.c
1045 lines (925 loc) · 34.2 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2009 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
48
49
50
51
static int DirectFB_SetTexturePalette(SDL_Renderer * renderer,
SDL_Texture * texture,
const SDL_Color * colors,
int firstcolor, int ncolors);
static int DirectFB_GetTexturePalette(SDL_Renderer * renderer,
SDL_Texture * texture,
52
53
SDL_Color * colors,
int firstcolor, int ncolors);
54
55
56
57
58
59
60
61
62
63
static int DirectFB_SetTextureAlphaMod(SDL_Renderer * renderer,
SDL_Texture * texture);
static int DirectFB_SetTextureColorMod(SDL_Renderer * renderer,
SDL_Texture * texture);
static int DirectFB_SetTextureBlendMode(SDL_Renderer * renderer,
SDL_Texture * texture);
static int DirectFB_SetTextureScaleMode(SDL_Renderer * renderer,
SDL_Texture * texture);
static int DirectFB_UpdateTexture(SDL_Renderer * renderer,
SDL_Texture * texture,
64
65
const SDL_Rect * rect,
const void *pixels, int pitch);
66
static int DirectFB_LockTexture(SDL_Renderer * renderer,
67
68
69
SDL_Texture * texture,
const SDL_Rect * rect, int markDirty,
void **pixels, int *pitch);
70
71
72
73
74
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);
75
static int DirectFB_RenderPoint(SDL_Renderer * renderer, int x, int y);
76
77
78
79
static int DirectFB_RenderLine(SDL_Renderer * renderer, int x1, int y1,
int x2, int y2);
static int DirectFB_RenderFill(SDL_Renderer * renderer,
const SDL_Rect * rect);
80
81
static int DirectFB_RenderCopy(SDL_Renderer * renderer,
SDL_Texture * texture,
82
83
84
85
86
87
88
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);
89
90
#define SDL_DFB_WINDOWSURFACE(win) IDirectFBSurface *destsurf = ((DFB_WindowData *) ((win)->driverdata))->surface;
91
92
93
94
95
96
SDL_RenderDriver DirectFB_RenderDriver = {
DirectFB_CreateRenderer,
{
"directfb",
(SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY |
SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |
97
98
SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_PRESENTDISCARD |
SDL_RENDERER_ACCELERATED),
99
100
(SDL_TEXTUREMODULATE_NONE | SDL_TEXTUREMODULATE_COLOR |
SDL_TEXTUREMODULATE_ALPHA),
101
102
(SDL_BLENDMODE_NONE | SDL_BLENDMODE_MASK | SDL_BLENDMODE_BLEND |
SDL_BLENDMODE_ADD | SDL_BLENDMODE_MOD),
103
104
(SDL_TEXTURESCALEMODE_NONE | SDL_TEXTURESCALEMODE_FAST |
SDL_TEXTURESCALEMODE_SLOW | SDL_TEXTURESCALEMODE_BEST),
105
106
107
14,
{
SDL_PIXELFORMAT_INDEX4LSB,
108
SDL_PIXELFORMAT_INDEX8,
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
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
{
127
SDL_Window *window;
128
129
DFBSurfaceFlipFlags flipflags;
int isyuvdirect;
130
int size_changed;
131
132
133
int lastBlendMode;
DFBSurfaceBlittingFlags blitFlags;
DFBSurfaceDrawingFlags drawFlags;
134
135
136
137
138
139
140
141
142
} DirectFB_RenderData;
typedef struct
{
IDirectFBSurface *surface;
Uint32 format;
void *pixels;
int pitch;
IDirectFBPalette *palette;
143
144
SDL_VideoDisplay *display;
SDL_DirtyRectList dirty;
145
#if (DFB_VERSION_ATLEAST(1,2,0))
146
147
DFBSurfaceRenderOptions render_options;
#endif
148
149
} DirectFB_TextureData;
150
151
152
153
154
155
156
157
158
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;
}
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
static int
TextureHasAlpha(DirectFB_TextureData * data)
{
/* Drawing primitive ? */
if (!data)
return 0;
switch (data->format) {
case SDL_PIXELFORMAT_INDEX4LSB:
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)
{
185
186
187
SDL_DFB_WINDOWSURFACE(data->window);
//FIXME: check for format change
188
189
190
191
192
193
if (1 || data->lastBlendMode != blendMode) {
switch (blendMode) {
case SDL_BLENDMODE_NONE:
/**< No blending */
data->blitFlags = DSBLIT_NOFX;
data->drawFlags = DSDRAW_NOFX;
194
195
destsurf->SetSrcBlendFunction(destsurf, DSBF_ONE);
destsurf->SetDstBlendFunction(destsurf, DSBF_ZERO);
196
197
198
199
break;
case SDL_BLENDMODE_MASK:
data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
data->drawFlags = DSDRAW_BLEND;
200
201
destsurf->SetSrcBlendFunction(destsurf, DSBF_SRCALPHA);
destsurf->SetDstBlendFunction(destsurf,
202
203
204
205
206
DSBF_INVSRCALPHA);
break;
case SDL_BLENDMODE_BLEND:
data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
data->drawFlags = DSDRAW_BLEND;
207
208
destsurf->SetSrcBlendFunction(destsurf, DSBF_SRCALPHA);
destsurf->SetDstBlendFunction(destsurf,
209
210
211
212
213
DSBF_INVSRCALPHA);
break;
case SDL_BLENDMODE_ADD:
data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
data->drawFlags = DSDRAW_BLEND;
214
215
216
217
// FIXME: SRCALPHA kills performance on radeon ...
// It will be cheaper to copy the surface to
// a temporay surface and premultiply
if (source && TextureHasAlpha(source))
218
destsurf->SetSrcBlendFunction(destsurf,
219
220
DSBF_SRCALPHA);
else
221
222
destsurf->SetSrcBlendFunction(destsurf, DSBF_ONE);
destsurf->SetDstBlendFunction(destsurf, DSBF_ONE);
223
224
225
226
break;
case SDL_BLENDMODE_MOD:
data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
data->drawFlags = DSDRAW_BLEND;
227
228
destsurf->SetSrcBlendFunction(destsurf, DSBF_DESTCOLOR);
destsurf->SetDstBlendFunction(destsurf, DSBF_ZERO);
229
230
231
232
233
234
break;
}
data->lastBlendMode = blendMode;
}
}
235
236
237
238
239
240
241
242
void
DirectFB_AddRenderDriver(_THIS)
{
int i;
for (i = 0; i < _this->num_displays; i++)
SDL_AddRenderDriver(i, &DirectFB_RenderDriver);
}
243
244
245
246
247
static int
DisplayPaletteChanged(void *userdata, SDL_Palette * palette)
{
#if USE_DISPLAY_PALETTE
DirectFB_RenderData *data = (DirectFB_RenderData *) userdata;
248
SDL_DFB_WINDOWSURFACE(data->window);
249
250
251
252
253
254
255
IDirectFBPalette *surfpal;
int ret;
int i;
int ncolors;
DFBColor entries[256];
256
SDL_DFB_CHECKERR(destsurf->GetPalette(destsurf, &surfpal));
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
/* FIXME: number of colors */
ncolors = (palette->ncolors < 256 ? palette->ncolors : 256);
for (i = 0; i < ncolors; ++i) {
entries[i].r = palette->colors[i].r;
entries[i].g = palette->colors[i].g;
entries[i].b = palette->colors[i].b;
entries[i].a = palette->colors[i].unused;
}
SDL_DFB_CHECKERR(surfpal->SetEntries(surfpal, entries, ncolors, 0));
return 0;
error:
#endif
return -1;
}
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
SDL_Renderer *
DirectFB_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_DFB_WINDOWDATA(window);
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
SDL_Renderer *renderer = NULL;
DirectFB_RenderData *data = NULL;
DFBResult ret;
DFBSurfaceCapabilities scaps;
char *p;
SDL_DFB_CALLOC(renderer, 1, sizeof(*renderer));
SDL_DFB_CALLOC(data, 1, sizeof(*data));
renderer->DisplayModeChanged = DirectFB_DisplayModeChanged;
290
renderer->ActivateRenderer = DirectFB_ActivateRenderer;
291
292
293
294
295
296
297
298
299
300
301
302
renderer->CreateTexture = DirectFB_CreateTexture;
renderer->QueryTexturePixels = DirectFB_QueryTexturePixels;
renderer->SetTexturePalette = DirectFB_SetTexturePalette;
renderer->GetTexturePalette = DirectFB_GetTexturePalette;
renderer->SetTextureAlphaMod = DirectFB_SetTextureAlphaMod;
renderer->SetTextureColorMod = DirectFB_SetTextureColorMod;
renderer->SetTextureBlendMode = DirectFB_SetTextureBlendMode;
renderer->SetTextureScaleMode = DirectFB_SetTextureScaleMode;
renderer->UpdateTexture = DirectFB_UpdateTexture;
renderer->LockTexture = DirectFB_LockTexture;
renderer->UnlockTexture = DirectFB_UnlockTexture;
renderer->DirtyTexture = DirectFB_DirtyTexture;
303
renderer->RenderPoint = DirectFB_RenderPoint;
304
renderer->RenderLine = DirectFB_RenderLine;
305
306
307
308
309
310
renderer->RenderFill = DirectFB_RenderFill;
renderer->RenderCopy = DirectFB_RenderCopy;
renderer->RenderPresent = DirectFB_RenderPresent;
renderer->DestroyTexture = DirectFB_DestroyTexture;
renderer->DestroyRenderer = DirectFB_DestroyRenderer;
renderer->info = DirectFB_RenderDriver.info;
311
renderer->window = window->id; /* SDL window id */
312
313
314
315
316
renderer->driverdata = data;
renderer->info.flags =
SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTDISCARD;
317
data->window = window;
318
319
data->flipflags = DSFLIP_PIPELINE | DSFLIP_BLIT;
320
321
if (flags & SDL_RENDERER_PRESENTVSYNC) {
322
data->flipflags |= DSFLIP_WAITFORSYNC;
323
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
324
325
} else
data->flipflags |= DSFLIP_ONSYNC;
326
327
SDL_DFB_CHECKERR(windata->surface->GetCapabilities(windata->surface, &scaps));
328
329
330
331
332
333
334
if (scaps & DSCAPS_DOUBLE)
renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2;
else if (scaps & DSCAPS_TRIPLE)
renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3;
else
renderer->info.flags |= SDL_RENDERER_SINGLEBUFFER;
335
data->isyuvdirect = 0; /* default is off! */
336
p = SDL_getenv(DFBENV_USE_YUV_DIRECT);
337
338
339
if (p)
data->isyuvdirect = atoi(p);
340
341
342
343
344
/* Set up a palette watch on the display palette */
if (display->palette) {
SDL_AddPaletteWatch(display->palette, DisplayPaletteChanged, data);
}
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
return renderer;
error:
SDL_DFB_FREE(renderer);
SDL_DFB_FREE(data);
return NULL;
}
static DFBSurfacePixelFormat
SDLToDFBPixelFormat(Uint32 format)
{
switch (format) {
case SDL_PIXELFORMAT_INDEX4LSB:
return DSPF_ALUT44;
case SDL_PIXELFORMAT_INDEX8:
return DSPF_LUT8;
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) */
case SDL_PIXELFORMAT_INDEX1LSB:
return DSPF_UNKNOWN;
case SDL_PIXELFORMAT_INDEX1MSB:
return DSPF_UNKNOWN;
case SDL_PIXELFORMAT_INDEX4MSB:
return DSPF_UNKNOWN;
case SDL_PIXELFORMAT_RGB444:
394
#if (DFB_VERSION_ATLEAST(1,2,0))
395
396
return DSPF_RGB444;
#else
397
return DSPF_UNKNOWN;
398
#endif
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
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
417
DirectFB_ActivateRenderer(SDL_Renderer * renderer)
418
419
420
421
422
{
SDL_DFB_RENDERERDATA(renderer);
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
SDL_DFB_WINDOWDATA(window);
423
424
if (renddata->size_changed || windata->wm_needs_redraw) {
DirectFB_AdjustWindowSurface(window);
425
}
426
427
428
return 0;
}
429
430
431
432
433
434
435
436
437
static int
DirectFB_DisplayModeChanged(SDL_Renderer * renderer)
{
SDL_DFB_RENDERERDATA(renderer);
renddata->size_changed = SDL_TRUE;
return 0;
}
438
static int
439
DirectFB_AcquireVidLayer(SDL_Renderer * renderer, SDL_Texture * texture)
440
441
442
443
444
445
{
SDL_DFB_RENDERERDATA(renderer);
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
SDL_DFB_DEVICEDATA(display->device);
DFB_DisplayData *dispdata = (DFB_DisplayData *) display->driverdata;
446
DirectFB_TextureData *data = texture->driverdata;
447
DFBDisplayLayerConfig layconf;
448
int ret;
449
450
if (renddata->isyuvdirect && (dispdata->vidID >= 0)
451
&& (!dispdata->vidIDinuse)
452
&& SDL_ISPIXELFORMAT_FOURCC(data->format)) {
453
454
455
layconf.flags =
DLCONF_WIDTH | DLCONF_HEIGHT | DLCONF_PIXELFORMAT |
DLCONF_SURFACE_CAPS;
456
457
458
layconf.width = texture->w;
layconf.height = texture->h;
layconf.pixelformat = SDLToDFBPixelFormat(data->format);
459
layconf.surface_caps = DSCAPS_VIDEOONLY | DSCAPS_DOUBLE;
460
461
462
463
464
465
466
SDL_DFB_CHECKERR(devdata->dfb->GetDisplayLayer(devdata->dfb,
dispdata->vidID,
&dispdata->vidlayer));
SDL_DFB_CHECKERR(dispdata->
vidlayer->SetCooperativeLevel(dispdata->vidlayer,
DLSCL_EXCLUSIVE));
467
468
469
470
471
472
if (devdata->use_yuv_underlays) {
ret = dispdata->vidlayer->SetLevel(dispdata->vidlayer, -1);
if (ret != DFB_OK)
SDL_DFB_DEBUG("Underlay Setlevel not supported\n");
}
473
474
475
476
477
478
SDL_DFB_CHECKERR(dispdata->
vidlayer->SetConfiguration(dispdata->vidlayer,
&layconf));
SDL_DFB_CHECKERR(dispdata->
vidlayer->GetSurface(dispdata->vidlayer,
&data->surface));
479
480
dispdata->vidIDinuse = 1;
data->display = display;
481
return 0;
482
}
483
484
return 1;
error:
485
if (dispdata->vidlayer) {
486
SDL_DFB_RELEASE(data->surface);
487
488
489
SDL_DFB_CHECKERR(dispdata->
vidlayer->SetCooperativeLevel(dispdata->vidlayer,
DLSCL_ADMINISTRATIVE));
490
SDL_DFB_RELEASE(dispdata->vidlayer);
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
}
return 1;
}
static int
DirectFB_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
SDL_DFB_DEVICEDATA(display->device);
DirectFB_TextureData *data;
DFBResult ret;
DFBSurfaceDescription dsc;
SDL_DFB_CALLOC(data, 1, sizeof(*data));
texture->driverdata = data;
data->format = texture->format;
data->pitch = (texture->w * SDL_BYTESPERPIXEL(data->format));
if (DirectFB_AcquireVidLayer(renderer, texture) != 0) {
512
513
514
515
516
/* fill surface description */
dsc.flags =
DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS;
dsc.width = texture->w;
dsc.height = texture->h;
517
/* <1.2 Never use DSCAPS_VIDEOONLY here. It kills performance
518
* No DSCAPS_SYSTEMONLY either - let dfb decide
519
* 1.2: DSCAPS_SYSTEMONLY boosts performance by factor ~8
520
* Depends on other settings as well. Let dfb decide.
521
*/
522
dsc.caps = DSCAPS_PREMULTIPLIED;
523
#if 0
524
525
526
527
if (texture->access == SDL_TEXTUREACCESS_STREAMING)
dsc.caps |= DSCAPS_SYSTEMONLY;
else
dsc.caps |= DSCAPS_VIDEOONLY;
528
#endif
529
530
531
532
533
534
535
536
537
538
539
540
/* find the right pixelformat */
dsc.pixelformat = SDLToDFBPixelFormat(data->format);
if (dsc.pixelformat == DSPF_UNKNOWN) {
SDL_SetError("Unknown pixel format %d\n", data->format);
goto error;
}
data->pixels = NULL;
/* Create the surface */
541
542
SDL_DFB_CHECKERR(devdata->dfb->CreateSurface(devdata->dfb, &dsc,
&data->surface));
543
544
if (SDL_ISPIXELFORMAT_INDEXED(data->format)
&& !SDL_ISPIXELFORMAT_FOURCC(data->format)) {
545
546
SDL_DFB_CHECKERR(data->surface->GetPalette(data->surface,
&data->palette));
547
548
549
}
}
550
#if (DFB_VERSION_ATLEAST(1,2,0))
551
552
553
554
555
556
557
558
data->render_options = DSRO_NONE;
#endif
if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
SDL_DFB_CALLOC(data->pixels, 1, texture->h * data->pitch);
}
559
560
561
562
563
564
565
566
567
568
return 0;
error:
SDL_DFB_RELEASE(data->palette);
SDL_DFB_RELEASE(data->surface);
SDL_DFB_FREE(texture->driverdata);
return -1;
}
static int
569
570
DirectFB_QueryTexturePixels(SDL_Renderer * renderer,
SDL_Texture * texture, void **pixels, int *pitch)
571
{
572
573
DirectFB_TextureData *texturedata =
(DirectFB_TextureData *) texture->driverdata;
574
575
576
577
578
579
580
581
if (texturedata->display) {
return -1;
} else {
*pixels = texturedata->pixels;
*pitch = texturedata->pitch;
}
return 0;
582
583
584
}
static int
585
586
DirectFB_SetTexturePalette(SDL_Renderer * renderer,
SDL_Texture * texture,
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
const SDL_Color * colors, int firstcolor,
int ncolors)
{
DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata;
DFBResult ret;
if (SDL_ISPIXELFORMAT_INDEXED(data->format)
&& !SDL_ISPIXELFORMAT_FOURCC(data->format)) {
DFBColor entries[256];
int i;
for (i = 0; i < ncolors; ++i) {
entries[i].r = colors[i].r;
entries[i].g = colors[i].g;
entries[i].b = colors[i].b;
entries[i].a = 0xFF;
}
604
605
606
SDL_DFB_CHECKERR(data->
palette->SetEntries(data->palette, entries, ncolors,
firstcolor));
607
608
609
610
611
612
613
614
615
616
return 0;
} else {
SDL_SetError("YUV textures don't have a palette");
return -1;
}
error:
return -1;
}
static int
617
618
619
DirectFB_GetTexturePalette(SDL_Renderer * renderer,
SDL_Texture * texture, SDL_Color * colors,
int firstcolor, int ncolors)
620
621
622
623
624
625
626
627
628
{
DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata;
DFBResult ret;
if (SDL_ISPIXELFORMAT_INDEXED(data->format)
&& !SDL_ISPIXELFORMAT_FOURCC(data->format)) {
DFBColor entries[256];
int i;
629
630
631
SDL_DFB_CHECKERR(data->
palette->GetEntries(data->palette, entries, ncolors,
firstcolor));
632
633
634
635
636
for (i = 0; i < ncolors; ++i) {
colors[i].r = entries[i].r;
colors[i].g = entries[i].g;
colors[i].b = entries[i].b;
637
colors->unused = SDL_ALPHA_OPAQUE;
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
}
return 0;
} else {
SDL_SetError("YUV textures don't have a palette");
return -1;
}
error:
return -1;
}
static int
DirectFB_SetTextureAlphaMod(SDL_Renderer * renderer, SDL_Texture * texture)
{
return 0;
}
static int
DirectFB_SetTextureColorMod(SDL_Renderer * renderer, SDL_Texture * texture)
{
return 0;
}
static int
DirectFB_SetTextureBlendMode(SDL_Renderer * renderer, SDL_Texture * texture)
{
switch (texture->blendMode) {
664
665
666
667
668
case SDL_BLENDMODE_NONE:
case SDL_BLENDMODE_MASK:
case SDL_BLENDMODE_BLEND:
case SDL_BLENDMODE_ADD:
case SDL_BLENDMODE_MOD:
669
670
671
return 0;
default:
SDL_Unsupported();
672
texture->blendMode = SDL_BLENDMODE_NONE;
673
674
675
676
677
678
679
return -1;
}
}
static int
DirectFB_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture)
{
680
#if (DFB_VERSION_ATLEAST(1,2,0))
681
682
683
DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata;
684
685
686
switch (texture->scaleMode) {
case SDL_TEXTURESCALEMODE_NONE:
case SDL_TEXTURESCALEMODE_FAST:
687
688
data->render_options = DSRO_NONE;
break;
689
case SDL_TEXTURESCALEMODE_SLOW:
690
691
data->render_options = DSRO_SMOOTH_UPSCALE | DSRO_SMOOTH_DOWNSCALE;
break;
692
case SDL_TEXTURESCALEMODE_BEST:
693
694
695
data->render_options =
DSRO_SMOOTH_UPSCALE | DSRO_SMOOTH_DOWNSCALE | DSRO_ANTIALIAS;
break;
696
697
default:
SDL_Unsupported();
698
data->render_options = DSRO_NONE;
699
700
701
texture->scaleMode = SDL_TEXTURESCALEMODE_NONE;
return -1;
}
702
#endif
703
704
705
706
707
708
709
710
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;
711
712
DFBResult ret;
Uint8 *dpixels;
713
int dpitch;
714
715
716
Uint8 *src, *dst;
int row;
size_t length;
717
718
int bpp = DFB_BYTES_PER_PIXEL(SDLToDFBPixelFormat(texture->format));
// FIXME: SDL_BYTESPERPIXEL(texture->format) broken for yuv yv12 3 planes
719
720
SDL_DFB_CHECKERR(data->surface->Lock(data->surface,
721
722
DSLF_WRITE | DSLF_READ,
((void **) &dpixels), &dpitch));
723
src = (Uint8 *) pixels;
724
725
dst = (Uint8 *) dpixels + rect->y * dpitch + rect->x * bpp;
length = rect->w * bpp;
726
727
728
729
for (row = 0; row < rect->h; ++row) {
SDL_memcpy(dst, src, length);
src += pitch;
dst += dpitch;
730
}
731
SDL_DFB_CHECKERR(data->surface->Unlock(data->surface));
732
return 0;
733
734
error:
return 1;
735
736
737
738
739
}
static int
DirectFB_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
740
741
const SDL_Rect * rect, int markDirty,
void **pixels, int *pitch)
742
{
743
744
DirectFB_TextureData *texturedata =
(DirectFB_TextureData *) texture->driverdata;
745
746
DFBResult ret;
747
748
if (markDirty) {
SDL_AddDirtyRect(&texturedata->dirty, rect);
749
750
}
751
752
753
if (texturedata->display) {
void *fdata;
int fpitch;
754
755
756
757
758
759
760
761
762
763
764
765
766
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 +
rect->x * SDL_BYTESPERPIXEL(texture->format));
*pitch = texturedata->pitch;
}
767
return 0;
768
769
770
771
772
773
774
775
error:
return -1;
}
static void
DirectFB_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
{
776
777
DirectFB_TextureData *texturedata =
(DirectFB_TextureData *) texture->driverdata;
778
779
780
781
782
if (texturedata->display) {
texturedata->surface->Unlock(texturedata->surface);
texturedata->pixels = NULL;
}
783
784
785
786
787
788
}
static void
DirectFB_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture,
int numrects, const SDL_Rect * rects)
{
789
790
791
792
793
794
DirectFB_TextureData *data = (DirectFB_TextureData *) texture->driverdata;
int i;
for (i = 0; i < numrects; ++i) {
SDL_AddDirtyRect(&data->dirty, &rects[i]);
}
795
796
}
797
798
static int
PrepareDraw(SDL_Renderer * renderer)
799
800
{
DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
801
802
SDL_DFB_WINDOWSURFACE(data->window);
803
DFBResult ret;
804
805
806
807
808
809
810
811
Uint8 r, g, b, a;
r = renderer->r;
g = renderer->g;
b = renderer->b;
a = renderer->a;
SetBlendMode(data, renderer->blendMode, NULL);
812
SDL_DFB_CHECKERR(destsurf->SetDrawingFlags(destsurf,
813
data->drawFlags));
814
815
816
817
818
819
820
821
822
823
824
825
826
827
switch (renderer->blendMode) {
case SDL_BLENDMODE_NONE:
case SDL_BLENDMODE_MASK:
case SDL_BLENDMODE_BLEND:
break;
case SDL_BLENDMODE_ADD:
case SDL_BLENDMODE_MOD:
r = ((int) r * (int) a) / 255;
g = ((int) g * (int) a) / 255;
b = ((int) b * (int) a) / 255;
a = 255;
break;
}
828
829
SDL_DFB_CHECKERR(destsurf->SetColor(destsurf, r, g, b, a));
830
831
832
833
834
return 0;
error:
return -1;
}
835
836
837
838
static int
DirectFB_RenderPoint(SDL_Renderer * renderer, int x, int y)
{
DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
839
SDL_DFB_WINDOWSURFACE(data->window);
840
841
842
DFBResult ret;
PrepareDraw(renderer);
843
SDL_DFB_CHECKERR(destsurf->DrawLine(destsurf, x, y, x, y));
844
845
846
847
848
return 0;
error:
return -1;
}
849
850
851
852
static int
DirectFB_RenderLine(SDL_Renderer * renderer, int x1, int y1, int x2, int y2)
{
DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
853
SDL_DFB_WINDOWSURFACE(data->window);
854
855
856
DFBResult ret;
PrepareDraw(renderer);
857
/* Use antialiasing when available */
858
#if (DFB_VERSION_ATLEAST(1,2,0))
859
SDL_DFB_CHECKERR(destsurf->SetRenderOptions(destsurf,
860
861
DSRO_ANTIALIAS));
#endif
862
SDL_DFB_CHECKERR(destsurf->DrawLine(destsurf, x1, y1, x2, y2));
863
864
865
866
867
868
869
870
871
return 0;
error:
return -1;
}
static int
DirectFB_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect)
{
DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
872
SDL_DFB_WINDOWSURFACE(data->window);
873
874
875
DFBResult ret;
PrepareDraw(renderer);
876
SDL_DFB_CHECKERR(destsurf->FillRectangle(destsurf, rect->x, rect->y,
877
rect->w, rect->h));
878
879
880
881
882
883
884
885
886
887
888
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;
889
SDL_DFB_WINDOWSURFACE(data->window);
890
891
DirectFB_TextureData *texturedata =
(DirectFB_TextureData *) texture->driverdata;
892
Uint8 alpha = 0xFF;
893
894
DFBResult ret;
895
if (texturedata->display) {
896
897
898
int px, py;
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
SDL_DFB_WINDOWDATA(window);
899
900
SDL_VideoDisplay *display = texturedata->display;
DFB_DisplayData *dispdata = (DFB_DisplayData *) display->driverdata;
901
902
903
904
905
906
SDL_DFB_CHECKERR(dispdata->
vidlayer->SetSourceRectangle(dispdata->vidlayer,
srcrect->x, srcrect->y,
srcrect->w,
srcrect->h));
907
windata->window->GetPosition(windata->window, &px, &py);
908
909
910
911
912
913
914
915
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));
916
917
918
919
} else {
DFBRectangle sr, dr;
DFBSurfaceBlittingFlags flags = 0;
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
if (texturedata->dirty.list) {
SDL_DirtyRect *dirty;
void *pixels;
int bpp = SDL_BYTESPERPIXEL(texture->format);
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);
}
937
938
939
SDLtoDFBRect(srcrect, &sr);
SDLtoDFBRect(dstrect, &dr);
940
941
SDL_DFB_CHECKERR(destsurf->SetColor(destsurf, 0xFF, 0xFF, 0xFF, 0xFF));
942
943
if (texture->modMode &
(SDL_TEXTUREMODULATE_COLOR | SDL_TEXTUREMODULATE_ALPHA)) {
944
if (texture->modMode & SDL_TEXTUREMODULATE_ALPHA) {
945
alpha = texture->a;
946
SDL_DFB_CHECKERR(destsurf->SetColor(destsurf, 0xFF, 0xFF,
947
0xFF, alpha));
948
949
}
if (texture->modMode & SDL_TEXTUREMODULATE_COLOR) {
950
951
SDL_DFB_CHECKERR(destsurf->SetColor(destsurf,
952
953
954
texture->r,
texture->g,
texture->b, alpha));
955
flags |= DSBLIT_COLORIZE;
956
}
957
958
959
if (alpha < 0xFF)
flags |= DSBLIT_SRC_PREMULTCOLOR;
} else
960
SDL_DFB_CHECKERR(destsurf->SetColor(destsurf, 0xFF, 0xFF,
961
0xFF, 0xFF));
962
963
SetBlendMode(data, texture->blendMode, texturedata);
964
965
SDL_DFB_CHECKERR(destsurf->SetBlittingFlags(destsurf,
966
967
data->blitFlags
| flags));
968
969
#if (DFB_VERSION_ATLEAST(1,2,0))
970
SDL_DFB_CHECKERR(destsurf->SetRenderOptions(destsurf,
971
972
texturedata->
render_options));
973
#endif
974
975
if (srcrect->w == dstrect->w && srcrect->h == dstrect->h) {
976
SDL_DFB_CHECKERR(destsurf->Blit(destsurf,
977
978
texturedata->surface,
&sr, dr.x, dr.y));
979
} else {
980
SDL_DFB_CHECKERR(destsurf->StretchBlit(destsurf,
981
982
texturedata->surface,
&sr, &dr));
983
984
985
986
987
988
989
990
991
992
993
994
}
}
return 0;
error:
return -1;
}
static void
DirectFB_RenderPresent(SDL_Renderer * renderer)
{
DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->driverdata;
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
995
SDL_DFB_WINDOWDATA(window);
996
997
998
999
1000
DFBRectangle sr;
DFBResult ret;
sr.x = 0;