From fd7f778fd9bd7b99ce790081544b28adede189b2 Mon Sep 17 00:00:00 2001

From: Gerd Hoffmann <kraxel@redhat.com>

Date: Wed, 22 Feb 2017 12:36:19 +0100

Subject: [PATCH 01/24] ui/vnc: introduce VNC_DIRTY_PIXELS_PER_BIT macro

MIME-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

RH-Author: Gerd Hoffmann <kraxel@redhat.com>

Message-id: <1487766986-6329-2-git-send-email-kraxel@redhat.com>

Patchwork-id: 73972

O-Subject: [RHEL-7.4 qemu-kvm PATCH 1/8] ui/vnc: introduce VNC_DIRTY_PIXELS_PER_BIT macro

Bugzilla: 1377977

RH-Acked-by: Thomas Huth <thuth@redhat.com>

RH-Acked-by: Marc-André Lureau <mlureau@redhat.com>

RH-Acked-by: Laurent Vivier <lvivier@redhat.com>

From: Peter Lieven <pl@kamp.de>

Signed-off-by: Peter Lieven <pl@kamp.de>

Reviewed-by: Wenchao Xia <xiawenc@linux.vnet.ibm.com>

Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>

(cherry picked from commit b4c85ddcec24c60616aad9b3b7fc36ce19ba3ca4)

Signed-off-by: Miroslav Rezanina <mrezanin@redhat.com>

---

 ui/vnc.c | 65 ++++++++++++++++++++++++++++++++++++++++------------------------

 ui/vnc.h |  6 +++++-

 2 files changed, 46 insertions(+), 25 deletions(-)

diff --git a/ui/vnc.c b/ui/vnc.c

index a0e2d33..0c799ed 100644

--- a/ui/vnc.c

+++ b/ui/vnc.c

