small refactor but also possible some breaking, to test..

Author: jquast

gambaterm/colors.py

@@ -22,9 +22,9 @@ def cycle(self) -> ColorMode:
 
     def cycle_back(self) -> ColorMode:
         """Cycle to the previous color mode."""
-        value = self - 1
-        if value == ColorMode.COULD_NOT_DETECT:
-            value = ColorMode.HAS_24_BIT_COLOR
+        value = int(self) - 1
+        if value <= int(ColorMode.COULD_NOT_DETECT):
+            value = int(ColorMode.HAS_24_BIT_COLOR)
         return ColorMode(value)
 
     def report(self) -> str:

gambaterm/graphics_scaler.py

@@ -20,7 +20,6 @@
 if TYPE_CHECKING:
     from blessed import Terminal
     from .console import Console
-    from .colors import ColorMode
 
 BASELINE_ID = 1
 DELTA_ID = 2
@@ -61,7 +60,7 @@ def parse_autoscale(value: str) -> AutoScaleConfig:
         elif token.endswith("kb"):
             bandwidth_mbits = float(token[:-2]) / 125.0
         elif token.endswith("mb"):
-            bandwidth_mbits = float(token[:-2])
+            bandwidth_mbits = float(token[:-2]) * 8.0
         elif token.endswith("s"):
             seconds = int(token[:-1])
             saw_seconds = True
