21 #include "../../SDL_internal.h" 23 #if SDL_VIDEO_DRIVER_DIRECTFB 30 #include "../SDL_sysvideo.h" 31 #include "../../render/SDL_sysrender.h" 33 #ifndef DFB_VERSION_ATLEAST 35 #define DFB_VERSIONNUM(X, Y, Z) \ 36 ((X)*1000 + (Y)*100 + (Z)) 38 #define DFB_COMPILEDVERSION \ 39 DFB_VERSIONNUM(DIRECTFB_MAJOR_VERSION, DIRECTFB_MINOR_VERSION, DIRECTFB_MICRO_VERSION) 41 #define DFB_VERSION_ATLEAST(X, Y, Z) \ 42 (DFB_COMPILEDVERSION >= DFB_VERSIONNUM(X, Y, Z)) 44 #define SDL_DFB_CHECK(x) x 49 #define USE_DISPLAY_PALETTE (0) 52 #define SDL_DFB_RENDERERDATA(rend) DirectFB_RenderData *renddata = ((rend) ? (DirectFB_RenderData *) (rend)->driverdata : NULL) 64 void **
pixels,
int *pitch);
68 int firstcolor,
int ncolors);
72 int firstcolor,
int ncolors);
84 const void *
pixels,
int pitch);
88 void **
pixels,
int *pitch);
122 #define SDL_DFB_WINDOWSURFACE(win) IDirectFBSurface *destsurf = ((DFB_WindowData *) ((win)->driverdata))->surface; 125 DirectFB_CreateRenderer,
146 DFBSurfaceFlipFlags flipflags;
149 DFBSurfaceBlittingFlags blitFlags;
150 DFBSurfaceDrawingFlags drawFlags;
152 } DirectFB_RenderData;
156 IDirectFBSurface *surface;
160 IDirectFBPalette *palette;
165 #if (DFB_VERSION_ATLEAST(1,2,0)) 166 DFBSurfaceRenderOptions render_options;
168 } DirectFB_TextureData;
171 SDLtoDFBRect(
const SDL_Rect * sr, DFBRectangle * dr)
179 SDLtoDFBRect_Float(
const SDL_FRect * sr, DFBRectangle * dr)
189 TextureHasAlpha(DirectFB_TextureData *
data)
197 switch (data->format) {
237 SetBlendMode(DirectFB_RenderData * data,
int blendMode,
238 DirectFB_TextureData *
source)
240 IDirectFBSurface *destsurf = data->target;
243 if (1 || data->lastBlendMode != blendMode) {
247 data->blitFlags = DSBLIT_NOFX;
248 data->drawFlags = DSDRAW_NOFX;
249 SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_ONE));
250 SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_ZERO));
253 case SDL_BLENDMODE_MASK:
254 data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
255 data->drawFlags = DSDRAW_BLEND;
256 SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_SRCALPHA));
257 SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_INVSRCALPHA));
261 data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
262 data->drawFlags = DSDRAW_BLEND;
263 SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_SRCALPHA));
264 SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_INVSRCALPHA));
267 data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
268 data->drawFlags = DSDRAW_BLEND;
272 if (source && TextureHasAlpha(source))
273 SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_SRCALPHA));
275 SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_ONE));
276 SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_ONE));
279 data->blitFlags = DSBLIT_BLEND_ALPHACHANNEL;
280 data->drawFlags = DSDRAW_BLEND;
281 SDL_DFB_CHECK(destsurf->SetSrcBlendFunction(destsurf, DSBF_ZERO));
282 SDL_DFB_CHECK(destsurf->SetDstBlendFunction(destsurf, DSBF_SRCCOLOR));
291 DisplayPaletteChanged(
void *userdata,
SDL_Palette * palette)
293 #if USE_DISPLAY_PALETTE 294 DirectFB_RenderData *data = (DirectFB_RenderData *) userdata;
295 SDL_DFB_WINDOWSURFACE(data->window);
296 IDirectFBPalette *surfpal;
300 DFBColor entries[256];
307 for (i = 0; i < ncolors; ++
i) {
325 SDL_DFB_RENDERERDATA(renderer);
338 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
339 IDirectFBSurface *destsurf = data->target;
341 DirectFB_ActivateRenderer(renderer);
343 PrepareDraw(renderer);
345 destsurf->Clear(destsurf, renderer->
r, renderer->
g, renderer->
b, renderer->
a);
354 IDirectFBSurface *winsurf = get_dfb_surface(window);
357 DirectFB_RenderData *data =
NULL;
358 DFBSurfaceCapabilities scaps;
391 renderer->QueryTexturePixels = DirectFB_QueryTexturePixels;
392 renderer->SetTexturePalette = DirectFB_SetTexturePalette;
393 renderer->GetTexturePalette = DirectFB_GetTexturePalette;
394 renderer->SetTextureScaleMode = DirectFB_SetTextureScaleMode;
395 renderer->DirtyTexture = DirectFB_DirtyTexture;
396 renderer->SetDrawBlendMode = DirectFB_SetDrawBlendMode;
397 renderer->RenderDrawRects = DirectFB_RenderDrawRects;
400 renderer->
info = DirectFB_RenderDriver.
info;
408 data->target = winsurf;
410 data->flipflags = DSFLIP_PIPELINE | DSFLIP_BLIT;
413 data->flipflags |= DSFLIP_WAITFORSYNC | DSFLIP_ONSYNC;
416 data->flipflags |= DSFLIP_ONSYNC;
421 if (scaps & DSCAPS_DOUBLE)
422 renderer->
info.
flags |= SDL_RENDERER_PRESENTFLIP2;
423 else if (scaps & DSCAPS_TRIPLE)
424 renderer->
info.
flags |= SDL_RENDERER_PRESENTFLIP3;
426 renderer->
info.
flags |= SDL_RENDERER_SINGLEBUFFER;
433 if (display-> palette) {
434 SDL_AddPaletteWatch(display->palette, DisplayPaletteChanged, data);
449 SDL_DFB_RENDERERDATA(renderer);
453 if (renddata->size_changed ) {
465 DFB_DisplayData *dispdata = (DFB_DisplayData *) display->
driverdata;
466 DirectFB_TextureData *data = texture->
driverdata;
467 DFBDisplayLayerConfig layconf;
470 if (devdata->use_yuv_direct && (dispdata->vidID >= 0)
471 && (!dispdata->vidIDinuse)
474 DLCONF_WIDTH | DLCONF_HEIGHT | DLCONF_PIXELFORMAT |
476 layconf.width = texture->
w;
477 layconf.height = texture->
h;
479 layconf.surface_caps = DSCAPS_VIDEOONLY | DSCAPS_DOUBLE;
483 &dispdata->vidlayer));
485 vidlayer->SetCooperativeLevel(dispdata->vidlayer,
488 if (devdata->use_yuv_underlays) {
489 ret = dispdata->vidlayer->SetLevel(dispdata->vidlayer, -1);
494 vidlayer->SetConfiguration(dispdata->vidlayer,
497 vidlayer->GetSurface(dispdata->vidlayer,
499 dispdata->vidIDinuse = 1;
500 data->display = display;
505 if (dispdata->vidlayer) {
508 vidlayer->SetCooperativeLevel(dispdata->vidlayer,
509 DLSCL_ADMINISTRATIVE));
521 DirectFB_TextureData *
data;
522 DFBSurfaceDescription dsc;
523 DFBSurfacePixelFormat pixelformat;
525 DirectFB_ActivateRenderer(renderer);
532 if (pixelformat == DSPF_UNKNOWN) {
533 SDL_SetError(
"Unknown pixel format %d\n", data->format);
537 data->format = texture->
format;
538 data->pitch = texture->
w * DFB_BYTES_PER_PIXEL(pixelformat);
540 if (DirectFB_AcquireVidLayer(renderer, texture) != 0) {
543 DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS;
544 dsc.width = texture->
w;
545 dsc.height = texture->
h;
549 dsc.width += (dsc.width % 2);
550 dsc.height += (dsc.height % 2);
557 dsc.caps = DSCAPS_PREMULTIPLIED;
560 dsc.caps |= DSCAPS_SYSTEMONLY;
562 dsc.caps |= DSCAPS_VIDEOONLY;
565 dsc.pixelformat = pixelformat;
579 DFBPaletteDescription pal_desc;
580 pal_desc.flags = DPDESC_SIZE;
582 SDL_DFB_CHECKERR(devdata->dfb->CreatePalette(devdata->dfb, &pal_desc,&data->palette));
588 #if (DFB_VERSION_ATLEAST(1,2,0)) 589 data->render_options = DSRO_NONE;
595 SDL_DFB_ALLOC_CLEAR(data->pixels, (texture->
h * data->pitch + ((texture->
h + texture->
h % 2) * (data->pitch + data->pitch % 2) * 2) / 4));
614 DirectFB_TextureData *texturedata =
617 if (texturedata->display) {
620 *pixels = texturedata->pixels;
621 *pitch = texturedata->pitch;
632 DirectFB_TextureData *data = (DirectFB_TextureData *) texture->
driverdata;
635 DFBColor entries[256];
641 for (i = 0; i < ncolors; ++
i) {
642 entries[
i].r = colors[
i].
r;
643 entries[
i].g = colors[
i].
g;
644 entries[
i].b = colors[
i].
b;
648 palette->SetEntries(data->palette, entries, ncolors, firstcolor));
651 return SDL_SetError(
"YUV textures don't have a palette");
660 int firstcolor,
int ncolors)
662 DirectFB_TextureData *data = (DirectFB_TextureData *) texture->
driverdata;
666 DFBColor entries[256];
670 palette->GetEntries(data->palette, entries, ncolors,
673 for (i = 0; i < ncolors; ++
i) {
674 colors[
i].
r = entries[
i].r;
675 colors[
i].
g = entries[
i].g;
676 colors[
i].
b = entries[
i].b;
681 return SDL_SetError(
"YUV textures don't have a palette");
735 #if (DFB_VERSION_ATLEAST(1,2,0)) 737 DirectFB_TextureData *data = (DirectFB_TextureData *) texture->
driverdata;
739 switch (texture->scaleMode) {
740 case SDL_SCALEMODE_NONE:
741 case SDL_SCALEMODE_FAST:
742 data->render_options = DSRO_NONE;
744 case SDL_SCALEMODE_SLOW:
745 data->render_options = DSRO_SMOOTH_UPSCALE | DSRO_SMOOTH_DOWNSCALE;
747 case SDL_SCALEMODE_BEST:
748 data->render_options =
749 DSRO_SMOOTH_UPSCALE | DSRO_SMOOTH_DOWNSCALE | DSRO_ANTIALIAS;
752 data->render_options = DSRO_NONE;
753 texture->scaleMode = SDL_SCALEMODE_NONE;
765 DirectFB_TextureData *data = (DirectFB_TextureData *) texture->
driverdata;
774 DirectFB_ActivateRenderer(renderer);
782 DSLF_WRITE | DSLF_READ,
783 ((
void **) &dpixels), &dpitch));
784 src = (
Uint8 *) pixels;
795 src = (
Uint8 *) pixels + texture->
h * pitch;
796 dst = (
Uint8 *) dpixels + texture->
h * dpitch + rect->
y * dpitch / 4 + rect->
x *
bpp / 2;
797 for (
row = 0;
row < rect->
h / 2 + (rect->
h & 1); ++
row) {
802 src = (
Uint8 *) pixels + texture->
h * pitch + texture->
h * pitch / 4;
803 dst = (
Uint8 *) dpixels + texture->
h * dpitch + texture->
h * dpitch / 4 + rect->
y * dpitch / 4 + rect->
x *
bpp / 2;
804 for (
row = 0;
row < rect->
h / 2 + (rect->
h & 1); ++
row) {
820 const SDL_Rect * rect,
void **pixels,
int *pitch)
822 DirectFB_TextureData *texturedata =
825 DirectFB_ActivateRenderer(renderer);
829 SDL_AddDirtyRect(&texturedata->dirty, rect);
833 if (texturedata->display) {
838 DSLF_WRITE | DSLF_READ,
844 (
void *) ((
Uint8 *) texturedata->pixels +
845 rect->
y * texturedata->pitch +
847 *pitch = texturedata->pitch;
848 texturedata->isDirty = 1;
859 DirectFB_TextureData *texturedata =
862 DirectFB_ActivateRenderer(renderer);
864 if (texturedata->display) {
865 SDL_DFB_CHECK(texturedata->surface->Unlock(texturedata->surface));
866 texturedata->pixels =
NULL;
875 DirectFB_TextureData *data = (DirectFB_TextureData *) texture->
driverdata;
878 for (i = 0; i < numrects; ++
i) {
879 SDL_AddDirtyRect(&data->dirty, &rects[i]);
886 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
887 DirectFB_TextureData *tex_data =
NULL;
889 DirectFB_ActivateRenderer(renderer);
891 tex_data = (DirectFB_TextureData *) texture->
driverdata;
892 data->target = tex_data->surface;
894 data->target = get_dfb_surface(data->window);
896 data->lastBlendMode = 0;
904 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
905 IDirectFBSurface *destsurf = data->target;
924 r = ((int) r * (
int)
a) / 255;
925 g = ((int)
g * (
int)
a) / 255;
926 b = ((int)
b * (
int)
a) / 255;
937 static int DirectFB_RenderDrawPoints(
SDL_Renderer * renderer,
940 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
941 IDirectFBSurface *destsurf = data->target;
942 DFBRegion clip_region;
945 DirectFB_ActivateRenderer(renderer);
947 PrepareDraw(renderer);
948 destsurf->GetClip(destsurf, &clip_region);
949 for (i=0; i <
count; i++) {
950 int x = points[
i].
x + clip_region.x1;
951 int y = points[
i].
y + clip_region.y1;
959 static int DirectFB_RenderDrawLines(
SDL_Renderer * renderer,
962 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
963 IDirectFBSurface *destsurf = data->target;
964 DFBRegion clip_region;
967 DirectFB_ActivateRenderer(renderer);
969 PrepareDraw(renderer);
971 #if (DFB_VERSION_ATLEAST(1,2,0)) 975 destsurf->GetClip(destsurf, &clip_region);
976 for (i=0; i < count - 1; i++) {
977 int x1 = points[
i].
x + clip_region.x1;
978 int y1 = points[
i].
y + clip_region.y1;
979 int x2 = points[i + 1].
x + clip_region.x1;
980 int y2 = points[i + 1].
y + clip_region.y1;
992 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
993 IDirectFBSurface *destsurf = data->target;
994 DFBRegion clip_region;
997 DirectFB_ActivateRenderer(renderer);
999 PrepareDraw(renderer);
1001 destsurf->GetClip(destsurf, &clip_region);
1002 for (i=0; i<
count; i++) {
1004 dst.
x += clip_region.x1;
1005 dst.
y += clip_region.y1;
1018 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
1019 IDirectFBSurface *destsurf = data->target;
1020 DFBRegion clip_region;
1023 DirectFB_ActivateRenderer(renderer);
1025 PrepareDraw(renderer);
1027 destsurf->GetClip(destsurf, &clip_region);
1028 for (i=0; i<
count; i++) {
1030 dst.
x += clip_region.x1;
1031 dst.
y += clip_region.y1;
1045 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
1046 IDirectFBSurface *destsurf = data->target;
1047 DirectFB_TextureData *texturedata =
1048 (DirectFB_TextureData *) texture->
driverdata;
1050 DFBRegion clip_region;
1051 DFBRectangle sr, dr;
1053 DirectFB_ActivateRenderer(renderer);
1055 SDLtoDFBRect(srcrect, &sr);
1056 SDLtoDFBRect_Float(dstrect, &dr);
1058 destsurf->GetClip(destsurf, &clip_region);
1059 dr.x += clip_region.x1;
1060 dr.y += clip_region.y1;
1062 if (texturedata->display) {
1065 IDirectFBWindow *dfbwin = get_dfb_window(window);
1068 DFB_DisplayData *dispdata = (DFB_DisplayData *) display->
driverdata;
1071 vidlayer->SetSourceRectangle(dispdata->vidlayer,
1072 sr.x, sr.y, sr.w, sr.h));
1073 dfbwin->GetPosition(dfbwin, &px, &py);
1074 px += windata->client.x;
1075 py += windata->client.y;
1077 vidlayer->SetScreenRectangle(dispdata->vidlayer,
1083 DFBSurfaceBlittingFlags flags = 0;
1086 if (texturedata->dirty.list) {
1087 SDL_DirtyRect *dirty;
1090 int pitch = texturedata->pitch;
1092 for (dirty = texturedata->dirty.list; dirty; dirty = dirty->next) {
1095 (
void *) ((
Uint8 *) texturedata->pixels +
1096 rect->
y * pitch + rect->
x *
bpp);
1097 DirectFB_UpdateTexture(renderer, texture, rect,
1099 texturedata->pitch);
1101 SDL_ClearDirtyRects(&texturedata->dirty);
1104 if (texturedata->isDirty)
1110 rect.
w = texture->
w;
1111 rect.
h = texture->
h;
1113 DirectFB_UpdateTexture(renderer, texture, &rect, texturedata->pixels, texturedata->pitch);
1116 alpha = r = g = b = 0xff;
1119 flags |= DSBLIT_BLEND_COLORALPHA;
1126 flags |= DSBLIT_COLORIZE;
1129 SetColor(destsurf, r, g, b, alpha));
1133 SetBlendMode(data, texture->
blendMode, texturedata);
1136 data->blitFlags | flags));
1138 #if (DFB_VERSION_ATLEAST(1,2,0)) 1144 if (srcrect->
w == dstrect->
w && srcrect->
h == dstrect->
h) {
1146 texturedata->surface,
1150 texturedata->surface,
1162 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
1167 DirectFB_ActivateRenderer(renderer);
1169 if (shape_data && shape_data->
surface) {
1171 SDL_DFB_CHECK(windata->window_surface->SetSrcBlendFunction(windata->window_surface, DSBF_ONE));
1172 SDL_DFB_CHECK(windata->window_surface->SetDstBlendFunction(windata->window_surface, DSBF_ONE));
1173 SDL_DFB_CHECK(windata->window_surface->SetDrawingFlags(windata->window_surface, DSDRAW_BLEND));
1174 SDL_DFB_CHECK(windata->window_surface->SetColor(windata->window_surface, 0, 0, 0, 0xff));
1175 SDL_DFB_CHECK(windata->window_surface->FillRectangle(windata->window_surface, 0,0, windata->size.w, windata->size.h));
1178 SDL_DFB_CHECK(windata->surface->SetSrcBlendFunction(windata->surface, DSBF_DESTCOLOR));
1179 SDL_DFB_CHECK(windata->surface->SetDstBlendFunction(windata->surface, DSBF_ZERO));
1180 SDL_DFB_CHECK(windata->surface->SetBlittingFlags(windata->surface, DSBLIT_BLEND_ALPHACHANNEL));
1181 #if (DFB_VERSION_ATLEAST(1,2,0)) 1182 SDL_DFB_CHECK(windata->surface->SetRenderOptions(windata->surface, DSRO_NONE));
1195 DirectFB_TextureData *data = (DirectFB_TextureData *) texture->
driverdata;
1197 DirectFB_ActivateRenderer(renderer);
1204 if (data->display) {
1205 DFB_DisplayData *dispdata =
1206 (DFB_DisplayData *) data->display->driverdata;
1207 dispdata->vidIDinuse = 0;
1209 SDL_DFB_CHECK(dispdata->vidlayer->SetCooperativeLevel(dispdata->vidlayer,
1210 DLSCL_ADMINISTRATIVE));
1221 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
1224 if (display->palette) {
1225 SDL_DelPaletteWatch(display->palette, DisplayPaletteChanged, data);
1236 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
1237 IDirectFBSurface *winsurf = data->target;
1242 dreg.x2 = dreg.x1 + renderer->
viewport.
w - 1;
1243 dreg.y2 = dreg.y1 + renderer->
viewport.
h - 1;
1245 winsurf->SetClip(winsurf, &dreg);
1253 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
1254 IDirectFBSurface *destsurf = get_dfb_surface(data->window);
1258 region.x1 = rect->
x;
1259 region.x2 = rect->
x + rect->
w;
1260 region.y1 = rect->
y;
1261 region.y2 = rect->
y + rect->
h;
1278 DFBSurfacePixelFormat dfb_format;
1279 DirectFB_RenderData *data = (DirectFB_RenderData *) renderer->
driverdata;
1280 IDirectFBSurface *winsurf = data->target;
1282 DirectFB_ActivateRenderer(renderer);
1284 winsurf->GetPixelFormat(winsurf, &dfb_format);
1286 winsurf->Lock(winsurf, DSLF_READ, (
void **) &laypixels, &laypitch);
1290 sdl_format, laypixels, laypitch,
1291 format, pixels, pitch);
1293 winsurf->Unlock(winsurf);
1301 Uint32 format,
const void * pixels,
int pitch)
1308 DFBSurfacePixelFormat dfb_format;
1310 SDL_DFB_CHECK(windata->surface->GetPixelFormat(windata->surface, &dfb_format));
1313 SDL_DFB_CHECK(windata->surface->Lock(windata->surface, DSLF_WRITE, (
void **) &laypixels, &laypitch));
1317 format, pixels, pitch,
1318 sdl_format, laypixels, laypitch);
int(* RenderDrawLines)(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
int(* RenderDrawPoints)(SDL_Renderer *renderer, const SDL_FPoint *points, int count)
int(* LockTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, void **pixels, int *pitch)
GLuint GLfloat GLfloat GLfloat x1
GLdouble GLdouble GLdouble r
void DirectFB_SetSupportedPixelFormats(SDL_RendererInfo *ri)
int(* RenderReadPixels)(SDL_Renderer *renderer, const SDL_Rect *rect, Uint32 format, void *pixels, int pitch)
#define SDL_ISPIXELFORMAT_INDEXED(format)
struct wl_surface * surface
GLint GLint GLint GLint GLint x
GLuint GLuint GLsizei count
static SDL_Window * window
DFBSurfacePixelFormat DirectFB_SDLToDFBPixelFormat(Uint32 format)
GLenum GLenum GLuint texture
GLfixed GLfixed GLfixed y2
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
set set set set set set set macro pixldst1 abits if abits op else op endif endm macro pixldst2 abits if abits op else op endif endm macro pixldst4 abits if abits op else op endif endm macro pixldst0 abits op endm macro pixldst3 mem_operand op endm macro pixldst30 mem_operand op endm macro pixldst abits if abits elseif abits elseif abits elseif abits elseif abits pixldst0 abits else pixldst0 abits pixldst0 abits pixldst0 abits pixldst0 abits endif elseif abits else pixldst0 abits pixldst0 abits endif elseif abits else error unsupported bpp *numpix else pixst endif endm macro pixld1_s mem_operand if asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl elseif asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl else error unsupported endif endm macro pixld2_s mem_operand if mov asr add asl add asl mov asr sub UNIT_X add asl mov asr add asl add asl mov asr add UNIT_X add asl else pixld1_s mem_operand pixld1_s mem_operand endif endm macro pixld0_s mem_operand if asr adds SRC_WIDTH_FIXED bpl add asl elseif asr adds SRC_WIDTH_FIXED bpl add asl endif endm macro pixld_s_internal mem_operand if mem_operand pixld2_s mem_operand pixdeinterleave basereg elseif mem_operand elseif mem_operand elseif mem_operand elseif mem_operand pixld0_s mem_operand else pixld0_s mem_operand pixld0_s mem_operand pixld0_s mem_operand pixld0_s mem_operand endif elseif mem_operand else pixld0_s mem_operand pixld0_s mem_operand endif elseif mem_operand else error unsupported mem_operand if bpp mem_operand endif endm macro vuzp8 reg2 vuzp d d ®2 endm macro vzip8 reg2 vzip d d ®2 endm macro pixdeinterleave basereg basereg basereg basereg basereg endif endm macro pixinterleave basereg basereg basereg basereg basereg endif endm macro PF boost_increment endif if endif PF tst PF addne PF subne PF cmp ORIG_W if endif if endif if endif PF subge ORIG_W PF subges if endif if endif if endif endif endm macro cache_preload_simple endif if dst_r_bpp pld [DST_R, #(PREFETCH_DISTANCE_SIMPLE *dst_r_bpp/8)] endif if mask_bpp pld if[MASK, #(PREFETCH_DISTANCE_SIMPLE *mask_bpp/8)] endif endif endm macro fetch_mask_pixblock pixld mask_basereg pixblock_size MASK endm macro ensure_destination_ptr_alignment process_pixblock_tail_head if beq irp local skip1(dst_w_bpp<=(lowbit *8)) &&((lowbit *8)<(pixblock_size *dst_w_bpp)) .if lowbit< 16 tst DST_R
#define SDL_BYTESPERPIXEL(X)
int(* RenderFillRects)(SDL_Renderer *renderer, const SDL_FRect *rects, int count)
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
IDirectFBSurface * surface
Uint32 DirectFB_DFBToSDLPixelFormat(DFBSurfacePixelFormat pixelformat)
uint32_t Uint32
An unsigned 32-bit integer type.
set set set set set set set macro pixldst1 abits if abits op else op endif endm macro pixldst2 abits if abits op else op endif endm macro pixldst4 abits if abits op else op endif endm macro pixldst0 abits op endm macro pixldst3 mem_operand op endm macro pixldst30 mem_operand op endm macro pixldst abits if abits elseif abits elseif abits elseif abits elseif abits pixldst0 abits else pixldst0 abits pixldst0 abits pixldst0 abits pixldst0 abits endif elseif abits else pixldst0 abits pixldst0 abits endif elseif abits else error unsupported bpp
SDL_FORCE_INLINE SDL_bool SDL_RectEmpty(const SDL_Rect *r)
Returns true if the rectangle has no area.
int(* RenderClear)(SDL_Renderer *renderer)
GLfloat GLfloat GLfloat alpha
void(* DestroyRenderer)(SDL_Renderer *renderer)
GLfixed GLfixed GLint GLint GLfixed points
#define SDL_DFB_RELEASE(x)
int(* SetTextureBlendMode)(SDL_Renderer *renderer, SDL_Texture *texture)
#define SDL_VERSION(x)
Macro to determine SDL version program was compiled against.
static SDL_BlendMode blendMode
int(* UpdateTexture)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *rect, const void *pixels, int pitch)
int(* SetTextureColorMod)(SDL_Renderer *renderer, SDL_Texture *texture)
#define SDL_DFB_DEVICEDATA(dev)
GLint GLint GLint GLint GLint GLint y
static SDL_Renderer * renderer
SDL_WindowShaper * shaper
uint8_t Uint8
An unsigned 8-bit integer type.
void(* UnlockTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
GLsizei GLsizei GLchar * source
int(* SetRenderTarget)(SDL_Renderer *renderer, SDL_Texture *texture)
int(* UpdateViewport)(SDL_Renderer *renderer)
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
int(* RenderCopy)(SDL_Renderer *renderer, SDL_Texture *texture, const SDL_Rect *srcrect, const SDL_FRect *dstrect)
Window state change event data (event.window.*)
#define SDL_GetWindowWMInfo
#define SDL_DFB_ALLOC_CLEAR(r, s)
#define SDL_DFB_CHECKERR(x...)
#define SDL_DFB_WINDOWDATA(win)
SDL_VideoDisplay * SDL_GetDisplayForWindow(SDL_Window *window)
#define SDL_DFB_CHECK(x...)
int(* SetTextureAlphaMod)(SDL_Renderer *renderer, SDL_Texture *texture)
The type used to identify a window.
SDL_Rect rects[MAX_RECTS]
#define SDL_DFB_DEBUG(x...)
void(* WindowEvent)(SDL_Renderer *renderer, const SDL_WindowEvent *event)
union SDL_SysWMinfo::@18 info
#define SDL_ConvertPixels
void(* DestroyTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
int(* CreateTexture)(SDL_Renderer *renderer, SDL_Texture *texture)
void(* RenderPresent)(SDL_Renderer *renderer)
#define SDL_ISPIXELFORMAT_FOURCC(format)
GLuint GLsizei GLsizei * length
GLboolean GLboolean GLboolean GLboolean a
int(* UpdateClipRect)(SDL_Renderer *renderer)
GLboolean GLboolean GLboolean b
#define SDL_Unsupported()
A rectangle, with the origin at the upper left.