@@ -442,17 +442,19 @@ static void vnc_dpy_update(DisplayChangeListener *dcl,

        iteration.  otherwise, if (x % 16) != 0, the last iteration may span

        two 16-pixel blocks but we only mark the first as dirty

     */

-    w += (x % 16);

-    x -= (x % 16);

+    w += (x % VNC_DIRTY_PIXELS_PER_BIT);

+    x -= (x % VNC_DIRTY_PIXELS_PER_BIT);

     x = MIN(x, width);

     y = MIN(y, height);

     w = MIN(x + w, width) - x;

     h = MIN(h, height);

-    for (; y < h; y++)

-        for (i = 0; i < w; i += 16)

-            set_bit((x + i) / 16, s->dirty[y]);

+    for (; y < h; y++) {

+        for (i = 0; i < w; i += VNC_DIRTY_PIXELS_PER_BIT) {

+            set_bit((x + i) / VNC_DIRTY_PIXELS_PER_BIT, s->dirty[y]);

+        }

+    }

 }

 void vnc_framebuffer_update(VncState *vs, int x, int y, int w, int h,

@@ -769,11 +771,12 @@ static void vnc_dpy_copy(DisplayChangeListener *dcl,

         y = dst_y + h - 1;

         inc = -1;

     }

-    w_lim = w - (16 - (dst_x % 16));

-    if (w_lim < 0)

+    w_lim = w - (VNC_DIRTY_PIXELS_PER_BIT - (dst_x % VNC_DIRTY_PIXELS_PER_BIT));

+    if (w_lim < 0) {

         w_lim = w;

-    else

-        w_lim = w - (w_lim % 16);

+    } else {

+        w_lim = w - (w_lim % VNC_DIRTY_PIXELS_PER_BIT);

+    }

     for (i = 0; i < h; i++) {

         for (x = 0; x <= w_lim;

                 x += s, src_row += cmp_bytes, dst_row += cmp_bytes) {

@@ -781,10 +784,11 @@ static void vnc_dpy_copy(DisplayChangeListener *dcl,

                 if ((s = w - w_lim) == 0)

                     break;

             } else if (!x) {

-                s = (16 - (dst_x % 16));

+                s = (VNC_DIRTY_PIXELS_PER_BIT -

+                    (dst_x % VNC_DIRTY_PIXELS_PER_BIT));

                 s = MIN(s, w_lim);

             } else {

-                s = 16;

+                s = VNC_DIRTY_PIXELS_PER_BIT;

             }

             cmp_bytes = s * VNC_SERVER_FB_BYTES;

             if (memcmp(src_row, dst_row, cmp_bytes) == 0)

@@ -792,7 +796,8 @@ static void vnc_dpy_copy(DisplayChangeListener *dcl,

             memmove(dst_row, src_row, cmp_bytes);

             QTAILQ_FOREACH(vs, &vd->clients, next) {

                 if (!vnc_has_feature(vs, VNC_FEATURE_COPYRECT)) {

-                    set_bit(((x + dst_x) / 16), vs->dirty[y]);

+                    set_bit(((x + dst_x) / VNC_DIRTY_PIXELS_PER_BIT),

+                            vs->dirty[y]);

                 }

             }

         }

@@ -911,7 +916,7 @@ static int vnc_update_client(VncState *vs, int has_dirty)

         for (y = 0; y < height; y++) {

             int x;

             int last_x = -1;

-            for (x = 0; x < width / 16; x++) {

+            for (x = 0; x < width / VNC_DIRTY_PIXELS_PER_BIT; x++) {

                 if (test_and_clear_bit(x, vs->dirty[y])) {

                     if (last_x == -1) {

                         last_x = x;

@@ -921,16 +926,22 @@ static int vnc_update_client(VncState *vs, int has_dirty)

                         int h = find_and_clear_dirty_height(vs, y, last_x, x,

                                                             height);

-                        n += vnc_job_add_rect(job, last_x * 16, y,

-                                              (x - last_x) * 16, h);

+                        n += vnc_job_add_rect(job,

+                                              last_x * VNC_DIRTY_PIXELS_PER_BIT,

+                                              y,

+                                              (x - last_x) *

+                                              VNC_DIRTY_PIXELS_PER_BIT,

+                                              h);

                     }

                     last_x = -1;

                 }

             }

             if (last_x != -1) {

                 int h = find_and_clear_dirty_height(vs, y, last_x, x, height);

-                n += vnc_job_add_rect(job, last_x * 16, y,

-                                      (x - last_x) * 16, h);

+                n += vnc_job_add_rect(job, last_x * VNC_DIRTY_PIXELS_PER_BIT,

+                                      y,

+                                      (x - last_x) * VNC_DIRTY_PIXELS_PER_BIT,

+                                      h);

             }

         }

@@ -1861,7 +1872,7 @@ static void framebuffer_update_request(VncState *vs, int incremental,

                                        int w, int h)

 {

     int i;

-    const size_t width = surface_width(vs->vd->ds) / 16;

+    const size_t width = surface_width(vs->vd->ds) / VNC_DIRTY_PIXELS_PER_BIT;

     const size_t height = surface_height(vs->vd->ds);

     if (y_position > height) {

@@ -2573,7 +2584,9 @@ static int vnc_refresh_lossy_rect(VncDisplay *vd, int x, int y)

         vs->lossy_rect[sty][stx] = 0;

         for (j = 0; j < VNC_STAT_RECT; ++j) {

-            bitmap_set(vs->dirty[y + j], x / 16, VNC_STAT_RECT / 16);

+            bitmap_set(vs->dirty[y + j],

+                       x / VNC_DIRTY_PIXELS_PER_BIT,

+                       VNC_STAT_RECT / VNC_DIRTY_PIXELS_PER_BIT);

         }

         has_dirty++;

     }

@@ -2720,17 +2733,21 @@ static int vnc_refresh_server_surface(VncDisplay *vd)

             }

             server_ptr = server_row;

-            for (x = 0; x + 15 < width;

-                    x += 16, guest_ptr += cmp_bytes, server_ptr += cmp_bytes) {

-                if (!test_and_clear_bit((x / 16), vd->guest.dirty[y]))

+            for (x = 0; x + VNC_DIRTY_PIXELS_PER_BIT - 1 < width;

+                 x += VNC_DIRTY_PIXELS_PER_BIT, guest_ptr += cmp_bytes,

+                 server_ptr += cmp_bytes) {

+                if (!test_and_clear_bit((x / VNC_DIRTY_PIXELS_PER_BIT),

+                    vd->guest.dirty[y])) {

                     continue;

-                if (memcmp(server_ptr, guest_ptr, cmp_bytes) == 0)

+                }

+                if (memcmp(server_ptr, guest_ptr, cmp_bytes) == 0) {

                     continue;

+                }

                 memcpy(server_ptr, guest_ptr, cmp_bytes);

                 if (!vd->non_adaptive)

                     vnc_rect_updated(vd, x, y, &tv;;

                 QTAILQ_FOREACH(vs, &vd->clients, next) {

-                    set_bit((x / 16), vs->dirty[y]);

+                    set_bit((x / VNC_DIRTY_PIXELS_PER_BIT), vs->dirty[y]);

                 }

                 has_dirty++;

             }

diff --git a/ui/vnc.h b/ui/vnc.h

index 0efc5c6..561f383 100644

--- a/ui/vnc.h

+++ b/ui/vnc.h

@@ -81,8 +81,12 @@ typedef void VncSendHextileTile(VncState *vs,

 #define VNC_MAX_WIDTH 2560

 #define VNC_MAX_HEIGHT 2048

+/* VNC_DIRTY_PIXELS_PER_BIT is the number of dirty pixels represented

+ * by one bit in the dirty bitmap */

+#define VNC_DIRTY_PIXELS_PER_BIT 16

+

 /* VNC_DIRTY_BITS is the number of bits in the dirty bitmap. */

-#define VNC_DIRTY_BITS (VNC_MAX_WIDTH / 16)

+#define VNC_DIRTY_BITS (VNC_MAX_WIDTH / VNC_DIRTY_PIXELS_PER_BIT)

 #define VNC_STAT_RECT  64

 #define VNC_STAT_COLS (VNC_MAX_WIDTH / VNC_STAT_RECT)

-- 

1.8.3.1