diff --git a/legacy/evas/configure.ac b/legacy/evas/configure.ac index e9b12bd43a..06641f58ef 100644 --- a/legacy/evas/configure.ac +++ b/legacy/evas/configure.ac @@ -958,7 +958,6 @@ src/modules/engines/software_ddraw/Makefile src/modules/engines/direct3d/Makefile src/modules/engines/software_16_wince/Makefile src/modules/engines/software_x11/Makefile -src/modules/engines/software_xcb/Makefile src/modules/engines/fb/Makefile src/modules/engines/buffer/Makefile src/modules/engines/software_win32_gdi/Makefile @@ -1013,12 +1012,11 @@ echo "Configuration Options Summary:" echo echo "Engines:" echo " Software Memory Buffer.....: $have_evas_engine_buffer" -echo " Software X11...............: $have_evas_engine_software_x11" +echo " Software X11...............: $have_evas_engine_software_x11 (XCB: $have_evas_engine_software_xcb)" echo " XRender X11................: $have_evas_engine_xrender_x11" echo " OpenGL X11.................: $have_evas_engine_gl_x11" echo " Glitz X11..................: $have_evas_engine_glitz_x11" echo " Cairo X11..................: $have_evas_engine_cairo_x11" -echo " Software XCB...............: $have_evas_engine_software_xcb" echo " XRender XCB................: $have_evas_engine_xrender_xcb" echo " Software DirectDraw........: $have_evas_engine_software_ddraw" echo " Direct3d...................: $have_evas_engine_direct3d" diff --git a/legacy/evas/src/modules/engines/Makefile.am b/legacy/evas/src/modules/engines/Makefile.am index b2c61164ad..1f15466ed0 100644 --- a/legacy/evas/src/modules/engines/Makefile.am +++ b/legacy/evas/src/modules/engines/Makefile.am @@ -14,7 +14,6 @@ software_qtopia \ software_win32_gdi \ software_ddraw \ software_x11 \ -software_xcb \ xrender_x11 \ xrender_xcb \ software_sdl \ diff --git a/legacy/evas/src/modules/engines/software_x11/Evas_Engine_Software_X11.h b/legacy/evas/src/modules/engines/software_x11/Evas_Engine_Software_X11.h index 1cf972bacc..0d570b3885 100644 --- a/legacy/evas/src/modules/engines/software_x11/Evas_Engine_Software_X11.h +++ b/legacy/evas/src/modules/engines/software_x11/Evas_Engine_Software_X11.h @@ -3,7 +3,19 @@ #include -typedef struct _Evas_Engine_Info_Software_X11 Evas_Engine_Info_Software_X11; +typedef struct _Evas_Engine_Info_Software_X11 Evas_Engine_Info_Software_X11; + +/* + * backend: 0 == Xlib, 1 == XCB + * + * Xlib | XCB + * connection | Display * | xcb_connection_t * + * screen | NULL | xcb_screen_t * + * drawable | Drawable | xcb_drawable_t + * mask | Drawable | xcb_drawable_t + * visual | Visual * | xcb_visualtype_t * + * colormap | Colormap | xcb_colormap_t + */ struct _Evas_Engine_Info_Software_X11 { @@ -13,27 +25,29 @@ struct _Evas_Engine_Info_Software_X11 /* engine specific data & parameters it needs to set up */ struct { - Display *display; - Drawable drawable; - Pixmap mask; - Visual *visual; - Colormap colormap; - int depth; - int rotation; + int backend; + void *connection; + void *screen; + unsigned int drawable; + unsigned int mask; + void *visual; + unsigned int colormap; + int depth; + int rotation; - int alloc_grayscale : 1; - int debug : 1; - int shape_dither : 1; - int destination_alpha : 1; - int track_mask_changes : 1; + int alloc_grayscale : 1; + int debug : 1; + int shape_dither : 1; + int destination_alpha : 1; + int track_mask_changes : 1; - int alloc_colors_max; + int alloc_colors_max; } info; /* engine specific function calls to query stuff about the destination */ struct { - Visual * (*best_visual_get) (Display *disp, int screen); - Colormap (*best_colormap_get) (Display *disp, int screen); - int (*best_depth_get) (Display *disp, int screen); + void *(*best_visual_get) (int backend, void *connection, int screen); + unsigned int (*best_colormap_get) (int backend, void *connection, int screen); + int (*best_depth_get) (int backend, void *connection, int screen); } func; int mask_changed; diff --git a/legacy/evas/src/modules/engines/software_x11/Makefile.am b/legacy/evas/src/modules/engines/software_x11/Makefile.am index 01fd759fbc..0d0b5c6f65 100644 --- a/legacy/evas/src/modules/engines/software_x11/Makefile.am +++ b/legacy/evas/src/modules/engines/software_x11/Makefile.am @@ -8,7 +8,8 @@ AM_CPPFLAGS = \ -I$(top_srcdir)/src/modules/engines \ @FREETYPE_CFLAGS@ \ @EINA_CFLAGS@ \ -@evas_engine_software_x11_cflags@ +@evas_engine_software_x11_cflags@ \ +@evas_engine_software_xcb_cflags@ if BUILD_ENGINE_SOFTWARE_X11 @@ -18,12 +19,22 @@ pkg_LTLIBRARIES = module.la module_la_SOURCES = \ evas_engine.c \ -evas_outbuf.c \ -evas_x_buffer.c \ -evas_x_color.c \ -evas_x_main.c +evas_xlib_outbuf.c \ +evas_xlib_buffer.c \ +evas_xlib_color.c \ +evas_xlib_main.c -module_la_LIBADD = $(top_builddir)/src/lib/libevas.la @EINA_LIBS@ @evas_engine_software_x11_libs@ +if BUILD_ENGINE_SOFTWARE_XCB + +module_la_SOURCES += \ +evas_xcb_outbuf.c \ +evas_xcb_buffer.c \ +evas_xcb_color.c \ +evas_xcb_main.c + +endif + +module_la_LIBADD = $(top_builddir)/src/lib/libevas.la @EINA_LIBS@ @evas_engine_software_x11_libs@ @evas_engine_software_xcb_libs@ module_la_LDFLAGS = -module -avoid-version module_la_LIBTOOLFLAGS = --tag=disable-static @@ -31,4 +42,11 @@ include_HEADERS = Evas_Engine_Software_X11.h endif -EXTRA_DIST = evas_engine.h +EXTRA_DIST = \ +evas_engine.h \ +evas_xlib_outbuf.h \ +evas_xlib_buffer.h \ +evas_xlib_color.h \ +evas_xcb_outbuf.h \ +evas_xcb_buffer.h \ +evas_xcb_color.h diff --git a/legacy/evas/src/modules/engines/software_x11/evas_engine.c b/legacy/evas/src/modules/engines/software_x11/evas_engine.c index 40342ebaae..54ae2c0211 100644 --- a/legacy/evas/src/modules/engines/software_x11/evas_engine.c +++ b/legacy/evas/src/modules/engines/software_x11/evas_engine.c @@ -1,8 +1,17 @@ #include "evas_common.h" #include "evas_private.h" -#include "evas_engine.h" + #include "Evas_Engine_Software_X11.h" +#include "evas_engine.h" +#include "evas_xlib_outbuf.h" +#include "evas_xlib_color.h" + +#ifdef BUILD_ENGINE_SOFTWARE_XCB +# include "evas_xcb_outbuf.h" +# include "evas_xcb_color.h" +#endif + /* function tables - filled in later (func and parent func) */ static Evas_Func func, pfunc; @@ -11,18 +20,28 @@ typedef struct _Render_Engine Render_Engine; struct _Render_Engine { - Tilebuf *tb; - Outbuf *ob; - Tilebuf_Rect *rects; - Eina_Inlist *cur_rect; - int end : 1; + Tilebuf *tb; + Outbuf *ob; + Tilebuf_Rect *rects; + Eina_Inlist *cur_rect; + int end : 1; + + void (*outbuf_free)(Outbuf *ob); + void (*outbuf_reconfigure)(Outbuf *ob, int w, int h, int rot, Outbuf_Depth depth); + int (*outbuf_get_rot)(Outbuf *ob); + RGBA_Image *(*outbuf_new_region_for_update)(Outbuf *ob, int x, int y, int w, int h, int *cx, int *cy, int *cw, int *ch); + void (*outbuf_push_updated_region)(Outbuf *ob, RGBA_Image *update, int x, int y, int w, int h); + void (*outbuf_free_region_for_update)(Outbuf *ob, RGBA_Image *update); + void (*outbuf_flush)(Outbuf *ob); + void (*outbuf_idle_flush)(Outbuf *ob); }; /* prototypes we will use here */ -static void *_output_setup(int w, int h, int rot, Display *disp, Drawable draw, Visual *vis, Colormap cmap, int depth, int debug, int grayscale, int max_colors, Pixmap mask, int shape_dither, int destination_alpha); -static Visual *_best_visual_get(Display *disp, int screen); -static Colormap _best_colormap_get(Display *disp, int screen); -static int _best_depth_get(Display *disp, int screen); +static void *_output_xlib_setup(int w, int h, int rot, Display *disp, Drawable draw, Visual *vis, Colormap cmap, int depth, int debug, int grayscale, int max_colors, Pixmap mask, int shape_dither, int destination_alpha); + +static void *_best_visual_get (int backend, void *connection, int screen); +static unsigned int _best_colormap_get (int backend, void *connection, int screen); +static int _best_depth_get (int backend, void *connection, int screen); static void *eng_info(Evas *e); static void eng_info_free(Evas *e, void *info); @@ -38,42 +57,53 @@ static void eng_output_redraws_next_update_push(void *data, void *surface, int x static void eng_output_flush(void *data); static void eng_output_idle_flush(void *data); + /* internal engine routines */ + static void * -_output_setup(int w, int h, int rot, Display *disp, Drawable draw, Visual *vis, Colormap cmap, int depth, int debug, int grayscale, int max_colors, Pixmap mask, int shape_dither, int destination_alpha) +_output_xlib_setup(int w, + int h, + int rot, + Display *disp, + Drawable draw, + Visual *vis, + Colormap cmap, + int depth, + int debug, + int grayscale, + int max_colors, + Pixmap mask, + int shape_dither, + int destination_alpha) { Render_Engine *re; re = calloc(1, sizeof(Render_Engine)); - /* if we haven't initialized - init (automatic abort if already done) */ - evas_common_cpu_init(); - evas_common_blend_init(); - evas_common_image_init(); - evas_common_convert_init(); - evas_common_scale_init(); - evas_common_rectangle_init(); - evas_common_gradient_init(); - evas_common_polygon_init(); - evas_common_line_init(); - evas_common_font_init(); - evas_common_draw_init(); - evas_common_tilebuf_init(); + evas_software_xlib_x_init(); + evas_software_xlib_x_color_init(); + evas_software_xlib_outbuf_init(); - evas_software_x11_x_init(); - evas_software_x11_x_color_init(); - evas_software_x11_outbuf_init(); - - re->ob = evas_software_x11_outbuf_setup_x(w, h, rot, OUTBUF_DEPTH_INHERIT, - disp, draw, vis, cmap, depth, - grayscale, max_colors, mask, - shape_dither, destination_alpha); + re->ob = evas_software_xlib_outbuf_setup_x(w, + h, + rot, + OUTBUF_DEPTH_INHERIT, + disp, + draw, + vis, + cmap, + depth, + grayscale, + max_colors, + mask, + shape_dither, + destination_alpha); if (!re->ob) { free(re); return NULL; } - + /* for updates return 1 big buffer, but only use portions of it, also cache it and keepit around until an idle_flush */ /* disable for now - i am hunting down why some expedite tests are slower, @@ -82,12 +112,12 @@ _output_setup(int w, int h, int rot, Display *disp, Drawable draw, Visual *vis, * re->ob->onebuf = 1; */ - - evas_software_x11_outbuf_debug_set(re->ob, debug); + + evas_software_xlib_outbuf_debug_set(re->ob, debug); re->tb = evas_common_tilebuf_new(w, h); if (!re->tb) { - evas_software_x11_outbuf_free(re->ob); + evas_software_xlib_outbuf_free(re->ob); free(re); return NULL; } @@ -96,25 +126,179 @@ _output_setup(int w, int h, int rot, Display *disp, Drawable draw, Visual *vis, return re; } -static Visual * -_best_visual_get(Display *disp, int screen) +#ifdef BUILD_ENGINE_SOFTWARE_XCB +static void * +_output_xcb_setup(int w, + int h, + int rot, + xcb_connection_t *conn, + xcb_screen_t *screen, + xcb_drawable_t draw, + xcb_visualtype_t *vis, + xcb_colormap_t cmap, + int depth, + int debug, + int grayscale, + int max_colors, + xcb_drawable_t mask, + int shape_dither, + int destination_alpha) { - if (!disp) return NULL; - return DefaultVisual(disp, screen); + Render_Engine *re; + + re = calloc(1, sizeof(Render_Engine)); + + evas_software_xcb_x_init(); + evas_software_xcb_x_color_init(); + evas_software_xcb_outbuf_init(); + + re->ob = evas_software_xcb_outbuf_setup_x(w, + h, + rot, + OUTBUF_DEPTH_INHERIT, + conn, + screen, + draw, + vis, + cmap, + depth, + grayscale, + max_colors, + mask, + shape_dither, + destination_alpha); + if (!re->ob) + { + free(re); + return NULL; + } + + /* for updates return 1 big buffer, but only use portions of it, also cache + it and keepit around until an idle_flush */ + /* disable for now - i am hunting down why some expedite tests are slower, + * as well as shaped stuff is broken and probable non-32bpp is broken as + * convert funcs dont do the right thing + * + re->ob->onebuf = 1; + */ + + evas_software_xcb_outbuf_debug_set(re->ob, debug); + re->tb = evas_common_tilebuf_new(w, h); + if (!re->tb) + { + evas_software_xcb_outbuf_free(re->ob); + free(re); + return NULL; + } + /* in preliminary tests 16x16 gave highest framerates */ + evas_common_tilebuf_set_tile_size(re->tb, TILESIZE, TILESIZE); + return re; +} +#endif + +static void * +_best_visual_get(int backend, void *connection, int screen) +{ + if (!connection) return NULL; + + if (backend == 0) + { + return DefaultVisual((Display *)connection, screen); + } + +#ifdef BUILD_ENGINE_SOFTWARE_XCB + if (backend == 1) + { + xcb_screen_iterator_t iter_screen; + xcb_depth_iterator_t iter_depth; + xcb_screen_t *s; + + iter_screen = xcb_setup_roots_iterator(xcb_get_setup((xcb_connection_t *)connection)); + for (; iter_screen.rem; --screen, xcb_screen_next (&iter_screen)) + if (screen == 0) + { + s = iter_screen.data; + break; + } + + iter_depth = xcb_screen_allowed_depths_iterator(s); + for (; iter_depth.rem; xcb_depth_next (&iter_depth)) + { + xcb_visualtype_iterator_t iter_vis; + + iter_vis = xcb_depth_visuals_iterator(iter_depth.data); + for (; iter_vis.rem; xcb_visualtype_next (&iter_vis)) + { + if (s->root_visual == iter_vis.data->visual_id) + return iter_vis.data; + } + } + } +#endif + + return NULL; } -static Colormap -_best_colormap_get(Display *disp, int screen) +static unsigned int +_best_colormap_get(int backend, void *connection, int screen) { - if (!disp) return 0; - return DefaultColormap(disp, screen); + if (!connection) return 0; + + if (backend == 0) + { + return DefaultColormap((Display *)connection, screen); + } + +#ifdef BUILD_ENGINE_SOFTWARE_XCB + if (backend == 1) + { + xcb_screen_iterator_t iter_screen; + xcb_screen_t *s; + + iter_screen = xcb_setup_roots_iterator(xcb_get_setup((xcb_connection_t *)connection)); + for (; iter_screen.rem; --screen, xcb_screen_next (&iter_screen)) + if (screen == 0) + { + s = iter_screen.data; + break; + } + + return s->default_colormap; + } +#endif + + return 0; } static int -_best_depth_get(Display *disp, int screen) +_best_depth_get(int backend, void *connection, int screen) { - if (!disp) return 0; - return DefaultDepth(disp, screen); + if (!connection) return 0; + + if (backend == 0) + { + return DefaultDepth((Display *)connection, screen); + } + +#ifdef BUILD_ENGINE_SOFTWARE_XCB + if (backend == 1) + { + xcb_screen_iterator_t iter_screen; + xcb_screen_t *s; + + iter_screen = xcb_setup_roots_iterator(xcb_get_setup((xcb_connection_t *)connection)); + for (; iter_screen.rem; --screen, xcb_screen_next (&iter_screen)) + if (screen == 0) + { + s = iter_screen.data; + break; + } + + return s->root_depth; + } +#endif + + return 0; } /* engine api this module provides */ @@ -148,48 +332,134 @@ eng_info_free(Evas *e, void *info) static void eng_setup(Evas *e, void *in) { - Render_Engine *re; + Render_Engine *re; Evas_Engine_Info_Software_X11 *info; info = (Evas_Engine_Info_Software_X11 *)in; if (!e->engine.data.output) - e->engine.data.output = - _output_setup(e->output.w, - e->output.h, - info->info.rotation, - info->info.display, - info->info.drawable, - info->info.visual, - info->info.colormap, - info->info.depth, - info->info.debug, - info->info.alloc_grayscale, - info->info.alloc_colors_max, - info->info.mask, - info->info.shape_dither, - info->info.destination_alpha); + { + /* if we haven't initialized - init (automatic abort if already done) */ + evas_common_cpu_init(); + evas_common_blend_init(); + evas_common_image_init(); + evas_common_convert_init(); + evas_common_scale_init(); + evas_common_rectangle_init(); + evas_common_gradient_init(); + evas_common_polygon_init(); + evas_common_line_init(); + evas_common_font_init(); + evas_common_draw_init(); + evas_common_tilebuf_init(); + + if (info->info.backend == 0) + { + re = _output_xlib_setup(e->output.w, + e->output.h, + info->info.rotation, + info->info.connection, + info->info.drawable, + info->info.visual, + info->info.colormap, + info->info.depth, + info->info.debug, + info->info.alloc_grayscale, + info->info.alloc_colors_max, + info->info.mask, + info->info.shape_dither, + info->info.destination_alpha); + + re->outbuf_free = evas_software_xlib_outbuf_free; + re->outbuf_reconfigure = evas_software_xlib_outbuf_reconfigure; + re->outbuf_get_rot = evas_software_xlib_outbuf_get_rot; + re->outbuf_new_region_for_update = evas_software_xlib_outbuf_new_region_for_update; + re->outbuf_push_updated_region = evas_software_xlib_outbuf_push_updated_region; + re->outbuf_free_region_for_update = evas_software_xlib_outbuf_free_region_for_update; + re->outbuf_flush = evas_software_xlib_outbuf_flush; + re->outbuf_idle_flush = evas_software_xlib_outbuf_idle_flush; + } + + if (info->info.backend == 1) + { +#ifdef BUILD_ENGINE_SOFTWARE_XCB + re = _output_xcb_setup(e->output.w, + e->output.h, + info->info.rotation, + info->info.connection, + info->info.screen, + info->info.drawable, + info->info.visual, + info->info.colormap, + info->info.depth, + info->info.debug, + info->info.alloc_grayscale, + info->info.alloc_colors_max, + info->info.mask, + info->info.shape_dither, + info->info.destination_alpha); + + re->outbuf_free = evas_software_xcb_outbuf_free; + re->outbuf_reconfigure = evas_software_xcb_outbuf_reconfigure; + re->outbuf_get_rot = evas_software_xcb_outbuf_get_rot; + re->outbuf_new_region_for_update = evas_software_xcb_outbuf_new_region_for_update; + re->outbuf_push_updated_region = evas_software_xcb_outbuf_push_updated_region; + re->outbuf_free_region_for_update = evas_software_xcb_outbuf_free_region_for_update; + re->outbuf_flush = evas_software_xcb_outbuf_flush; + re->outbuf_idle_flush = evas_software_xcb_outbuf_idle_flush; +#endif + } + + e->engine.data.output = re; + } else { - int ponebuf = 0; - + int ponebuf = 0; + re = e->engine.data.output; ponebuf = re->ob->onebuf; - evas_software_x11_outbuf_free(re->ob); - re->ob = evas_software_x11_outbuf_setup_x(e->output.w, - e->output.h, - info->info.rotation, - OUTBUF_DEPTH_INHERIT, - info->info.display, - info->info.drawable, - info->info.visual, - info->info.colormap, - info->info.depth, - info->info.alloc_grayscale, - info->info.alloc_colors_max, - info->info.mask, - info->info.shape_dither, - info->info.destination_alpha); - evas_software_x11_outbuf_debug_set(re->ob, info->info.debug); + + if (info->info.backend == 0) + { + evas_software_xlib_outbuf_free(re->ob); + re->ob = evas_software_xlib_outbuf_setup_x(e->output.w, + e->output.h, + info->info.rotation, + OUTBUF_DEPTH_INHERIT, + info->info.connection, + info->info.drawable, + info->info.visual, + info->info.colormap, + info->info.depth, + info->info.alloc_grayscale, + info->info.alloc_colors_max, + info->info.mask, + info->info.shape_dither, + info->info.destination_alpha); + evas_software_xlib_outbuf_debug_set(re->ob, info->info.debug); + } + + if (info->info.backend == 1) + { +#ifdef BUILD_ENGINE_SOFTWARE_XCB + evas_software_xcb_outbuf_free(re->ob); + re->ob = evas_software_xcb_outbuf_setup_x(e->output.w, + e->output.h, + info->info.rotation, + OUTBUF_DEPTH_INHERIT, + info->info.connection, + info->info.screen, + info->info.drawable, + info->info.visual, + info->info.colormap, + info->info.depth, + info->info.alloc_grayscale, + info->info.alloc_colors_max, + info->info.mask, + info->info.shape_dither, + info->info.destination_alpha); + evas_software_xcb_outbuf_debug_set(re->ob, info->info.debug); +#endif + } re->ob->onebuf = ponebuf; } if (!e->engine.data.output) return; @@ -198,9 +468,6 @@ eng_setup(Evas *e, void *in) e->engine.func->context_new(e->engine.data.output); re = e->engine.data.output; - evas_software_x11_outbuf_drawable_set(re->ob, info->info.drawable); - evas_software_x11_outbuf_mask_set(re->ob, info->info.mask); - evas_software_x11_outbuf_rotation_set(re->ob, info->info.rotation); } static void @@ -211,7 +478,7 @@ eng_output_free(void *data) if (!data) return; re = (Render_Engine *)data; - evas_software_x11_outbuf_free(re->ob); + re->outbuf_free(re->ob); evas_common_tilebuf_free(re->tb); if (re->rects) evas_common_tilebuf_free_render_rects(re->rects); free(re); @@ -226,9 +493,9 @@ eng_output_resize(void *data, int w, int h) Render_Engine *re; re = (Render_Engine *)data; - evas_software_x11_outbuf_reconfigure(re->ob, w, h, - evas_software_x11_outbuf_get_rot(re->ob), - OUTBUF_DEPTH_INHERIT); + re->outbuf_reconfigure(re->ob, w, h, + re->outbuf_get_rot(re->ob), + OUTBUF_DEPTH_INHERIT); evas_common_tilebuf_free(re->tb); re->tb = evas_common_tilebuf_new(w, h); if (re->tb) @@ -301,8 +568,7 @@ eng_output_redraws_next_update_get(void *data, int *x, int *y, int *w, int *h, i re->end = 1; } - surface = evas_software_x11_outbuf_new_region_for_update - (re->ob, ux, uy, uw, uh, cx, cy, cw, ch); + surface = re->outbuf_new_region_for_update (re->ob, ux, uy, uw, uh, cx, cy, cw, ch); *x = ux; *y = uy; *w = uw; *h = uh; return surface; } @@ -315,8 +581,8 @@ eng_output_redraws_next_update_push(void *data, void *surface, int x, int y, int re = (Render_Engine *)data; evas_common_pipe_begin(surface); evas_common_pipe_flush(surface); - evas_software_x11_outbuf_push_updated_region(re->ob, surface, x, y, w, h); - evas_software_x11_outbuf_free_region_for_update(re->ob, surface); + re->outbuf_push_updated_region(re->ob, surface, x, y, w, h); + re->outbuf_free_region_for_update(re->ob, surface); evas_common_cpu_end_opt(); } @@ -326,7 +592,7 @@ eng_output_flush(void *data) Render_Engine *re; re = (Render_Engine *)data; - evas_software_x11_outbuf_flush(re->ob); + re->outbuf_flush(re->ob); } static void @@ -335,7 +601,7 @@ eng_output_idle_flush(void *data) Render_Engine *re; re = (Render_Engine *)data; - evas_software_x11_outbuf_idle_flush(re->ob); + re->outbuf_idle_flush(re->ob); } diff --git a/legacy/evas/src/modules/engines/software_x11/evas_engine.h b/legacy/evas/src/modules/engines/software_x11/evas_engine.h index 1daa2ef3b4..867b54a827 100644 --- a/legacy/evas/src/modules/engines/software_x11/evas_engine.h +++ b/legacy/evas/src/modules/engines/software_x11/evas_engine.h @@ -1,31 +1,36 @@ #ifndef EVAS_ENGINE_H #define EVAS_ENGINE_H +#include +#include + #include #include #include #include -#include -#include -typedef struct _Outbuf Outbuf; -typedef struct _Outbuf_Region Outbuf_Region; -typedef struct _X_Output_Buffer X_Output_Buffer; +#ifdef BUILD_ENGINE_SOFTWARE_XCB +# include +# include +#endif -typedef enum _Outbuf_Depth Outbuf_Depth; + +typedef enum _Outbuf_Depth Outbuf_Depth; enum _Outbuf_Depth { OUTBUF_DEPTH_NONE, - OUTBUF_DEPTH_INHERIT, - OUTBUF_DEPTH_RGB_16BPP_565_565_DITHERED, - OUTBUF_DEPTH_RGB_16BPP_555_555_DITHERED, - OUTBUF_DEPTH_RGB_16BPP_444_444_DITHERED, - OUTBUF_DEPTH_RGB_16BPP_565_444_DITHERED, - OUTBUF_DEPTH_RGB_32BPP_888_8888, - OUTBUF_DEPTH_LAST + OUTBUF_DEPTH_INHERIT, + OUTBUF_DEPTH_RGB_16BPP_565_565_DITHERED, + OUTBUF_DEPTH_RGB_16BPP_555_555_DITHERED, + OUTBUF_DEPTH_RGB_16BPP_444_444_DITHERED, + OUTBUF_DEPTH_RGB_16BPP_565_444_DITHERED, + OUTBUF_DEPTH_RGB_32BPP_888_8888, + OUTBUF_DEPTH_LAST }; +typedef struct _Outbuf Outbuf; + struct _Outbuf { Outbuf_Depth depth; @@ -35,19 +40,37 @@ struct _Outbuf struct { Convert_Pal *pal; - struct { - Display *disp; - Window win; - Pixmap mask; - Visual *vis; - Colormap cmap; - int depth; - int shm; - GC gc; - GC gcm; - unsigned char swap : 1; - unsigned char bit_swap : 1; - } x; + union { + struct { + Display *disp; + Window win; + Pixmap mask; + Visual *vis; + Colormap cmap; + int depth; + int shm; + GC gc; + GC gcm; + unsigned char swap : 1; + unsigned char bit_swap : 1; + } xlib; +#ifdef BUILD_ENGINE_SOFTWARE_XCB + struct { + xcb_connection_t *conn; + xcb_screen_t *screen; + xcb_drawable_t win; + xcb_drawable_t mask; + xcb_visualtype_t *vis; + xcb_colormap_t cmap; + int depth; + int shm; + xcb_gcontext_t gc; + xcb_gcontext_t gcm; + unsigned char swap : 1; + unsigned char bit_swap : 1; + } xcb; +#endif + } x11; struct { DATA32 r, g, b; } mask; @@ -68,60 +91,9 @@ struct _Outbuf } priv; }; -struct _Outbuf_Region -{ - X_Output_Buffer *xob, *mxob; - int x, y, w, h; -}; -struct _X_Output_Buffer -{ - Display *display; - XImage *xim; - XShmSegmentInfo *shm_info; - Visual *visual; - void *data; - int w, h, bpl; - int psize; -}; +void evas_software_xlib_x_init (void); +void evas_software_xcb_x_init (void); -/****/ -void evas_software_x11_x_init (void); - -void evas_software_x11_x_write_mask_line (Outbuf *buf, X_Output_Buffer *xob, DATA32 *src, int w, int y); -int evas_software_x11_x_can_do_shm (Display *d); -X_Output_Buffer *evas_software_x11_x_output_buffer_new (Display *d, Visual *v, int depth, int w, int h, int try_shm, void *data); -void evas_software_x11_x_output_buffer_free (X_Output_Buffer *xob, int sync); -void evas_software_x11_x_output_buffer_paste (X_Output_Buffer *xob, Drawable d, GC gc, int x, int y, int sync); -DATA8 *evas_software_x11_x_output_buffer_data (X_Output_Buffer *xob, int *bytes_per_line_ret); -int evas_software_x11_x_output_buffer_depth (X_Output_Buffer *xob); -int evas_software_x11_x_output_buffer_byte_order (X_Output_Buffer *xob); -int evas_software_x11_x_output_buffer_bit_order (X_Output_Buffer *xob); - -void evas_software_x11_x_color_init (void); -Convert_Pal *evas_software_x11_x_color_allocate (Display *disp, Colormap cmap, Visual *vis, Convert_Pal_Mode colors); -void evas_software_x11_x_color_deallocate (Display *disp, Colormap cmap, Visual *vis, Convert_Pal *pal); - -void evas_software_x11_outbuf_init (void); -void evas_software_x11_outbuf_free (Outbuf *buf); - -Outbuf *evas_software_x11_outbuf_setup_x (int w, int h, int rot, Outbuf_Depth depth, Display *disp, Drawable draw, Visual *vis, Colormap cmap, int x_depth, int grayscale, int max_colors, Pixmap mask, int shape_dither, int destination_alpha); - -RGBA_Image *evas_software_x11_outbuf_new_region_for_update (Outbuf *buf, int x, int y, int w, int h, int *cx, int *cy, int *cw, int *ch); -void evas_software_x11_outbuf_free_region_for_update (Outbuf *buf, RGBA_Image *update); -void evas_software_x11_outbuf_flush (Outbuf *buf); -void evas_software_x11_outbuf_idle_flush (Outbuf *buf); -void evas_software_x11_outbuf_push_updated_region (Outbuf *buf, RGBA_Image *update, int x, int y, int w, int h); -void evas_software_x11_outbuf_reconfigure (Outbuf *buf, int w, int h, int rot, Outbuf_Depth depth); -int evas_software_x11_outbuf_get_width (Outbuf *buf); -int evas_software_x11_outbuf_get_height (Outbuf *buf); -Outbuf_Depth evas_software_x11_outbuf_get_depth (Outbuf *buf); -int evas_software_x11_outbuf_get_rot (Outbuf *buf); -void evas_software_x11_outbuf_drawable_set (Outbuf *buf, Drawable draw); -void evas_software_x11_outbuf_mask_set (Outbuf *buf, Pixmap mask); -void evas_software_x11_outbuf_rotation_set (Outbuf *buf, int rot); - -void evas_software_x11_outbuf_debug_set (Outbuf *buf, int debug); -void evas_software_x11_outbuf_debug_show (Outbuf *buf, Drawable draw, int x, int y, int w, int h); #endif diff --git a/legacy/evas/src/modules/engines/software_x11/evas_x_main.c b/legacy/evas/src/modules/engines/software_x11/evas_x_main.c deleted file mode 100644 index e1ec13f804..0000000000 --- a/legacy/evas/src/modules/engines/software_x11/evas_x_main.c +++ /dev/null @@ -1,10 +0,0 @@ -#include "evas_common.h" -#include "evas_engine.h" - -#include -#include - -void -evas_software_x11_x_init(void) -{ -} diff --git a/legacy/evas/src/modules/engines/software_x11/evas_xcb_buffer.c b/legacy/evas/src/modules/engines/software_x11/evas_xcb_buffer.c new file mode 100644 index 0000000000..9d6d77cfd4 --- /dev/null +++ b/legacy/evas/src/modules/engines/software_x11/evas_xcb_buffer.c @@ -0,0 +1,288 @@ +#include "evas_common.h" + +#include "evas_xcb_buffer.h" + +static int _xcb_err = 0; + +void +evas_software_xcb_x_write_mask_line(Outbuf *buf, + Xcb_Output_Buffer *xcbob, + DATA32 *src, + int w, + int y) +{ + int x; + DATA32 *src_ptr; + DATA8 *dst_ptr; + int bpl = 0; + + src_ptr = src; + dst_ptr = evas_software_xcb_x_output_buffer_data(xcbob, &bpl); + dst_ptr = dst_ptr + (bpl * y); + w -= 7; + if (buf->priv.x11.xcb.bit_swap) + { + for (x = 0; x < w; x += 8) + { + *dst_ptr = + ((A_VAL(&(src_ptr[0])) >> 7) << 7) | + ((A_VAL(&(src_ptr[1])) >> 7) << 6) | + ((A_VAL(&(src_ptr[2])) >> 7) << 5) | + ((A_VAL(&(src_ptr[3])) >> 7) << 4) | + ((A_VAL(&(src_ptr[4])) >> 7) << 3) | + ((A_VAL(&(src_ptr[5])) >> 7) << 2) | + ((A_VAL(&(src_ptr[6])) >> 7) << 1) | + ((A_VAL(&(src_ptr[7])) >> 7) << 0); + src_ptr += 8; + dst_ptr++; + } + } + else + { + for (x = 0; x < w; x += 8) + { + *dst_ptr = + ((A_VAL(&(src_ptr[0])) >> 7) << 0) | + ((A_VAL(&(src_ptr[1])) >> 7) << 1) | + ((A_VAL(&(src_ptr[2])) >> 7) << 2) | + ((A_VAL(&(src_ptr[3])) >> 7) << 3) | + ((A_VAL(&(src_ptr[4])) >> 7) << 4) | + ((A_VAL(&(src_ptr[5])) >> 7) << 5) | + ((A_VAL(&(src_ptr[6])) >> 7) << 6) | + ((A_VAL(&(src_ptr[7])) >> 7) << 7); + src_ptr += 8; + dst_ptr++; + } + } + w += 7; + for (; x < w; x ++) + { + xcb_image_put_pixel(xcbob->image, x, y, A_VAL(src_ptr) >> 7); + src_ptr++; + } +} + +int +evas_software_xcb_x_can_do_shm(xcb_connection_t *c, + xcb_screen_t *screen) +{ + static xcb_connection_t *cached_c = NULL; + static int cached_result = 0; + + if (c == cached_c) return cached_result; + cached_c = c; + + if (xcb_get_extension_data(c, &xcb_shm_id)) + { + Xcb_Output_Buffer *xcbob; + + xcbob = evas_software_xcb_x_output_buffer_new(c, + screen->root_depth, + 16, + 16, + 2, + NULL); + if (!xcbob) + { + cached_result = 0; + return 0; + } + evas_software_xcb_x_output_buffer_free(xcbob, 1); + cached_result = 1; + return 1; + } + cached_result = 0; + return 0; +} + +/* + * FIXME: no error mechanism + */ + +/* static void */ +/* x_output_tmp_xcb_err(xcb_connection_t *c, XErrorEvent * ev) */ +/* { */ +/* _xcb_err = 1; */ +/* return; */ +/* } */ + +Xcb_Output_Buffer * +evas_software_xcb_x_output_buffer_new(xcb_connection_t *c, + int depth, + int w, + int h, + int try_shm, + void *data) +{ + Xcb_Output_Buffer *xcbob; + + xcbob = calloc(1, sizeof(Xcb_Output_Buffer)); + if (!xcbob) return NULL; + + xcbob->connection = c; + xcbob->image = NULL; + xcbob->shm_info = NULL; + xcbob->w = w; + xcbob->h = h; + + try_shm = 0; + + if (try_shm > 0) + { + xcbob->shm_info = malloc(sizeof(xcb_shm_segment_info_t)); + if (xcbob->shm_info) + { + xcbob->shm_info->shmseg = xcb_generate_id(c); + xcbob->image = xcb_image_create_native(c, w, h, + XCB_IMAGE_FORMAT_Z_PIXMAP, + depth, NULL, ~0, NULL); + if (xcbob->image) + { + xcbob->shm_info->shmid = shmget(IPC_PRIVATE, + xcbob->image->size, + IPC_CREAT | 0777); + if (xcbob->shm_info->shmid >= 0) + { + xcbob->shm_info->shmaddr = xcbob->image->data = + shmat(xcbob->shm_info->shmid, 0, 0); + if (xcbob->shm_info->shmaddr != NULL) + { + /* + * FIXME: no error mechanism + */ + + /* XErrorHandler ph; */ + /* EventHandlers eh; */ + + // free(xcb_get_input_focus_reply(c, xcb_get_input_focus_unchecked(c), NULL)); + _xcb_err = 0; + /* ph = XSetErrorHandler((XErrorHandler) */ + /* x_output_tmp_x_err); */ + xcb_shm_attach(c, + xcbob->shm_info->shmseg, + xcbob->shm_info->shmid, 0); + // free(xcb_get_input_focus_reply(c, xcb_get_input_focus_unchecked(c), NULL)); + /* XSetErrorHandler((XErrorHandler)ph); */ + if (!_xcb_err) + { + xcbob->bpl = xcbob->image->stride; + xcbob->psize = xcbob->bpl * xcbob->h; + return xcbob; + } + } + shmdt(xcbob->shm_info->shmaddr); + shmctl(xcbob->shm_info->shmid, IPC_RMID, 0); + } + if (xcbob->image) xcb_image_destroy(xcbob->image); + xcbob->image = NULL; + } + if (xcbob->shm_info) free(xcbob->shm_info); + xcbob->shm_info = NULL; + } + } + + if (try_shm > 1) return NULL; + + xcbob->image = xcb_image_create_native(c, w, h, XCB_IMAGE_FORMAT_Z_PIXMAP, + depth, NULL, ~0, NULL); + if (!xcbob->image) + { + free(xcbob); + return NULL; + } + + xcbob->data = data; + + if (!xcbob->image->data) + { + xcbob->image->data = malloc(xcbob->image->size); + if (!xcbob->image->data) + { + xcb_image_destroy(xcbob->image); + free(xcbob); + return NULL; + } + } + + xcbob->bpl = xcbob->image->stride; + xcbob->psize = xcbob->image->size; + + return xcbob; +} + +void +evas_software_xcb_x_output_buffer_free(Xcb_Output_Buffer *xcbob, + int sync) +{ + if (xcbob->shm_info) + { + if (sync) + free(xcb_get_input_focus_reply(xcbob->connection, + xcb_get_input_focus_unchecked(xcbob->connection), + NULL)); + xcb_shm_detach(xcbob->connection, xcbob->shm_info->shmseg); + xcb_image_destroy(xcbob->image); + shmdt(xcbob->shm_info->shmaddr); + shmctl(xcbob->shm_info->shmid, IPC_RMID, 0); + free(xcbob->shm_info); + } + else + { + if (xcbob->data) xcbob->image->data = NULL; + xcb_image_destroy(xcbob->image); + } + free(xcbob); +} + +void +evas_software_xcb_x_output_buffer_paste(Xcb_Output_Buffer *xcbob, + xcb_drawable_t d, + xcb_gcontext_t gc, + int x, + int y, + int sync) +{ + if (xcbob->shm_info) + { + xcb_image_shm_put(xcbob->connection, d, gc, + xcbob->image, *xcbob->shm_info, + 0, 0, + x, y, + xcbob->image->width, xcbob->image->height, + 0); + if (sync) + free(xcb_get_input_focus_reply(xcbob->connection, + xcb_get_input_focus_unchecked(xcbob->connection), + NULL)); + } + else + xcb_image_put(xcbob->connection, d, gc, + xcbob->image, + x, y, 0); +} + +DATA8 * +evas_software_xcb_x_output_buffer_data(Xcb_Output_Buffer *xcbob, + int *bytes_per_line_ret) +{ + if (bytes_per_line_ret) *bytes_per_line_ret = xcbob->image->stride; + return xcbob->image->data; +} + +int +evas_software_xcb_x_output_buffer_depth(Xcb_Output_Buffer *xcbob) +{ + return xcbob->image->bpp; +} + +int +evas_software_xcb_x_output_buffer_byte_order(Xcb_Output_Buffer *xcbob) +{ + return xcbob->image->byte_order; +} + +int +evas_software_xcb_x_output_buffer_bit_order(Xcb_Output_Buffer *xcbob) +{ + return xcbob->image->bit_order; +} diff --git a/legacy/evas/src/modules/engines/software_x11/evas_xcb_buffer.h b/legacy/evas/src/modules/engines/software_x11/evas_xcb_buffer.h new file mode 100644 index 0000000000..f68d1dbcfa --- /dev/null +++ b/legacy/evas/src/modules/engines/software_x11/evas_xcb_buffer.h @@ -0,0 +1,50 @@ +#ifndef EVAS_XCB_BUFFER_H +#define EVAS_XCB_BUFFER_H + + +#include "evas_engine.h" + + +typedef struct _Xcb_Output_Buffer Xcb_Output_Buffer; + +struct _Xcb_Output_Buffer +{ + xcb_connection_t *connection; + xcb_image_t *image; + xcb_shm_segment_info_t *shm_info; + void *data; + int w; + int h; + int bpl; + int psize; +}; + +void evas_software_xcb_x_write_mask_line (Outbuf *buf, + Xcb_Output_Buffer *xcbob, + DATA32 *src, + int w, + int y); +int evas_software_xcb_x_can_do_shm (xcb_connection_t *c, + xcb_screen_t *screen); +Xcb_Output_Buffer *evas_software_xcb_x_output_buffer_new (xcb_connection_t *c, + int depth, + int w, + int h, + int try_shm, + void *data); +void evas_software_xcb_x_output_buffer_free (Xcb_Output_Buffer *xcbob, + int sync); +void evas_software_xcb_x_output_buffer_paste (Xcb_Output_Buffer *xcbob, + xcb_drawable_t d, + xcb_gcontext_t gc, + int x, + int y, + int sync); +DATA8 *evas_software_xcb_x_output_buffer_data (Xcb_Output_Buffer *xcbob, + int *bytes_per_line_ret); +int evas_software_xcb_x_output_buffer_depth (Xcb_Output_Buffer *xcbob); +int evas_software_xcb_x_output_buffer_byte_order(Xcb_Output_Buffer *xcbob); +int evas_software_xcb_x_output_buffer_bit_order (Xcb_Output_Buffer *xcbob); + + +#endif diff --git a/legacy/evas/src/modules/engines/software_x11/evas_xcb_color.c b/legacy/evas/src/modules/engines/software_x11/evas_xcb_color.c new file mode 100644 index 0000000000..55adca607f --- /dev/null +++ b/legacy/evas/src/modules/engines/software_x11/evas_xcb_color.c @@ -0,0 +1,424 @@ +#include "evas_common.h" + +#include "evas_engine.h" + +typedef struct _Convert_Pal_Priv Convert_Pal_Priv; + +struct _Convert_Pal_Priv +{ + xcb_connection_t *conn; + xcb_colormap_t cmap; + xcb_visualtype_t *vis; +}; + +typedef DATA8 * (*Xcb_Func_Alloc_Colors) (xcb_connection_t *conn, xcb_colormap_t cmap, xcb_visualtype_t *v); + +static Xcb_Func_Alloc_Colors x_color_alloc[PAL_MODE_LAST + 1]; +static int x_color_count[PAL_MODE_LAST + 1]; +static Eina_List *palettes = NULL; + +static DATA8 * x_color_alloc_rgb(int nr, int ng, int nb, xcb_connection_t *conn, xcb_colormap_t cmap, xcb_visualtype_t *v); +static DATA8 * x_color_alloc_gray(int ng, xcb_connection_t *conn, xcb_colormap_t cmap, xcb_visualtype_t *v); + +static DATA8 * x_color_alloc_rgb_332 (xcb_connection_t *conn, xcb_colormap_t cmap, xcb_visualtype_t *v); +static DATA8 * x_color_alloc_rgb_666 (xcb_connection_t *conn, xcb_colormap_t cmap, xcb_visualtype_t *v); +static DATA8 * x_color_alloc_rgb_232 (xcb_connection_t *conn, xcb_colormap_t cmap, xcb_visualtype_t *v); +static DATA8 * x_color_alloc_rgb_222 (xcb_connection_t *conn, xcb_colormap_t cmap, xcb_visualtype_t *v); +static DATA8 * x_color_alloc_rgb_221 (xcb_connection_t *conn, xcb_colormap_t cmap, xcb_visualtype_t *v); +static DATA8 * x_color_alloc_rgb_121 (xcb_connection_t *conn, xcb_colormap_t cmap, xcb_visualtype_t *v); +static DATA8 * x_color_alloc_rgb_111 (xcb_connection_t *conn, xcb_colormap_t cmap, xcb_visualtype_t *v); +static DATA8 * x_color_alloc_gray_256 (xcb_connection_t *conn, xcb_colormap_t cmap, xcb_visualtype_t *v); +static DATA8 * x_color_alloc_gray_64 (xcb_connection_t *conn, xcb_colormap_t cmap, xcb_visualtype_t *v); +static DATA8 * x_color_alloc_gray_16 (xcb_connection_t *conn, xcb_colormap_t cmap, xcb_visualtype_t *v); +static DATA8 * x_color_alloc_gray_4 (xcb_connection_t *conn, xcb_colormap_t cmap, xcb_visualtype_t *v); +static DATA8 * x_color_alloc_mono (xcb_connection_t *conn, xcb_colormap_t cmap, xcb_visualtype_t *v); + +static DATA8 * +x_color_alloc_rgb(int nr, + int ng, + int nb, + xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *v) +{ + int r, g, b, i; + DATA8 *color_lut; + int sig_mask = 0; + int delt = 0; + + for (i = 0; i < v->bits_per_rgb_value; i++) sig_mask |= (0x1 << i); + sig_mask <<= (16 - v->bits_per_rgb_value); + i = 0; + color_lut = malloc((nr) * (ng) * (nb)); + if (!color_lut) return NULL; + delt = 0x0101 * 3; + /* FIXME: remove the round-trip ? */ + for (r = 0; r < (nr); r++) + { + for (g = 0; g < (ng); g++) + { + for (b = 0; b < (nb); b++) + { + xcb_coloritem_t xcl; + xcb_coloritem_t xcl_in; + xcb_alloc_color_reply_t *rep; + int val; + int dr, dg, db; + + val = (int)((((double)r) / ((nr) - 1)) * 255); + val = (val << 8) | val; + xcl.red = (uint16_t)(val); + val = (int)((((double)g) / ((ng) - 1)) * 255); + val = (val << 8) | val; + xcl.green = (uint16_t)(val); + val = (int)((((double)b) / ((nb) - 1)) * 255); + val = (val << 8) | val; + xcl.blue = (uint16_t)(val); + xcl_in = xcl; + rep = xcb_alloc_color_reply(conn, + xcb_alloc_color_unchecked(conn, + cmap, + xcl.red, + xcl.green, + xcl.blue), + 0); + dr = (int)xcl_in.red - (int)xcl.red; + if (dr < 0) dr = -dr; + dg = (int)xcl_in.green - (int)xcl.green; + if (dg < 0) dg = -dg; + db = (int)xcl_in.blue - (int)xcl.blue; + if (db < 0) db = -db; +/* + printf("ASK [%i]: %04x %04x %04x = %04x %04x %04x | dif = %04x / %04x\n", + ret, + xcl_in.red, xcl_in.green, xcl_in.blue, + xcl.red, xcl.green, xcl.blue, + (dr + dg +db), delt); + */ + + /* TODO: XAllocColor tries to approach the color */ + /* in case the allocation fails */ + /* XCB does not that (i think). It should be done */ + /* So if rep == NULL, the other following tests */ + /* should be always satisfied */ + if ((!rep) || + ((dr + dg + db) > delt) + /* + ((xcl_in.red & sig_mask) != (xcl.red & sig_mask)) || + ((xcl_in.green & sig_mask) != (xcl.green & sig_mask)) || + ((xcl_in.blue & sig_mask) != (xcl.blue & sig_mask)) + */ + ) + { + uint32_t pixels[256]; + int j; + + if (i > 0) + { + for (j = 0; j < i; j++) + pixels[j] = (uint32_t)color_lut[j]; + xcb_free_colors(conn, cmap, 0, i, pixels); + } + free(color_lut); + return NULL; + } + color_lut[i] = rep->pixel; + i++; + free(rep); + } + } + } + return color_lut; +} + +static DATA8 * +x_color_alloc_gray(int ng, + xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *v) +{ + int g, i; + DATA8 *color_lut; + int sig_mask = 0; + + for (i = 0; i < v->bits_per_rgb_value; i++) sig_mask |= (0x1 << i); + sig_mask <<= (16 - v->bits_per_rgb_value); + i = 0; + color_lut = malloc(ng); + if (!color_lut) return NULL; + /* FIXME: remove the round-trip ? */ + for (g = 0; g < (ng); g++) + { + xcb_coloritem_t xcl; + xcb_coloritem_t xcl_in; + int val; + xcb_alloc_color_reply_t *rep; + + val = (int)((((double)g) / ((ng) - 1)) * 255); + val = (val << 8) | val; + xcl.red = (uint16_t)(val); + xcl.green = (uint16_t)(val); + xcl.blue = (uint16_t)(val); + xcl_in = xcl; + rep = xcb_alloc_color_reply(conn, + xcb_alloc_color_unchecked(conn, + cmap, + xcl.red, + xcl.green, + xcl.blue), + 0); + /* FIXME: XAllocColor tries to approach the color */ + /* in case the allocation fails */ + /* XCB does not that (i think). It should be done */ + /* So if rep == NULL, the other following tests */ + /* should be always satisfied */ + if ((!rep) || + ((xcl_in.red & sig_mask) != (xcl.red & sig_mask)) || + ((xcl_in.green & sig_mask) != (xcl.green & sig_mask)) || + ((xcl_in.blue & sig_mask) != (xcl.blue & sig_mask))) + { + uint32_t pixels[256]; + int j; + + if (i > 0) + { + for (j = 0; j < i; j++) + pixels[j] = (uint32_t) color_lut[j]; + xcb_free_colors(conn, cmap, 0, i, pixels); + } + free(color_lut); + return NULL; + } + color_lut[i] = rep->pixel; + i++; + free(rep); + } + return color_lut; +} + +static DATA8 * +x_color_alloc_rgb_332(xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *v) +{ + return x_color_alloc_rgb(8, 8, 4, conn, cmap, v); +} + +static DATA8 * +x_color_alloc_rgb_666(xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *v) +{ + return x_color_alloc_rgb(6, 6, 6, conn, cmap, v); +} + +static DATA8 * +x_color_alloc_rgb_232(xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *v) +{ + return x_color_alloc_rgb(4, 8, 4, conn, cmap, v); +} + +static DATA8 * +x_color_alloc_rgb_222(xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *v) +{ + return x_color_alloc_rgb(4, 4, 4, conn, cmap, v); +} + +static DATA8 * +x_color_alloc_rgb_221(xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *v) +{ + return x_color_alloc_rgb(4, 4, 2, conn, cmap, v); +} + +static DATA8 * +x_color_alloc_rgb_121(xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *v) +{ + return x_color_alloc_rgb(2, 4, 2, conn, cmap, v); +} + +static DATA8 * +x_color_alloc_rgb_111(xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *v) +{ + return x_color_alloc_rgb(2, 2, 2, conn, cmap, v); +} + +static DATA8 * +x_color_alloc_gray_256(xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *v) +{ + return x_color_alloc_gray(256, conn, cmap, v); +} + +static DATA8 * +x_color_alloc_gray_64(xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *v) +{ + return x_color_alloc_gray(64, conn, cmap, v); +} + +static DATA8 * +x_color_alloc_gray_16(xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *v) +{ + return x_color_alloc_gray(32, conn, cmap, v); +} + +static DATA8 * +x_color_alloc_gray_4(xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *v) +{ + return x_color_alloc_gray(16, conn, cmap, v); +} + +static DATA8 * +x_color_alloc_mono(xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *v) +{ + return x_color_alloc_gray(2, conn, cmap, v); +} + +void +evas_software_xcb_x_color_init(void) +{ + static int initialised = 0; + + if (initialised) return; + x_color_alloc[PAL_MODE_NONE] = NULL; + x_color_count[PAL_MODE_NONE] = 0; + + x_color_alloc[PAL_MODE_MONO] = x_color_alloc_mono; + x_color_count[PAL_MODE_MONO] = 2; + + x_color_alloc[PAL_MODE_GRAY4] = x_color_alloc_gray_4; + x_color_count[PAL_MODE_GRAY4] = 4; + + x_color_alloc[PAL_MODE_GRAY16] = x_color_alloc_gray_16; + x_color_count[PAL_MODE_GRAY16] = 16; + + x_color_alloc[PAL_MODE_GRAY64] = x_color_alloc_gray_64; + x_color_count[PAL_MODE_GRAY64] = 64; + + x_color_alloc[PAL_MODE_GRAY256] = x_color_alloc_gray_256; + x_color_count[PAL_MODE_GRAY256] = 256; + + x_color_alloc[PAL_MODE_RGB111] = x_color_alloc_rgb_111; + x_color_count[PAL_MODE_RGB111] = 2 * 2 * 2; + + x_color_alloc[PAL_MODE_RGB121] = x_color_alloc_rgb_121; + x_color_count[PAL_MODE_RGB121] = 2 * 4 * 2; + + x_color_alloc[PAL_MODE_RGB221] = x_color_alloc_rgb_221; + x_color_count[PAL_MODE_RGB221] = 4 * 4 * 2; + + x_color_alloc[PAL_MODE_RGB222] = x_color_alloc_rgb_222; + x_color_count[PAL_MODE_RGB222] = 4 * 4 * 4; + + x_color_alloc[PAL_MODE_RGB232] = x_color_alloc_rgb_232; + x_color_count[PAL_MODE_RGB232] = 4 * 8 * 4; + + x_color_alloc[PAL_MODE_RGB666] = x_color_alloc_rgb_666; + x_color_count[PAL_MODE_RGB666] = 6 * 6 * 6; + + x_color_alloc[PAL_MODE_RGB332] = x_color_alloc_rgb_332; + x_color_count[PAL_MODE_RGB332] = 8 * 8 * 4; + + x_color_alloc[PAL_MODE_LAST] = NULL; + x_color_count[PAL_MODE_LAST] = 0; + initialised = 1; +} + +Convert_Pal * +evas_software_xcb_x_color_allocate(xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *vis, + Convert_Pal_Mode colors) +{ + Convert_Pal_Priv *palpriv; + Convert_Pal *pal; + Convert_Pal_Mode c; + Eina_List *l; + +/* printf("ALLOC cmap=%i vis=%p\n", cmap, vis);*/ + EINA_LIST_FOREACH(palettes, l, pal) + { + palpriv = pal->data; + if ((conn == palpriv->conn) && + (vis == palpriv->vis) && + (cmap == palpriv->cmap)) + { + pal->references++; + return pal; + } + } + pal = calloc(1, sizeof(struct _Convert_Pal)); + if (!pal) return NULL; + for (c = colors; c > PAL_MODE_NONE; c--) + { + if (x_color_alloc[c]) + { +/* printf("TRY PAL %i\n", c);*/ + pal->lookup = (x_color_alloc[c])(conn, cmap, vis); + if (pal->lookup) break; + } + } + pal->references = 1; + pal->colors = c; + pal->count = x_color_count[c]; + palpriv = calloc(1, sizeof(Convert_Pal_Priv)); + pal->data = palpriv; + if (!palpriv) + { + if (pal->lookup) free(pal->lookup); + free(pal); + return NULL; + } + palpriv->conn = conn; + palpriv->vis = vis; + palpriv->cmap = cmap; + if (pal->colors == PAL_MODE_NONE) + { + if (pal->lookup) free(pal->lookup); + free(pal); + return NULL; + } + palettes = eina_list_append(palettes, pal); + return pal; +} + +void +evas_software_xcb_x_color_deallocate(xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *vis, + Convert_Pal *pal) +{ + uint32_t pixels[256]; + int j; + + pal->references--; + if (pal->references > 0) return; + if (pal->lookup) + { + for(j = 0; j < pal->count; j++) + pixels[j] = (uint32_t) pal->lookup[j]; + xcb_free_colors(conn, cmap, 0, pal->count, pixels); + free(pal->lookup); + } + free(pal->data); + palettes = eina_list_remove(palettes, pal); + free(pal); +} diff --git a/legacy/evas/src/modules/engines/software_x11/evas_xcb_color.h b/legacy/evas/src/modules/engines/software_x11/evas_xcb_color.h new file mode 100644 index 0000000000..0d04000fdb --- /dev/null +++ b/legacy/evas/src/modules/engines/software_x11/evas_xcb_color.h @@ -0,0 +1,15 @@ +#ifndef EVAS_XCB_COLOR_H +#define EVAS_XCB_COLOR_H + + +void evas_software_xcb_x_color_init (void); +Convert_Pal *evas_software_xcb_x_color_allocate (xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *vis, + Convert_Pal_Mode colors); +void evas_software_xcb_x_color_deallocate (xcb_connection_t *conn, + xcb_colormap_t cmap, + xcb_visualtype_t *vis, + Convert_Pal *pal); + +#endif diff --git a/legacy/evas/src/modules/engines/software_x11/evas_xcb_main.c b/legacy/evas/src/modules/engines/software_x11/evas_xcb_main.c new file mode 100644 index 0000000000..e395b02917 --- /dev/null +++ b/legacy/evas/src/modules/engines/software_x11/evas_xcb_main.c @@ -0,0 +1,7 @@ +#include "evas_common.h" +#include "evas_engine.h" + +void +evas_software_xcb_x_init(void) +{ +} diff --git a/legacy/evas/src/modules/engines/software_x11/evas_xcb_outbuf.c b/legacy/evas/src/modules/engines/software_x11/evas_xcb_outbuf.c new file mode 100644 index 0000000000..80126c1cc5 --- /dev/null +++ b/legacy/evas/src/modules/engines/software_x11/evas_xcb_outbuf.c @@ -0,0 +1,1053 @@ +#include +#include +#include +#include +#include + +#include "evas_common.h" +#include "evas_macros.h" +#include "evas_xcb_outbuf.h" +#include "evas_xcb_buffer.h" +#include "evas_xcb_color.h" + + +typedef struct _Outbuf_Region Outbuf_Region; + +struct _Outbuf_Region +{ + Xcb_Output_Buffer *xcbob; + Xcb_Output_Buffer *mxcbob; + int x; + int y; + int w; + int h; +}; + +static Eina_List *shmpool = NULL; +static int shmsize = 0; +static int shmmemlimit = 10 * 1024 * 1024; +static int shmcountlimit = 32; + +static Xcb_Output_Buffer * +_find_xcbob(xcb_connection_t *conn, int depth, int w, int h, int shm, void *data) +{ + Eina_List *l; + Eina_List *xl; + Xcb_Output_Buffer *xcbob = NULL; + Xcb_Output_Buffer *xcbob2; + int fitness = 0x7fffffff; + int sz; + int lbytes; + int bpp; + +// return evas_software_xcb_x_output_buffer_new(d, v, depth, w, h, shm, data); + if (!shm) + return evas_software_xcb_x_output_buffer_new(conn, depth, w, h, shm, data); + if (depth > 1) + { + bpp = depth / 8; + if (bpp == 3) bpp = 4; + lbytes = (((w * bpp) + 3) / 4) * 4; + } + else + lbytes = ((w + 31) / 32) * 4; + sz = lbytes * h; + EINA_LIST_FOREACH(shmpool, l, xcbob2) + { + int szdif; + + if ((xcbob2->image->depth != depth) || + (xcbob2->connection != conn)) + continue; + szdif = xcbob2->psize - sz; + if (szdif < 0) continue; + if (szdif == 0) + { + xcbob = xcbob2; + xl = l; + goto have_xcbob; + } + if (szdif < fitness) + { + fitness = szdif; + xcbob = xcbob2; + xl = l; + } + } + if ((fitness > (100 * 100)) || (!xcbob)) + return evas_software_xcb_x_output_buffer_new(conn, depth, w, h, shm, data); + + have_xcbob: + shmpool = eina_list_remove_list(shmpool, xl); + xcbob->w = w; + xcbob->h = h; + xcbob->bpl = lbytes; + xcbob->image->width = xcbob->w; + xcbob->image->height = xcbob->h; + xcbob->image->stride = xcbob->bpl; + shmsize -= xcbob->psize * (xcbob->image->depth / 8); + return xcbob; +} + +static void +_unfind_xcbob(Xcb_Output_Buffer *xcbob, int sync) +{ +// evas_software_xcb_x_output_buffer_free(xcbob, sync); return; + if (xcbob->shm_info) + { + shmpool = eina_list_prepend(shmpool, xcbob); + shmsize += xcbob->psize * xcbob->image->depth / 8; + while ((shmsize > (shmmemlimit)) || + (eina_list_count(shmpool) > shmcountlimit)) + { + Eina_List *xl; + + xl = eina_list_last(shmpool); + if (!xl) + { + shmsize = 0; + break; + } + xcbob = xl->data; + shmpool = eina_list_remove_list(shmpool, xl); + evas_software_xcb_x_output_buffer_free(xcbob, sync); + } + } + else + evas_software_xcb_x_output_buffer_free(xcbob, sync); +} + +static void +_clear_xcbob(int sync) +{ + while (shmpool) + { + Xcb_Output_Buffer *xcbob; + + xcbob = shmpool->data; + shmpool = eina_list_remove_list(shmpool, shmpool); + evas_software_xcb_x_output_buffer_free(xcbob, sync); + } + shmsize = 0; +} + +void +evas_software_xcb_outbuf_init(void) +{ +} + +void +evas_software_xcb_outbuf_free(Outbuf * buf) +{ + while (buf->priv.pending_writes) + { + RGBA_Image *im; + Outbuf_Region *obr; + + im = buf->priv.pending_writes->data; + buf->priv.pending_writes = eina_list_remove_list(buf->priv.pending_writes, buf->priv.pending_writes); + obr = im->extended_info; + evas_cache_image_drop(&im->cache_entry); + if (obr->xcbob) _unfind_xcbob(obr->xcbob, 0); + if (obr->mxcbob) _unfind_xcbob(obr->mxcbob, 0); + free(obr); + } + evas_software_xcb_outbuf_idle_flush(buf); + evas_software_xcb_outbuf_flush(buf); + if (buf->priv.x11.xcb.gc) + xcb_free_gc(buf->priv.x11.xcb.conn, buf->priv.x11.xcb.gc); + if (buf->priv.x11.xcb.gcm) + xcb_free_gc(buf->priv.x11.xcb.conn, buf->priv.x11.xcb.gcm); + if (buf->priv.pal) + evas_software_xcb_x_color_deallocate(buf->priv.x11.xcb.conn, + buf->priv.x11.xcb.cmap, + buf->priv.x11.xcb.vis, + buf->priv.pal); + free(buf); + _clear_xcbob(0); +} + +void +evas_software_xcb_outbuf_rotation_set(Outbuf *buf, int rot) +{ + buf->rot = rot; +} + +Outbuf * +evas_software_xcb_outbuf_setup_x(int w, + int h, + int rot, + Outbuf_Depth depth, + xcb_connection_t *conn, + xcb_screen_t *screen, + xcb_drawable_t draw, + xcb_visualtype_t *vis, + xcb_colormap_t cmap, + int x_depth, + int grayscale, + int max_colors, + xcb_drawable_t mask, + int shape_dither, + int destination_alpha) +{ + Outbuf *buf; + + buf = calloc(1, sizeof(Outbuf)); + if (!buf) + return NULL; + + buf->w = w; + buf->h = h; + buf->depth = depth; + buf->rot = rot; + + buf->priv.x11.xcb.conn = conn; + buf->priv.x11.xcb.screen = screen; + buf->priv.x11.xcb.vis = vis; + buf->priv.x11.xcb.cmap = cmap; + buf->priv.x11.xcb.depth = x_depth; + + buf->priv.mask_dither = shape_dither; + buf->priv.destination_alpha = destination_alpha; + + { + Gfx_Func_Convert conv_func; + Xcb_Output_Buffer *xcbob; + + buf->priv.x11.xcb.shm = evas_software_xcb_x_can_do_shm(buf->priv.x11.xcb.conn, buf->priv.x11.xcb.screen); + xcbob = evas_software_xcb_x_output_buffer_new(buf->priv.x11.xcb.conn, + buf->priv.x11.xcb.depth, + 1, 1, + buf->priv.x11.xcb.shm, NULL); + + conv_func = NULL; + if (xcbob) + { +#ifdef WORDS_BIGENDIAN + if (evas_software_xcb_x_output_buffer_byte_order(xcbob) == XCB_IMAGE_ORDER_LSB_FIRST) + buf->priv.x11.xcb.swap = 1; + if (evas_software_xcb_x_output_buffer_bit_order(xcbob) == XCB_IMAGE_ORDER_MSB_FIRST) + buf->priv.x11.xcb.bit_swap = 1; +#else + if (evas_software_xcb_x_output_buffer_byte_order(xcbob) == XCB_IMAGE_ORDER_MSB_FIRST) + buf->priv.x11.xcb.swap = 1; + if (evas_software_xcb_x_output_buffer_bit_order(xcbob) == XCB_IMAGE_ORDER_MSB_FIRST) + buf->priv.x11.xcb.bit_swap = 1; +#endif + if (((vis->_class == XCB_VISUAL_CLASS_TRUE_COLOR) || + (vis->_class == XCB_VISUAL_CLASS_DIRECT_COLOR)) && + (x_depth > 8)) + + { + buf->priv.mask.r = (DATA32) vis->red_mask; + buf->priv.mask.g = (DATA32) vis->green_mask; + buf->priv.mask.b = (DATA32) vis->blue_mask; + if (buf->priv.x11.xcb.swap) + { + SWAP32(buf->priv.mask.r); + SWAP32(buf->priv.mask.g); + SWAP32(buf->priv.mask.b); + } + } + else if ((vis->_class == XCB_VISUAL_CLASS_STATIC_GRAY) || + (vis->_class == XCB_VISUAL_CLASS_GRAY_SCALE) || + (vis->_class == XCB_VISUAL_CLASS_STATIC_COLOR) || + (vis->_class == XCB_VISUAL_CLASS_PSEUDO_COLOR) || + (x_depth <= 8)) + { + Convert_Pal_Mode pm = PAL_MODE_RGB332; + + if ((vis->_class == XCB_VISUAL_CLASS_GRAY_SCALE) || + (vis->_class == XCB_VISUAL_CLASS_STATIC_GRAY)) + grayscale = 1; + if (grayscale) + { + if (max_colors >= 256) + pm = PAL_MODE_GRAY256; + else if (max_colors >= 64) + pm = PAL_MODE_GRAY64; + else if (max_colors >= 16) + pm = PAL_MODE_GRAY16; + else if (max_colors >= 4) + pm = PAL_MODE_GRAY4; + else + pm = PAL_MODE_MONO; + } + else + { + if (max_colors >= 256) + pm = PAL_MODE_RGB332; + else if (max_colors >= 216) + pm = PAL_MODE_RGB666; + else if (max_colors >= 128) + pm = PAL_MODE_RGB232; + else if (max_colors >= 64) + pm = PAL_MODE_RGB222; + else if (max_colors >= 32) + pm = PAL_MODE_RGB221; + else if (max_colors >= 16) + pm = PAL_MODE_RGB121; + else if (max_colors >= 8) + pm = PAL_MODE_RGB111; + else if (max_colors >= 4) + pm = PAL_MODE_GRAY4; + else + pm = PAL_MODE_MONO; + } + /* FIXME: only alloc once per display+cmap */ + buf->priv.pal = + evas_software_xcb_x_color_allocate(conn, + cmap, + vis, + PAL_MODE_RGB666); + if (!buf->priv.pal) + { + free(buf); + return NULL; + } + } + if (buf->priv.pal) + { + if (buf->rot == 0 || buf->rot == 180) + conv_func = evas_common_convert_func_get(0, + buf->w, + buf->h, + evas_software_xcb_x_output_buffer_depth (xcbob), + buf->priv.mask.r, + buf->priv.mask.g, + buf->priv.mask.b, + buf->priv.pal->colors, + buf->rot); + else if (buf->rot == 90 || buf->rot == 270) + conv_func = evas_common_convert_func_get(0, + buf->h, + buf->w, + evas_software_xcb_x_output_buffer_depth (xcbob), + buf->priv.mask.r, + buf->priv.mask.g, + buf->priv.mask.b, + buf->priv.pal->colors, + buf->rot); + } + else + { + if (buf->rot == 0 || buf->rot == 180) + conv_func = evas_common_convert_func_get(0, + buf->w, + buf->h, + evas_software_xcb_x_output_buffer_depth(xcbob), + buf->priv.mask.r, + buf->priv.mask.g, + buf->priv.mask.b, + PAL_MODE_NONE, + buf->rot); + else if (buf->rot == 90 || buf->rot == 270) + conv_func = evas_common_convert_func_get(0, + buf->h, + buf->w, + evas_software_xcb_x_output_buffer_depth(xcbob), + buf->priv.mask.r, + buf->priv.mask.g, + buf->priv.mask.b, + PAL_MODE_NONE, + buf->rot); + } + evas_software_xcb_x_output_buffer_free(xcbob, 1); + if (!conv_func) + { + printf(".[ Evas Error ].\n" + " {\n" + " At depth %i:\n" + " RGB format mask: %08x, %08x, %08x\n" + " Palette mode: %i\n" + " Not supported by and compiled in converters!\n" + " }\n", + buf->priv.x11.xcb.depth, + buf->priv.mask.r, + buf->priv.mask.g, + buf->priv.mask.b, + buf->priv.pal->colors); + } + } + evas_software_xcb_outbuf_drawable_set(buf, draw); + evas_software_xcb_outbuf_mask_set(buf, mask); + } + + return buf; +} + +RGBA_Image * +evas_software_xcb_outbuf_new_region_for_update(Outbuf *buf, + int x, + int y, + int w, + int h, + int *cx, + int *cy, + int *cw, + int *ch) +{ + RGBA_Image *im; + Outbuf_Region *obr; + int bpl = 0; + int use_shm = 1; + int alpha; + + if ((buf->onebuf) && (buf->priv.x11.xcb.shm)) + { + Evas_Rectangle *rect; + + rect = malloc(sizeof(Evas_Rectangle)); + RECTS_CLIP_TO_RECT(x, y, w, h, 0, 0, buf->w, buf->h); + rect->x = x; + rect->y = y; + rect->w = w; + rect->h = h; + buf->priv.onebuf_regions = eina_list_append(buf->priv.onebuf_regions, rect); + if (buf->priv.onebuf) + { + *cx = x; + *cy = y; + *cw = w; + *ch = h; + if (!buf->priv.synced) + { + /* we sync */ + free(xcb_get_input_focus_reply(buf->priv.x11.xcb.conn, xcb_get_input_focus_unchecked(buf->priv.x11.xcb.conn), NULL)); + buf->priv.synced = 1; + } + if ((buf->priv.x11.xcb.mask) || (buf->priv.destination_alpha)) + { + int yy; + + im = buf->priv.onebuf; + for (yy = y; yy < (y + h); yy++) + { + memset(im->image.data + (im->cache_entry.w * yy) + x, + 0, w * sizeof(DATA32)); + } + } + return buf->priv.onebuf; + } + obr = calloc(1, sizeof(Outbuf_Region)); + obr->x = 0; + obr->y = 0; + obr->w = buf->w; + obr->h = buf->h; + *cx = x; + *cy = y; + *cw = w; + *ch = h; + + alpha = ((buf->priv.x11.xcb.mask) || (buf->priv.destination_alpha)); + + use_shm = buf->priv.x11.xcb.shm; + if ((buf->rot == 0) && + (buf->priv.mask.r == 0xff0000) && + (buf->priv.mask.g == 0x00ff00) && + (buf->priv.mask.b == 0x0000ff)) + { + obr->xcbob = evas_software_xcb_x_output_buffer_new(buf->priv.x11.xcb.conn, + buf->priv.x11.xcb.depth, + buf->w, buf->h, + use_shm, + NULL); + im = (RGBA_Image *) evas_cache_image_data(evas_common_image_cache_get(), + buf->w, buf->h, + (DATA32 *)evas_software_xcb_x_output_buffer_data(obr->xcbob, &bpl), + alpha, EVAS_COLORSPACE_ARGB8888); + im->extended_info = obr; + if (buf->priv.x11.xcb.mask) + obr->mxcbob = evas_software_xcb_x_output_buffer_new(buf->priv.x11.xcb.conn, + 1, + buf->w, buf->h, + use_shm, + NULL); + } + else + { + im = (RGBA_Image *) evas_cache_image_empty(evas_common_image_cache_get()); + im->cache_entry.flags.alpha |= alpha ? 1 : 0; + evas_cache_image_surface_alloc(&im->cache_entry, buf->w, buf->h); + im->extended_info = obr; + if ((buf->rot == 0) || (buf->rot == 180)) + obr->xcbob = evas_software_xcb_x_output_buffer_new(buf->priv.x11.xcb.conn, + buf->priv.x11.xcb.depth, + buf->w, buf->h, + use_shm, + NULL); + else if ((buf->rot == 90) || (buf->rot == 270)) + obr->xcbob = evas_software_xcb_x_output_buffer_new(buf->priv.x11.xcb.conn, + buf->priv.x11.xcb.depth, + buf->h, buf->w, + use_shm, + NULL); + if (buf->priv.x11.xcb.mask) + obr->mxcbob = evas_software_xcb_x_output_buffer_new(buf->priv.x11.xcb.conn, + 1, buf->w, buf->h, + use_shm, + NULL); + } + if (alpha) + /* FIXME: faster memset! */ + memset(im->image.data, 0, w * h * sizeof(DATA32)); + + buf->priv.onebuf = im; + return im; + } + + + obr = calloc(1, sizeof(Outbuf_Region)); + obr->x = x; + obr->y = y; + obr->w = w; + obr->h = h; + *cx = 0; + *cy = 0; + *cw = w; + *ch = h; + + use_shm = buf->priv.x11.xcb.shm; + /* FIXME: magic - i found if shm regions are smaller than 200x200 its + * faster to use ximages over unix sockets - trial and error + */ +// use_shm = 0; /* 630 -> 1006 fps */ +// if ((w * h) < (200 * 200)) use_shm = 0; /* 630 -> 962 fps */ + + alpha = ((buf->priv.x11.xcb.mask) || (buf->priv.destination_alpha)); + + if ((buf->rot == 0) && + (buf->priv.mask.r == 0xff0000) && + (buf->priv.mask.g == 0x00ff00) && + (buf->priv.mask.b == 0x0000ff)) + { + obr->xcbob = _find_xcbob(buf->priv.x11.xcb.conn, + buf->priv.x11.xcb.depth, + w, h, + use_shm, + NULL); + im = (RGBA_Image *) evas_cache_image_data(evas_common_image_cache_get(), + w, h, + (DATA32 *) evas_software_xcb_x_output_buffer_data(obr->xcbob, &bpl), + alpha, EVAS_COLORSPACE_ARGB8888); + im->extended_info = obr; + if (buf->priv.x11.xcb.mask) + obr->mxcbob = _find_xcbob(buf->priv.x11.xcb.conn, + 1, w, h, + use_shm, + NULL); +/* obr->mxcbob = evas_software_xcb_x_output_buffer_new(buf->priv.x11.xcb.conn, */ +/* 1, */ +/* w, */ +/* h, */ +/* use_shm, */ +/* NULL); */ + } + else + { + im = (RGBA_Image *) evas_cache_image_empty(evas_common_image_cache_get()); + im->cache_entry.flags.alpha |= alpha ? 1 : 0; + evas_cache_image_surface_alloc(&im->cache_entry, w, h); + im->extended_info = obr; + if ((buf->rot == 0) || (buf->rot == 180)) + obr->xcbob = _find_xcbob(buf->priv.x11.xcb.conn, + buf->priv.x11.xcb.depth, + w, h, + use_shm, + NULL); +/* obr->xcbob = evas_software_xcb_x_output_buffer_new(buf->priv.x11.xcb.conn, */ +/* buf->priv.x11.xcb.depth, */ +/* w, */ +/* h, */ +/* use_shm, */ +/* NULL); */ + else if ((buf->rot == 90) || (buf->rot == 270)) + obr->xcbob = _find_xcbob(buf->priv.x11.xcb.conn, + buf->priv.x11.xcb.depth, + h, w, + use_shm, + NULL); +/* obr->xcbob = evas_software_xcb_x_output_buffer_new(buf->priv.x11.xcb.conn, */ +/* buf->priv.x11.xcb.depth, */ +/* h, */ +/* w, */ +/* use_shm, */ +/* NULL); */ + if (buf->priv.x11.xcb.mask) + obr->mxcbob = _find_xcbob(buf->priv.x11.xcb.conn, + 1, w, h, + use_shm, + NULL); +/* obr->mxcbob = evas_software_xcb_x_output_buffer_new(buf->priv.x11.xcb.conn, */ +/* 1, */ +/* w, */ +/* h, */ +/* use_shm, */ +/* NULL); */ + } + if ((buf->priv.x11.xcb.mask) || (buf->priv.destination_alpha)) + /* FIXME: faster memset! */ + memset(im->image.data, 0, w * h * sizeof(DATA32)); + + buf->priv.pending_writes = eina_list_append(buf->priv.pending_writes, im); + return im; +} + +void +evas_software_xcb_outbuf_free_region_for_update(Outbuf *buf, + RGBA_Image *update) +{ + /* no need to do anything - they are cleaned up on flush */ +} + +void +evas_software_xcb_outbuf_flush(Outbuf *buf) +{ + Eina_List *l; + RGBA_Image *im; + Outbuf_Region *obr; + + + if ((buf->priv.onebuf) && (buf->priv.onebuf_regions)) + { + pixman_region16_t tmpr; + + im = buf->priv.onebuf; + obr = im->extended_info; + pixman_region_init(&tmpr); + while (buf->priv.onebuf_regions) + { + Evas_Rectangle *rect; + + rect = buf->priv.onebuf_regions->data; + buf->priv.onebuf_regions = eina_list_remove_list(buf->priv.onebuf_regions, buf->priv.onebuf_regions); + pixman_region_union_rect(&tmpr, &tmpr, + rect->x, rect->y, + rect->w, rect->h); + if (buf->priv.debug) + evas_software_xcb_outbuf_debug_show(buf, buf->priv.x11.xcb.win, + rect->x, rect->y, rect->w, rect->h); + free(rect); + } + xcb_set_clip_rectangles(buf->priv.x11.xcb.conn, XCB_CLIP_ORDERING_YX_BANDED, + buf->priv.x11.xcb.gc, + 0, 0, pixman_region_n_rects(&tmpr), + (const xcb_rectangle_t *)pixman_region_rectangles(&tmpr, NULL)); + evas_software_xcb_x_output_buffer_paste(obr->xcbob, buf->priv.x11.xcb.win, + buf->priv.x11.xcb.gc, + 0, 0, 0); + if (obr->mxcbob) + { + xcb_set_clip_rectangles(buf->priv.x11.xcb.conn, XCB_CLIP_ORDERING_YX_BANDED, + buf->priv.x11.xcb.gcm, + 0, 0, pixman_region_n_rects(&tmpr), + (const xcb_rectangle_t *)pixman_region_rectangles(&tmpr, NULL)); + evas_software_xcb_x_output_buffer_paste(obr->mxcbob, + buf->priv.x11.xcb.mask, + buf->priv.x11.xcb.gcm, + 0, 0, 0); + } + buf->priv.synced = 0; + } + else + { +#if 1 + /* we sync */ + free(xcb_get_input_focus_reply(buf->priv.x11.xcb.conn, xcb_get_input_focus_unchecked(buf->priv.x11.xcb.conn), NULL)); + EINA_LIST_FOREACH(buf->priv.pending_writes, l, im) + { + obr = im->extended_info; + if (buf->priv.debug) + evas_software_xcb_outbuf_debug_show(buf, + buf->priv.x11.xcb.win, + obr->x, + obr->y, + obr->w, + obr->h); + evas_software_xcb_x_output_buffer_paste(obr->xcbob, + buf->priv.x11.xcb.win, + buf->priv.x11.xcb.gc, + obr->x, + obr->y, 0); + if (obr->mxcbob) + evas_software_xcb_x_output_buffer_paste(obr->mxcbob, + buf->priv.x11.xcb.mask, + buf->priv.x11.xcb.gcm, + obr->x, + obr->y, 0); + } + while (buf->priv.pending_writes) + { + im = buf->priv.pending_writes->data; + buf->priv.pending_writes = eina_list_remove_list(buf->priv.pending_writes, + buf->priv.pending_writes); + obr = im->extended_info; + evas_cache_image_drop(&im->cache_entry); + if (obr->xcbob) _unfind_xcbob(obr->xcbob, 0); + if (obr->mxcbob) _unfind_xcbob(obr->mxcbob, 0); +/* if (obr->xcbob) evas_software_xcb_x_output_buffer_free(obr->xcbob, 0); */ +/* if (obr->mxcbob) evas_software_xcb_x_output_buffer_free(obr->mxcbob, 0); */ + free(obr); + } + buf->priv.prev_pending_writes = buf->priv.pending_writes; + buf->priv.pending_writes = NULL; + xcb_flush(buf->priv.x11.xcb.conn); +#else + /* XX async push - disable */ + /* + EINA_LIST_FOREACH(buf->priv.pending_writes, l, im) + { + obr = im->extended_info; + if (buf->priv.debug) + evas_software_x11_outbuf_debug_show(buf, buf->priv.x11.xcb.win, + obr->x, obr->y, obr->w, obr->h); + evas_software_x11_x_output_buffer_paste(obr->xcbob, buf->priv.x11.xcb.win, + buf->priv.x11.xcb.gc, + obr->x, obr->y, 0); + if (obr->mxcbob) + evas_software_x11_x_output_buffer_paste(obr->mxcbob, + buf->priv.x11.xcb.mask, + buf->priv.x11.xcb.gcm, + obr->x, obr->y, 0); + } + */ + /* we sync */ + free(xcb_get_input_focus_reply(buf->priv.x11.xcb.conn, xcb_get_input_focus_unchecked(buf->priv.x11.xcb.conn), NULL)); + + while (buf->priv.pending_writes) + { + im = eina_list_data_get(buf->priv.pending_writes); + buf->priv.pending_writes = eina_list_remove_list(buf->priv.pending_writes, buf->priv.pending_writes); + obr = im->extended_info; + evas_cache_image_drop(&im->cache_entry); + if (obr->xcbob) _unfind_xcbob(obr->xcbob, 0); + if (obr->mxcbob) _unfind_xcbob(obr->mxcbob, 0); +/* + if (obr->xcbob) evas_software_x11_x_output_buffer_free(obr->xcbob, 0); + if (obr->mxcbob) evas_software_x11_x_output_buffer_free(obr->mxcbob, 0); + */ + free(obr); + evas_cache_image_drop(&im->cache_entry); + } +#endif + } + evas_common_cpu_end_opt(); +} + +void +evas_software_xcb_outbuf_idle_flush(Outbuf *buf) +{ + if (buf->priv.onebuf) + { + RGBA_Image *im; + Outbuf_Region *obr; + + im = buf->priv.onebuf; + buf->priv.onebuf = NULL; + obr = im->extended_info; + if (obr->xcbob) evas_software_xcb_x_output_buffer_free(obr->xcbob, 0); + if (obr->mxcbob) evas_software_xcb_x_output_buffer_free(obr->mxcbob, 0); + free(obr); + evas_cache_image_drop(&im->cache_entry); + } + else + { + if (buf->priv.prev_pending_writes) + free(xcb_get_input_focus_reply(buf->priv.x11.xcb.conn, xcb_get_input_focus_unchecked(buf->priv.x11.xcb.conn), NULL)); + while (buf->priv.prev_pending_writes) + { + RGBA_Image *im; + Outbuf_Region *obr; + + im = buf->priv.prev_pending_writes->data; + buf->priv.prev_pending_writes = + eina_list_remove_list(buf->priv.prev_pending_writes, + buf->priv.prev_pending_writes); + obr = im->extended_info; + evas_cache_image_drop(&im->cache_entry); + if (obr->xcbob) _unfind_xcbob(obr->xcbob, 0); + if (obr->mxcbob) _unfind_xcbob(obr->mxcbob, 0); + free(obr); + } + _clear_xcbob(0); + } +} + +void +evas_software_xcb_outbuf_push_updated_region(Outbuf *buf, + RGBA_Image *update, + int x, + int y, + int w, + int h) +{ + Gfx_Func_Convert conv_func = NULL; + Outbuf_Region *obr; + DATA32 *src_data; + void *data; + int bpl = 0; + int yy; + + obr = update->extended_info; + if (buf->priv.pal) + { + if ((buf->rot == 0) || (buf->rot == 180)) + conv_func = evas_common_convert_func_get(0, w, h, + evas_software_xcb_x_output_buffer_depth + (obr->xcbob), buf->priv.mask.r, + buf->priv.mask.g, buf->priv.mask.b, + buf->priv.pal->colors, buf->rot); + else if ((buf->rot == 90) || (buf->rot == 270)) + conv_func = evas_common_convert_func_get(0, h, w, + evas_software_xcb_x_output_buffer_depth + (obr->xcbob), buf->priv.mask.r, + buf->priv.mask.g, buf->priv.mask.b, + buf->priv.pal->colors, buf->rot); + } + else + { + if ((buf->rot == 0) || (buf->rot == 180)) + conv_func = evas_common_convert_func_get(0, w, h, + evas_software_xcb_x_output_buffer_depth + (obr->xcbob), buf->priv.mask.r, + buf->priv.mask.g, buf->priv.mask.b, + PAL_MODE_NONE, buf->rot); + else if ((buf->rot == 90) || (buf->rot == 270)) + conv_func = evas_common_convert_func_get(0, h, w, + evas_software_xcb_x_output_buffer_depth + (obr->xcbob), buf->priv.mask.r, + buf->priv.mask.g, buf->priv.mask.b, + PAL_MODE_NONE, buf->rot); + } + if (!conv_func) return; + + data = evas_software_xcb_x_output_buffer_data(obr->xcbob, &bpl); + src_data = update->image.data; + if (buf->rot == 0) + { + obr->x = x; + obr->y = y; + } + else if (buf->rot == 90) + { + obr->x = y; + obr->y = buf->w - x - w; + } + else if (buf->rot == 180) + { + obr->x = buf->w - x - w; + obr->y = buf->h - y - h; + } + else if (buf->rot == 270) + { + obr->x = buf->h - y - h; + obr->y = x; + } + if ((buf->rot == 0) || (buf->rot == 180)) + { + obr->w = w; + obr->h = h; + } + else if ((buf->rot == 90) || (buf->rot == 270)) + { + obr->w = h; + obr->h = w; + } + if (buf->priv.pal) + { + if (data != src_data) + conv_func(src_data, data, + 0, + bpl / + ((evas_software_xcb_x_output_buffer_depth(obr->xcbob) / 8)) - obr->w, + obr->w, obr->h, x, y, + buf->priv.pal->lookup); + } + else + { + if (data != src_data) + conv_func(src_data, data, + 0, + bpl / + ((evas_software_xcb_x_output_buffer_depth(obr->xcbob) / 8)) - obr->w, + obr->w, obr->h, x, y, NULL); + } +#if 1 +#else + /* XX async push */ + if (!((buf->priv.onebuf) && (buf->priv.onebuf_regions))) + { + if (buf->priv.debug) + evas_software_xcb_outbuf_debug_show(buf, buf->priv.x11.xcb.win, + obr->x, obr->y, obr->w, obr->h); + evas_software_xcb_x_output_buffer_paste(obr->xcbob, buf->priv.x11.xcb.win, + buf->priv.x11.xcb.gc, + obr->x, obr->y, 0); + } +#endif + if (obr->mxcbob) + { + for (yy = 0; yy < obr->h; yy++) + evas_software_xcb_x_write_mask_line(buf, obr->mxcbob, + src_data + (yy * obr->w), + obr->w, + yy); +#if 1 +#else + /* XX async push */ + if (!((buf->priv.onebuf) && (buf->priv.onebuf_regions))) + evas_software_xcb_x_output_buffer_paste(obr->mxcbob, + buf->priv.x11.xcb.mask, + buf->priv.x11.xcb.gcm, + obr->x, obr->y, 0); +#endif + } +#if 1 +#else + xcb_flush(buf->priv.x11.xcb.conn); +#endif +} + +void +evas_software_xcb_outbuf_reconfigure(Outbuf *buf, + int w, + int h, + int rot, + Outbuf_Depth depth) +{ + if ((w == buf->w) && + (h == buf->h) && + (rot == buf->rot) && + (depth == buf->depth)) return; + buf->w = w; + buf->h = h; + buf->rot = rot; + evas_software_xcb_outbuf_idle_flush(buf); +} + +int +evas_software_xcb_outbuf_get_width(Outbuf * buf) +{ + return buf->w; +} + +int +evas_software_xcb_outbuf_get_height(Outbuf * buf) +{ + return buf->h; +} + +Outbuf_Depth +evas_software_xcb_outbuf_get_depth(Outbuf * buf) +{ + return buf->depth; +} + +int +evas_software_xcb_outbuf_get_rot(Outbuf * buf) +{ + return buf->rot; +} + +void +evas_software_xcb_outbuf_drawable_set(Outbuf *buf, + xcb_drawable_t draw) +{ + if (buf->priv.x11.xcb.win == draw) return; + if (buf->priv.x11.xcb.gc) + { + xcb_free_gc(buf->priv.x11.xcb.conn, buf->priv.x11.xcb.gc); + buf->priv.x11.xcb.gc = 0; + } + buf->priv.x11.xcb.win = draw; + buf->priv.x11.xcb.gc = xcb_generate_id(buf->priv.x11.xcb.conn); + xcb_create_gc(buf->priv.x11.xcb.conn, buf->priv.x11.xcb.gc, buf->priv.x11.xcb.win, 0, NULL); +} + +void +evas_software_xcb_outbuf_mask_set(Outbuf *buf, + xcb_drawable_t mask) +{ + if (buf->priv.x11.xcb.mask == mask) return; + if (buf->priv.x11.xcb.gcm) + { + xcb_free_gc(buf->priv.x11.xcb.conn, buf->priv.x11.xcb.gcm); + buf->priv.x11.xcb.gcm = 0; + } + buf->priv.x11.xcb.mask = mask; + if (buf->priv.x11.xcb.mask) + { + buf->priv.x11.xcb.gcm = xcb_generate_id(buf->priv.x11.xcb.conn); + xcb_create_gc(buf->priv.x11.xcb.conn, buf->priv.x11.xcb.gcm, buf->priv.x11.xcb.win, 0, NULL); + } +} + +void +evas_software_xcb_outbuf_debug_set(Outbuf *buf, + int debug) +{ + buf->priv.debug = debug; +} +void +evas_software_xcb_outbuf_debug_show(Outbuf *buf, + xcb_drawable_t draw, + int x, + int y, + int w, + int h) +{ + int i; + xcb_screen_t *screen = NULL; + + { + xcb_get_geometry_reply_t *geom; + xcb_drawable_t root; + xcb_screen_iterator_t i; + + geom = xcb_get_geometry_reply (buf->priv.x11.xcb.conn, xcb_get_geometry_unchecked(buf->priv.x11.xcb.conn, draw), 0); + root = geom->root; + free (geom); + geom = xcb_get_geometry_reply (buf->priv.x11.xcb.conn, xcb_get_geometry_unchecked(buf->priv.x11.xcb.conn, root), 0); + + i = xcb_setup_roots_iterator((xcb_setup_t *)xcb_get_setup(buf->priv.x11.xcb.conn)); + for (; i.rem; xcb_screen_next(&i)) + if (i.data->root == geom->root) + { + screen = i.data; + break; + } + free (geom); + } + for (i = 0; i < 20; i++) + { +/* xcb_image_t *image; */ + xcb_rectangle_t rect = { x, y, w, h}; + uint32_t mask; + uint32_t value[2]; + + mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES; + value[0] = screen->black_pixel; + value[1] = XCB_EXPOSURES_NOT_ALLOWED; /* no graphics exposures allowed */ + xcb_change_gc(buf->priv.x11.xcb.conn, buf->priv.x11.xcb.gc, mask, value); + xcb_poly_fill_rectangle (buf->priv.x11.xcb.conn, draw, buf->priv.x11.xcb.gc, 1, &rect); + /* we sync */ + free(xcb_get_input_focus_reply(buf->priv.x11.xcb.conn, xcb_get_input_focus_unchecked(buf->priv.x11.xcb.conn), NULL)); +// image = xcb_image_get(buf->priv.x11.xcb.conn, draw, x, y, w, h, XCB_ALL_PLANES, XCB_IMAGE_FORMAT_Z_PIXMAP); +// if (image) +// xcb_image_destroy(image); + /* we sync */ + free(xcb_get_input_focus_reply(buf->priv.x11.xcb.conn, xcb_get_input_focus_unchecked(buf->priv.x11.xcb.conn), NULL)); + mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES; + value[0] = screen->white_pixel; + value[1] = XCB_EXPOSURES_NOT_ALLOWED; /* no graphics exposures allowed */ + xcb_change_gc(buf->priv.x11.xcb.conn, buf->priv.x11.xcb.gc, mask, value); + xcb_poly_fill_rectangle (buf->priv.x11.xcb.conn, draw, buf->priv.x11.xcb.gc, 1, &rect); + /* we sync */ + free(xcb_get_input_focus_reply(buf->priv.x11.xcb.conn, xcb_get_input_focus_unchecked(buf->priv.x11.xcb.conn), NULL)); +// image = xcb_image_get(buf->priv.x11.xcb.conn, draw, x, y, w, h, XCB_ALL_PLANES, XCB_IMAGE_FORMAT_Z_PIXMAP); +// if (image) +// xcb_image_destroy(image); + /* we sync */ + free(xcb_get_input_focus_reply(buf->priv.x11.xcb.conn, xcb_get_input_focus_unchecked(buf->priv.x11.xcb.conn), NULL)); + } +} diff --git a/legacy/evas/src/modules/engines/software_x11/evas_xcb_outbuf.h b/legacy/evas/src/modules/engines/software_x11/evas_xcb_outbuf.h new file mode 100644 index 0000000000..76b505b740 --- /dev/null +++ b/legacy/evas/src/modules/engines/software_x11/evas_xcb_outbuf.h @@ -0,0 +1,86 @@ +#ifndef EVAS_XCB_OUTBUF_H +#define EVAS_XCB_OUTBUF_H + + +#include "evas_engine.h" + + +void evas_software_xcb_outbuf_init (void); + +void evas_software_xcb_outbuf_free (Outbuf *buf); + +Outbuf *evas_software_xcb_outbuf_setup_x (int w, + int h, + int rot, + Outbuf_Depth depth, + xcb_connection_t *conn, + xcb_screen_t *screen, + xcb_drawable_t draw, + xcb_visualtype_t *vis, + xcb_colormap_t cmap, + int x_depth, + int grayscale, + int max_colors, + xcb_drawable_t mask, + int shape_dither, + int destination_alpha); + + +RGBA_Image *evas_software_xcb_outbuf_new_region_for_update (Outbuf *buf, + int x, + int y, + int w, + int h, + int *cx, + int *cy, + int *cw, + int *ch); + +void evas_software_xcb_outbuf_free_region_for_update (Outbuf *buf, + RGBA_Image *update); + +void evas_software_xcb_outbuf_flush (Outbuf *buf); + +void evas_software_xcb_outbuf_idle_flush (Outbuf *buf); + +void evas_software_xcb_outbuf_push_updated_region (Outbuf *buf, + RGBA_Image *update, + int x, + int y, + int w, + int h); + +void evas_software_xcb_outbuf_reconfigure (Outbuf *buf, + int w, + int h, + int rot, + Outbuf_Depth depth); + +int evas_software_xcb_outbuf_get_width (Outbuf *buf); + +int evas_software_xcb_outbuf_get_height (Outbuf *buf); + +Outbuf_Depth evas_software_xcb_outbuf_get_depth (Outbuf *buf); + +int evas_software_xcb_outbuf_get_rot (Outbuf *buf); + +void evas_software_xcb_outbuf_drawable_set (Outbuf *buf, + xcb_drawable_t draw); + +void evas_software_xcb_outbuf_mask_set (Outbuf *buf, + xcb_drawable_t mask); + +void evas_software_xcb_outbuf_rotation_set (Outbuf *buf, + int rot); + +void evas_software_xcb_outbuf_debug_set (Outbuf *buf, + int debug); + +void evas_software_xcb_outbuf_debug_show (Outbuf *buf, + xcb_drawable_t draw, + int x, + int y, + int w, + int h); + +#endif diff --git a/legacy/evas/src/modules/engines/software_x11/evas_x_buffer.c b/legacy/evas/src/modules/engines/software_x11/evas_xlib_buffer.c similarity index 83% rename from legacy/evas/src/modules/engines/software_x11/evas_x_buffer.c rename to legacy/evas/src/modules/engines/software_x11/evas_xlib_buffer.c index 35974698fa..5f3825c344 100644 --- a/legacy/evas/src/modules/engines/software_x11/evas_x_buffer.c +++ b/legacy/evas/src/modules/engines/software_x11/evas_xlib_buffer.c @@ -1,10 +1,11 @@ #include "evas_common.h" -#include "evas_engine.h" + +#include "evas_xlib_buffer.h" static int _x_err = 0; void -evas_software_x11_x_write_mask_line(Outbuf *buf, X_Output_Buffer *xob, DATA32 *src, int w, int y) +evas_software_xlib_x_write_mask_line(Outbuf *buf, X_Output_Buffer *xob, DATA32 *src, int w, int y) { int x; DATA32 *src_ptr; @@ -12,10 +13,10 @@ evas_software_x11_x_write_mask_line(Outbuf *buf, X_Output_Buffer *xob, DATA32 *s int bpl = 0; src_ptr = src; - dst_ptr = evas_software_x11_x_output_buffer_data(xob, &bpl); + dst_ptr = evas_software_xlib_x_output_buffer_data(xob, &bpl); dst_ptr = dst_ptr + (bpl * y); w -= 7; - if (buf->priv.x.bit_swap) + if (buf->priv.x11.xlib.bit_swap) { for (x = 0; x < w; x += 8) { @@ -58,7 +59,7 @@ evas_software_x11_x_write_mask_line(Outbuf *buf, X_Output_Buffer *xob, DATA32 *s } int -evas_software_x11_x_can_do_shm(Display *d) +evas_software_xlib_x_can_do_shm(Display *d) { static Display *cached_d = NULL; static int cached_result = 0; @@ -69,7 +70,7 @@ evas_software_x11_x_can_do_shm(Display *d) { X_Output_Buffer *xob; - xob = evas_software_x11_x_output_buffer_new + xob = evas_software_xlib_x_output_buffer_new (d, DefaultVisual(d, DefaultScreen(d)), DefaultDepth(d, DefaultScreen(d)), 16, 16, 2, NULL); if (!xob) @@ -77,7 +78,7 @@ evas_software_x11_x_can_do_shm(Display *d) cached_result = 0; return 0; } - evas_software_x11_x_output_buffer_free(xob, 1); + evas_software_xlib_x_output_buffer_free(xob, 1); cached_result = 1; return 1; } @@ -95,7 +96,7 @@ x_output_tmp_x_err(Display * d, XErrorEvent * ev) //static int creates = 0; X_Output_Buffer * -evas_software_x11_x_output_buffer_new(Display *d, Visual *v, int depth, int w, int h, int try_shm, void *data) +evas_software_xlib_x_output_buffer_new(Display *d, Visual *v, int depth, int w, int h, int try_shm, void *data) { X_Output_Buffer *xob; @@ -188,7 +189,7 @@ evas_software_x11_x_output_buffer_new(Display *d, Visual *v, int depth, int w, i } void -evas_software_x11_x_output_buffer_free(X_Output_Buffer *xob, int sync) +evas_software_xlib_x_output_buffer_free(X_Output_Buffer *xob, int sync) { if (xob->shm_info) { @@ -212,7 +213,7 @@ evas_software_x11_x_output_buffer_free(X_Output_Buffer *xob, int sync) } void -evas_software_x11_x_output_buffer_paste(X_Output_Buffer *xob, Drawable d, GC gc, int x, int y, int sync) +evas_software_xlib_x_output_buffer_paste(X_Output_Buffer *xob, Drawable d, GC gc, int x, int y, int sync) { if (xob->shm_info) { @@ -230,26 +231,26 @@ evas_software_x11_x_output_buffer_paste(X_Output_Buffer *xob, Drawable d, GC gc, } DATA8 * -evas_software_x11_x_output_buffer_data(X_Output_Buffer *xob, int *bytes_per_line_ret) +evas_software_xlib_x_output_buffer_data(X_Output_Buffer *xob, int *bytes_per_line_ret) { if (bytes_per_line_ret) *bytes_per_line_ret = xob->xim->bytes_per_line; - return xob->xim->data; + return (DATA8 *)xob->xim->data; } int -evas_software_x11_x_output_buffer_depth(X_Output_Buffer *xob) +evas_software_xlib_x_output_buffer_depth(X_Output_Buffer *xob) { return xob->xim->bits_per_pixel; } int -evas_software_x11_x_output_buffer_byte_order(X_Output_Buffer *xob) +evas_software_xlib_x_output_buffer_byte_order(X_Output_Buffer *xob) { return xob->xim->byte_order; } int -evas_software_x11_x_output_buffer_bit_order(X_Output_Buffer *xob) +evas_software_xlib_x_output_buffer_bit_order(X_Output_Buffer *xob) { return xob->xim->bitmap_bit_order; } diff --git a/legacy/evas/src/modules/engines/software_x11/evas_xlib_buffer.h b/legacy/evas/src/modules/engines/software_x11/evas_xlib_buffer.h new file mode 100644 index 0000000000..5ad91a77fc --- /dev/null +++ b/legacy/evas/src/modules/engines/software_x11/evas_xlib_buffer.h @@ -0,0 +1,42 @@ +#ifndef EVAS_XLIB_BUFFER_H +#define EVAS_XLIB_BUFFER_H + + +#include "evas_engine.h" + + +typedef struct _X_Output_Buffer X_Output_Buffer; + +struct _X_Output_Buffer +{ + Display *display; + XImage *xim; + XShmSegmentInfo *shm_info; + Visual *visual; + void *data; + int w; + int h; + int bpl; + int psize; +}; + +void evas_software_xlib_x_write_mask_line (Outbuf *buf, X_Output_Buffer *xob, DATA32 *src, int w, int y); + +int evas_software_xlib_x_can_do_shm (Display *d); + +X_Output_Buffer *evas_software_xlib_x_output_buffer_new (Display *d, Visual *v, int depth, int w, int h, int try_shm, void *data); + +void evas_software_xlib_x_output_buffer_free (X_Output_Buffer *xob, int sync); + +void evas_software_xlib_x_output_buffer_paste (X_Output_Buffer *xob, Drawable d, GC gc, int x, int y, int sync); + +DATA8 *evas_software_xlib_x_output_buffer_data (X_Output_Buffer *xob, int *bytes_per_line_ret); + +int evas_software_xlib_x_output_buffer_depth (X_Output_Buffer *xob); + +int evas_software_xlib_x_output_buffer_byte_order (X_Output_Buffer *xob); + +int evas_software_xlib_x_output_buffer_bit_order (X_Output_Buffer *xob); + + +#endif diff --git a/legacy/evas/src/modules/engines/software_x11/evas_x_color.c b/legacy/evas/src/modules/engines/software_x11/evas_xlib_color.c similarity index 94% rename from legacy/evas/src/modules/engines/software_x11/evas_x_color.c rename to legacy/evas/src/modules/engines/software_x11/evas_xlib_color.c index 70f637b1c9..f3ef02d58a 100644 --- a/legacy/evas/src/modules/engines/software_x11/evas_x_color.c +++ b/legacy/evas/src/modules/engines/software_x11/evas_xlib_color.c @@ -1,4 +1,5 @@ #include "evas_common.h" + #include "evas_engine.h" #include @@ -77,7 +78,7 @@ x_color_alloc_rgb(int nr, int ng, int nb, Display *d, Colormap cmap, Visual *v) if (dg < 0) dg = -dg; db = (int)xcl_in.blue - (int)xcl.blue; if (db < 0) db = -db; -/* +/* printf("ASK [%i]: %04x %04x %04x = %04x %04x %04x | dif = %04x / %04x\n", ret, xcl_in.red, xcl_in.green, xcl_in.blue, @@ -86,7 +87,7 @@ x_color_alloc_rgb(int nr, int ng, int nb, Display *d, Colormap cmap, Visual *v) */ if ((ret == 0) || ((dr + dg + db) > delt) -/* +/* || ((xcl_in.red & sig_mask) != (xcl.red & sig_mask)) || ((xcl_in.green & sig_mask) != (xcl.green & sig_mask)) || @@ -236,7 +237,7 @@ x_color_alloc_mono(Display *d, Colormap cmap, Visual *v) } void -evas_software_x11_x_color_init(void) +evas_software_xlib_x_color_init(void) { static int initialised = 0; @@ -286,7 +287,10 @@ evas_software_x11_x_color_init(void) } Convert_Pal * -evas_software_x11_x_color_allocate(Display *disp, Colormap cmap, Visual *vis, Convert_Pal_Mode colors) +evas_software_xlib_x_color_allocate(Display *disp, + Colormap cmap, + Visual *vis, + Convert_Pal_Mode colors) { Convert_Pal_Priv *palpriv; Convert_Pal *pal; @@ -341,7 +345,10 @@ evas_software_x11_x_color_allocate(Display *disp, Colormap cmap, Visual *vis, Co } void -evas_software_x11_x_color_deallocate(Display *disp, Colormap cmap, Visual *vis, Convert_Pal *pal) +evas_software_xlib_x_color_deallocate(Display *disp, + Colormap cmap, + Visual *vis, + Convert_Pal *pal) { unsigned long pixels[256]; int j; diff --git a/legacy/evas/src/modules/engines/software_x11/evas_xlib_color.h b/legacy/evas/src/modules/engines/software_x11/evas_xlib_color.h new file mode 100644 index 0000000000..e9f8afb27f --- /dev/null +++ b/legacy/evas/src/modules/engines/software_x11/evas_xlib_color.h @@ -0,0 +1,16 @@ +#ifndef EVAS_XLIB_COLOR_H +#define EVAS_XLIB_COLOR_H + +void evas_software_xlib_x_color_init (void); + +Convert_Pal *evas_software_xlib_x_color_allocate (Display *disp, + Colormap cmap, + Visual *vis, + Convert_Pal_Mode colors); + +void evas_software_xlib_x_color_deallocate (Display *disp, + Colormap cmap, + Visual *vis, + Convert_Pal *pal); + +#endif diff --git a/legacy/evas/src/modules/engines/software_x11/evas_xlib_main.c b/legacy/evas/src/modules/engines/software_x11/evas_xlib_main.c new file mode 100644 index 0000000000..3c153e1494 --- /dev/null +++ b/legacy/evas/src/modules/engines/software_x11/evas_xlib_main.c @@ -0,0 +1,7 @@ +#include "evas_common.h" +#include "evas_engine.h" + +void +evas_software_xlib_x_init(void) +{ +} diff --git a/legacy/evas/src/modules/engines/software_x11/evas_outbuf.c b/legacy/evas/src/modules/engines/software_x11/evas_xlib_outbuf.c similarity index 61% rename from legacy/evas/src/modules/engines/software_x11/evas_outbuf.c rename to legacy/evas/src/modules/engines/software_x11/evas_xlib_outbuf.c index fe7016b23c..3f84cf6ef9 100644 --- a/legacy/evas/src/modules/engines/software_x11/evas_outbuf.c +++ b/legacy/evas/src/modules/engines/software_x11/evas_xlib_outbuf.c @@ -1,13 +1,30 @@ -#include "evas_common.h" -#include "evas_engine.h" -#include "evas_macros.h" #include #include +#include "evas_common.h" +#include "evas_macros.h" +#include "evas_xlib_outbuf.h" +#include "evas_xlib_buffer.h" +#include "evas_xlib_color.h" + + +typedef struct _Outbuf_Region Outbuf_Region; + +struct _Outbuf_Region +{ + X_Output_Buffer *xob; + X_Output_Buffer *mxob; + int x; + int y; + int w; + int h; +}; + static Eina_List *shmpool = NULL; static int shmsize = 0; static int shmmemlimit = 10 * 1024 * 1024; static int shmcountlimit = 32; + static X_Output_Buffer * _find_xob(Display *d, Visual *v, int depth, int w, int h, int shm, void *data) { @@ -16,10 +33,10 @@ _find_xob(Display *d, Visual *v, int depth, int w, int h, int shm, void *data) X_Output_Buffer *xob2; int fitness = 0x7fffffff; int sz, lbytes, bpp; - -// return evas_software_x11_x_output_buffer_new(d, v, depth, w, h, shm, data); + +// return evas_software_xlib_x_output_buffer_new(d, v, depth, w, h, shm, data); if (!shm) - return evas_software_x11_x_output_buffer_new(d, v, depth, w, h, shm, data); + return evas_software_xlib_x_output_buffer_new(d, v, depth, w, h, shm, data); if (depth > 1) { bpp = depth / 8; @@ -52,8 +69,8 @@ _find_xob(Display *d, Visual *v, int depth, int w, int h, int shm, void *data) } } if ((fitness > (100 * 100)) || (!xob)) - return evas_software_x11_x_output_buffer_new(d, v, depth, w, h, shm, data); - + return evas_software_xlib_x_output_buffer_new(d, v, depth, w, h, shm, data); + have_xob: shmpool = eina_list_remove_list(shmpool, xl); xob->w = w; @@ -69,7 +86,7 @@ _find_xob(Display *d, Visual *v, int depth, int w, int h, int shm, void *data) static void _unfind_xob(X_Output_Buffer *xob, int sync) { -// evas_software_x11_x_output_buffer_free(xob, sync); return; +// evas_software_xlib_x_output_buffer_free(xob, sync); return; if (xob->shm_info) { shmpool = eina_list_prepend(shmpool, xob); @@ -78,7 +95,7 @@ _unfind_xob(X_Output_Buffer *xob, int sync) (eina_list_count(shmpool) > shmcountlimit)) { Eina_List *xl; - + xl = eina_list_last(shmpool); if (!xl) { @@ -87,11 +104,11 @@ _unfind_xob(X_Output_Buffer *xob, int sync) } xob = xl->data; shmpool = eina_list_remove_list(shmpool, xl); - evas_software_x11_x_output_buffer_free(xob, sync); + evas_software_xlib_x_output_buffer_free(xob, sync); } } - else - evas_software_x11_x_output_buffer_free(xob, sync); + else + evas_software_xlib_x_output_buffer_free(xob, sync); } static void @@ -100,27 +117,27 @@ _clear_xob(int sync) while (shmpool) { X_Output_Buffer *xob; - + xob = shmpool->data; shmpool = eina_list_remove_list(shmpool, shmpool); - evas_software_x11_x_output_buffer_free(xob, sync); + evas_software_xlib_x_output_buffer_free(xob, sync); } shmsize = 0; } void -evas_software_x11_outbuf_init(void) +evas_software_xlib_outbuf_init(void) { } void -evas_software_x11_outbuf_free(Outbuf *buf) +evas_software_xlib_outbuf_free(Outbuf *buf) { while (buf->priv.pending_writes) { RGBA_Image *im; Outbuf_Region *obr; - + im = buf->priv.pending_writes->data; buf->priv.pending_writes = eina_list_remove_list(buf->priv.pending_writes, buf->priv.pending_writes); obr = im->extended_info; @@ -129,27 +146,21 @@ evas_software_x11_outbuf_free(Outbuf *buf) if (obr->mxob) _unfind_xob(obr->mxob, 0); free(obr); } - evas_software_x11_outbuf_idle_flush(buf); - evas_software_x11_outbuf_flush(buf); - if (buf->priv.x.gc) - XFreeGC(buf->priv.x.disp, buf->priv.x.gc); - if (buf->priv.x.gcm) - XFreeGC(buf->priv.x.disp, buf->priv.x.gcm); + evas_software_xlib_outbuf_idle_flush(buf); + evas_software_xlib_outbuf_flush(buf); + if (buf->priv.x11.xlib.gc) + XFreeGC(buf->priv.x11.xlib.disp, buf->priv.x11.xlib.gc); + if (buf->priv.x11.xlib.gcm) + XFreeGC(buf->priv.x11.xlib.disp, buf->priv.x11.xlib.gcm); if (buf->priv.pal) - evas_software_x11_x_color_deallocate(buf->priv.x.disp, buf->priv.x.cmap, - buf->priv.x.vis, buf->priv.pal); + evas_software_xlib_x_color_deallocate(buf->priv.x11.xlib.disp, buf->priv.x11.xlib.cmap, + buf->priv.x11.xlib.vis, buf->priv.pal); free(buf); _clear_xob(0); } -void -evas_software_x11_outbuf_rotation_set(Outbuf *buf, int rot) -{ - buf->rot = rot; -} - -Outbuf * -evas_software_x11_outbuf_setup_x(int w, int h, int rot, Outbuf_Depth depth, +Outbuf * +evas_software_xlib_outbuf_setup_x(int w, int h, int rot, Outbuf_Depth depth, Display *disp, Drawable draw, Visual *vis, Colormap cmap, int x_depth, int grayscale, int max_colors, Pixmap mask, @@ -166,10 +177,10 @@ evas_software_x11_outbuf_setup_x(int w, int h, int rot, Outbuf_Depth depth, buf->depth = depth; buf->rot = rot; - buf->priv.x.disp = disp; - buf->priv.x.vis = vis; - buf->priv.x.cmap = cmap; - buf->priv.x.depth = x_depth; + buf->priv.x11.xlib.disp = disp; + buf->priv.x11.xlib.vis = vis; + buf->priv.x11.xlib.cmap = cmap; + buf->priv.x11.xlib.depth = x_depth; buf->priv.mask_dither = shape_dither; buf->priv.destination_alpha = destination_alpha; @@ -178,25 +189,25 @@ evas_software_x11_outbuf_setup_x(int w, int h, int rot, Outbuf_Depth depth, Gfx_Func_Convert conv_func; X_Output_Buffer *xob; - buf->priv.x.shm = evas_software_x11_x_can_do_shm(buf->priv.x.disp); - xob = evas_software_x11_x_output_buffer_new(buf->priv.x.disp, - buf->priv.x.vis, - buf->priv.x.depth, - 1, 1, buf->priv.x.shm, NULL); + buf->priv.x11.xlib.shm = evas_software_xlib_x_can_do_shm(buf->priv.x11.xlib.disp); + xob = evas_software_xlib_x_output_buffer_new(buf->priv.x11.xlib.disp, + buf->priv.x11.xlib.vis, + buf->priv.x11.xlib.depth, + 1, 1, buf->priv.x11.xlib.shm, NULL); conv_func = NULL; if (xob) { #ifdef WORDS_BIGENDIAN - if (evas_software_x11_x_output_buffer_byte_order(xob) == LSBFirst) - buf->priv.x.swap = 1; - if (evas_software_x11_x_output_buffer_bit_order(xob) == MSBFirst) - buf->priv.x.bit_swap = 1; + if (evas_software_xlib_x_output_buffer_byte_order(xob) == LSBFirst) + buf->priv.x11.xlib.swap = 1; + if (evas_software_xlib_x_output_buffer_bit_order(xob) == MSBFirst) + buf->priv.x11.xlib.bit_swap = 1; #else - if (evas_software_x11_x_output_buffer_byte_order(xob) == MSBFirst) - buf->priv.x.swap = 1; - if (evas_software_x11_x_output_buffer_bit_order(xob) == MSBFirst) - buf->priv.x.bit_swap = 1; + if (evas_software_xlib_x_output_buffer_byte_order(xob) == MSBFirst) + buf->priv.x11.xlib.swap = 1; + if (evas_software_xlib_x_output_buffer_bit_order(xob) == MSBFirst) + buf->priv.x11.xlib.bit_swap = 1; #endif if (((vis->class == TrueColor) || (vis->class == DirectColor)) && (x_depth > 8)) @@ -204,7 +215,7 @@ evas_software_x11_outbuf_setup_x(int w, int h, int rot, Outbuf_Depth depth, buf->priv.mask.r = (DATA32) vis->red_mask; buf->priv.mask.g = (DATA32) vis->green_mask; buf->priv.mask.b = (DATA32) vis->blue_mask; - if (buf->priv.x.swap) + if (buf->priv.x11.xlib.swap) { SWAP32(buf->priv.mask.r); SWAP32(buf->priv.mask.g); @@ -256,7 +267,7 @@ evas_software_x11_outbuf_setup_x(int w, int h, int rot, Outbuf_Depth depth, pm = PAL_MODE_MONO; } /* FIXME: only alloc once per display+cmap */ - buf->priv.pal = evas_software_x11_x_color_allocate(disp, cmap, vis, + buf->priv.pal = evas_software_xlib_x_color_allocate(disp, cmap, vis, PAL_MODE_RGB666); if (!buf->priv.pal) { @@ -268,7 +279,7 @@ evas_software_x11_outbuf_setup_x(int w, int h, int rot, Outbuf_Depth depth, { if (buf->rot == 0 || buf->rot == 180) conv_func = evas_common_convert_func_get(0, buf->w, buf->h, - evas_software_x11_x_output_buffer_depth + evas_software_xlib_x_output_buffer_depth (xob), buf->priv.mask.r, buf->priv.mask.g, buf->priv.mask.b, @@ -276,7 +287,7 @@ evas_software_x11_outbuf_setup_x(int w, int h, int rot, Outbuf_Depth depth, buf->rot); else if (buf->rot == 90 || buf->rot == 270) conv_func = evas_common_convert_func_get(0, buf->h, buf->w, - evas_software_x11_x_output_buffer_depth + evas_software_xlib_x_output_buffer_depth (xob), buf->priv.mask.r, buf->priv.mask.g, buf->priv.mask.b, @@ -287,20 +298,20 @@ evas_software_x11_outbuf_setup_x(int w, int h, int rot, Outbuf_Depth depth, { if (buf->rot == 0 || buf->rot == 180) conv_func = evas_common_convert_func_get(0, buf->w, buf->h, - evas_software_x11_x_output_buffer_depth + evas_software_xlib_x_output_buffer_depth (xob), buf->priv.mask.r, buf->priv.mask.g, buf->priv.mask.b, PAL_MODE_NONE, buf->rot); else if (buf->rot == 90 || buf->rot == 270) conv_func = evas_common_convert_func_get(0, buf->h, buf->w, - evas_software_x11_x_output_buffer_depth + evas_software_xlib_x_output_buffer_depth (xob), buf->priv.mask.r, buf->priv.mask.g, buf->priv.mask.b, PAL_MODE_NONE, buf->rot); } - evas_software_x11_x_output_buffer_free(xob, 1); + evas_software_xlib_x_output_buffer_free(xob, 1); if (!conv_func) { printf(".[ Evas Error ].\n" @@ -310,20 +321,20 @@ evas_software_x11_outbuf_setup_x(int w, int h, int rot, Outbuf_Depth depth, " Palette mode: %i\n" " Not supported by compiled in converters!\n" " }\n", - buf->priv.x.depth, + buf->priv.x11.xlib.depth, buf->priv.mask.r, buf->priv.mask.g, buf->priv.mask.b, buf->priv.pal->colors); } } - evas_software_x11_outbuf_drawable_set(buf, draw); - evas_software_x11_outbuf_mask_set(buf, mask); + evas_software_xlib_outbuf_drawable_set(buf, draw); + evas_software_xlib_outbuf_mask_set(buf, mask); } return buf; } -RGBA_Image * -evas_software_x11_outbuf_new_region_for_update(Outbuf *buf, int x, int y, int w, int h, int *cx, int *cy, int *cw, int *ch) +RGBA_Image * +evas_software_xlib_outbuf_new_region_for_update(Outbuf *buf, int x, int y, int w, int h, int *cx, int *cy, int *cw, int *ch) { RGBA_Image *im; Outbuf_Region *obr; @@ -331,10 +342,10 @@ evas_software_x11_outbuf_new_region_for_update(Outbuf *buf, int x, int y, int w, int use_shm = 1; int alpha; - if ((buf->onebuf) && (buf->priv.x.shm)) + if ((buf->onebuf) && (buf->priv.x11.xlib.shm)) { Evas_Rectangle *rect; - + rect = malloc(sizeof(Evas_Rectangle)); RECTS_CLIP_TO_RECT(x, y, w, h, 0, 0, buf->w, buf->h); rect->x = x; @@ -350,13 +361,13 @@ evas_software_x11_outbuf_new_region_for_update(Outbuf *buf, int x, int y, int w, *ch = h; if (!buf->priv.synced) { - XSync(buf->priv.x.disp, False); + XSync(buf->priv.x11.xlib.disp, False); buf->priv.synced = 1; } - if ((buf->priv.x.mask) || (buf->priv.destination_alpha)) + if ((buf->priv.x11.xlib.mask) || (buf->priv.destination_alpha)) { int yy; - + im = buf->priv.onebuf; for (yy = y; yy < (y + h); yy++) { @@ -376,29 +387,29 @@ evas_software_x11_outbuf_new_region_for_update(Outbuf *buf, int x, int y, int w, *cw = w; *ch = h; - alpha = ((buf->priv.x.mask) || (buf->priv.destination_alpha)); + alpha = ((buf->priv.x11.xlib.mask) || (buf->priv.destination_alpha)); - use_shm = buf->priv.x.shm; + use_shm = buf->priv.x11.xlib.shm; if ((buf->rot == 0) && (buf->priv.mask.r == 0xff0000) && (buf->priv.mask.g == 0x00ff00) && (buf->priv.mask.b == 0x0000ff)) { - obr->xob = evas_software_x11_x_output_buffer_new(buf->priv.x.disp, - buf->priv.x.vis, - buf->priv.x.depth, + obr->xob = evas_software_xlib_x_output_buffer_new(buf->priv.x11.xlib.disp, + buf->priv.x11.xlib.vis, + buf->priv.x11.xlib.depth, buf->w, buf->h, use_shm, NULL); im = (RGBA_Image *) evas_cache_image_data(evas_common_image_cache_get(), buf->w, buf->h, - (DATA32 *) evas_software_x11_x_output_buffer_data(obr->xob, &bpl), + (DATA32 *) evas_software_xlib_x_output_buffer_data(obr->xob, &bpl), alpha, EVAS_COLORSPACE_ARGB8888); im->extended_info = obr; - if (buf->priv.x.mask) - obr->mxob = evas_software_x11_x_output_buffer_new(buf->priv.x.disp, - buf->priv.x.vis, - 1, + if (buf->priv.x11.xlib.mask) + obr->mxob = evas_software_xlib_x_output_buffer_new(buf->priv.x11.xlib.disp, + buf->priv.x11.xlib.vis, + 1, buf->w, buf->h, use_shm, NULL); @@ -410,22 +421,22 @@ evas_software_x11_outbuf_new_region_for_update(Outbuf *buf, int x, int y, int w, evas_cache_image_surface_alloc(&im->cache_entry, buf->w, buf->h); im->extended_info = obr; if ((buf->rot == 0) || (buf->rot == 180)) - obr->xob = evas_software_x11_x_output_buffer_new(buf->priv.x.disp, - buf->priv.x.vis, - buf->priv.x.depth, + obr->xob = evas_software_xlib_x_output_buffer_new(buf->priv.x11.xlib.disp, + buf->priv.x11.xlib.vis, + buf->priv.x11.xlib.depth, buf->w, buf->h, use_shm, NULL); else if ((buf->rot == 90) || (buf->rot == 270)) - obr->xob = evas_software_x11_x_output_buffer_new(buf->priv.x.disp, - buf->priv.x.vis, - buf->priv.x.depth, + obr->xob = evas_software_xlib_x_output_buffer_new(buf->priv.x11.xlib.disp, + buf->priv.x11.xlib.vis, + buf->priv.x11.xlib.depth, buf->h, buf->w, use_shm, NULL); - if (buf->priv.x.mask) - obr->mxob = evas_software_x11_x_output_buffer_new(buf->priv.x.disp, - buf->priv.x.vis, + if (buf->priv.x11.xlib.mask) + obr->mxob = evas_software_xlib_x_output_buffer_new(buf->priv.x11.xlib.disp, + buf->priv.x11.xlib.vis, 1, buf->w, buf->h, use_shm, NULL); @@ -448,46 +459,46 @@ evas_software_x11_outbuf_new_region_for_update(Outbuf *buf, int x, int y, int w, *cw = w; *ch = h; - use_shm = buf->priv.x.shm; + use_shm = buf->priv.x11.xlib.shm; /* FIXME: magic - i found if shm regions are smaller than 200x200 its * faster to use ximages over unix sockets - trial and error */ // use_shm = 0; /* 630 -> 1006 fps */ // if ((w * h) < (200 * 200)) use_shm = 0; /* 630 -> 962 fps */ - alpha = ((buf->priv.x.mask) || (buf->priv.destination_alpha)); + alpha = ((buf->priv.x11.xlib.mask) || (buf->priv.destination_alpha)); if ((buf->rot == 0) && (buf->priv.mask.r == 0xff0000) && (buf->priv.mask.g == 0x00ff00) && (buf->priv.mask.b == 0x0000ff)) { - obr->xob = _find_xob(buf->priv.x.disp, - buf->priv.x.vis, - buf->priv.x.depth, + obr->xob = _find_xob(buf->priv.x11.xlib.disp, + buf->priv.x11.xlib.vis, + buf->priv.x11.xlib.depth, w, h, use_shm, NULL); -/* obr->xob = evas_software_x11_x_output_buffer_new(buf->priv.x.disp, */ -/* buf->priv.x.vis, */ -/* buf->priv.x.depth, */ -/* w, h, */ -/* use_shm, */ -/* NULL); */ +/* obr->xob = evas_software_xlib_x_output_buffer_new(buf->priv.x11.xlib.disp, */ +/* buf->priv.x11.xlib.vis, */ +/* buf->priv.x11.xlib.depth, */ +/* w, h, */ +/* use_shm, */ +/* NULL); */ im = (RGBA_Image *) evas_cache_image_data(evas_common_image_cache_get(), w, h, - (DATA32 *) evas_software_x11_x_output_buffer_data(obr->xob, &bpl), + (DATA32 *) evas_software_xlib_x_output_buffer_data(obr->xob, &bpl), alpha, EVAS_COLORSPACE_ARGB8888); im->extended_info = obr; - if (buf->priv.x.mask) - obr->mxob = _find_xob(buf->priv.x.disp, - buf->priv.x.vis, + if (buf->priv.x11.xlib.mask) + obr->mxob = _find_xob(buf->priv.x11.xlib.disp, + buf->priv.x11.xlib.vis, 1, w, h, use_shm, NULL); -/* - obr->mxob = evas_software_x11_x_output_buffer_new(buf->priv.x.disp, - buf->priv.x.vis, +/* + obr->mxob = evas_software_xlib_x_output_buffer_new(buf->priv.x11.xlib.disp, + buf->priv.x11.xlib.vis, 1, w, h, use_shm, NULL); @@ -500,50 +511,50 @@ evas_software_x11_outbuf_new_region_for_update(Outbuf *buf, int x, int y, int w, evas_cache_image_surface_alloc(&im->cache_entry, w, h); im->extended_info = obr; if ((buf->rot == 0) || (buf->rot == 180)) - obr->xob = _find_xob(buf->priv.x.disp, - buf->priv.x.vis, - buf->priv.x.depth, + obr->xob = _find_xob(buf->priv.x11.xlib.disp, + buf->priv.x11.xlib.vis, + buf->priv.x11.xlib.depth, w, h, use_shm, NULL); -/* - obr->xob = evas_software_x11_x_output_buffer_new(buf->priv.x.disp, - buf->priv.x.vis, - buf->priv.x.depth, +/* + obr->xob = evas_software_xlib_x_output_buffer_new(buf->priv.x11.xlib.disp, + buf->priv.x11.xlib.vis, + buf->priv.x11.xlib.depth, w, h, use_shm, NULL); */ else if ((buf->rot == 90) || (buf->rot == 270)) - obr->xob = _find_xob(buf->priv.x.disp, - buf->priv.x.vis, - buf->priv.x.depth, + obr->xob = _find_xob(buf->priv.x11.xlib.disp, + buf->priv.x11.xlib.vis, + buf->priv.x11.xlib.depth, h, w, use_shm, NULL); -/* - obr->xob = evas_software_x11_x_output_buffer_new(buf->priv.x.disp, - buf->priv.x.vis, - buf->priv.x.depth, +/* + obr->xob = evas_software_xlib_x_output_buffer_new(buf->priv.x11.xlib.disp, + buf->priv.x11.xlib.vis, + buf->priv.x11.xlib.depth, h, w, use_shm, NULL); */ - if (buf->priv.x.mask) - obr->mxob = _find_xob(buf->priv.x.disp, - buf->priv.x.vis, + if (buf->priv.x11.xlib.mask) + obr->mxob = _find_xob(buf->priv.x11.xlib.disp, + buf->priv.x11.xlib.vis, 1, w, h, use_shm, NULL); -/* - obr->mxob = evas_software_x11_x_output_buffer_new(buf->priv.x.disp, - buf->priv.x.vis, +/* + obr->mxob = evas_software_xlib_x_output_buffer_new(buf->priv.x11.xlib.disp, + buf->priv.x11.xlib.vis, 1, w, h, use_shm, NULL); */ } - if ((buf->priv.x.mask) || (buf->priv.destination_alpha)) + if ((buf->priv.x11.xlib.mask) || (buf->priv.destination_alpha)) /* FIXME: faster memset! */ memset(im->image.data, 0, w * h * sizeof(DATA32)); @@ -552,13 +563,13 @@ evas_software_x11_outbuf_new_region_for_update(Outbuf *buf, int x, int y, int w, } void -evas_software_x11_outbuf_free_region_for_update(Outbuf *buf, RGBA_Image *update) +evas_software_xlib_outbuf_free_region_for_update(Outbuf *buf, RGBA_Image *update) { /* no need to do anything - they are cleaned up on flush */ } void -evas_software_x11_outbuf_flush(Outbuf *buf) +evas_software_xlib_outbuf_flush(Outbuf *buf) { Eina_List *l; RGBA_Image *im; @@ -584,20 +595,20 @@ evas_software_x11_outbuf_flush(Outbuf *buf) xr.height = rect->h; XUnionRectWithRegion(&xr, tmpr, tmpr); if (buf->priv.debug) - evas_software_x11_outbuf_debug_show(buf, buf->priv.x.win, + evas_software_xlib_outbuf_debug_show(buf, buf->priv.x11.xlib.win, rect->x, rect->y, rect->w, rect->h); free(rect); } - XSetRegion(buf->priv.x.disp, buf->priv.x.gc, tmpr); - evas_software_x11_x_output_buffer_paste(obr->xob, buf->priv.x.win, - buf->priv.x.gc, + XSetRegion(buf->priv.x11.xlib.disp, buf->priv.x11.xlib.gc, tmpr); + evas_software_xlib_x_output_buffer_paste(obr->xob, buf->priv.x11.xlib.win, + buf->priv.x11.xlib.gc, 0, 0, 0); if (obr->mxob) { - XSetRegion(buf->priv.x.disp, buf->priv.x.gcm, tmpr); - evas_software_x11_x_output_buffer_paste(obr->mxob, - buf->priv.x.mask, - buf->priv.x.gcm, + XSetRegion(buf->priv.x11.xlib.disp, buf->priv.x11.xlib.gcm, tmpr); + evas_software_xlib_x_output_buffer_paste(obr->mxob, + buf->priv.x11.xlib.mask, + buf->priv.x11.xlib.gcm, 0, 0, 0); } XDestroyRegion(tmpr); @@ -605,88 +616,88 @@ evas_software_x11_outbuf_flush(Outbuf *buf) } else { -#if 1 - XSync(buf->priv.x.disp, False); +#if 1 + XSync(buf->priv.x11.xlib.disp, False); EINA_LIST_FOREACH(buf->priv.pending_writes, l, im) { obr = im->extended_info; if (buf->priv.debug) - evas_software_x11_outbuf_debug_show(buf, buf->priv.x.win, + evas_software_xlib_outbuf_debug_show(buf, buf->priv.x11.xlib.win, obr->x, obr->y, obr->w, obr->h); - evas_software_x11_x_output_buffer_paste(obr->xob, buf->priv.x.win, - buf->priv.x.gc, + evas_software_xlib_x_output_buffer_paste(obr->xob, buf->priv.x11.xlib.win, + buf->priv.x11.xlib.gc, obr->x, obr->y, 0); if (obr->mxob) - evas_software_x11_x_output_buffer_paste(obr->mxob, - buf->priv.x.mask, - buf->priv.x.gcm, + evas_software_xlib_x_output_buffer_paste(obr->mxob, + buf->priv.x11.xlib.mask, + buf->priv.x11.xlib.gcm, obr->x, obr->y, 0); } while (buf->priv.prev_pending_writes) { im = buf->priv.prev_pending_writes->data; - buf->priv.prev_pending_writes = - eina_list_remove_list(buf->priv.prev_pending_writes, + buf->priv.prev_pending_writes = + eina_list_remove_list(buf->priv.prev_pending_writes, buf->priv.prev_pending_writes); obr = im->extended_info; evas_cache_image_drop(&im->cache_entry); if (obr->xob) _unfind_xob(obr->xob, 0); if (obr->mxob) _unfind_xob(obr->mxob, 0); -/* - if (obr->xob) evas_software_x11_x_output_buffer_free(obr->xob, 0); - if (obr->mxob) evas_software_x11_x_output_buffer_free(obr->mxob, 0); +/* + if (obr->xob) evas_software_xlib_x_output_buffer_free(obr->xob, 0); + if (obr->mxob) evas_software_xlib_x_output_buffer_free(obr->mxob, 0); */ free(obr); } buf->priv.prev_pending_writes = buf->priv.pending_writes; buf->priv.pending_writes = NULL; - XFlush(buf->priv.x.disp); -#else + XFlush(buf->priv.x11.xlib.disp); +#else /* XX async push - disable */ /* EINA_LIST_FOREACH(buf->priv.pending_writes, l, im) { obr = im->extended_info; if (buf->priv.debug) - evas_software_x11_outbuf_debug_show(buf, buf->priv.x.win, + evas_software_xlib_outbuf_debug_show(buf, buf->priv.x11.xlib.win, obr->x, obr->y, obr->w, obr->h); - evas_software_x11_x_output_buffer_paste(obr->xob, buf->priv.x.win, - buf->priv.x.gc, + evas_software_xlib_x_output_buffer_paste(obr->xob, buf->priv.x11.xlib.win, + buf->priv.x11.xlib.gc, obr->x, obr->y, 0); if (obr->mxob) - evas_software_x11_x_output_buffer_paste(obr->mxob, - buf->priv.x.mask, - buf->priv.x.gcm, + evas_software_xlib_x_output_buffer_paste(obr->mxob, + buf->priv.x11.xlib.mask, + buf->priv.x11.xlib.gcm, obr->x, obr->y, 0); } */ - XSync(buf->priv.x.disp, False); - + XSync(buf->priv.x11.xlib.disp, False); + while (buf->priv.pending_writes) { RGBA_Image *im; Outbuf_Region *obr; - + im = eina_list_data_get(buf->priv.pending_writes); buf->priv.pending_writes = eina_list_remove_list(buf->priv.pending_writes, buf->priv.pending_writes); obr = im->extended_info; evas_cache_image_drop(&im->cache_entry); if (obr->xob) _unfind_xob(obr->xob, 0); if (obr->mxob) _unfind_xob(obr->mxob, 0); -/* - if (obr->xob) evas_software_x11_x_output_buffer_free(obr->xob, 0); - if (obr->mxob) evas_software_x11_x_output_buffer_free(obr->mxob, 0); +/* + if (obr->xob) evas_software_xlib_x_output_buffer_free(obr->xob, 0); + if (obr->mxob) evas_software_xlib_x_output_buffer_free(obr->mxob, 0); */ free(obr); evas_cache_image_drop(&im->cache_entry); } -#endif +#endif } evas_common_cpu_end_opt(); } void -evas_software_x11_outbuf_idle_flush(Outbuf *buf) +evas_software_xlib_outbuf_idle_flush(Outbuf *buf) { if (buf->priv.onebuf) { @@ -696,22 +707,22 @@ evas_software_x11_outbuf_idle_flush(Outbuf *buf) im = buf->priv.onebuf; buf->priv.onebuf = NULL; obr = im->extended_info; - if (obr->xob) evas_software_x11_x_output_buffer_free(obr->xob, 0); - if (obr->mxob) evas_software_x11_x_output_buffer_free(obr->mxob, 0); + if (obr->xob) evas_software_xlib_x_output_buffer_free(obr->xob, 0); + if (obr->mxob) evas_software_xlib_x_output_buffer_free(obr->mxob, 0); free(obr); evas_cache_image_drop(&im->cache_entry); } else { - if (buf->priv.prev_pending_writes) XSync(buf->priv.x.disp, False); + if (buf->priv.prev_pending_writes) XSync(buf->priv.x11.xlib.disp, False); while (buf->priv.prev_pending_writes) { RGBA_Image *im; Outbuf_Region *obr; - + im = buf->priv.prev_pending_writes->data; - buf->priv.prev_pending_writes = - eina_list_remove_list(buf->priv.prev_pending_writes, + buf->priv.prev_pending_writes = + eina_list_remove_list(buf->priv.prev_pending_writes, buf->priv.prev_pending_writes); obr = im->extended_info; evas_cache_image_drop(&im->cache_entry); @@ -724,7 +735,7 @@ evas_software_x11_outbuf_idle_flush(Outbuf *buf) } void -evas_software_x11_outbuf_push_updated_region(Outbuf *buf, RGBA_Image *update, int x, int y, int w, int h) +evas_software_xlib_outbuf_push_updated_region(Outbuf *buf, RGBA_Image *update, int x, int y, int w, int h) { Gfx_Func_Convert conv_func = NULL; Outbuf_Region *obr; @@ -737,13 +748,13 @@ evas_software_x11_outbuf_push_updated_region(Outbuf *buf, RGBA_Image *update, in { if ((buf->rot == 0) || (buf->rot == 180)) conv_func = evas_common_convert_func_get(0, w, h, - evas_software_x11_x_output_buffer_depth + evas_software_xlib_x_output_buffer_depth (obr->xob), buf->priv.mask.r, buf->priv.mask.g, buf->priv.mask.b, buf->priv.pal->colors, buf->rot); else if ((buf->rot == 90) || (buf->rot == 270)) conv_func = evas_common_convert_func_get(0, h, w, - evas_software_x11_x_output_buffer_depth + evas_software_xlib_x_output_buffer_depth (obr->xob), buf->priv.mask.r, buf->priv.mask.g, buf->priv.mask.b, buf->priv.pal->colors, buf->rot); @@ -752,20 +763,20 @@ evas_software_x11_outbuf_push_updated_region(Outbuf *buf, RGBA_Image *update, in { if ((buf->rot == 0) || (buf->rot == 180)) conv_func = evas_common_convert_func_get(0, w, h, - evas_software_x11_x_output_buffer_depth + evas_software_xlib_x_output_buffer_depth (obr->xob), buf->priv.mask.r, buf->priv.mask.g, buf->priv.mask.b, PAL_MODE_NONE, buf->rot); else if ((buf->rot == 90) || (buf->rot == 270)) conv_func = evas_common_convert_func_get(0, h, w, - evas_software_x11_x_output_buffer_depth + evas_software_xlib_x_output_buffer_depth (obr->xob), buf->priv.mask.r, buf->priv.mask.g, buf->priv.mask.b, PAL_MODE_NONE, buf->rot); } if (!conv_func) return; - data = evas_software_x11_x_output_buffer_data(obr->xob, &bpl); + data = evas_software_xlib_x_output_buffer_data(obr->xob, &bpl); src_data = update->image.data; if (buf->rot == 0) { @@ -803,7 +814,7 @@ evas_software_x11_outbuf_push_updated_region(Outbuf *buf, RGBA_Image *update, in conv_func(src_data, data, 0, bpl / - ((evas_software_x11_x_output_buffer_depth(obr->xob) / + ((evas_software_xlib_x_output_buffer_depth(obr->xob) / 8)) - obr->w, obr->w, obr->h, x, y, buf->priv.pal->lookup); } @@ -813,46 +824,46 @@ evas_software_x11_outbuf_push_updated_region(Outbuf *buf, RGBA_Image *update, in conv_func(src_data, data, 0, bpl / - ((evas_software_x11_x_output_buffer_depth(obr->xob) / + ((evas_software_xlib_x_output_buffer_depth(obr->xob) / 8)) - obr->w, obr->w, obr->h, x, y, NULL); } #if 1 -#else +#else /* XX async push */ if (!((buf->priv.onebuf) && (buf->priv.onebuf_regions))) - { + { if (buf->priv.debug) - evas_software_x11_outbuf_debug_show(buf, buf->priv.x.win, + evas_software_xlib_outbuf_debug_show(buf, buf->priv.x11.xlib.win, obr->x, obr->y, obr->w, obr->h); - evas_software_x11_x_output_buffer_paste(obr->xob, buf->priv.x.win, - buf->priv.x.gc, + evas_software_xlib_x_output_buffer_paste(obr->xob, buf->priv.x11.xlib.win, + buf->priv.x11.xlib.gc, obr->x, obr->y, 0); } -#endif +#endif if (obr->mxob) { for (yy = 0; yy < obr->h; yy++) - evas_software_x11_x_write_mask_line(buf, obr->mxob, + evas_software_xlib_x_write_mask_line(buf, obr->mxob, src_data + (yy * obr->w), obr->w, yy); #if 1 -#else +#else /* XX async push */ if (!((buf->priv.onebuf) && (buf->priv.onebuf_regions))) - evas_software_x11_x_output_buffer_paste(obr->mxob, - buf->priv.x.mask, - buf->priv.x.gcm, + evas_software_xlib_x_output_buffer_paste(obr->mxob, + buf->priv.x11.xlib.mask, + buf->priv.x11.xlib.gcm, obr->x, obr->y, 0); -#endif +#endif } #if 1 #else - XFlush(buf->priv.x.disp); -#endif + XFlush(buf->priv.x11.xlib.disp); +#endif } void -evas_software_x11_outbuf_reconfigure(Outbuf * buf, int w, int h, int rot, +evas_software_xlib_outbuf_reconfigure(Outbuf * buf, int w, int h, int rot, Outbuf_Depth depth) { if ((w == buf->w) && @@ -862,72 +873,72 @@ evas_software_x11_outbuf_reconfigure(Outbuf * buf, int w, int h, int rot, buf->w = w; buf->h = h; buf->rot = rot; - evas_software_x11_outbuf_idle_flush(buf); + evas_software_xlib_outbuf_idle_flush(buf); } int -evas_software_x11_outbuf_get_width(Outbuf * buf) +evas_software_xlib_outbuf_get_width(Outbuf * buf) { return buf->w; } int -evas_software_x11_outbuf_get_height(Outbuf * buf) +evas_software_xlib_outbuf_get_height(Outbuf * buf) { return buf->h; } Outbuf_Depth -evas_software_x11_outbuf_get_depth(Outbuf * buf) +evas_software_xlib_outbuf_get_depth(Outbuf * buf) { return buf->depth; } int -evas_software_x11_outbuf_get_rot(Outbuf * buf) +evas_software_xlib_outbuf_get_rot(Outbuf * buf) { return buf->rot; } void -evas_software_x11_outbuf_drawable_set(Outbuf * buf, Drawable draw) +evas_software_xlib_outbuf_drawable_set(Outbuf * buf, Drawable draw) { XGCValues gcv; - if (buf->priv.x.win == draw) return; - if (buf->priv.x.gc) + if (buf->priv.x11.xlib.win == draw) return; + if (buf->priv.x11.xlib.gc) { - XFreeGC(buf->priv.x.disp, buf->priv.x.gc); - buf->priv.x.gc = NULL; + XFreeGC(buf->priv.x11.xlib.disp, buf->priv.x11.xlib.gc); + buf->priv.x11.xlib.gc = NULL; } - buf->priv.x.win = draw; - buf->priv.x.gc = XCreateGC(buf->priv.x.disp, buf->priv.x.win, 0, &gcv); + buf->priv.x11.xlib.win = draw; + buf->priv.x11.xlib.gc = XCreateGC(buf->priv.x11.xlib.disp, buf->priv.x11.xlib.win, 0, &gcv); } void -evas_software_x11_outbuf_mask_set(Outbuf * buf, Pixmap mask) +evas_software_xlib_outbuf_mask_set(Outbuf * buf, Pixmap mask) { XGCValues gcv; - if (buf->priv.x.mask == mask) return; - if (buf->priv.x.gcm) + if (buf->priv.x11.xlib.mask == mask) return; + if (buf->priv.x11.xlib.gcm) { - XFreeGC(buf->priv.x.disp, buf->priv.x.gcm); - buf->priv.x.gcm = NULL; + XFreeGC(buf->priv.x11.xlib.disp, buf->priv.x11.xlib.gcm); + buf->priv.x11.xlib.gcm = NULL; } - buf->priv.x.mask = mask; - if (buf->priv.x.mask) - buf->priv.x.gcm = XCreateGC(buf->priv.x.disp, buf->priv.x.mask, 0, &gcv); + buf->priv.x11.xlib.mask = mask; + if (buf->priv.x11.xlib.mask) + buf->priv.x11.xlib.gcm = XCreateGC(buf->priv.x11.xlib.disp, buf->priv.x11.xlib.mask, 0, &gcv); } void -evas_software_x11_outbuf_debug_set(Outbuf * buf, int debug) +evas_software_xlib_outbuf_debug_set(Outbuf * buf, int debug) { buf->priv.debug = debug; } void -evas_software_x11_outbuf_debug_show(Outbuf * buf, Drawable draw, int x, int y, int w, +evas_software_xlib_outbuf_debug_show(Outbuf * buf, Drawable draw, int x, int y, int w, int h) { int i; @@ -939,32 +950,32 @@ evas_software_x11_outbuf_debug_show(Outbuf * buf, Drawable draw, int x, int y, i Window wdum, root; XWindowAttributes wattr; - XGetGeometry(buf->priv.x.disp, draw, &root, &wx, &wy, &ww, &wh, &bd, &dp); - XGetGeometry(buf->priv.x.disp, root, &wdum, &wx, &wy, &ww, &wh, &bd, &dp); - XGetWindowAttributes(buf->priv.x.disp, root, &wattr); + XGetGeometry(buf->priv.x11.xlib.disp, draw, &root, &wx, &wy, &ww, &wh, &bd, &dp); + XGetGeometry(buf->priv.x11.xlib.disp, root, &wdum, &wx, &wy, &ww, &wh, &bd, &dp); + XGetWindowAttributes(buf->priv.x11.xlib.disp, root, &wattr); screen_num = XScreenNumberOfScreen(wattr.screen); } for (i = 0; i < 20; i++) { // XImage *xim; - XSetForeground(buf->priv.x.disp, buf->priv.x.gc, - BlackPixel(buf->priv.x.disp, screen_num)); - XFillRectangle(buf->priv.x.disp, draw, buf->priv.x.gc, x, y, w, h); - XSync(buf->priv.x.disp, False); + XSetForeground(buf->priv.x11.xlib.disp, buf->priv.x11.xlib.gc, + BlackPixel(buf->priv.x11.xlib.disp, screen_num)); + XFillRectangle(buf->priv.x11.xlib.disp, draw, buf->priv.x11.xlib.gc, x, y, w, h); + XSync(buf->priv.x11.xlib.disp, False); // xim = -// XGetImage(buf->priv.x.disp, draw, x, y, w, h, 0xffffffff, ZPixmap); +// XGetImage(buf->priv.x11.xlib.disp, draw, x, y, w, h, 0xffffffff, ZPixmap); // if (xim) // XDestroyImage(xim); - XSync(buf->priv.x.disp, False); - XSetForeground(buf->priv.x.disp, buf->priv.x.gc, - WhitePixel(buf->priv.x.disp, screen_num)); - XFillRectangle(buf->priv.x.disp, draw, buf->priv.x.gc, x, y, w, h); - XSync(buf->priv.x.disp, False); + XSync(buf->priv.x11.xlib.disp, False); + XSetForeground(buf->priv.x11.xlib.disp, buf->priv.x11.xlib.gc, + WhitePixel(buf->priv.x11.xlib.disp, screen_num)); + XFillRectangle(buf->priv.x11.xlib.disp, draw, buf->priv.x11.xlib.gc, x, y, w, h); + XSync(buf->priv.x11.xlib.disp, False); // xim = -// XGetImage(buf->priv.x.disp, draw, x, y, w, h, 0xffffffff, ZPixmap); +// XGetImage(buf->priv.x11.xlib.disp, draw, x, y, w, h, 0xffffffff, ZPixmap); // if (xim) // XDestroyImage(xim); - XSync(buf->priv.x.disp, False); + XSync(buf->priv.x11.xlib.disp, False); } } diff --git a/legacy/evas/src/modules/engines/software_x11/evas_xlib_outbuf.h b/legacy/evas/src/modules/engines/software_x11/evas_xlib_outbuf.h new file mode 100644 index 0000000000..2a3983a236 --- /dev/null +++ b/legacy/evas/src/modules/engines/software_x11/evas_xlib_outbuf.h @@ -0,0 +1,85 @@ +#ifndef EVAS_XLIB_OUTBUF_H +#define EVAS_XLIB_OUTBUF_H + + +#include "evas_engine.h" + + +void evas_software_xlib_outbuf_init (void); + +void evas_software_xlib_outbuf_free (Outbuf *buf); + +Outbuf *evas_software_xlib_outbuf_setup_x (int w, + int h, + int rot, + Outbuf_Depth depth, + Display *disp, + Drawable draw, + Visual *vis, + Colormap cmap, + int x_depth, + int grayscale, + int max_colors, + Pixmap mask, + int shape_dither, + int destination_alpha); + + +RGBA_Image *evas_software_xlib_outbuf_new_region_for_update (Outbuf *buf, + int x, + int y, + int w, + int h, + int *cx, + int *cy, + int *cw, + int *ch); + +void evas_software_xlib_outbuf_free_region_for_update (Outbuf *buf, + RGBA_Image *update); + +void evas_software_xlib_outbuf_flush (Outbuf *buf); + +void evas_software_xlib_outbuf_idle_flush (Outbuf *buf); + +void evas_software_xlib_outbuf_push_updated_region (Outbuf *buf, + RGBA_Image *update, + int x, + int y, + int w, + int h); + +void evas_software_xlib_outbuf_reconfigure (Outbuf *buf, + int w, + int h, + int rot, + Outbuf_Depth depth); + +int evas_software_xlib_outbuf_get_width (Outbuf *buf); + +int evas_software_xlib_outbuf_get_height (Outbuf *buf); + +Outbuf_Depth evas_software_xlib_outbuf_get_depth (Outbuf *buf); + +int evas_software_xlib_outbuf_get_rot (Outbuf *buf); + +void evas_software_xlib_outbuf_drawable_set (Outbuf *buf, + Drawable draw); + +void evas_software_xlib_outbuf_mask_set (Outbuf *buf, + Pixmap mask); + +void evas_software_xlib_outbuf_rotation_set (Outbuf *buf, + int rot); + +void evas_software_xlib_outbuf_debug_set (Outbuf *buf, + int debug); + +void evas_software_xlib_outbuf_debug_show (Outbuf *buf, + Drawable draw, + int x, + int y, + int w, + int h); + +#endif