Async bitmap present

rendercanvas/_coreutils.py

@@ -6,10 +6,19 @@
 import re
 import sys
 import time
+import queue
 import weakref
 import logging
+import threading
 import ctypes.util
 from contextlib import contextmanager
+from collections import namedtuple
+
+
+# %% Constants
+
+
+IS_WIN = sys.platform.startswith("win")  # Note that IS_WIN is false on Pyodide
 
 
 # %% Logging
@@ -93,6 +102,122 @@ def proxy(*args, **kwargs):
     return proxy
 
 
+# %% Helper for scheduling call-laters
+
+
+class CallLaterThread(threading.Thread):
+    """An object that can be used to do "call later" from a dedicated thread.
+
+    Care is taken to realize precise timing, so it can be used to implement
+    precise sleeping and call_later on Windows (to overcome Windows' notorious
+    15.6ms ticks).
+    """
+
+    Item = namedtuple("Item", ["time", "index", "callback", "args"])
+
+    def __init__(self):
+        super().__init__()
+        self._queue = queue.SimpleQueue()
+        self._count = 0
+        self.daemon = True  # don't let this thread prevent shutdown
+        self.start()
+
+    def call_later_from_thread(self, delay, callback, *args):
+        """In delay seconds, call the callback from the scheduling thread."""
+        self._count += 1
+        item = CallLaterThread.Item(
+            time.perf_counter() + float(delay), self._count, callback, args
+        )
+        self._queue.put(item)
+
+    def run(self):
+        perf_counter = time.perf_counter
+        Empty = queue.Empty  # noqa: N806
+        q = self._queue
+        priority = []
+        is_win = IS_WIN
+
+        wait_until = None
+        timestep = 0.001  # for doing small sleeps
+        leeway = timestep / 2  # a little offset so waiting exactly right on average
+
+        while True:
+            # == Wait for input
+
+            if wait_until is None:
+                # Nothing to do but wait
+                new_item = q.get(True, None)
+            else:
+                # We wait for the queue with a timeout. But because the timeout is not very precise,
+                # we wait shorter, and then go in a loop with some hard sleeps.
+                # Windows has 15.6 ms resolution ticks. But also on other OSes,
+                # it benefits precision to do the last bit with hard sleeps.
+                offset = 0.016 if is_win else 0.004
+                try:
+                    new_item = q.get(True, max(0, wait_until - perf_counter() - offset))
+                except Empty:
+                    new_item = None
+                    while perf_counter() < wait_until:
+                        time.sleep(timestep)
+                        try:
+                            new_item = q.get_nowait()
+                            break
+                        except Empty:
+                            pass
+
+            # Put it in our priority queue
+            if new_item is not None:
+                priority.append(new_item)
+                priority.sort(reverse=True)
+
+            del new_item
+
+            # == Process items until we have to wait
+
+            item = None
+            while True:
+                # Get item that is up next
+                try:
+                    item = priority.pop(-1)
+                except IndexError:
+                    wait_until = None
+                    break
+
+                # If it's not yet time for the item, put it back, and go wait
+                item_time_threshold = item.time - leeway
+                if perf_counter() < item_time_threshold:
+                    priority.append(item)
+                    wait_until = item_time_threshold
+                    break
+
+                # Otherwise, handle the callback
+                try:
+                    item.callback(*item.args)
+                except Exception as err:
+                    logger.error(f"Error in CallLaterThread callback: {err}")
+
+            del item
+
+
+_call_later_thread = None
+
+
+def call_later_from_thread(delay: float, callback: object, *args: object):
+    """Utility that calls a callback after a specified delay, from a separate thread.
+
+    The caller is responsible for the given callback to be thread-safe.
+    There is one global thread that handles all callbacks. This thread is spawned the first time
+    that this function is called.
+
+    Note that this function should only be used in environments where threading is available.
+    E.g. on Pyodide this will raise ``RuntimeError: can't start new thread``.
+    """
+    global _call_later_thread
+    if _call_later_thread is None:
+        _call_later_thread = CallLaterThread()
+    return _call_later_thread.call_later_from_thread(delay, callback, *args)
+
+
 # %% lib support
 
 

rendercanvas/_scheduler.py

@@ -2,17 +2,13 @@
 The scheduler class/loop.
 """
 
-import sys
 import time
 import weakref
 
 from ._enums import UpdateMode
 from .utils.asyncs import sleep, Event
 
 
-IS_WIN = sys.platform.startswith("win")
-
-
 class Scheduler:
     """Helper class to schedule event processing and drawing."""
 
@@ -121,20 +117,9 @@ async def __scheduler_task(self):
             # Determine amount of sleep
             sleep_time = delay - (time.perf_counter() - last_tick_time)
 
-            if IS_WIN:
-                # On Windows OS-level timers have an in accuracy of 15.6 ms.
-                # This can cause sleep to take longer than intended. So we sleep
-                # less, and then do a few small sync-sleeps that have high accuracy.
-                await sleep(max(0, sleep_time - 0.0156))
-                sleep_time = delay - (time.perf_counter() - last_tick_time)
-                while sleep_time > 0:
-                    time.sleep(min(sleep_time, 0.001))  # sleep hard for at most 1ms
-                    await sleep(0)  # Allow other tasks to run but don't wait
-                    sleep_time = delay - (time.perf_counter() - last_tick_time)
-            else:
-                # Wait. Even if delay is zero, it gives control back to the loop,
-                # allowing other tasks to do work.
-                await sleep(max(0, sleep_time))
+            # Wait. Even if delay is zero, it gives control back to the loop,
+            # allowing other tasks to do work.
+            await sleep(max(0, sleep_time))
 
             # Below is the "tick"
 

rendercanvas/contexts/bitmapcontext.py

@@ -36,7 +36,7 @@ def set_bitmap(self, bitmap):
         """Set the rendered bitmap image.
 
         Call this in the draw event. The bitmap must be an object that can be
-        conveted to a memoryview, like a numpy array. It must represent a 2D
+        converted to a memoryview, like a numpy array. It must represent a 2D
         image in either grayscale or rgba format, with uint8 values
         """