Controls added

Author: JVSCHANDRADITHYA

ascii_play/player.py

@@ -1,10 +1,14 @@
 """
 ascii_play.player
-~~~~~~~~~~~~~~~~~
-Video decode + render loop with audio sync.
 
-Audio: extracted to wav, played via sounddevice (works on Windows natively).
-Sync: audio clock is master, video sleeps to match frame timing.
+
+Video decode + render loop with audio sync and keyboard controls.
+
+Controls:
+  space       pause / resume
+  right arrow seek forward 5 seconds
+  left arrow  seek backward 5 seconds
+  q           quit
 """
 
 import os
@@ -24,6 +28,74 @@
 from .renderers import MODES, render_half
 
 
+# ── keyboard input ────────────────────────────────────────────────────────────
+
+def _make_kb():
+    """
+    Returns a non-blocking keyboard reader.
+    On Windows uses msvcrt, on Linux uses termios raw mode.
+    Returns (read_fn, cleanup_fn).
+    read_fn() → None | "pause" | "seek_fwd" | "seek_back" | "quit"
+    """
+    if sys.platform == "win32":
+        import msvcrt
+
+        KEY_MAP = {
+            b" ":     "pause",
+            b"q":     "quit",
+            b"Q":     "quit",
+        }
+        EXTENDED = {
+            b"M":     "seek_fwd",   # right arrow
+            b"K":     "seek_back",  # left arrow
+        }
+
+        def read_key():
+            if not msvcrt.kbhit():
+                return None
+            ch = msvcrt.getch()
+            if ch in (b"\x00", b"\xe0"):
+                ch2 = msvcrt.getch()
+                return EXTENDED.get(ch2)
+            return KEY_MAP.get(ch)
+
+        return read_key, lambda: None
+
+    else:
+        import tty, termios, select
+
+        fd   = sys.stdin.fileno()
+        old  = termios.tcgetattr(fd)
+        tty.setraw(fd)
+
+        KEY_MAP = {
+            " ":      "pause",
+            "q":      "quit",
+            "Q":      "quit",
+        }
+        ESC_MAP = {
+            "\x1b[C": "seek_fwd",
+            "\x1b[D": "seek_back",
+        }
+
+        def read_key():
+            r, _, _ = select.select([sys.stdin], [], [], 0)
+            if not r:
+                return None
+            ch = sys.stdin.read(1)
+            if ch == "\x1b":
+                r2, _, _ = select.select([sys.stdin], [], [], 0.05)
+                if r2:
+                    ch += sys.stdin.read(2)
+                return ESC_MAP.get(ch)
+            return KEY_MAP.get(ch)
+
+        def cleanup():
+            termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+        return read_key, cleanup
+
+
 # ── audio ─────────────────────────────────────────────────────────────────────
 
 def _has_audio_deps():
@@ -56,9 +128,13 @@ def __init__(self, wav_path):
         self._started = threading.Event()
         self._done    = threading.Event()
         self._sd      = sd
+        self._paused  = False
 
     def _callback(self, outdata, frames, time_info, status):
         with self._lock:
+            if self._paused:
+                outdata[:] = 0
+                return
             chunk = self._data[self._pos : self._pos + frames]
             if len(chunk) < frames:
                 outdata[:len(chunk)] = chunk
@@ -86,6 +162,19 @@ def time(self):
         with self._lock:
             return self._pos / self._sr
 
+    def seek(self, seconds):
+        with self._lock:
+            new_pos = int((self._pos / self._sr + seconds) * self._sr)
+            self._pos = max(0, min(new_pos, len(self._data) - 1))
+
+    def pause(self):
+        with self._lock:
+            self._paused = True
+
+    def resume(self):
+        with self._lock:
+            self._paused = False
+
     def is_done(self):
         return self._done.is_set()
 
@@ -119,17 +208,24 @@ def _on_signal(sig, _frame):
     sys.stdout.write(clear_screen())
     sys.stdout.flush()
 
+    read_key, kb_cleanup = _make_kb()
+
     try:
-        _loop(filename, renderer, mode, scale, loop, info, quality, audio, interrupted)
+        _loop(filename, renderer, mode, scale, loop, info, quality,
+              audio, interrupted, read_key)
     finally:
+        kb_cleanup()
         sys.stdout.write(reset())
         sys.stdout.write(normal_screen())
         sys.stdout.write(cursor_show())
         sys.stdout.flush()
 
 
