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