@@ -241,6 +240,12 @@ def __init__(
     def position(self) -> tuple[int, int]:
         return self.refx_kitty, self.refy_kitty
 
+    def close(self) -> None:
+        """Close the stats file handle if it is not /dev/null."""
+        if self._stats_fh is not None and self._stats_fh.name != os.devnull:
+            self._stats_fh.close()
+        self._stats_fh = None
+
     @classmethod
     def recompute(
         cls,
@@ -402,20 +407,27 @@ def blit_sixel(
 
         self._profile.deltas += 1
 
-        colors = to_rgb(video)
-        indices, palette = quantize_colors(colors, 256)
-        indices = np.asarray(indices)
+        # Quantize only changed pixels for the overlay delta — unchanged
+        # pixels are transparent (skip_index=255) and already on screen
+        # from the prior frame via P2=1 mode.
+        changed_pixels = video[diff].reshape(-1, 1)
+        changed_colors = to_rgb(changed_pixels)
+        max_colors = min(256, changed_colors.shape[0])
+        indices_delta, palette = quantize_colors(changed_colors, max_colors)
         palette = np.asarray(palette)
-        indices[~diff] = 255
+        indices = np.full(video.shape, 255, dtype=np.uint8)
+        indices[diff] = np.asarray(indices_delta).ravel()
 
         result = encode_sixel(
-            colors,
+            to_rgb(video),
             max_colors=256,
             scale=self.scale,
             indices=indices,
             palette=palette,
             skip_index=255,
         )
+        # Baseline updated every overlay: sixel P2=1 transparency requires
+        # frame-to-frame diffs so unchanged pixels aren't double-rendered.
         self._sixel_baseline = video.copy()
         self._profile.bytes_out += len(result)
         elapsed_us = int((time.perf_counter() - t0) * 1e6)
@@ -590,6 +602,10 @@ def _encode_kitty(self, video, encode_fn):
             ),
         ]
         self._had_delta = True
+        # Baseline NOT updated after delta: kitty p=1 rect replacement
+        # diffs against the last keyframe, not the previous frame.  Each
+        # p=1 replacement removes the prior delta at the target rect, so
+        # keyframe-relative diffs avoid compounding residual artifacts.
         result = b"".join(result_parts)
         elapsed_us = int((time.perf_counter() - t0) * 1e6)
         self._stats_fh.write(
@@ -607,7 +623,6 @@ def blit_kitty(
         last_frame: np.ndarray | None,
         width: int,
         height: int,
-        color_mode: ColorMode,
     ) -> bytes:
         """Encode ``video`` as a kitty RGBA escape sequence.
 

gambaterm/main.py

@@ -14,7 +14,7 @@
 from .console import GameboyColor, Console
 from .audio import audio_player
 from .colors import detect_local_color_mode, ColorMode
-from .remote_terminal import GraphicsProtocol, _FORCE_SIXEL_BLITLESS, does_sixel
+from .remote_terminal import GraphicsProtocol, _FORCE_SIXEL_BLITLESS, _BAD_TEXT, does_sixel
 from .graphics_scaler import parse_autoscale
 from .keyboard_input import is_kitty_keyboard_protocol_supported
 from .input_getter import BaseInputGetter
@@ -195,6 +195,8 @@ def detect_graphics_local(
     if does_sixel(terminal, sv=sv):
         available.append(GraphicsProtocol.SIXEL)
     # Prefer kitty, then sixel, then text
+    if GraphicsProtocol.KITTY in available:
+        return GraphicsProtocol.KITTY, available
     return available[-1], available
 
 
@@ -249,13 +251,12 @@ def main(
 
     # Prefer text mode when it fits the terminal, unless the terminal has
     # poor unicode rendering (Rio, mlterm).
-    _bad_text = ("rio", "mlterm")  # corrupted unicode font rendering
     term_height = terminal.height or 24
     term_width = terminal.width or 80
     if (
         term_width >= console.WIDTH
         and term_height >= console.HEIGHT // 2
-        and not terminal_name.startswith(_bad_text)
+        and not terminal_name.startswith(_BAD_TEXT)
     ):
         args.graphics_protocol = GraphicsProtocol.TEXT
 

gambaterm/remote_terminal.py

@@ -128,7 +128,9 @@ def does_sixel(
 
 def _version_in_range(version: str, lo_excl: str, hi_excl: str) -> bool:
     """Return True if *version* is in (lo_excl, hi_excl)."""
-    v = tuple(int(p) for p in version.split("."))
+    # Strip pre-release suffixes (e.g. "0.4.0-alpha") before numeric parse.
+    _nums = __import__("re").split(r"[^\d]", version)
+    v = tuple(int(p) for p in _nums if p)
     lo = tuple(int(p) for p in lo_excl.split("."))
     hi = tuple(int(p) for p in hi_excl.split("."))
     return lo < v < hi
@@ -174,6 +176,9 @@ def _detect(self, timeout: float = 3.0) -> KeyboardSupport:
 
 _FORCE_SIXEL_BLITLESS = ("contour", "tabby", "konsole", "mlterm", "iterm2")
 
+# Terminals with corrupted unicode font rendering — always prefer graphics.
+_BAD_TEXT = ("rio", "mlterm")
+
 
 def detect_graphics_frontend(
     terminal: RemoteTerminal,

gambaterm/run.py

@@ -17,7 +17,10 @@
 from .input_getter import BaseInputGetter
 from .colors import ColorMode
 from .graphics_scaler import GraphicsScaler, AutoScale, AutoScaleConfig, _SCALE_CEILING
-from .remote_terminal import GraphicsProtocol
+from .remote_terminal import GraphicsProtocol, _BAD_TEXT
+
+# Terminals needing full frames every frame (no dirty-rect / overlay deltas).
+_FORCE_KITTY_BLITLESS = ("rio", "ghostty")
 
 
 @contextlib.contextmanager
@@ -35,21 +38,6 @@ def get_ref(width: int, height: int, console: Console) -> tuple[int, int]:
     return refx, refy
 
 
-# Terminals with corrupted unicode font rendering — always prefer graphics.
-_BAD_TEXT = ("rio", "mlterm")
-# Terminals needing full frames every frame (no dirty-rect / overlay deltas).
-_FORCE_KITTY_BLITLESS = ("rio", "ghostty")
-
-
-def _is_mlterm(term: Terminal) -> bool:
-    """Return True if the terminal is mlterm (loses sixel on focus-out)."""
-    try:
-        sv = term.get_software_version(timeout=0.25)
-        return sv is not None and "mlterm" in sv.name.lower()
-    except Exception:
-        return False
-
-
 def write_frame(term: Terminal, frame_data: bytes) -> None:
     # Fix code page issue on windows:
     # `sys.stdout.buffer.raw` is a `WindowsConsoleIO` that always support UTF-8
@@ -180,7 +168,7 @@ def run(
                 cycle = [
                     p
                     for p in graphics_cycle
-                    if p is not GraphicsProtocol.TEXT or terminal_name not in _BAD_TEXT
+                    if p is not GraphicsProtocol.TEXT or not terminal_name.startswith(_BAD_TEXT)
                 ]
                 if cycle:
                     idx = cycle.index(graphics_protocol)
@@ -192,7 +180,7 @@ def run(
                 average_over = int(round(fps))  # frames
                 audio_out.update_speed(console, speed)
             elif key.key_name in ("FOCUS_IN", "FOCUS_OUT"):
-                if graphics_protocol is GraphicsProtocol.SIXEL and _is_mlterm(term):
+                if graphics_protocol is GraphicsProtocol.SIXEL and terminal_name.startswith("mlterm"):
                     if scaler is not None:
                         scaler._sixel_baseline = None
             elif key.key_name in ("KEY_GRAVE_ACCENT", "KEY_TILDE") or key in ("`", "~"):
@@ -229,7 +217,7 @@ def run(
                     if (
                         new_width >= console.WIDTH
                         and new_height >= console.HEIGHT // 2
-                        and not terminal_name.startswith(("rio", "mlterm"))
+                        and not terminal_name.startswith(_BAD_TEXT)
                     ):
                         new_graphics_protocol = GraphicsProtocol.TEXT
                         changed = True
@@ -242,7 +230,7 @@ def run(
                         if (
                             text_fits
                             and graphics_protocol is not GraphicsProtocol.TEXT
-                            and terminal_name not in _BAD_TEXT
+                            and not terminal_name.startswith(_BAD_TEXT)
                         ):
                             new_graphics_protocol = GraphicsProtocol.TEXT
                         elif (
@@ -285,6 +273,8 @@ def run(
                     graphics_protocol = new_graphics_protocol
                     term.number_of_colors = new_color_mode.number_of_colors
                     last_frame.fill(0)
+                    if scaler is not None:
+                        scaler.close()
                     scaler = None
                     force_status_update = True
 
@@ -329,9 +319,9 @@ def run(
                         frame_data += scaler.blit_sixel_blitless(video, width, height)
                     else:
                         frame_data += scaler.blit_kitty(
-                            video, last_frame, width, height, color_mode
+                            video, last_frame, width, height
                         )
-                        if terminal_name in _FORCE_KITTY_BLITLESS:
+                        if terminal_name.startswith(_FORCE_KITTY_BLITLESS):
                             scaler._baseline = None
                     if sync_end:
                         frame_data += sync_end
@@ -351,6 +341,8 @@ def run(
         if data_length and auto_scale is not None and autoscale is not None:
             data_rate_kb_s = sum(data_length) / len(data_length) * fps / 1000
             if auto_scale.feed_bandwidth(data_rate_kb_s, autoscale.bandwidth_mbits):
+                if scaler is not None:
+                    scaler.close()
                 scaler = GraphicsScaler.recompute(
                     term,
                     console,
@@ -404,6 +396,8 @@ def run(
                         and graphics_protocol is GraphicsProtocol.KITTY
                     ):
                         kitty_pending_delete = True
+                    if scaler is not None:
+                        scaler.close()
                     scaler = GraphicsScaler.recompute(
                         term,
                         console,

termblit_ext/graphicsblit.pyx

@@ -119,15 +119,20 @@ def encode_sixel(float[:, :, ::1] colors, int max_colors=256, int scale=1,
     cdef int h = colors.shape[0]
     cdef int w = colors.shape[1]
 
+    # Compute scaled dimensions up front — needed even when using
+    # precomputed indices (the overlay delta path avoids scaling colors).
+    cdef int use_precomputed = indices is not None and palette is not None
+    if scale > 1:
+        h *= scale
+        w *= scale
+
     # Scale via numpy (already fast C)
     cdef float[:, :, ::1] scaled_colors
-    cdef int use_precomputed = indices is not None and palette is not None
     if scale > 1:
-        arr = np.asarray(colors)
-        arr = np.repeat(np.repeat(arr, scale, axis=0), scale, axis=1)
-        scaled_colors = arr
-        h = scaled_colors.shape[0]
-        w = scaled_colors.shape[1]
+        if not use_precomputed:
+            arr = np.asarray(colors)
+            arr = np.repeat(np.repeat(arr, scale, axis=0), scale, axis=1)
+            scaled_colors = arr
         if use_precomputed:
             indices = np.ascontiguousarray(
                 np.repeat(np.repeat(np.asarray(indices), scale, axis=0),
@@ -144,7 +149,7 @@ def encode_sixel(float[:, :, ::1] colors, int max_colors=256, int scale=1,
         scaled_colors = arr
         h = scaled_colors.shape[0]
         if use_precomputed:
-            indices_padded = np.zeros((h, w), dtype=np.uint8)
+            indices_padded = np.full((h, w), skip_index, dtype=np.uint8)
             indices_padded[:indices.shape[0], :] = np.asarray(indices)
             indices = indices_padded
 

tests/test_graphics_renderer.py

@@ -84,11 +84,11 @@ def test_kitty_dirty_rect_delta():
     )
 
     baseline = np.full((10, 10), 0xFF00FF00, dtype=np.uint32)
-    scaler.blit_kitty(baseline, None, 10, 10, None)
+    scaler.blit_kitty(baseline, None, 10, 10)
 
     changed = baseline.copy()
     changed[3, 4] = 0xFFFF0000
-    result = scaler.blit_kitty(changed, baseline, 10, 10, None)
+    result = scaler.blit_kitty(changed, baseline, 10, 10)
 
     text = result.decode("latin-1")
     assert "i=2" in text
@@ -113,14 +113,14 @@ def test_kitty_rebaseline_deletes_delta():
     )
 
     baseline = np.full((10, 10), 0xFF00FF00, dtype=np.uint32)
-    scaler.blit_kitty(baseline, None, 10, 10, None)
+    scaler.blit_kitty(baseline, None, 10, 10)
 
     changed = baseline.copy()
     changed[0, 0] = 0xFFFF0000
-    scaler.blit_kitty(changed, baseline, 10, 10, None)
+    scaler.blit_kitty(changed, baseline, 10, 10)
 
     big_change = np.full((10, 10), 0xFF0000FF, dtype=np.uint32)
-    result = scaler.blit_kitty(big_change, changed, 10, 10, None)
+    result = scaler.blit_kitty(big_change, changed, 10, 10)
     text = result.decode("latin-1")
     assert "i=1" in text
     assert "a=d,d=i,i=2" in text
@@ -313,7 +313,7 @@ def test_disabled(self, value):
 
     @pytest.mark.parametrize("value,seconds,fps,mbits", [
         ("30fps", -1, 30.0, 0.0),
-        ("60s,30fps,10mb", 60, 30.0, 10.0),
+        ("60s,30fps,10mb", 60, 30.0, 80.0),
         ("1500kb", -1, 40.0, 12.0),
         ("always,25fps", -1, 25.0, 0.0),
     ])