Ticket #1426: scroll-cythonized-v4.patch

setup.py

@@ -2174 +2174 @@
                 ["xpra/server/window/region.pyx"],
                 **O3_pkgconfig))
     cython_add(Extension("xpra.server.window.motion",
-                ["xpra/server/window/motion.pyx"],
+                ["xpra/server/window/motion.pyx", "xpra/server/window/xxhash.c"],
                 **O3_pkgconfig))
 
 

unittests/unit/server/motion_test.py

@@ -11 +11 @@
 from xpra.util import envbool
 try:
         from xpra.server.window import motion
+        log = motion.log                #@UndefinedVariable
 except ImportError:
         motion = None
 
@@ -20 +21 @@
 
 class TestMotion(unittest.TestCase):
 
-        def calculate_distances(self, array1, array2, min_hits=2, max_distance=1):
-                sd = motion.scroll_distances(array1, array2, max_distance)
-                return sd.get_best_scroll_values(min_hits)
+        def calculate_distances(self, array1, array2, min_hits=2, max_distance=1000):
+                assert len(array1)==len(array2)
+                rect = (0, 0, 1, len(array1))
+                return self.do_calculate_distances(rect, array1, array2, min_hits, max_distance)
 
+        def do_calculate_distances(self, rect, array1, array2, min_hits=2, max_distance=1000):
+                sd = motion.ScrollData(*rect)
+                sd._test_update(array1)
+                sd._test_update(array2)
+                sd.calculate(max_distance)
+                return sd.get_scroll_values(min_hits)
+
+        def test_simple(self):
+                self.calculate_distances([0], [1], 0, 100)
+
         def test_match_distance(self):
                 def t(a1, a2, distance, matches):
-                        sd = motion.scroll_distances(a1, a2)
-                        line_defs = sd.match_distance(distance)
+                        scrolls = self.calculate_distances(a1, a2, 0)[0]
+                        line_defs = scrolls.get(distance)
+                        assert line_defs, "distance %i not found in scroll data: %s for a1=%s, a2=%s" % (distance, scrolls, a1, a2)
                         linecount = sum(line_defs.values())
                         assert linecount==matches, "expected %i matches for distance=%i but got %i for a1=%s, a2=%s, result=%s" % (matches, distance, linecount, a1, a2, line_defs)
                 for N in (1, 10, 100):
@@ -36 +49 @@
 
                         a = [1]*N
                         t(a, a, 0, N)
-                        for M in range(N):
-                                t(a, a, M, N-M)
 
                 #from a1 to a2: shift by 2, get 2 hits
                 t([3, 4, 5, 6], [1, 2, 3, 4], 2, 2)
@@ -54 +65 @@
         def test_calculate_distances(self):
                 array1 = [crc32(str(x)) for x in (1234, "abc", 99999)]
                 array2 = array1[:]
-                d = self.calculate_distances(array1, array2, 1)
+                d = self.calculate_distances(array1, array2, 1)[0]
                 assert len(d)==1 and sum(d[0].values())==len(array1), "expected %i matches but got %s" % (len(array1), d[0])
 
                 array1 = range(1, 5)
                 array2 = range(2, 6)
-                d = self.calculate_distances(array1, array2)
+                d = self.calculate_distances(array1, array2)[0]
                 assert len(d)==1, "expected 1 match but got: %s" % len(d)
                 common = set(array1).intersection(set(array2))
                 assert -1 in d, "expected distance of -1 but got: %s" % d.keys()
@@ -81 +92 @@
                 start = time.time()
                 array1 = range(N)
                 array2 = [N*2-x*2 for x in range(N)]
-                d = self.calculate_distances(array1, array2, 1)
+                d = self.calculate_distances(array1, array2, 1)[0]
                 end = time.time()
                 if SHOW_PERF:
-                        print("calculate_distances %4i^2 in %5.1f ms" % (N, (end-start)*1000))
+                        log.info("calculate_distances %4i^2 in %5.1f ms" % (N, (end-start)*1000))
 
         def test_detect_motion(self):
-                W, H, BPP = 1920, 1080, 4
+                self.do_test_detect_motion(5, 5)
+                self.do_test_detect_motion(1920, 1080)
+
+        def do_test_detect_motion(self, W, H):
+                BPP = 4
                 #W, H, BPP = 2, 4, 4
                 LEN = W * H * BPP
                 import numpy as np
                 try:
