diff options
Diffstat (limited to 'x11vnc/8to24.c')
| -rw-r--r-- | x11vnc/8to24.c | 1065 |
1 files changed, 790 insertions, 275 deletions
diff --git a/x11vnc/8to24.c b/x11vnc/8to24.c index 873ba25..bfe9292 100644 --- a/x11vnc/8to24.c +++ b/x11vnc/8to24.c @@ -10,17 +10,25 @@ int multivis_24count = 0; void check_for_multivis(void); void bpp8to24(int, int, int, int); -void mark_8bpp(void); +void mark_8bpp(int); static void set_root_cmap(void); -static void check_pointer_in_depth24(void); +static int check_pointer_in_depth24(void); static void parse_cmap8to24(void); +static void set_poll_fb(void); static int check_depth(Window win, Window top, int doall); static int check_depth_win(Window win, Window top, XWindowAttributes attr); -static int get_8pp_region(sraRegionPtr region8bpp, sraRegionPtr rect, - int validate); +static XImage *p_xi(XImage *xi, Visual *visual, int win_depth, int *w); +static int poll_line(int x1, int x2, int y1, int n, sraRegionPtr mod); +static void poll_line_complement(int x1, int x2, int y1, sraRegionPtr mod); +static int poll_8bpp(sraRegionPtr, int); +static void poll_8bpp_complement(sraRegionPtr); +static void mark_rgn_rects(sraRegionPtr mod); +static int get_8bpp_regions(int validate); static int get_cmap(int j, Colormap cmap); -static void do_8bpp_region(sraRect rect); +static void do_8bpp_region(int n, sraRegionPtr mark); +static XImage *cmap_xi(XImage *xi, Visual *visual, int win_depth); +static void transform_rect(sraRect rect, Window win, int win_depth, int cm); /* struct for keeping info about the 8bpp windows: */ typedef struct window8 { @@ -33,9 +41,17 @@ typedef struct window8 { Colormap cmap; Bool map_installed; int fetched; + sraRegionPtr clip_region; } window8bpp_t; +enum mark_8bpp_modes { + MARK_8BPP_ALL = 0, + MARK_8BPP_POINTER, + MARK_8BPP_TOP +}; + static Colormap root_cmap = 0; + static void set_root_cmap(void) { static time_t last_set = 0; time_t now = time(0); @@ -59,11 +75,10 @@ static void set_root_cmap(void) { static window8bpp_t windows_8bpp[MAX_8BPP_WINDOWS]; static int db24 = 0; -static int xgetimage_8to24 = 0; -static int do_hibits = 0; -static double poll_8to24_delay = 0.0; +static int xgetimage_8to24 = 1; +static double poll_8to24_delay = POLL_8TO24_DELAY; -static void check_pointer_in_depth24(void) { +static int check_pointer_in_depth24(void) { int tries = 0, in_24 = 0; XWindowAttributes attr; Window c, w; @@ -72,7 +87,7 @@ static void check_pointer_in_depth24(void) { c = window; if (now > last_keyboard_time + 1.0 && now > last_pointer_time + 1.0) { - return; + return 0; } X_LOCK; @@ -95,27 +110,32 @@ static void check_pointer_in_depth24(void) { y2 = y1 + attr.height; x1 = nfix(x1, dpy_x); y1 = nfix(y1, dpy_y); - x2 = nfix(x2, dpy_x); - y2 = nfix(y2, dpy_y); -if (db24 > 1) fprintf(stderr, "check_pointer_in_depth24 %d %d %d %d\n", x1, y1, x2, y2); + x2 = nfix(x2, dpy_x+1); + y2 = nfix(y2, dpy_y+1); mark_rect_as_modified(x1, y1, x2, y2, 0); + +if (db24 > 1) fprintf(stderr, "check_pointer_in_depth24 %d %d %d %d\n", x1, y1, x2, y2); + + return 1; } + return 0; } static void parse_cmap8to24(void) { if (cmap8to24_str) { char *p, *str = strdup(cmap8to24_str); p = strtok(str, ","); + /* defaults: */ db24 = 0; - xgetimage_8to24 = 0; - do_hibits = 0; + xgetimage_8to24 = 1; + poll_8to24_delay = POLL_8TO24_DELAY; while (p) { if (strstr(p, "dbg=") == p) { db24 = atoi(p + strlen("dbg=")); - } else if (!strcmp(p, "highbits")) { - do_hibits = 1; - } else if (!strcmp(p, "getimage")) { - xgetimage_8to24 = 1; + } else if (strstr(p, "poll=") == p) { + poll_8to24_delay = atof(p + strlen("poll=")); + } else if (!strcmp(p, "nogetimage")) { + xgetimage_8to24 = 0; } p = strtok(NULL, ","); } @@ -124,17 +144,35 @@ static void parse_cmap8to24(void) { if (getenv("DEBUG_8TO24") != NULL) { db24 = atoi(getenv("DEBUG_8TO24")); } - if (getenv("XGETIMAGE_8TO24") != NULL) { - xgetimage_8to24 = 1; + if (getenv("NOXGETIMAGE_8TO24") != NULL) { + xgetimage_8to24 = 0; } - if (getenv("HIGHBITS_8TO24") != NULL) { - do_hibits = 1; + } +} + +static char *poll8_fb = NULL, *poll24_fb = NULL; +static int poll8_fb_w = 0, poll8_fb_h = 0; +static int poll24_fb_w = 0, poll24_fb_h = 0; + +static void pfb(int fac, char **fb, int *w, int *h) { + if (! *fb || *w != dpy_x || *h != dpy_y) { + if (*fb) { + free(*fb); } + *fb = (char *) calloc(fac * dpy_x * dpy_y, 1); + *w = dpy_x; + *h = dpy_y; } } -void poll_8bpp(void) { - +static void set_poll_fb(void) { + /* create polling framebuffers or recreate if too small. */ + + if (! xgetimage_8to24) { + return; /* this saves a bit of RAM */ + } + pfb(4, &poll24_fb, &poll24_fb_w, &poll24_fb_h); + pfb(1, &poll8_fb, &poll8_fb_w, &poll8_fb_h); } void check_for_multivis(void) { @@ -142,13 +180,23 @@ void check_for_multivis(void) { int doall = 0; int k, i, cnt, diff; static int first = 1; + static Window *stack_old = NULL; + static int stack_old_len = 0; static double last_parse = 0.0; static double last_update = 0.0; static double last_clear = 0.0; static double last_poll = 0.0; + static double last_fixup = 0.0; + static double last_call = 0.0; + static double last_query = 0.0; double now = dnow(); - static Window *stack_old = NULL; - static int stack_old_len = 0; + + if (now > last_parse + 0.75) { + last_parse = now; + parse_cmap8to24(); + } +if (db24 > 2) fprintf(stderr, " check_for_multivis: %.4f\n", now - last_call); + last_call = now; if (first) { int i; @@ -159,16 +207,14 @@ void check_for_multivis(void) { windows_8bpp[i].map_state = IsUnmapped; windows_8bpp[i].cmap = (Colormap) 0; windows_8bpp[i].fetched = 0; + windows_8bpp[i].clip_region = NULL; } + set_poll_fb(); + first = 0; doall = 1; /* fetch everything first time */ } - if (now > last_parse + 0.75) { - last_parse = now; - parse_cmap8to24(); - } - set_root_cmap(); /* @@ -197,8 +243,8 @@ void check_for_multivis(void) { } /* snapshot + update the current stacking order: */ - snapshot_stack_list(0, 0.25); - if (doall || now > last_update + 0.25) { + if (doall || now > last_update + 0.15) { + snapshot_stack_list(0, 0.0); update_stack_list(); last_update = now; } @@ -207,7 +253,8 @@ void check_for_multivis(void) { diff = 0; cnt = 0; for (k=0; k < stack_list_num; k++) { - if (stack_list[k].valid && stack_list[k].map_state == IsViewable) { + if (stack_list[k].valid && stack_list[k].map_state == + IsViewable) { if (stack_old[cnt] != stack_list[k].win) { diff = 1; break; @@ -216,26 +263,6 @@ void check_for_multivis(void) { } } - if (poll_8to24_delay > 0.0 && now > last_poll + poll_8to24_delay) { - last_poll = now; - } - - /* - * if there are 8bpp visible and a stacking order change - * refresh vnc with coverage of the 8bpp regions: - */ - if (diff && multivis_count) { -if (db24) fprintf(stderr, "check_for_multivis stack diff: mark_all %f\n", now - x11vnc_start); - mark_8bpp(); - - } else if (depth == 8 && multivis_24count) { - static double last_check = 0.0; - if (now > last_check + 0.25) { - last_check = now; - check_pointer_in_depth24(); - } - } - multivis_count = 0; multivis_24count = 0; @@ -248,7 +275,6 @@ if (db24) fprintf(stderr, "check_for_multivis stack diff: mark_all %f\n", now - X_LOCK; for (i=0; i < MAX_8BPP_WINDOWS; i++) { Window w = windows_8bpp[i].win; -if ((db24) && w != None) fprintf(stderr, " windows_8bpp: 0x%lx i=%02d ms: %d dep=%d\n", windows_8bpp[i].win, i, windows_8bpp[i].map_state, windows_8bpp[i].depth); if (! valid_window(w, &attr, 1)) { /* catch windows that went away: */ windows_8bpp[i].win = None; @@ -271,6 +297,10 @@ if ((db24) && w != None) fprintf(stderr, " windows_8bpp: 0x%lx i=%02d ms: %d d Window win = stack_list[k].win; + if (now < last_query + 0.05) { + break; + } + if (win == None) { continue; } @@ -291,7 +321,7 @@ if ((db24) && w != None) fprintf(stderr, " windows_8bpp: 0x%lx i=%02d ms: %d d if (check_depth(win, win, doall)) { /* - * returns 1 if no need to recurse down e.g. IT + * returns 1 if no need to recurse down e.g. It * is 8bpp and we assume all lower one are too. */ continue; @@ -342,6 +372,50 @@ if ((db24) && w != None) fprintf(stderr, " windows_8bpp: 0x%lx i=%02d ms: %d d X_UNLOCK; } } + last_query = dnow(); + + if (screen_fixup_8 > 0.0 && now > last_fixup + screen_fixup_8) { + last_fixup = now; + mark_8bpp(MARK_8BPP_ALL); + last_poll = now; + + } else if (poll_8to24_delay > 0.0) { + int area = -1; + int validate = 0; + + if (diff && multivis_count) { + validate = 1; + } + if (now > last_poll + poll_8to24_delay) { + sraRegionPtr mod; + + last_poll = now; + mod = sraRgnCreate(); + area = poll_8bpp(mod, validate); + if (depth == 24) { + poll_8bpp_complement(mod); + } + mark_rgn_rects(mod); + sraRgnDestroy(mod); + } + if (0 && area < dpy_x * dpy_y / 2 && diff && multivis_count) { + mark_8bpp(MARK_8BPP_POINTER); + last_poll = now; + } + + } else if (diff && multivis_count) { + mark_8bpp(MARK_8BPP_ALL); + last_poll = now; + + } else if (depth == 8 && multivis_24count) { + static double last_check = 0.0; + if (now > last_check + 0.4) { + last_check = now; + if (check_pointer_in_depth24()) { + last_poll = now; + } + } + } } static int check_depth(Window win, Window top, int doall) { @@ -356,9 +430,9 @@ static int check_depth(Window win, Window top, int doall) { X_UNLOCK; if (! doall && attr.map_state != IsViewable) { /* - * store results anyway... this may lead to table filling up, - * but currently this allows us to update state of onetime mapped - * windows. + * store results anyway... this may lead to table + * filling up, but currently this allows us to update + * state of onetime mapped windows. */ check_depth_win(win, top, attr); return 1; /* indicate done */ @@ -372,8 +446,8 @@ static int check_depth(Window win, Window top, int doall) { static int check_depth_win(Window win, Window top, XWindowAttributes attr) { int store_it = 0; /* - * only store windows with depth not equal to the default visual's depth - * note some windows can have depth == 0 ... (skip them). + * only store windows with depth not equal to the default visual's + * depth note some windows can have depth == 0 ... (skip them). */ if (attr.depth > 0) { set_root_cmap(); @@ -384,8 +458,8 @@ static int check_depth_win(Window win, Window top, XWindowAttributes attr) { store_it = 1; } } - if (store_it) { + if (store_it) { int i, j = -1, none = -1, nomap = -1; int new = 0; if (attr.map_state == IsViewable) { @@ -450,6 +524,7 @@ if (db24 > 1) fprintf(stderr, "multivis: STORE 0x%lx j: %3d ms: %d dep=%d\n", wi windows_8bpp[j].map_installed = attr.map_installed; windows_8bpp[j].w = attr.width; windows_8bpp[j].h = attr.height; + windows_8bpp[j].fetched = 1; /* translate x y to be WRT the root window (not parent) */ X_LOCK; @@ -458,8 +533,6 @@ if (db24 > 1) fprintf(stderr, "multivis: STORE 0x%lx j: %3d ms: %d dep=%d\n", wi windows_8bpp[j].x = x; windows_8bpp[j].y = y; - windows_8bpp[j].fetched = 1; - if (new || now_vis) { if (db24) fprintf(stderr, "new/now_vis: 0x%lx %d/%d\n", win, new, now_vis); /* mark it immediately if a new one: */ @@ -482,12 +555,354 @@ if (db24 > 1) fprintf(stderr, " ------------ 0x%lx i=%d\n", windows_8bp return 0; } +static XImage *p_xi(XImage *xi, Visual *visual, int win_depth, int *w) { + if (xi == NULL || *w < dpy_x) { + char *d; + if (xi) { + XDestroyImage(xi); + } + if (win_depth == 8) { + d = (char *) malloc(dpy_x * 1); + } else { + d = (char *) malloc(dpy_x * 4); + } + *w = dpy_x; + xi = XCreateImage(dpy, visual, win_depth, ZPixmap, 0, d, + dpy_x, 1, 8, 0); + } + return xi; +} + +static int poll_line(int x1, int x2, int y1, int n, sraRegionPtr mod) { + int fac, n_off, w, xo, yo; + char *poll_fb, *dst, *src; + int w2, xl, xh, stride = 32; + int inrun = 0, rx1 = -1, rx2 = -1; + + static XImage *xi8 = NULL, *xi24 = NULL, *xi_r; + static int xi8_w = 0, xi24_w = 0; + + XErrorHandler old_handler = NULL; + XWindowAttributes attr; + XImage *xi; + Window c, win = windows_8bpp[n].win; + + sraRegionPtr rect; + int mx1, mx2, my1, my2; + int ns = NSCAN/2; + + if (win == None) { + return 1; + } + if (windows_8bpp[n].map_state != IsViewable) { + return 1; + } + if (! xgetimage_8to24) { + return 1; + } + + X_LOCK; + if (! valid_window(windows_8bpp[n].win, &attr, 1)) { + X_UNLOCK; + return 0; + } + + if (attr.depth != 8 && attr.depth != 24) { + X_UNLOCK; + return 1; + } else if (attr.depth == 8) { + xi = xi8 = p_xi(xi8, attr.visual, 8, &xi8_w); + + poll_fb = poll8_fb; + fac = 1; + n_off = poll8_fb_w * y1 + x1; + } else { + xi = xi24 = p_xi(xi24, attr.visual, 24, &xi24_w); + + poll_fb = poll24_fb; + fac = 4; + n_off = poll24_fb_w * y1 + x1; + } + + xtranslate(win, window, 0, 0, &xo, &yo, &c, 1); + xo = x1 - xo; + yo = y1 - yo; + w = x2 - x1; + + if (xo < 0 || yo < 0 || xo + w > attr.width) { +if (db24 > 2) fprintf(stderr, "avoid bad match...\n"); + X_UNLOCK; + return 0; + } + + trapped_xerror = 0; + old_handler = XSetErrorHandler(trap_xerror); + xi_r = XGetSubImage(dpy, win, xo, yo, w, 1, AllPlanes, ZPixmap, xi, + 0, 0); + XSetErrorHandler(old_handler); + X_UNLOCK; + + if (! xi_r || trapped_xerror) { + trapped_xerror = 0; + return 0; + } + trapped_xerror = 0; + + src = xi->data; + dst = poll_fb + fac * n_off; + + inrun = 0; + + xl = x1; + while (xl < x2) { + xh = xl + stride; + if (xh > x2) { + xh = x2; + } + w2 = xh - xl; + if (memcmp(dst, src, fac * w2)) { + if (inrun) { + rx2 = xh; + } else { + rx1 = xl; + rx2 = xh; + inrun = 1; + } + } else { + if (inrun) { + mx1 = rx1; + mx2 = rx2; + my1 = nfix(y1 - ns, dpy_y); + my2 = nfix(y1 + ns, dpy_y+1); + + rect = sraRgnCreateRect(mx1, my1, mx2, my2); + sraRgnOr(mod, rect); + sraRgnDestroy(rect); + inrun = 0; + } + } + + xl += stride; + dst += fac * stride; + src += fac * stride; + } + + if (inrun) { + mx1 = rx1; + mx2 = rx2; + my1 = nfix(y1 - ns, dpy_y); + my2 = nfix(y1 + ns, dpy_y+1); + + rect = sraRgnCreateRect(mx1, my1, mx2, my2); + sraRgnOr(mod, rect); + sraRgnDestroy(rect); + } + return 1; +} + +static void poll_line_complement(int x1, int x2, int y1, sraRegionPtr mod) { + int n_off, w, xl, xh, stride = 32; + char *dst, *src; + int inrun = 0, rx1 = -1, rx2 = -1; + sraRegionPtr rect; + int mx1, mx2, my1, my2; + int ns = NSCAN/2; + + if (depth != 24) { + return; + } + if (! cmap8to24_fb) { + return; + } + if (! xgetimage_8to24) { + return; + } + + n_off = main_bytes_per_line * y1 + 4 * x1; + + src = main_fb + n_off; + dst = cmap8to24_fb + n_off; + + inrun = 0; + + xl = x1; + while (xl < x2) { + xh = xl + stride; + if (xh > x2) { + xh = x2; + } + w = xh - xl; + if (memcmp(dst, src, 4 * w)) { + if (inrun) { + rx2 = xh; + } else { + rx1 = xl; + rx2 = xh; + inrun = 1; + } + } else { + if (inrun) { + mx1 = rx1; + mx2 = rx2; + my1 = nfix(y1 - ns, dpy_y); + my2 = nfix(y1 + ns, dpy_y+1); + + rect = sraRgnCreateRect(mx1, my1, mx2, my2); + sraRgnOr(mod, rect); + sraRgnDestroy(rect); + + inrun = 0; + } + } + + xl += stride; + dst += 4 * stride; + src += 4 * stride; + } + + if (inrun) { + mx1 = rx1; + mx2 = rx2; + my1 = nfix(y1 - ns, dpy_y); + my2 = nfix(y1 + ns, dpy_y+1); + + rect = sraRgnCreateRect(mx1, my1, mx2, my2); + sraRgnOr(mod, rect); + sraRgnDestroy(rect); + + inrun = 0; + } +} + #define CMAPMAX 64 -Colormap cmaps[CMAPMAX]; -int ncmaps; +static Colormap cmaps[CMAPMAX]; +static int ncmaps; + +static int poll_8bpp(sraRegionPtr mod, int validate) { + int i, y, ysh, map_count; + static int ycnt = 0; + sraRegionPtr line; + sraRect rect; + sraRectangleIterator *iter; + int br = 0, area = 0; + static double last_call = 0.0; + + map_count = get_8bpp_regions(validate); + +if (db24 > 1) fprintf(stderr, "poll_8bpp mc: %d\n", map_count); + + if (! map_count) { + return 0; + } + + set_poll_fb(); + + ysh = scanlines[(ycnt++) % NSCAN]; +if (db24 > 2) fprintf(stderr, "poll_8bpp: ysh: %2d %.4f\n", ysh, dnow() - last_call); + last_call = dnow(); + + for (i=0; i < MAX_8BPP_WINDOWS; i++) { + sraRegionPtr reg = windows_8bpp[i].clip_region; + + if (! reg || sraRgnEmpty(reg)) { + continue; + } + y = ysh; + while (y < dpy_y) { + line = sraRgnCreateRect(0, y, dpy_x, y+1); + + if (sraRgnAnd(line, reg)) { + iter = sraRgnGetIterator(line); + while (sraRgnIteratorNext(iter, &rect)) { + if (! poll_line(rect.x1, rect.x2, + rect.y1, i, mod)) { + br = 1; + break; /* exception */ + } + } + sraRgnReleaseIterator(iter); + } + + sraRgnDestroy(line); + y += NSCAN; + if (br) break; + } + if (br) break; + } + + iter = sraRgnGetIterator(mod); + while (sraRgnIteratorNext(iter, &rect)) { + area += nabs((rect.x2 - rect.x1)*(rect.y2 - rect.y1)); + } + sraRgnReleaseIterator(iter); + + return area; +} + +static void poll_8bpp_complement(sraRegionPtr mod) { + int i, y, ysh; + static int ycnt = 0; + sraRegionPtr disp, line; + sraRect rect; + sraRectangleIterator *iter; + + disp = sraRgnCreateRect(0, 0, dpy_x, dpy_y); + + ysh = scanlines[(ycnt++) % NSCAN]; + + for (i=0; i < MAX_8BPP_WINDOWS; i++) { + sraRegionPtr reg = windows_8bpp[i].clip_region; + + if (! reg) { + continue; + } + if (windows_8bpp[i].map_state != IsViewable) { + continue; + } + sraRgnSubtract(disp, reg); + } -static int get_8pp_region(sraRegionPtr region8bpp, sraRegionPtr rect, - int validate) { + y = ysh; + while (y < dpy_y) { + line = sraRgnCreateRect(0, y, dpy_x, y+1); + + if (sraRgnAnd(line, disp)) { + iter = sraRgnGetIterator(line); + while (sraRgnIteratorNext(iter, &rect)) { + poll_line_complement(rect.x1, rect.x2, + rect.y1, mod); + } + sraRgnReleaseIterator(iter); + } + + sraRgnDestroy(line); + + y += NSCAN; + } + + sraRgnDestroy(disp); +} + +static void mark_rgn_rects(sraRegionPtr mod) { + sraRect rect; + sraRectangleIterator *iter; + int area = 0; + + if (sraRgnEmpty(mod)) { + return; + } + + iter = sraRgnGetIterator(mod); + while (sraRgnIteratorNext(iter, &rect)) { + mark_rect_as_modified(rect.x1, rect.y1, rect.x2, rect.y2, 0); + area += nabs((rect.x2 - rect.x1)*(rect.y2 - rect.y1)); + } + sraRgnReleaseIterator(iter); + +if (db24 > 1) fprintf(stderr, " mark_rgn_rects area: %d\n", area); +} + +static int get_8bpp_regions(int validate) { XWindowAttributes attr; int i, k, mapcount = 0; @@ -504,15 +919,16 @@ static int get_8pp_region(sraRegionPtr region8bpp, sraRegionPtr rect, Window c, w = windows_8bpp[i].win; int x, y; - if (wireframe_in_progress) { - break; /* skip updates during wireframe drag */ + if (windows_8bpp[i].clip_region) { + sraRgnDestroy(windows_8bpp[i].clip_region); } + windows_8bpp[i].clip_region = NULL; if (w == None) { continue; } -if (db24 > 1) fprintf(stderr, "get_8pp_region: 0x%lx ms=%d dep=%d i=%d\n", w, windows_8bpp[i].map_state, windows_8bpp[i].depth, i); +if (db24 > 1) fprintf(stderr, "get_8bpp_regions: 0x%lx ms=%d dep=%d i=%d\n", w, windows_8bpp[i].map_state, windows_8bpp[i].depth, i); if (validate) { /* * this could be slow: validating 8bpp windows each @@ -530,6 +946,15 @@ if (db24 > 1) fprintf(stderr, "get_8pp_region: 0x%lx ms=%d dep=%d i=%d\n", w, wi continue; } X_UNLOCK; + + windows_8bpp[i].depth = attr.depth; + windows_8bpp[i].map_state = attr.map_state; + windows_8bpp[i].cmap = attr.colormap; + windows_8bpp[i].map_installed = attr.map_installed; + windows_8bpp[i].w = attr.width; + windows_8bpp[i].h = attr.height; + windows_8bpp[i].fetched = 1; + if (attr.map_state != IsViewable) { continue; } @@ -537,34 +962,30 @@ if (db24 > 1) fprintf(stderr, "get_8pp_region: 0x%lx ms=%d dep=%d i=%d\n", w, wi X_LOCK; xtranslate(w, window, 0, 0, &x, &y, &c, 1); X_UNLOCK; + windows_8bpp[i].x = x; + windows_8bpp[i].y = y; } else { /* this will be faster: no call to X server: */ if (windows_8bpp[i].map_state != IsViewable) { continue; } - x = windows_8bpp[i].x; - y = windows_8bpp[i].y; - attr.width = windows_8bpp[i].w; - attr.height = windows_8bpp[i].h; + attr.depth = windows_8bpp[i].depth; attr.map_state = windows_8bpp[i].map_state; attr.colormap = windows_8bpp[i].cmap; + attr.map_installed = windows_8bpp[i].map_installed; + attr.width = windows_8bpp[i].w; + attr.height = windows_8bpp[i].h; + + x = windows_8bpp[i].x; + y = windows_8bpp[i].y; } mapcount++; /* tmp region for this 8bpp rectangle: */ tmp_reg = sraRgnCreateRect(nfix(x, dpy_x), nfix(y, dpy_y), - nfix(x + attr.width, dpy_x), nfix(y + attr.height, dpy_y)); - - /* find overlap with mark region in rect: */ - sraRgnAnd(tmp_reg, rect); - - if (sraRgnEmpty(tmp_reg)) { - /* skip if no overlap: */ - sraRgnDestroy(tmp_reg); - continue; - } + nfix(x + attr.width, dpy_x+1), nfix(y + attr.height, dpy_y+1)); /* loop over all toplevels, top to bottom clipping: */ for (k = stack_list_num - 1; k >= 0; k--) { @@ -574,7 +995,7 @@ if (db24 > 1) fprintf(stderr, "get_8pp_region: 0x%lx ms=%d dep=%d i=%d\n", w, wi if (db24 > 1 && stack_list[k].map_state == IsViewable) fprintf(stderr, "Stack win: 0x%lx %d iv=%d\n", swin, k, stack_list[k].map_state); if (swin == windows_8bpp[i].top) { - /* found our top level: we clip the rest. */ + /* found our top level: we skip the rest. */ if (db24 > 1) fprintf(stderr, "found top: 0x%lx %d iv=%d\n", swin, k, stack_list[k].map_state); break; } @@ -592,39 +1013,41 @@ if (db24 > 1) fprintf(stderr, "found top: 0x%lx %d iv=%d\n", swin, k, stack_list if (db24 > 1) fprintf(stderr, "subtract: 0x%lx %d -- %d %d %d %d\n", swin, k, sx, sy, sw, sh); tmp_reg2 = sraRgnCreateRect(nfix(sx, dpy_x), - nfix(sy, dpy_y), nfix(sx + sw, dpy_x), - nfix(sy + sh, dpy_y)); + nfix(sy, dpy_y), nfix(sx + sw, dpy_x+1), + nfix(sy + sh, dpy_y+1)); /* subtract it from the 8bpp window region */ sraRgnSubtract(tmp_reg, tmp_reg2); + sraRgnDestroy(tmp_reg2); + + if (sraRgnEmpty(tmp_reg)) { + break; + } } if (sraRgnEmpty(tmp_reg)) { /* skip this 8bpp if completely clipped away: */ sraRgnDestroy(tmp_reg); -if (db24 > 1) fprintf(stderr, "Empty tmp_reg\n"); continue; } /* otherwise, store any new colormaps: */ if (ncmaps < CMAPMAX && attr.colormap != (Colormap) 0) { - int m, sawit = 0; + int m, seen = 0; for (m=0; m < ncmaps; m++) { if (cmaps[m] == attr.colormap) { - sawit = 1; + seen = 1; break; } } - if (! sawit && attr.depth == 8) { + if (! seen && attr.depth == 8) { /* store only new ones: */ cmaps[ncmaps++] = attr.colormap; } } - /* now include this region with the full 8bpp region: */ - sraRgnOr(region8bpp, tmp_reg); - sraRgnDestroy(tmp_reg); + windows_8bpp[i].clip_region = tmp_reg; } return mapcount; @@ -701,131 +1124,125 @@ if (db24 > 2) fprintf(stderr, " cmap[%02d][%03d]: %03d %03d %03d 0x%08x \n", j, green = green << main_green_shift; blue = blue << main_blue_shift; + /* store it in the array to be used later */ rgb[j][i] = red | green | blue; } return 1; } -static void do_8bpp_region(sraRect rect) { - - char *src, *dst; - unsigned int *ui; - unsigned char *uc; - int ps, pixelsize = bpp/8; - - int do_getimage = xgetimage_8to24; - int line, n_off, j, h, w, vw; - unsigned int hi, idx; - XWindowAttributes attr; - XErrorHandler old_handler = NULL; - - double score, max_score = -1.0; - int m, best, best_depth = 0; - Window best_win = None; +static void do_8bpp_region(int n, sraRegionPtr mark) { + int k, cm = -1, failed = 0; + sraRectangleIterator *iter; + sraRegionPtr clip; + sraRect rect; + if (! windows_8bpp[n].clip_region) { + return; + } + if (windows_8bpp[n].win == None) { + return; + } + if (windows_8bpp[n].map_state != IsViewable) { + return; + } if (db24 > 1) fprintf(stderr, "ncmaps: %d\n", ncmaps); - /* - * try to pick the "best" colormap to use for - * this rectangle (often wrong... let them - * iconify or move the trouble windows, etc.) - */ - best = -1; - - for (m=0; m < MAX_8BPP_WINDOWS; m++) { - int mx1, my1, mx2, my2; - int k, failed = 0; - if (windows_8bpp[m].win == None) { - continue; - } - if (windows_8bpp[m].map_state != IsViewable) { - continue; - } - - /* see if XQueryColors failed: */ - for (k=0; k<ncmaps; k++) { - if (windows_8bpp[m].cmap == cmaps[k] && cmap_failed[k]) { + /* see if XQueryColors failed: */ + for (k=0; k<ncmaps; k++) { + if (windows_8bpp[n].cmap == cmaps[k]) { + cm = k; + if (cmap_failed[k]) { failed = 1; } + break; } - if (windows_8bpp[m].depth == 8 && failed) { - continue; - } + } - /* rectangle coords for this 8bpp win: */ - mx1 = windows_8bpp[m].x; - my1 = windows_8bpp[m].y; - mx2 = windows_8bpp[m].x + windows_8bpp[m].w; - my2 = windows_8bpp[m].y + windows_8bpp[m].h; + if (windows_8bpp[n].depth == 8) { /* 24 won't have a cmap */ + if (failed || cm == -1) { + return; + } + } - /* use overlap as score: */ - score = rect_overlap(mx1, my1, mx2, my2, rect.x1, rect.y1, - rect.x2, rect.y2); + clip = sraRgnCreateRgn(mark); + sraRgnAnd(clip, windows_8bpp[n].clip_region); - if (score > max_score) { - max_score = score; - best = m; - best_win = windows_8bpp[m].win; - best_depth = windows_8bpp[m].depth; + /* loop over the rectangles making up region */ + iter = sraRgnGetIterator(clip); + while (sraRgnIteratorNext(iter, &rect)) { + if (rect.x1 > rect.x2) { + int tmp = rect.x2; + rect.x2 = rect.x1; + rect.x1 = tmp; + } + if (rect.y1 > rect.y2) { + int tmp = rect.y2; + rect.y2 = rect.y1; + rect.y1 = tmp; } -if (db24 > 1) fprintf(stderr, "cmap_score: 0x%x %.3f %.3f\n", (int) windows_8bpp[m].cmap, score, max_score); + transform_rect(rect, windows_8bpp[n].win, + windows_8bpp[n].depth, cm); } + sraRgnReleaseIterator(iter); + sraRgnDestroy(clip); +} - if (best < 0) { - /* hmmm, use the first one then... */ - best = 0; +static XImage *cmap_xi(XImage *xi, Visual *visual, int win_depth) { + char *d; + if (xi) { + XDestroyImage(xi); + } + if (win_depth == 8) { + d = (char *) malloc(dpy_x * dpy_y * 1); + } else if (win_depth == 24) { + d = (char *) malloc(dpy_x * dpy_y * 4); } else { - int ok = 0; - /* - * find the cmap corresponding to best window - * note we reset best from the windows_8bpp - * index to the cmaps[]. - */ - for (m=0; m < ncmaps; m++) { - if (cmaps[m] == windows_8bpp[best].cmap) { - ok = 1; - best = m; - } - } - if (! ok) { - best = 0; - } + return (XImage *) NULL; } + return XCreateImage(dpy, visual, win_depth, ZPixmap, 0, d, dpy_x, + dpy_y, 8, 0); +} + + +static void transform_rect(sraRect rect, Window win, int win_depth, int cm) { + + char *src, *dst, *poll; + unsigned int *ui; + unsigned char *uc; + int ps, pixelsize = bpp/8; + int poll_Bpl; + int do_getimage = xgetimage_8to24; + int line, n_off, j, h, w, vw; + unsigned int hi, idx; + XWindowAttributes attr; + XErrorHandler old_handler = NULL; -if (db24 > 1) fprintf(stderr, "transform %d %d %d %d\n", rect.x1, rect.y1, rect.x2, rect.y2); +if (db24 > 1) fprintf(stderr, "transform %4d %4d %4d %4d cm: %d\n", rect.x1, rect.y1, rect.x2, rect.y2, cm); - /* now tranform the pixels in this rectangle: */ + /* now transform the pixels in this rectangle: */ n_off = main_bytes_per_line * rect.y1 + pixelsize * rect.x1; h = rect.y2 - rect.y1; w = rect.x2 - rect.x1; if (depth == 8) { - /* - * need to fetch depth 24 data. might need for - * best_depth == 8 too... (hi | ... failure). - */ - if (best_depth == 24) { - do_getimage = 1; - } else if (! do_hibits) { - do_getimage = 1; - } + /* need to fetch depth 24 data. */ + do_getimage = 1; } if (do_getimage) { X_LOCK; - vw = valid_window(best_win, &attr, 1); + vw = valid_window(win, &attr, 1); X_UNLOCK; } if (do_getimage && vw) { static XImage *xi_8 = NULL; static XImage *xi_24 = NULL; - XImage *xi = NULL; + XImage *xi = NULL, *xi_r; Window c; - char *d; unsigned int wu, hu; int xo, yo; @@ -833,7 +1250,7 @@ if (db24 > 1) fprintf(stderr, "transform %d %d %d %d\n", rect.x1, rect.y1, rect. hu = (unsigned int) h; X_LOCK; - xtranslate(best_win, window, 0, 0, &xo, &yo, &c, 1); + xtranslate(win, window, 0, 0, &xo, &yo, &c, 1); xo = rect.x1 - xo; yo = rect.y1 - yo; @@ -847,46 +1264,34 @@ if (db24 > 1) fprintf(stderr, "skipping due to potential bad match...\n"); #define GETSUBIMAGE #ifdef GETSUBIMAGE - if (best_depth == 8) { - if (xi_8 == NULL || xi_8->width != dpy_x || xi_8->height != dpy_y) { - if (xi_8) { - XDestroyImage(xi_8); + if (win_depth == 8) { + if (xi_8 == NULL || xi_8->width != dpy_x || + xi_8->height != dpy_y) { + xi_8 = cmap_xi(xi_8, attr.visual, attr.depth); } - d = (char *) malloc(dpy_x * dpy_y * attr.depth/8); - xi_8 = XCreateImage(dpy, attr.visual, attr.depth, - ZPixmap, 0, d, dpy_x, dpy_y, 8, 0); -if (db24) fprintf(stderr, "xi_8: %p\n", (void *) xi_8); - } - xi = xi_8; - } else if (best_depth == 24) { - if (xi_24 == NULL || xi_24->width != dpy_x || xi_24->height != dpy_y) { - if (xi_24) { - XDestroyImage(xi_24); + xi = xi_8; + } else if (win_depth == 24) { + if (xi_24 == NULL || xi_24->width != dpy_x || + xi_24->height != dpy_y) { + xi_24 = cmap_xi(xi_24, attr.visual, attr.depth); } - d = (char *) malloc(dpy_x * dpy_y * attr.depth/8); - xi_24 = XCreateImage(dpy, attr.visual, attr.depth, - ZPixmap, 0, d, dpy_x, dpy_y, 8, 0); -if (db24) fprintf(stderr, "xi_24: %p\n", (void *) xi_24); - } - xi = xi_24; + xi = xi_24; } #endif - trapped_xerror = 0; old_handler = XSetErrorHandler(trap_xerror); - /* FIXME: XGetSubImage? */ #ifndef GETSUBIMAGE - xi = XGetImage(dpy, best_win, xo, yo, wu, hu, - AllPlanes, ZPixmap); + xi = XGetImage(dpy, win, xo, yo, wu, hu, AllPlanes, ZPixmap); + xi_r = xi; #else - XGetSubImage(dpy, best_win, xo, yo, wu, hu, AllPlanes, + xi_r = XGetSubImage(dpy, win, xo, yo, wu, hu, AllPlanes, ZPixmap, xi, 0, 0); #endif XSetErrorHandler(old_handler); X_UNLOCK; - if (! xi || trapped_xerror) { + if (! xi_r || trapped_xerror) { trapped_xerror = 0; if (db24 > 1) fprintf(stderr, "xi-fail: 0x%p trap=%d %d %d %d %d\n", (void *)xi, trapped_xerror, xo, yo, w, h); return; @@ -905,6 +1310,8 @@ if (db24) fprintf(stderr, "xi: wrong depth: %d\n", xi->depth); return; } + set_poll_fb(); + if (xi->depth == 8) { int ps1, ps2, fac; @@ -921,6 +1328,8 @@ if (db24) fprintf(stderr, "xi: wrong depth: %d\n", xi->depth); src = xi->data; dst = cmap8to24_fb + fac * n_off; + poll = poll8_fb + poll8_fb_w * rect.y1 + rect.x1; + poll_Bpl = poll8_fb_w * 1; /* line by line ... */ for (line = 0; line < h; line++) { @@ -932,10 +1341,13 @@ if (db24) fprintf(stderr, "xi: wrong depth: %d\n", xi->depth); idx = (int) (*uc); - *ui = rgb[best][idx]; + *ui = rgb[cm][idx]; + + *(poll + ps1 * j) = *uc; } src += xi->bytes_per_line; dst += main_bytes_per_line * fac; + poll += poll_Bpl; } } else if (xi->depth == 24) { /* line by line ... */ @@ -943,16 +1355,22 @@ if (db24) fprintf(stderr, "xi: wrong depth: %d\n", xi->depth); if (depth == 8) { fac = 4; } else { - fac = 1; /* should not happen */ + fac = 1; /* will not happen */ } src = xi->data; dst = cmap8to24_fb + fac * n_off; + poll = poll24_fb + (poll24_fb_w * rect.y1 + rect.x1)*4; + poll_Bpl = poll24_fb_w * 4; + for (line = 0; line < h; line++) { - memcpy(dst, src, w * ps1); + memcpy(dst, src, w * ps1); + memcpy(poll, src, w * ps1); + src += xi->bytes_per_line; dst += main_bytes_per_line * fac; + poll += poll_Bpl; } } @@ -963,11 +1381,11 @@ if (db24) fprintf(stderr, "xi: wrong depth: %d\n", xi->depth); #endif } else if (! do_getimage) { - /* normal mode. */ int fac; if (depth == 8) { /* cooked up depth 24 TrueColor */ + /* but currently disabled (high bits no useful?) */ ps = 4; fac = 4; src = cmap8to24_fb + 4 * n_off; @@ -990,7 +1408,7 @@ if (db24) fprintf(stderr, "xi: wrong depth: %d\n", xi->depth); /* map to lookup index; rewrite pixel */ idx = hi >> 24; - *ui = hi | rgb[best][idx]; + *ui = hi | rgb[cm][idx]; } src += main_bytes_per_line * fac; } @@ -1001,55 +1419,44 @@ void bpp8to24(int x1, int y1, int x2, int y2) { char *src, *dst; unsigned char *uc; unsigned int *ui; - unsigned int hi; int idx, pixelsize = bpp/8; - int line, i, j, h, w; + int line, k, i, j, h, w; int n_off; - - sraRegionPtr rect, disp, region8bpp; - + sraRegionPtr rect; int validate = 1; static int last_map_count = 0, call_count = 0; + static double last_get_8bpp_validate = 0.0; + static double last_snapshot = 0.0; + double now, dt, d0; - if (! cmap8to24 || !cmap8to24_fb) { + if (! cmap8to24 || ! cmap8to24_fb) { /* hmmm, why were we called? */ return; } + now = dnow(); +if (db24 > 1) fprintf(stderr, "bpp8to24 %d %d %d %d %.4f\n", x1, y1, x2, y2, now - last_get_8bpp_validate); + call_count++; /* clip to display just in case: */ x1 = nfix(x1, dpy_x); y1 = nfix(y1, dpy_y); - x2 = nfix(x2, dpy_x); - y2 = nfix(y2, dpy_y); + x2 = nfix(x2, dpy_x+1); + y2 = nfix(y2, dpy_y+1); - /* create regions for finding overlap, etc. */ - disp = sraRgnCreateRect(0, 0, dpy_x, dpy_y); - rect = sraRgnCreateRect(x1, y1, x2, y2); - region8bpp = sraRgnCreate(); + if (wireframe_in_progress) { + /* + * draw_box() manages cmap8to24_fb for us so we get out as + * soon as we can. No need to cp main_fb -> cmap8to24_fb. + */ + return; + } X_LOCK; XFlush(dpy); /* make sure X server is up to date WRT input, etc */ X_UNLOCK; - if (last_map_count > MAX_8BPP_WINDOWS/4) { - /* table is filling up... skip validating sometimes: */ - int skip = 3; - if (last_map_count > MAX_8BPP_WINDOWS/2) { - skip = 6; - } else if (last_map_count > 3*MAX_8BPP_WINDOWS/4) { - skip = 12; - } - if (call_count % skip != 0) { - validate = 0; - } - } - -if (db24 > 2) {for(i=0;i<256;i++){histo[i]=0;}} - - last_map_count = get_8pp_region(region8bpp, rect, validate); - /* copy from main_fb to cmap8to24_fb regardless of 8bpp windows: */ h = y2 - y1; @@ -1058,6 +1465,7 @@ if (db24 > 2) {for(i=0;i<256;i++){histo[i]=0;}} if (depth == 8) { /* need to cook up to depth 24 TrueColor */ /* pixelsize = 1 */ + int tcm = CMAPMAX - 1; n_off = main_bytes_per_line * y1 + pixelsize * x1; @@ -1065,8 +1473,11 @@ if (db24 > 2) {for(i=0;i<256;i++){histo[i]=0;}} dst = cmap8to24_fb + 4 * n_off; set_root_cmap(); - if (get_cmap(0, root_cmap)) { + if (get_cmap(tcm, root_cmap)) { int ps1 = 1, ps2 = 4; +#if 0 + unsigned int hi; +#endif /* line by line ... */ for (line = 0; line < h; line++) { @@ -1078,12 +1489,14 @@ if (db24 > 2) {for(i=0;i<256;i++){histo[i]=0;}} idx = (int) (*uc); +#if 0 if (do_hibits) { hi = idx << 24; *ui = hi | rgb[0][idx]; } else { - *ui = rgb[0][idx]; } +#endif + *ui = rgb[tcm][idx]; if (db24 > 2) histo[idx]++; } src += main_bytes_per_line; @@ -1106,17 +1519,64 @@ if (db24 > 2) histo[idx]++; } } + if (last_map_count > MAX_8BPP_WINDOWS/4) { + /* table is filling up... skip validating sometimes: */ + int skip = 3; + if (last_map_count > MAX_8BPP_WINDOWS/2) { + skip = 6; + } else if (last_map_count > 3*MAX_8BPP_WINDOWS/4) { + skip = 12; + } + if (call_count % skip != 0) { + validate = 0; + } + } + +if (db24 > 2) {for(i=0;i<256;i++){histo[i]=0;}} + + dt = now - last_get_8bpp_validate; + d0 = dnow(); + if (dt < 0.0025) { + ; /* XXX does this still give painting errors? */ + } else { + int snapit = 0; + if (dt < 0.04) { + validate = 0; + } + if (last_map_count) { + if (now > last_snapshot + 0.05) { + snapit = 1; + } + } else { + if (now > last_snapshot + 0.4) { + snapit = 1; + } + } + + if (snapit) { + /* less problems if we update the stack frequently */ + snapshot_stack_list(0, 0.0); + update_stack_list(); + last_snapshot = now; + } + + last_map_count = get_8bpp_regions(validate); + if (validate) { + last_get_8bpp_validate = now; + } + } + if (db24 > 1) fprintf(stderr, "bpp8to24 w=%d h=%d m=%p c=%p r=%p ncmaps=%d\n", w, h, main_fb, cmap8to24_fb, rfb_fb, ncmaps); /* - * now go back and tranform and 8bpp regions to TrueColor in - * cmap8to24_fb. we have to guess the best colormap to use if - * there is more than one... + * now go back and transform and 8bpp regions to TrueColor in + * cmap8to24_fb. */ - if (! sraRgnEmpty(region8bpp) && (ncmaps || depth == 8)) { - sraRectangleIterator *iter; - sraRect rect; - int j; + if (last_map_count && (ncmaps || depth == 8)) { + int i, j; + int win[MAX_8BPP_WINDOWS]; + int did[MAX_8BPP_WINDOWS]; + int count = 0; /* * first, grab all of the associated colormaps from the @@ -1128,42 +1588,81 @@ if (db24 > 1) fprintf(stderr, "bpp8to24 w=%d h=%d m=%p c=%p r=%p ncmaps=%d\n", w } else { cmap_failed[j] = 0; } -if (db24 > 1) fprintf(stderr, "cmap %d\n", (int) cmaps[j]); +if (db24 > 2) fprintf(stderr, "cmap %d %.4f\n", (int) cmaps[j], dnow() - d0); + } + for (i=0; i < MAX_8BPP_WINDOWS; i++) { + sraRegionPtr reg = windows_8bpp[i].clip_region; + if (reg) { + rect = sraRgnCreateRect(x1, y1, x2, y2); + if (sraRgnAnd(rect, reg)) { + win[count] = i; + did[count++] = 0; + } + sraRgnDestroy(rect); + } } - /* loop over the rectangles making up region8bpp */ - iter = sraRgnGetIterator(region8bpp); - while (sraRgnIteratorNext(iter, &rect)) { - if (rect.x1 > rect.x2) { - int tmp = rect.x2; - rect.x2 = rect.x1; - rect.x1 = tmp; + if (count) { + + rect = sraRgnCreateRect(x1, y1, x2, y2); + /* try to apply lower windows first */ + for (k=0; k < stack_list_num; k++) { + Window swin = stack_list[k].win; + for (j=0; j<count; j++) { + i = win[j]; + if (did[j]) { + continue; + } + if (windows_8bpp[i].top == swin) { + do_8bpp_region(i, rect); + did[j] = 1; + break; + } + } } - if (rect.y1 > rect.y2) { - int tmp = rect.y2; - rect.y2 = rect.y1; - rect.y1 = tmp; + for (j=0; j<count; j++) { + if (! did[j]) { + i = win[j]; + do_8bpp_region(i, rect); + did[j] = 1; + } } - - do_8bpp_region(rect); + sraRgnDestroy(rect); } - sraRgnReleaseIterator(iter); } if (db24 > 2) {for(i=0; i<256;i++) {fprintf(stderr, " cmap histo[%03d] %d\n", i, histo[i]);}} - - /* cleanup */ - sraRgnDestroy(disp); - sraRgnDestroy(rect); - sraRgnDestroy(region8bpp); } -void mark_8bpp(void) { +void mark_8bpp(int mode) { int i, cnt = 0; + Window top = None; if (! cmap8to24 || !cmap8to24_fb) { return; } + + if (mode == MARK_8BPP_TOP) { + int k; + for (k = stack_list_num - 1; k >= 0; k--) { + Window swin = stack_list[k].win; + for (i=0; i < MAX_8BPP_WINDOWS; i++) { + if (windows_8bpp[i].win == None) { + continue; + } + if (windows_8bpp[i].map_state != IsViewable) { + continue; + } + if (swin == windows_8bpp[i].top) { + top = swin; + break; + } + } + if (top != None) { + break; + } + } + } /* for each mapped 8bpp window, mark it changed: */ @@ -1175,6 +1674,11 @@ void mark_8bpp(void) { if (windows_8bpp[i].win == None) { continue; } + if (mode == MARK_8BPP_TOP) { + if (windows_8bpp[i].top != top) { + continue; + } + } if (windows_8bpp[i].map_state != IsViewable) { XWindowAttributes attr; int vw; @@ -1196,13 +1700,24 @@ void mark_8bpp(void) { w = windows_8bpp[i].w; h = windows_8bpp[i].h; - /* apply a fuzz f around each one... constrain to screen */ x2 = x1 + w; y2 = y1 + h; + + if (mode == MARK_8BPP_POINTER) { + int b = 32; /* apply some fuzz for wm border */ + if (cursor_x < x1 - b || cursor_y < y1 - b) { + continue; + } + if (cursor_x > x2 + b || cursor_y > y2 + b) { + continue; + } + } + + /* apply fuzz f around each one; constrain to screen */ x1 = nfix(x1 - f, dpy_x); y1 = nfix(y1 - f, dpy_y); - x2 = nfix(x2 + f, dpy_x); - y2 = nfix(y2 + f, dpy_y); + x2 = nfix(x2 + f, dpy_x+1); + y2 = nfix(y2 + f, dpy_y+1); if (db24 > 1) fprintf(stderr, "mark_8bpp: 0x%lx %d %d %d %d\n", windows_8bpp[i].win, x1, y1, x2, y2); |