Make sure the frame data is written all at once (#36)

Author: vxgmichel

gambaterm/run.py

@@ -36,15 +36,15 @@ def get_ref(width: int, height: int, console: Console) -> tuple[int, int]:
     return refx, refy
 
 
-def write_bytes(term: Terminal, video_data: bytes) -> None:
+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
     # regardless of the configured codepage
     if sys.platform == "win32" and term.stream.fileno() == sys.stdout.fileno():
-        sys.stdout.buffer.write(video_data)
+        sys.stdout.buffer.write(frame_data)
         sys.stdout.buffer.flush()
     else:
-        os.write(term.stream.fileno(), video_data)
+        os.write(term.stream.fileno(), frame_data)
 
 
 def run(
@@ -92,6 +92,8 @@ def run(
     new_frame = False
     screen_ready = True
     frame_start_time = None
+    frame_data = bytearray()
+    current_title_sequence = b""
 
     # Loop over emulator frames
     for i in count():
@@ -134,52 +136,67 @@ def run(
 
         # Render video
         with timing(video_deltas):
-            # Send the frame
+            # Re-use the same buffer to accumulate frame data and avoid unnecessary allocations.
+            frame_data.clear()
+
+            # Detect if a shift is currently happening
             shift = shifting and shifting[-1] > 1 / fps
+
+            # Render a new frame only if:
+            # - it is the right time according to frame_advance
+            # - a new frame is available from the emulator
+            # - the screen is ready for a new frame (either CPR sync is disabled, or enabled and we received the CPR response)
+            # - we are not currently shifting (to prevent flooding the terminal with new frames when the rendering is too slow)
             if i % frame_advance == 0 and new_frame and screen_ready and not shift:
                 new_frame = False
-                # Check terminal size
+
+                # Detect terminal resize and color mode change
                 new_height = term.height or 24
                 new_width = term.width or 80
-                maybe_clear_seq = b""
+                maybe_clear_sequence = b""
                 if (new_height, new_width) != (
                     height,
                     width,
                 ) or new_color_mode != color_mode:
-                    maybe_clear_seq = b"\033[H\033[2J"
+                    maybe_clear_sequence = b"\033[H\033[2J"
                     height, width = new_height, new_width
                     refx, refy = get_ref(width, height, console)
                     color_mode = new_color_mode
                     last_frame.fill(0)
+
                 # Render frame with synchronized output mode (DEC 2026) to prevent flickering
                 # when the screen is cleared, or an artificial CRT-like "rolling band" side-effects
                 # from fast "sprite blinking" meant to cause "transparency" effect on original HW,
                 # https://zladx.github.io/posts/links-awakening-partial-translucency
-                video_data = (
-                    b"\033[?2026h"
-                    + maybe_clear_seq
-                    + blit(video, last_frame, refx, refy, width - 1, height, color_mode)
-                    + b"\033[?2026l"
+                frame_data += b"\033[?2026h"
+                frame_data += maybe_clear_sequence
+                frame_data += blit(
+                    video, last_frame, refx, refy, width - 1, height, color_mode
                 )
+                frame_data += b"\033[?2026l"
                 last_frame = video.copy()
+
                 # Update reporting
-                data_length.append(len(video_data))
+                data_length.append(len(frame_data))
                 shown_frames.append(True)
+
             # Ignore this video frame
             else:
-                video_data = None
                 data_length.append(0)
                 shown_frames.append(False)
 
+        # Pacing and synchronization
         with timing(sync_deltas):
             # Video sync
-            if video_data:
-                write_bytes(term, video_data)
+            if frame_data:
                 # Send CPR request
                 if use_cpr_sync:
-                    term.stream.write("\033[1;1H\033[6n")
-                    term.stream.flush()
+                    frame_data += b"\033[1;1H\033[6n"
                     screen_ready = False
+                # Add the current title
+                frame_data += current_title_sequence
+                # Write the entire frame in one go to avoid fragmentation
+                write_frame(term, frame_data)
             # Timing sync
             increment = samples / console.TICKS_IN_FRAME
             deadline = start + increment / fps
@@ -190,7 +207,7 @@ def run(
             shifting.append(time.time() - deadline)
             start = deadline
 
-        # Reporting
+        # Prepare title for the next frame
         if i % average_over == 1:
             tps = fps * console.TICKS_IN_FRAME
             emu_fps = tps * len(ticks) / sum(ticks)
@@ -207,5 +224,4 @@ def run(
             title += f"{data_rate:.0f} KB/s | "
             title += f"Audio: {audio_percent:.0f}% CPU | "
             title += f"{color_mode.report()} mode"
-            term.stream.write(term.set_window_title(title))
-            term.stream.flush()
+            current_title_sequence = term.set_window_title(title).encode("utf-8")