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