-def _loop(filename, renderer, mode, scale, loop, info, quality, audio, interrupted):
+def _loop(filename, renderer, mode, scale, loop, info, quality,
+          audio, interrupted, read_key):
+
     use_audio = audio and _has_audio_deps()
+    SEEK_SECS = 5
 
     while True:
         # ── extract + start audio ──────────────────────────────────────────
@@ -150,41 +246,75 @@ def _loop(filename, renderer, mode, scale, loop, info, quality, audio, interrupt
         # ── video decode ───────────────────────────────────────────────────
         video = imageio_ffmpeg.read_frames(filename)
         meta  = next(video)
-        fps   = meta.get("fps", 24) or 24
-        fps   = min(max(float(fps), 1), 120)   # clamp to sane range
+        fps   = min(max(float(meta.get("fps", 24) or 24), 1), 120)
         vw, vh = meta["size"]
         frame_size = (vh, vw, 3)
         spf   = 1.0 / fps
 
         frame_count = 0
         t_start     = time.perf_counter()
+        paused      = False
+        pause_start = 0.0
+        total_paused = 0.0
 
         try:
             for raw in video:
                 if interrupted.is_set():
                     return
 
+                # ── keyboard ───────────────────────────────────────────────
+                key = read_key()
+                if key == "quit":
+                    interrupted.set()
+                    return
+                elif key == "pause":
+                    paused = not paused
+                    if paused:
+                        pause_start = time.perf_counter()
+                        if clock: clock.pause()
+                    else:
+                        total_paused += time.perf_counter() - pause_start
+                        if clock: clock.resume()
+                elif key == "seek_fwd":
+                    frame_count = min(
+                        frame_count + int(SEEK_SECS * fps),
+                        int(meta.get("duration", 0) * fps) - 1
+                    )
+                    t_start -= SEEK_SECS
+                    if clock: clock.seek(SEEK_SECS)
+                elif key == "seek_back":
+                    frame_count = max(frame_count - int(SEEK_SECS * fps), 0)
+                    t_start += SEEK_SECS
+                    if clock: clock.seek(-SEEK_SECS)
+
+                # ── pause loop ─────────────────────────────────────────────
+                while paused and not interrupted.is_set():
+                    key2 = read_key()
+                    if key2 == "pause":
+                        paused = False
+                        total_paused += time.perf_counter() - pause_start
+                        if clock: clock.resume()
+                    elif key2 == "quit":
+                        interrupted.set()
+                        return
+                    time.sleep(0.05)
+
                 frame = np.frombuffer(raw, dtype=np.uint8).reshape(frame_size)
 
                 # ── timing ─────────────────────────────────────────────────
                 if clock is not None:
-                    # audio is master clock
                     audio_time     = clock.time
                     expected_frame = int(audio_time * fps)
-
                     if expected_frame > frame_count + 2:
-                        # more than 2 frames behind audio — skip to catch up
                         frame_count = expected_frame
                         continue
-
-                    # sleep until this frame is due per audio clock
                     target = t_start + (audio_time + spf)
                     slack  = target - time.perf_counter()
                     if slack > 0:
                         time.sleep(slack)
                 else:
-                    # no audio — wall clock timing
-                    target = t_start + frame_count * spf
+                    effective_start = t_start + total_paused
+                    target = effective_start + frame_count * spf
                     slack  = target - time.perf_counter()
                     if slack > 0:
                         time.sleep(slack)
@@ -198,9 +328,10 @@ def _loop(filename, renderer, mode, scale, loop, info, quality, audio, interrupt
                 out = renderer(frame, cols, render_rows, quality)
 
                 if info:
-                    elapsed    = time.perf_counter() - t_start
+                    elapsed    = time.perf_counter() - t_start - total_paused
                     actual_fps = frame_count / elapsed if elapsed > 0 else 0
                     audio_tag  = "audio" if clock else "no audio"
+                    pause_tag  = "  PAUSED" if paused else ""
                     out += (
                         move_to(rows)
                         + "\033[48;2;18;18;18m\033[38;2;170;170;170m"
@@ -210,6 +341,8 @@ def _loop(filename, renderer, mode, scale, loop, info, quality, audio, interrupt
                         + f"  │  {cols}×{render_rows}"
                         + f"  │  {actual_fps:.1f}/{fps:.0f} fps"
                         + f"  │  {audio_tag}"
+                        + f"  │  [space] pause  [←→] seek 5s  [q] quit"
+                        + pause_tag
                         + "\033[K"
                         + reset()
                     )