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