-                        na1 = np.random.randint(2**63-1, size=LEN//8, dtype="int64")
+                        na1 = np.random.randint(255, size=LEN, dtype="uint8")
                 except TypeError as e:
                         #older numpy version may not have dtype argument..
                         #and may not accept 64-bit values
@@ -110 +125 @@
                                 #older versions of numpy (ie: centos7)
                                 return a.tostring()
                 buf1 = tobytes(na1)
-                ov1 = motion.CRC_Image(buf1, W, H, W*BPP, BPP)
-                assert len(ov1)==H
+                #push first image:
+                sd = motion.ScrollData(0, 0, W, H)
                 #make a new "image" shifted N lines:
-                for N in (1, 20, 100):
-                        na2 = np.roll(na1, -N*W*BPP//8)
+                for N in (1, 2, 20, 100):
+                        if N>H//2:
+                                break
+                        sd.update(buf1, 0, 0, W, H, W*BPP, BPP)
+                        log("picture of height %i scrolled by %i", H, N)
+                        na2 = np.roll(na1, -N*W*BPP)
                         buf2 = tobytes(na2)
                         start = time.time()
-                        ov2 = motion.CRC_Image(buf2, W, H, W*BPP, BPP)
+                        sd.update(buf2, 0, 0, W, H, W*BPP, BPP)
                         end = time.time()
                         if SHOW_PERF:
-                                print("\nCRC_Image %ix%i (%.1fMB) in %4.2f ms" % (W, H, len(buf2)//1024//1024, 1000.0*(end-start)))
-                        assert len(ov2)==H
+                                log.info("hashed image %ix%i (%.1fMB) in %4.2f ms" % (W, H, len(buf2)//1024//1024, 1000.0*(end-start)))
                         start = time.time()
-                        distances = self.calculate_distances(ov1, ov2, min_hits=1)
+                        sd.calculate()
+                        sd_data = sd.get_scroll_values(1)
+                        scrolls, non_scrolls = sd_data
+                        log("scroll values=%s", dict(scrolls))
+                        log("non scroll values=%s", dict(non_scrolls))
                         end = time.time()
                         if SHOW_PERF:
-                                print("calculate_distances %4i^2 in %5.2f ms" % (H, 1000.0*(end-start)))
-                        line_defs = distances.get(-N, {})
+                                log.info("calculated distances %4i^2 in %5.2f ms" % (H, 1000.0*(end-start)))
+                        line_defs = scrolls.get(-N, {})
                         linecount = sum(line_defs.values())
-                        assert linecount>0, "could not find distance %i" % N
+                        assert linecount>0, "could not find distance %i in %s" % (N, line_defs)
                         assert linecount == (H-N), "expected to match %i lines but got %i" % (H-N, linecount)
                 if False:
                         import binascii
-                        print("na1:\n%s" % binascii.hexlify(tobytes(na1)))
-                        print("na2:\n%s" % binascii.hexlify(tobytes(na2)))
+                        log("na1:\n%s" % binascii.hexlify(tobytes(na1)))
+                        log("na2:\n%s" % binascii.hexlify(tobytes(na2)))
                         np.set_printoptions(threshold=np.inf)
-                        print("na1:\n%s" % (na1, ))
-                        print("na2:\n%s" % (na2, ))
-                        print("ov1:\n%s" % (ov1, ))
-                        print("ov2:\n%s" % (ov2, ))
+                        log("na1:\n%s" % (na1, ))
+                        log("na2:\n%s" % (na2, ))
 
         def test_csum_data(self):
                 a1=[
@@ -181 +201 @@
                         17157005122993541799, 5218869126146608853, 13274228147453099388, 16342723934713827717, 2435034235422505275, 3689766606612767057, 13721141386368216492, 14859793948180065358,
                         ]
                 #distances = motion.scroll_distances(a1[100:400], a2[100:400], 2, 1000)
-                distances = motion.scroll_distances(a1, a2, 2, 1000)
-                scroll, count = distances.get_best_match()
+                sd = motion.ScrollData(0, 0, 1050, len(a1))
+                sd._test_update(a1)
+                sd._test_update(a2)
+                sd.calculate(1000)
+                scroll, count = sd.get_best_match()
                 wh = len(a1)
-                print("best match: %s" % ((scroll, count),))
+                log("best match: %s" % ((scroll, count),))
                 x, y, w, h = 0, 0, 1050, 1151
-                raw_scroll = distances.get_best_scroll_values()
-                #non_scroll = distances.get_remaining_areas()
+                raw_scroll, non_scroll = sd.get_scroll_values()
+                assert len(non_scroll)>0
                 scrolls = []
                 def h(v):
                         return hex(v).lstrip("0x").rstrip("L")
                 for i in range(wh):
-                        print("%2i:     %16s    %16s" % (i, h(a1[i]), h(a2[i])))
+                        log("%2i:       %16s    %16s" % (i, h(a1[i]), h(a2[i])))
                 for scroll, line_defs in raw_scroll.items():
                         if scroll==0:
                                 continue

xpra/server/window/motion.pyx

@@ -9 +9 @@
 
 import os
 import time
+import struct
 import collections
 
-from xpra.util import envbool
+from xpra.util import envbool, repr_ellipsized, csv
 from xpra.log import Logger
 log = Logger("encoding", "scroll")
 
 from xpra.buffers.membuf cimport memalign, object_as_buffer
+from xpra.server.window.region import rectangle
 
+
 cdef int DEBUG = envbool("XPRA_SCROLL_DEBUG", False)
-hashfn = None
-if envbool("XPRA_XXHASH", True):
-    try:
-        import xxhash
-        def hashfn(x):
-            return xxhash.xxh64(x).intdigest()
-    except ImportError as e:
-        log.warn("Warning: xxhash python bindings not found")
-else:
-    log.warn("Warning: xxhash disabled")
-if hashfn is None:
-    log.warn(" no scrolling detection")
 
 
-from libc.stdint cimport int32_t, uint8_t, uint16_t, int16_t, uint32_t, int64_t
+from libc.stdint cimport uint8_t, uint16_t, int16_t, uint64_t, uintptr_t
 
 cdef extern from "string.h":
     void free(void * ptr) nogil
     void *memset(void * ptr, int value, size_t num) nogil
+    void *memcpy(void * destination, void * source, size_t num) nogil
 
+cdef extern from "xxhash.h":
+    ctypedef unsigned long long XXH64_hash_t
+    XXH64_hash_t XXH64(const void* input, size_t length, unsigned long long seed)
 
-def CRC_Image(pixels, unsigned int width, unsigned int height, unsigned int rowstride, unsigned char bpp=4):
-    global hashfn
-    if not hashfn:
-        return None
-    cdef uint8_t *buf = NULL
-    cdef Py_ssize_t buf_len = 0
-    assert object_as_buffer(pixels, <const void**> &buf, &buf_len)==0
-    assert buf_len>=0 and (<unsigned int> buf_len)>=rowstride*height, "buffer is too small for %ix%i" % (rowstride, height)
-    cdef unsigned int i
-    cdef size_t row_len = width*bpp
-    f = hashfn
-    crcs = []
-    for i in range(height):
-        crcs.append(f(buf[:row_len]))
-        buf += rowstride
-    return crcs
 
-
 DEF MAXINT64 = 2**63
 DEF MAXUINT64 = 2**64
 DEF MASK64 = 2**64-1
-cdef inline castint64(v):
-    if v>=MAXINT64:
-        return v-MAXUINT64
-    #assert v>=0, "invalid int to cast: %s" % v
-    return v
 
-cdef inline da(int64_t *a, uint16_t l):
-    return [a[i] for i in range(l)]
+def h(v):
+    return hex(v).lstrip("0x").rstrip("L")
 
-cdef inline dd(uint16_t *d, uint16_t l):
-    return [d[i] for i in range(l)]
+cdef inline uint64_t hashtoint64(s):
+    return <uint64_t> struct.unpack("@L", s)[0]
 
-cdef inline ds(int16_t *d, uint16_t l):
-    return [d[i] for i in range(l)]
+cdef da(uint64_t *a, uint16_t l):
+    return repr_ellipsized(csv(h(a[i]) for i in range(l)))
 
+cdef dd(uint16_t *d, uint16_t l):
+    return repr_ellipsized(csv(h(d[i]) for i in range(l)))
 
-assert sizeof(int64_t)==64//8, "uint64_t is not 64-bit: %i!" % sizeof(int64_t)
 
+assert sizeof(uint64_t)==64//8, "uint64_t is not 64-bit: %i!" % sizeof(uint64_t)
 
-cdef class ScrollDistances:
 
+cdef class ScrollData:
+
     cdef object __weakref__
     #for each distance, keep track of the hit count:
-    cdef uint16_t* distances
-    cdef uint16_t l
-    cdef int64_t *a1
-    cdef int64_t *a2
+    cdef uint16_t *distances
+    cdef uint64_t *a1        #checksums of reference picture
+    cdef uint64_t *a2        #checksums of latest picture
+    cdef uint8_t matched
+    cdef int16_t x
+    cdef int16_t y
+    cdef int16_t width
+    cdef int16_t height
 
-    def init(self, array1, array2, uint16_t max_distance=1000):
-        assert len(array1)==len(array2)
-        assert len(array1)<2**15 and len(array1)>0, "invalid array length: %i" % len(array1)
-        self.l = len(array1)
-        self.distances = <uint16_t*> memalign(2*self.l*sizeof(uint16_t))
-        cdef size_t asize = self.l*(sizeof(int64_t))
-        self.a1 = <int64_t*> memalign(asize)
-        self.a2 = <int64_t*> memalign(asize)
-        assert self.distances!=NULL and self.a1!=NULL and self.a2!=NULL, "scroll memory allocation failed"
-        for i in range(self.l):
-            self.a1[i] = castint64(array1[i])
-            self.a2[i] = castint64(array2[i])
-        #now compare all the values
-        self.calculate(max_distance)
+    def __cinit__(self, int16_t x=0, int16_t y=0, int16_t width=0, int16_t height=0):
+        self.x = x
+        self.y = y
+        self.width = width
+        self.height = height
 
     def __repr__(self):
-        return "ScrollDistances(%i)" % self.l
+        return "ScrollDistances(%ix%i)" % (self.width, self.height)
 
-    cdef calculate(self, uint16_t max_distance=1000):
-        cdef int64_t *a1 = self.a1
-        cdef int64_t *a2 = self.a2
-        cdef uint16_t l = self.l
+    #only used by the unit tests:
+    def _test_update(self, arr):
+        if self.a1:
+            free(self.a1)
+            self.a1 = NULL
+        if self.a2:
+            self.a1 = self.a2
+            self.a2 = NULL
+        cdef uint16_t l = len(arr)
+        cdef size_t asize = l*(sizeof(uint64_t))
+        self.a2 = <uint64_t*> memalign(asize)
+        assert self.a2!=NULL, "checksum memory allocation failed"
+        for i,v in enumerate(arr):
+            self.a2[i] = <uint64_t> abs(v)
+
+    def update(self, pixels, int16_t x, int16_t y, int16_t width, int16_t height, int16_t rowstride, uint8_t bpp=4):
+        """
+            Add a new image to compare with,
+            checksum its rows into a2,
+            and push existing values (if we had any) into a1.
+        """
+        if DEBUG:
+            log("%s.update%s a1=%#x, a2=%#x, distances=%#x, current size: %ix%i", self, (repr_ellipsized(pixels), x, y, width, height, rowstride, bpp), <uintptr_t> self.a1, <uintptr_t> self.a2, <uintptr_t> self.distances, self.width, self.height)
+        assert width>0 and height>0, "invalid dimensions: %ix%i" % (width, height)
+        #this is a new picture, shift a2 into a1 if we have it:
+        if self.a1:
+            free(self.a1)
+            self.a1 = NULL
+        if self.a2:
+            self.a1 = self.a2
+            self.a2 = NULL
+        #scroll area can move within the window:
+        self.x = x
+        self.y = y
+        #but cannot change size (checksums would not match):
+        if height!=self.height or width!=self.width:
+            log("new image size: %ix%i (was %ix%i), clearing reference checksums", width, height, self.width, self.height)
+            if self.a1:
+                free(self.a1)
+                self.a1 = NULL
+            if self.distances:
+                free(self.distances)
+                self.distances = NULL
+            self.width = width
+            self.height = height
+        #allocate new checksum array:
+        assert self.a2==NULL
+        cdef size_t asize = height*(sizeof(uint64_t))
+        self.a2 = <uint64_t*> memalign(asize)
+        assert self.a2!=NULL, "checksum memory allocation failed"
+        #checksum each line of the pixel array:
+        cdef uint8_t *buf = NULL
+        cdef Py_ssize_t buf_len = 0
+        assert object_as_buffer(pixels, <const void**> &buf, &buf_len)==0
+        assert buf_len>=0 and (<unsigned int> buf_len)>=rowstride*height, "buffer length=%i is too small for %ix%i" % (buf_len, rowstride, height)
+        cdef size_t row_len = width*bpp
+        assert row_len<=rowstride, "invalid row length: %ix%i=%i but rowstride is %i" % (width, bpp, width*bpp, rowstride)
+        cdef uint64_t *a2 = self.a2
+        cdef unsigned long long seed = 0
+        cdef uint16_t i
+        for i in range(height):
+            a2[i] = <uint64_t> XXH64(buf, row_len, seed)
+            #import xxhash
+            #a2[i] = <uint64_t> abs(xxhash.xxh64(buf[:row_len]).intdigest())
+            buf += rowstride
+
+    def calculate(self, uint16_t max_distance=1000):
+        """
+            Find all the scroll distances
+            that would move lines from a1 to a2.
+            The same lines may be accounted for multiple times.
+            The result is stored in the "distances" array.
+        """
+        if DEBUG:
+            log("calculate(%i) a1=%#x, a2=%#x, distances=%#x", max_distance, <uintptr_t> self.a1, <uintptr_t> self.a2, <uintptr_t> self.distances)
+        if self.a1==NULL or self.a2==NULL:
+            return
+        cdef uint64_t *a1 = self.a1
+        cdef uint64_t *a2 = self.a2
+        cdef uint16_t l = self.height
         cdef uint16_t y1, y2
         cdef uint16_t miny=0, maxy=0
-        cdef int64_t a2v
+        cdef uint64_t a2v
+        if self.distances==NULL:
+            self.distances = <uint16_t*> memalign(2*l*sizeof(uint16_t))
+            assert self.distances!=NULL, "distance memory allocation failed"
+        cdef uint16_t matches = 0
         with nogil:
-            memset(self.distances, 0, 2*self.l*sizeof(uint16_t))
+            memset(self.distances, 0, 2*l*sizeof(uint16_t))
             for y2 in range(l):
                 #miny = max(0, y2-max_distance):
                 if y2>max_distance:
@@ -133 +184 @@
                     if a1[y1]==a2v:
                         #distance = y1-y2
                         self.distances[l-(y1-y2)] += 1
+                        matches += 1
         if DEBUG:
-            log("ScrollDistance: l=%i, calculate(%s, %s, %i)=%s", self.l, da(self.a1, self.l), da(self.a2, self.l), max_distance, dd(self.distances, self.l*2))
+            log("ScrollDistance: height=%i, calculate:", l)
+            log(" a1=%s", da(self.a1, l))
+            log(" a2=%s", da(self.a2, l))
+            log(" %i matches, distances=%s", matches, dd(self.distances, l*2))
 
-    def get_best_scroll_values(self, uint16_t min_hits=2):
+    def get_scroll_values(self, uint16_t min_hits=2):
+        """
+            Return two dictionaries that describe how to go from a1 to a2.
+            * scrolls dictionary contains scroll definitions
+            * non-scrolls dictionary is everything else (that will need to be repainted)
+        """
         DEF MAX_MATCHES = 20
+        if self.a1==NULL or self.a2==NULL:
+            return None
         cdef uint16_t m_arr[MAX_MATCHES]    #number of hits
         cdef int16_t s_arr[MAX_MATCHES]     #scroll distance
         cdef int16_t i
@@ -147 +209 @@
         cdef int16_t low = 0
         cdef int16_t matches
         cdef uint16_t* distances = self.distances
-        cdef uint16_t l = self.l
+        cdef uint16_t l = self.height
+        #find the best values (highest match count):
         with nogil:
             for i in range(2*l):
                 matches = distances[i]
                 if matches>low and matches>min_hits:
                     #add this candidate match to the arrays:
+                    #find the lowest score index and replace it:
                     for j in range(MAX_MATCHES):
                         if m_arr[j]==low:
                             break
                     m_arr[j] = matches
                     s_arr[j] = i-l
-                    #find the new lowest value:
+                    #find the new lowest value we have:
                     low = matches
                     for j in range(MAX_MATCHES):
                         if m_arr[j]<low:
@@ -165 +229 @@
                             low = m_arr[j]
                             if low==0:
                                 break
-        if DEBUG:
-            log("get_best_scroll_values: arrays: matches=%s, scroll=%s", dd(m_arr, MAX_MATCHES), ds(s_arr, MAX_MATCHES))
         #first collect the list of distances sorted by highest number of matches:
         #(there can be more than one distance value for each match count):
         scroll_hits = {}
@@ -178 +240 @@
         #return a dict with the scroll distance as key,
         #and the list of matching lines in a dictionary:
         # {line-start : count, ..}
-        #this is destructive as we clear the checksums after use in match_distance()
-        scrolls = collections.OrderedDict()
-        cdef uint16_t m
-        #starting with the highest matches
-        for m in reversed(sorted(scroll_hits.keys())):
-            v = scroll_hits[m]
-            for scroll in v:
-                #find matching lines:
-                line_defs = self.match_distance(scroll)
-                if line_defs:
-                    scrolls[scroll] = line_defs
-        return scrolls
-
-    def get_remaining_areas(self):
-        #all the lines which have not been zeroed out
-        #when we matched them in match_distance
-        cdef int64_t *a2 = self.a2
-        cdef uint16_t i, start = 0, count = 0
-        line_defs = collections.OrderedDict()
-        for i in range(self.l):
-            if a2[i]!=0:
-                if count==0:
-                    start = i
-                count += 1
-            elif count>0:
+        #use a temporary buffer which we modify:
+        #(where we clear the values we have already matched)
+        cdef size_t asize = l*(sizeof(uint64_t))
+        cdef uint64_t *tmp = <uint64_t*> memalign(asize)
+        assert self.a2!=NULL, "checksum memory allocation failed"
+        cdef uint16_t start = 0, count = 0
+        try:
+            memcpy(tmp, self.a2, asize)
+            scrolls = collections.OrderedDict()
+            #starting with the highest matches
+            for i in reversed(sorted(scroll_hits.keys())):
+                v = scroll_hits[i]
+                for scroll in v:
+                    #find matching lines:
+                    line_defs = self.match_distance(tmp, scroll)
+                    if line_defs:
+                        scrolls[scroll] = line_defs
+            #same for the unmatched lines:
+            #all the lines in tmp which have not been zeroed out by match_distance()
+            line_defs = collections.OrderedDict()
+            for i in range(l):
+                if tmp[i]!=0:
+                    if count==0:
+                        start = i
+                    count += 1
+                elif count>0:
+                    line_defs[start] = count
+                    count = 0
+            if count>0:
                 line_defs[start] = count
-                count = 0
-        if count>0:
-            line_defs[start] = count
-        return line_defs
+        finally:
+            free(tmp)
+        return scrolls, line_defs
 
-    def match_distance(self, int16_t distance):
-        """ find the lines that match the given scroll distance """
-        cdef int64_t *a1 = self.a1
-        cdef int64_t *a2 = self.a2
+    cdef match_distance(self, uint64_t *tmp, int16_t distance):
+        """
+            find the lines that match the given scroll distance,
+            return a dictionary with the starting line as key
+            and the number of matching lines as value
+        """
+        cdef uint64_t *a1 = self.a1
+        cdef uint64_t *a2 = tmp         #this is a copy of a2 we can modify
         cdef char swap = 0
         if distance<0:
             #swap order:
             swap = 1
-            a1 = self.a2
+            a1 = tmp
             a2 = self.a1
             distance = -distance
-        if DEBUG:
-            log("match_distance(%i) l=%i, a1=%s, a2=%s", distance, self.l, da(a1, self.l), da(a2, self.l))
-        assert distance<self.l, "invalid distance %i for size %i" % (distance, self.l)
+        assert distance<self.height, "invalid distance %i for size %i" % (distance, self.height)
         cdef uint16_t i, start = 0, count = 0
         line_defs = collections.OrderedDict()
-        for i in range(self.l-distance):
+        for i in range(self.height-distance):
             #if DEBUG:
             #    log("%i: a1=%i / a2=%i", i, a1[i], a2[i+distance])
             if a1[i]!=0 and a1[i]==a2[i+distance]:
@@ -250 +317 @@
         if count>0:
             #last few lines ended as a match:
             line_defs[start] = count
-        if DEBUG:
-            log("match_distance(%i)=%s", distance, line_defs)
+        #if DEBUG:
+        #    log("match_distance(%i)=%s", distance, line_defs)
         return line_defs
 
 
+    def invalidate(self, int16_t x, int16_t y, int16_t w, int16_t h):
+        if self.a2==NULL:
+            #nothing to invalidate!
+            return
+        #do they intersect?
+        rect = rectangle(self.x, self.y, self.width, self.height)
+        inter = rect.intersection(x, y, w, h)
+        if not inter:
+            return
+        #remove any lines that have been updated
+        #by zeroing out their checksums:
+        assert len(inter)<=self.height
+        assert inter.y>=rect.y and inter.y+inter.height<=rect.y+rect.height
+        #the array indexes are relative to rect.y:
+        cdef int start_y = inter.y-rect.y
+        cdef int i
+        for i in range(start_y, start_y+inter.height):
+            self.a2[i] = 0
+        cdef uint16_t nonzero = 0
+        for i in range(self.height):
+            if self.a2[i]!=0:
+                nonzero += 1
+        log("invalidated %i lines checksums from intersection of scroll area %s and %s rectangle %s, remains %i", inter.height, rect, (x, y, w, h), nonzero)
+        #if more than half has already been invalidated, drop it completely:
+        if nonzero<=rect.height//2:
+            log("invalidating whole scroll data as only %i of it remains valid", 100*nonzero//rect.height)
+            free(self.a2)
+            self.a2 = NULL
+
+
     def get_best_match(self):
-        cdef int16_t max = 0
+        if self.a1==NULL or self.a2==NULL:
+            return 0, 0
+        cdef int16_t max_hits = 0
         cdef int d = 0
         cdef unsigned int i
-        for i in range(2*self.l):
-            if self.distances[i]>max:
-                max = self.distances[i]
-                d = i-self.l
-        return d, max
+        for i in range(2*self.height):
+            if self.distances[i]>max_hits:
+                max_hits = self.distances[i]
+                d = i-self.height
+        return d, max_hits
 
     def __dealloc__(self):
+        self.free()
+
+    def free(self):
         cdef void* ptr = <void*> self.distances
         if ptr:
             self.distances = NULL
@@ -278 +380 @@
         if ptr:
             self.a2 = NULL
             free(ptr)
-        
-
-def scroll_distances(array1, array2, unsigned int min_score=0, uint16_t max_distance=1000):
-    cdef ScrollDistances sd = ScrollDistances()
-    sd.init(array1, array2, max_distance)
-    return sd

xpra/server/window/window_video_source.py

@@ -14 +14 @@
 from xpra.codecs.codec_constants import TransientCodecException, RGB_FORMATS, PIXEL_SUBSAMPLING
 from xpra.server.window.window_source import WindowSource, STRICT_MODE, AUTO_REFRESH_SPEED, AUTO_REFRESH_QUALITY
 from xpra.server.window.region import rectangle, merge_all          #@UnresolvedImport
-from xpra.server.window.motion import scroll_distances, CRC_Image #@UnresolvedImport
+from xpra.server.window.motion import ScrollData                    #@UnresolvedImport
 from xpra.server.window.video_subregion import VideoSubregion, VIDEO_SUBREGION
 from xpra.server.window.video_scoring import get_pipeline_score
 from xpra.codecs.loader import PREFERED_ENCODING_ORDER, EDGE_ENCODING_ORDER
@@ -1425 +1425 @@
         #overriden so we can invalidate the scroll data:
         #log.error("make_draw_packet%s", (x, y, w, h, coding, "..", outstride, client_options)
         packet = WindowSource.make_draw_packet(self, x, y, w, h, coding, data, outstride, client_options)
-        lsd = self.scroll_data
-        if lsd and not options.get("scroll"):
-            rect, csums = lsd
+        sd = self.scroll_data
+        if sd and not options.get("scroll") and False:
             if client_options.get("scaled_size") or client_options.get("quality", 100)<20:
-                #don't scroll low quality content, better to refresh it
+                #don't scroll very low quality content, better to refresh it
                 scrolllog("low quality %s update, invalidating all scroll data (scaled_size=%s, quality=%s)", coding, client_options.get("scaled_size"), client_options.get("quality", 100))
-                self.scroll_data = None
+                sd.free()
             else:
-                #do they intersect?
-                inter = rect.intersection(x, y, w, h)
-                if inter:
-                    #remove any lines that have been updated
-                    #by zeroing out their checksums:
-                    assert len(csums)==rect.height
-                    assert inter.y>=rect.y and inter.y+inter.height<=rect.y+rect.height
-                    #the array indexes are relative to rect.y:
-                    start_y = inter.y-rect.y
-                    for iy in range(start_y, start_y+inter.height):
-                        csums[iy] = 0
-                    nonzero = len([True for v in csums if v!=0])
-                    scrolllog("removed %i lines checksums from intersection of scroll area %s and %s draw packet %s, remains %i", inter.height, rect, coding, (x, y, w, h), nonzero)
-                    #if more than half has already been invalidated, drop it completely:
-                    if nonzero<=rect.height//2:
-                        scrolllog("invalidating whole scroll data as only %i of it remains valid", 100*nonzero//rect.height)
-                        self.scroll_data = None
+                sd.invalidate(x, y, w, h)
         return packet
 
 
-    def encode_scrolling(self, image, distances, options):
+    def encode_scrolling(self, image, options={}):
         start = time.time()
         try:
             del options["av-sync"]
@@ -1461 +1444 @@
             pass
         #tells make_data_packet not to invalidate the scroll data:
         ww, wh = self.window_dimensions
-        scrolllog("encode_scrolling(%s, %s, [], [], %s) window-dimensions=%s", image, distances, options, (ww, wh))
+        scrolllog("encode_scrolling(%s, %s) window-dimensions=%s", image, options, (ww, wh))
         x, y, w, h = image.get_geometry()[:4]
-        raw_scroll = distances.get_best_scroll_values()
-        non_scroll = distances.get_remaining_areas()
+        raw_scroll, non_scroll = self.scroll_data.get_scroll_values()
         scrolllog(" will send scroll data=%s, non-scroll=%s", raw_scroll, non_scroll)
         flush = len(non_scroll)
         assert raw_scroll, "failed to detect scroll values"
@@ -1573 +1555 @@
         x, y, w, h = image.get_geometry()[:4]
         src_format = image.get_pixel_format()
         stride = image.get_rowstride()
-        img_data = None
         if self.pixel_format!=src_format:
             videolog.warn("image pixel format changed from %s to %s", self.pixel_format, src_format)
             self.pixel_format = src_format
@@ -1585 +1566 @@
             rgb_format = image.get_pixel_format() #ie: BGRA
             stride = image.get_rowstride()
             img = Image.frombuffer("RGBA", (w, h), memoryview_to_bytes(img_data), "raw", rgb_format.replace("BGRX", "BGRA"), stride)
+            img.convert("RGB")
             kwargs = {}
             if SAVE_VIDEO_FRAMES=="jpeg":
                 kwargs = {
@@ -1597 +1579 @@
             videolog("do_present_fbo: saving %4ix%-4i pixels, %7i bytes to %s", w, h, (stride*h), filename)
             img.save(filename, SAVE_VIDEO_FRAMES, **kwargs)
 
-        test_scrolling = self.supports_scrolling and not STRICT_MODE
-        if test_scrolling and self.b_frame_flush_timer:
-            scrolllog("not testing scrolling: b_frame_flush_timer=%s", self.b_frame_flush_timer)
-            test_scrolling = False
-            self.scroll_data = None
-        else:
-            lsd = self.scroll_data
-            try:
-                start = time.time()
-                img_data = img_data or image.get_pixels()
-                csums = CRC_Image(img_data, w, h, stride)
-                if csums:
-                    self.scroll_data = rectangle(x, y, w, h), csums
-                    options["scroll"] = True
-                    scrolllog("updated scroll data with %s, previously set: %s", self.scroll_data[0], (lsd or [None])[0])
-                if lsd and csums:
-                    rect, lcsums = lsd
-                    if rect.x!=x or rect.y!=y:
-                        #TODO: just adjust the scrolling packet for this offset
-                        scrolllog("scroll data position mismatch: %s vs %i,%i", rect, x, y)
-                    elif rect.width!=w or rect.height!=h:
-                        scrolllog("scroll data size mismatch: %s vs %ix%i", rect, w, h)
+        if self.supports_scrolling and not STRICT_MODE:
+            if self.b_frame_flush_timer and self.scroll_data:
+                scrolllog("not testing scrolling: b_frame_flush_timer=%s", self.b_frame_flush_timer)
+                self.scroll_data.free()
+                self.scroll_data = None
+            else:
+                try:
+                    start = time.time()
+                    if not self.scroll_data:
+                        self.scroll_data = ScrollData()
+                        scrolllog("new scroll data: %s", self.scroll_data)
+                    self.scroll_data.update(image.get_pixels(), x, y, w, h, image.get_rowstride(), len(src_format))
+                    max_distance = min(1000, (100-SCROLL_MIN_PERCENT)*h//100)
+                    self.scroll_data.calculate(max_distance)
+                    scroll, count = self.scroll_data.get_best_match()
+                    if count==0:
+                        scrolllog("no scroll distances found")
                     else:
-                        #same size, try to find scrolling value
-                        assert len(csums)==len(lcsums), "mismatch between checksums lists: %i vs %i items!" % (len(csums), len(lcsums))
-                        #no point in searching for a large scroll distance,
-                        #if we require a high match percentage:
-                        max_distance = min(1000, (100-SCROLL_MIN_PERCENT)*h//100)
-                        distances = scroll_distances(lcsums, csums, 2, max_distance)
-                        scroll, count = distances.get_best_match()
-                        if count==0:
-                            scrolllog("no scroll distances found")
-                        else:
-                            end = time.time()
-                            match_pct = int(100*count/h)
-                            scrolllog("best scroll guess took %ims, matches %i%% of %i lines: %s", (end-start)*1000, match_pct, h, scroll)
-                            #if enough scrolling is detected, use scroll encoding for this frame:
-                            if match_pct>=SCROLL_MIN_PERCENT:
-                                return self.encode_scrolling(image, distances, options)
-            except Exception:
-                scrolllog.error("Error during scrolling detection!", exc_info=True)
+                        end = time.time()
+                        match_pct = int(100*count/h)
+                        scrolllog("best scroll guess took %ims, matches %i%% of %i lines: %s", (end-start)*1000, match_pct, h, scroll)
+                        #if enough scrolling is detected, use scroll encoding for this frame:
+                        if match_pct>=SCROLL_MIN_PERCENT:
+                            return self.encode_scrolling(image, options)
+                except Exception:
+                    scrolllog.error("Error during scrolling detection")
+                    scrolllog.error(" with image=%s, options=%s", image, options, exc_info=True)
 
         def video_fallback():
             videolog.warn("using non-video fallback encoding")