code release

xlib/logic/DelayedBuffers.py

@@ -0,0 +1,106 @@
+from collections import deque
+from datetime import datetime
+
+
+class DelayedBuffers:
+    """
+    Buffers temporal data and "shows" it evenly with target delay.
+
+    first frame created
+    0 ms
+    |          1500ms first frame arrived, set minimum target delay
+                |
+                    more data arrived
+                    |  ||    || |  |
+                                        2000ms target delay (set by user)
+                                        |
+                ^-----buffered data-----^
+                                        |  |  |  |  |  |  |  |  |
+                                        ^----show data evenly---^
+    """
+    class ProcessResult:
+        __slots__ = ['new_data']
+
+        def __init__(self):
+            self.new_data = None
+
+    def __init__(self):
+
+        self._buffers = deque()
+        self._target_delay = 0
+
+        self._last_ts = datetime.now().timestamp()
+        self._last_data = None
+
+        self._avg_delay = 1.0
+
+    def _update_avg_frame_delay(self):
+        buffers = self._buffers
+        if len(buffers) >= 2:
+            x = tuple(buffer[0] for buffer in buffers)
+            self._avg_delay = min(1.0, (max(x)-min(x)) / (len(x)-1) )
+
+    def get_avg_delay(self): return self._avg_delay
+
+    def add_buffer(self, timestamp : float, data):
+        buffers = self._buffers
+        buffers_len = len(buffers)
+        
+        for i in range(buffers_len):
+            if timestamp < buffers[i][0]:
+                buffers.insert( i, (timestamp, data))
+                self._update_avg_frame_delay()
+                return
+        
+        buffers.append( (timestamp, data) )
+        self._update_avg_frame_delay()
+
+    def set_target_delay(self, target_delay_sec : float):
+        self._target_delay = target_delay_sec
+
+
+    def process(self) -> 'DelayedBuffers.ProcessResult':
+        """
+        processes inner logic
+
+        returns DelayedBuffers.ProcessResult()
+        """
+        result = DelayedBuffers.ProcessResult()
+        buffers = self._buffers
+        now = datetime.now().timestamp()
+
+        
+        if now - self._last_ts >= self._avg_delay:
+            self._last_ts += self._avg_delay
+
+            if len(buffers) != 0:
+                # Find nearest to target_delay
+                nearest_i = -1
+                nearest_diff = 999999
+                target_delay = self._target_delay
+
+                buffers_to_remove = []
+                for i, buffer in enumerate(buffers):
+                    ts = buffer[0]
+
+                    diff = abs(now - ts - target_delay)
+                    if diff <= nearest_diff:
+                        nearest_i = i
+                        nearest_diff = diff
+                        buffers_to_remove.append(buffer)
+                    else:
+                        break
+                
+                if len(buffers_to_remove) >= 2:
+                    buffers_to_remove.pop(-1)
+                    for buffer in buffers_to_remove:
+                        buffers.remove(buffer)
+                    self._update_avg_frame_delay()
+                
+                if len(buffers) != 0:
+                    _, new_data = buffers[0]
+                    if not self._last_data is new_data:
+                        self._last_data = new_data
+                        result.new_data = new_data
+
+        return result