py-termcam 0.2.0__py3-none-any.whl

py_termcam-0.2.0.dist-info/METADATA

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: py-termcam
+Version: 0.2.0
+Summary: Live webcam → terminal art in 8 styles, with a virtual camera for OBS. Works without a camera too.
+Author: termcam contributors
+License: MIT
+Keywords: webcam,terminal,ascii-art,creative-coding,cli,virtual-camera,obs
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video :: Capture
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: opencv-python>=4.8
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Provides-Extra: webcam
+Requires-Dist: pyvirtualcam>=0.12; extra == "webcam"
+Requires-Dist: numpy>=1.24; extra == "webcam"
+Dynamic: license-file
+
+# termcam
+
+Your webcam — live — rendered in the terminal as ASCII, neon, dither or
+glitch art. One keystroke changes the style. No GUI windows, no browser, just
+the console and you.
+
+No webcam? **termcam** generates a procedural plasma that still reacts to
+your keystrokes and serves as a screensaver-style demo.
+
+## Install
+
+```bash
+pip install termcam                # terminal + window art
+pip install "termcam[webcam]"      # + virtual camera (--out webcam)
+```
+
+## Quick start
+
+```bash
+termcam                 # uses webcam, ascii style, 24 fps
+termcam --source synth  # no webcam needed — procedural plasma
+termcam --source url --url "http://192.168.1.5:8080/video"  # phone via IP Webcam
+termcam --out webcam --source synth   # art becomes a virtual camera device
+termcam --out window --source synth   # art in a GUI window (OBS Window Capture)
+```
+
+### Hotkeys (while running)
+
+| Key | Action                    |
+|-----|---------------------------|
+| a   | ASCII (luminance → chars) |
+| s   | Neon (color gradient)     |
+| d   | Dither (pixel noise)      |
+| g   | Glitch (sparkling)        |
+| e   | Sketch (edge detection)   |
+| h   | Halftone (newsprint)      |
+| t   | Thermal (heatmap)         |
+| x   | Negative (film invert)    |
+| m   | Mirror / un-mirror        |
+| q   | Quit                      |
+
+Press the style key repeatedly for palette variants.
+
+## Styles
+
+- **ASCII** — classic monochrome luminance ramp (`" .:-=+*#%@"`)
+- **Neon** — full color, mapped through an ANSI 256 palette
+- **Dither** — 4×4 Bayer matrix noise, retro pixel look
+- **Glitch** — per-frame hash sparkle, chaotic but alive
+- **Sketch** — edge detection (Sobel-like), pencil-look line art, light/dark paper
+- **Halftone** — newspaper print: ink shades on paper-color background
+- **Thermal** — heatmap palettes (fire, inferno, deep water, lava-pink)
+- **Negative** — film negative, posterized, cyan/magenta/warm X-ray tints
+
+Every style has palette/param variants — keep pressing its key to cycle.
+
+## CLI options
+
+```
+termcam
+  --source {camera,synth,url}  input source       (default: camera)
+  --style {ascii,neon,dith,glitch,sketch,halftone,thermal,negative} (default: ascii)
+  --out {terminal,webcam,window,both}             (default: terminal)
+  --fps N                      frames per second  (default: 24)
+  --cols N                     terminal width hint (auto-detected)
+  --device N                   camera device index (default: 0)
+  --url URL                    MJPEG stream for --source url
+  --backend {auto,obs,unitycapture} virtual camera backend (default: auto)
+  --webcam-size WxH            virtual camera resolution (default: 1280x720)
+  --mirror                     flip horizontally
+```
+
+## Virtual camera & OBS
+
+You can turn the art itself into a webcam device.
+
+**As a real webcam in ANY app including OBS** (best: no OBS dependency):
+
+```bash
+pip install "termcam[webcam]"
+termcam --source synth --out webcam --backend unitycapture
+```
+
+This uses the free, open-source [UnityCapture](https://github.com/schellingb/UnityCapture)
+DirectShow filter as the virtual camera device **`Unity Video Capture`**. Install it
+once as administrator:
+
+1. Clone/download [UnityCapture](https://github.com/schellingb/UnityCapture).
+2. From `UnityCapture/Install` run `Install.bat` as administrator (registers two
+   DLLs via `regsvr32`). Keep that folder in place while installed.
+3. In OBS: **Sources → + → Video Capture Device → Unity Video Capture**.
+   The device appears even while termcam runs without OBS active.
+
+Remove it later with `Uninstall.bat` (as administrator).
+
+**As a webcam in other apps** (Zoom, Discord, …), using OBS's own virtual camera:
+
+```bash
+termcam --out webcam --source synth
+```
+
+With the `obs` backend, start **OBS Studio → Start Virtual Camera** once, then pick
+`OBS Virtual Camera` as the camera in any other app. Cannot be consumed as an
+input inside the same OBS instance.
+
+**Preview window** (for OBS Window Capture if you prefer):
+
+```bash
+termcam --out window --source synth
+```
+
+A window titled `termcam` opens; in OBS add **Sources → Window Capture →
+termcam**.
+
+Hotkeys work in every output mode (`a/s/d/g/e/h/t/x`, `m`, `q`).
+
+## Phone as a webcam
+
+No USB webcam? Any Android phone with a WiFi connection works — termcam just
+needs a URL. Tested target: a 2016 Samsung Galaxy J1 Mini (Android 5.1).
+
+1. Install the free app **IP Webcam** on the phone (Play Store; works on
+   Android 5.0+).
+2. Connect the phone and your PC to the **same WiFi** network.
+3. Open IP Webcam → tap **Start server** at the bottom. The app shows an
+   address like `http://192.168.1.5:8080`.
+4. Verify on the PC in a browser: open that address — you should see the
+   camera preview. (Phone as a hotspot also works: connect the PC to the
+   phone's hotspot instead.)
+5. Point termcam at the MJPEG stream:
+
+   ```bash
+   termcam --source url --url "http://192.168.1.5:8080/video"
+   ```
+
+6. Hotkeys are the same — `a/s/d/g` switches styles, so the low-res J1 Mini
+   camera becomes lo-fi neon/dither art.
+
+If IP Webcam has a password set (Settings → Login), embed it in the URL:
+`http://user:pass@192.168.1.5:8080/video`.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+MIT

py_termcam-0.2.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+py_termcam-0.2.0.dist-info/licenses/LICENSE,sha256=rE-db79bRxOsTi24b_Ftl_88x1942KjSRHl3ytqGcPc,1076
+termcam/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+termcam/__main__.py,sha256=PsGuEvRs1Sc3IsQLg89axd3jBAHqlEHvmEJ16WlFOCU,84
+termcam/camera.py,sha256=zgNOLj3UVE-ut4iyCFKnqsGM7cmkpc29Aq8mEZ1C3Bk,1675
+termcam/cli.py,sha256=113R6AZtczl8CRv8ikWnIXqmbodtxW7MOaogubQhlvc,3491
+termcam/colors.py,sha256=8qJ68-wp9ofIcDurcP6r8u_X5pZupy-ewZEyGj3S-8w,1256
+termcam/engine.py,sha256=p2NOCtlsbf_mAHhCbb_Qy52irPZ1hmIItqEB7ge3pFo,5987
+termcam/font.py,sha256=iLbmBHYZDWnyHze2yQrWWF8omL79CAHKBmev8Tai8LA,6987
+termcam/frame.py,sha256=HsJ2cWHAPgx7sjaPOtvJxsyL7Bev6fbCgGLXF1R3puI,964
+termcam/keys.py,sha256=7j54ua7_L76dG1XH54ejBEO6uaQ6wPyheq5Rvkx9BvY,1705
+termcam/renderer.py,sha256=zGzfd0ZIRusrqqGkJIX3ObnXqzHlIepogCVuWnx0XLg,754
+termcam/sources.py,sha256=ro9ho0UqcpDCU_DgYEOi2qFjzP7ZVbU5SreWVKc8joY,1018
+termcam/webcam.py,sha256=ZHufHtWZYFJQLafbFVyZLwqr75riugR8gubUy77DNDQ,5010
+termcam/styles/__init__.py,sha256=jH3jW8pTTsRrpC_VYSjGN1myRm8QUDYvrKcqnLXiWQY,507
+termcam/styles/ascii.py,sha256=sH2QoKrLW7VqYj-Ae-IX-oo3dAe51a8T2rq_yfBDJg0,1044
+termcam/styles/base.py,sha256=zn__8NGrr8pdQuB8qg53t5WLiex4zmBVqj2uqbJWmjQ,375
+termcam/styles/dither.py,sha256=Ey_7HeovUeIFO-MsPToTCWhQQIIx2UlnTF7DvNrisfw,1550
+termcam/styles/glitch.py,sha256=hnJYg8NTTuRbsza5N_HBb-XkFNC-7oyzdYyuBa6FrUA,1077
+termcam/styles/halftone.py,sha256=H78kXOxdht1ElJk2GGMdQfgKHv1BrAiqF7Ua8dktPbE,1119
+termcam/styles/negative.py,sha256=Bb0x_x7aj62_lRHnyaog05RtZyse4MYq_2wViZzGesc,1337
+termcam/styles/neon.py,sha256=LIshntk5x_yJsxq8-s77d7Gv_yTBZV1IKi0p-V8YsxY,1324
+termcam/styles/sketch.py,sha256=CJJOR5tYPwhar6YY45Xlr-6ki0AzLO-1nVKtkMbFk3g,1817
+termcam/styles/thermal.py,sha256=Ui9K0up1lP5uU5eF77GwRezXcFxSeugh78Wlh9H16eA,1593
+py_termcam-0.2.0.dist-info/METADATA,sha256=QhCbeg9R6peyYT7vQgtOhUfMyCxuelVRqM6TqyUYZZI,6194
+py_termcam-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+py_termcam-0.2.0.dist-info/entry_points.txt,sha256=HDUl6WFEcV6ypYg7UIinWseF0NQfaE7TM8HMx_PK6L0,45
+py_termcam-0.2.0.dist-info/top_level.txt,sha256=n_XNV7ddUcAGfKAcx1wjmx7F3YwZK2FHXD5Wr4-ll1o,8
+py_termcam-0.2.0.dist-info/RECORD,,

py_termcam-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

py_termcam-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+termcam = termcam.cli:main

py_termcam-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 termcam contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

py_termcam-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+termcam

termcam/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

termcam/camera.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import cv2
+
+from .frame import Frame
+
+
+def _read_and_resize(cap, cols: int, rows: int) -> Frame:
+    ok, frame = cap.read()
+    if not ok:
+        raise RuntimeError("Source returned no frame")
+    resized = cv2.resize(
+        frame,
+        (cols, rows * 2),
+        interpolation=cv2.INTER_AREA,
+    )
+    pixels = [
+        [(int(p[2]), int(p[1]), int(p[0])) for p in row] for row in resized
+    ]
+    return Frame(cols, rows * 2, pixels)
+
+
+class CameraSource:
+    def __init__(self, device: int = 0, cols: int = 80, rows: int = 40) -> None:
+        self.device = device
+        self.cols = cols
+        self.rows = rows
+        self._cap = cv2.VideoCapture(device)
+        if not self._cap.isOpened():
+            raise RuntimeError(f"Could not open camera device {device}")
+
+    def read(self) -> Frame:
+        try:
+            return _read_and_resize(self._cap, self.cols, self.rows)
+        except RuntimeError:
+            raise RuntimeError("Camera returned no frame") from None
+
+    def close(self) -> None:
+        self._cap.release()
+
+
+class UrlSource:
+    def __init__(self, url: str, cols: int = 80, rows: int = 40) -> None:
+        self.url = url
+        self.cols = cols
+        self.rows = rows
+        self._cap = cv2.VideoCapture(url)
+        if not self._cap.isOpened():
+            raise RuntimeError(f"Could not open stream at {url}")
+
+    def read(self) -> Frame:
+        try:
+            return _read_and_resize(self._cap, self.cols, self.rows)
+        except RuntimeError:
+            raise RuntimeError(f"Stream returned no frame: {self.url}") from None
+
+    def close(self) -> None:
+        self._cap.release()

termcam/cli.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import argparse
+import sys
+
+from .engine import DEFAULT_STYLE, STYLES, _use_utf8, build_source, run
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="termcam",
+        description=(
+            "Live webcam → terminal art. Keystrokes: a/s/d/g/e/h/t/x styles, "
+            "m mirror, q quit."
+        ),
+    )
+    parser.add_argument(
+        "--source", choices=("camera", "synth", "url"), default="camera",
+        help="input source (default: camera)",
+    )
+    parser.add_argument(
+        "--style", choices=tuple(STYLES), default=DEFAULT_STYLE,
+        help=f"initial style (default: {DEFAULT_STYLE})",
+    )
+    parser.add_argument(
+        "--out",
+        choices=("terminal", "webcam", "window", "both"),
+        default="terminal",
+        help="where to show art: terminal, virtual camera (webcam), preview window, or both",
+    )
+    parser.add_argument(
+        "--backend",
+        choices=("auto", "obs", "unitycapture"),
+        default="auto",
+        help="virtual camera backend (default: auto)",
+    )
+    parser.add_argument(
+        "--webcam-size",
+        default="1280x720",
+        metavar="WxH",
+        help="virtual camera resolution (default: 1280x720)",
+    )
+    parser.add_argument("--fps", type=int, default=24, help="frames per second (default: 24)")
+    parser.add_argument("--device", type=int, default=0, help="camera device index (default: 0)")
+    parser.add_argument(
+        "--url", default="",
+        help="MJPEG stream URL for --source url (e.g. http://192.168.1.5:8080/video)",
+    )
+    parser.add_argument("--cols", type=int, default=0, help="horizontal cells (0 = auto-detect)")
+    parser.add_argument("--mirror", action="store_true", help="start mirrored")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    _use_utf8()
+    args = _build_parser().parse_args(argv)
+
+    if args.source == "url" and not args.url:
+        print("--source url requires --url http://<host>:<port>/video", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        width_s, height_s = args.webcam_size.lower().split("x", 1)
+        webcam_size = (int(width_s), int(height_s))
+    except (ValueError, IndexError):
+        print(f"Bad --webcam-size {args.webcam_size!r}; expected WxH like 1280x720", file=sys.stderr)
+        sys.exit(1)
+    if webcam_size[0] <= 0 or webcam_size[1] <= 0:
+        print("Bad --webcam-size; width and height must be positive", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        source = build_source(args.source, args.device, args.cols or 80, 40, args.url)
+    except RuntimeError as exc:
+        if args.source == "camera":
+            print(f"Camera unavailable ({exc}). Falling back to synth.", file=sys.stderr)
+            source = build_source("synth", 0, args.cols or 80, 40)
+        else:
+            print(f"{exc}. Try --source synth as a demo.", file=sys.stderr)
+            sys.exit(1)
+
+    print(
+        "a/s/d/g/e/h/t/x = styles, m = mirror, q = quit. Pressing a style key again cycles variants.",
+        file=sys.stderr,
+    )
+    try:
+        run(
+            source,
+            fps=args.fps,
+            initial_style=args.style,
+            mirror=args.mirror,
+            out=args.out,
+            webcam_size=webcam_size,
+            backend=args.backend,
+        )
+    except RuntimeError as exc:
+        print(str(exc), file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

termcam/colors.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+RGB = tuple[int, int, int]
+
+
+def luminance(r: int, g: int, b: int) -> float:
+    return (0.2126 * r + 0.7152 * g + 0.0722 * b) / 255.0
+
+
+def clamp(v: int) -> int:
+    return max(0, min(255, v))
+
+
+def to_ansi256(r: int, g: int, b: int) -> int:
+    r, g, b = clamp(r), clamp(g), clamp(b)
+    if r == g == b:
+        if r < 8:
+            return 16
+        if r > 248:
+            return 231
+        return round((r - 8) / 10) * 36 + 232
+    r_i = round(r / 51)
+    g_i = round(g / 51)
+    b_i = round(b / 51)
+    return 16 + 36 * r_i + 6 * g_i + b_i
+
+
+def lerp(a: RGB, b: RGB, t: float) -> RGB:
+    t = max(0.0, min(1.0, t))
+    return (
+        round(a[0] + (b[0] - a[0]) * t),
+        round(a[1] + (b[1] - a[1]) * t),
+        round(a[2] + (b[2] - a[2]) * t),
+    )
+
+
+NEON_STOPS = [
+    (12, 12, 60),
+    (0, 255, 255),
+    (255, 0, 255),
+    (255, 255, 0),
+    (255, 255, 255),
+]
+
+NEON_ALT_STOPS = [
+    (0, 0, 0),
+    (255, 0, 128),
+    (255, 140, 0),
+    (255, 255, 255),
+]
+
+
+def gradient(stops: list[RGB], t: float) -> RGB:
+    t = max(0.0, min(1.0, t))
+    if t >= 1.0:
+        return stops[-1]
+    scaled = t * (len(stops) - 1)
+    index = int(scaled)
+    return lerp(stops[index], stops[index + 1], scaled - index)

termcam/engine.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+import ctypes
+import os
+import sys
+import time
+
+from .camera import CameraSource, UrlSource
+from .keys import KeyReader, enable_raw_input, restore_terminal
+from .renderer import HIDE_CURSOR, HOME, SHOW_CURSOR, render
+from .sources import SynthSource
+from .styles import (
+    AsciiStyle,
+    DitherStyle,
+    GlitchStyle,
+    HalftoneStyle,
+    NegativeStyle,
+    NeonStyle,
+    SketchStyle,
+    Style,
+    ThermalStyle,
+)
+
+STYLES: dict[str, type[Style]] = {
+    "ascii": AsciiStyle,
+    "neon": NeonStyle,
+    "dither": DitherStyle,
+    "glitch": GlitchStyle,
+    "sketch": SketchStyle,
+    "halftone": HalftoneStyle,
+    "thermal": ThermalStyle,
+    "negative": NegativeStyle,
+}
+DEFAULT_STYLE = "ascii"
+
+KEY_MAP = {
+    "a": "ascii",
+    "s": "neon",
+    "d": "dither",
+    "g": "glitch",
+    "e": "sketch",
+    "h": "halftone",
+    "t": "thermal",
+    "x": "negative",
+}
+
+ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+
+
+def _enable_vt() -> None:
+    if os.name != "nt":
+        return
+    try:
+        kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+        handle = kernel32.GetStdHandle(-11)
+        mode = ctypes.c_uint32()
+        if kernel32.GetConsoleMode(handle, ctypes.byref(mode)):
+            kernel32.SetConsoleMode(handle, mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+    except OSError:
+        pass
+
+
+def _use_utf8() -> None:
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            try:
+                stream.reconfigure(encoding="utf-8", errors="replace")
+            except (OSError, ValueError):
+                pass
+
+
+def build_source(kind: str, device: int, cols: int, rows: int, url: str = ""):
+    if kind == "synth":
+        return SynthSource(cols, rows)
+    if kind == "url":
+        return UrlSource(url, cols, rows)
+    return CameraSource(device, cols, rows)
+
+
+def _resized(source, cols: int, rows: int):
+    if isinstance(source, SynthSource):
+        return SynthSource(cols, rows)
+    if isinstance(source, UrlSource):
+        return UrlSource(source.url, cols, rows)
+    return CameraSource(source.device, cols, rows)
+
+
+def run(
+    source,
+    fps: int = 24,
+    initial_style: str = DEFAULT_STYLE,
+    mirror: bool = False,
+    out: str = "terminal",
+    webcam_size: tuple[int, int] = (1280, 720),
+    backend: str | None = "auto",
+) -> None:
+    _use_utf8()
+    _enable_vt()
+
+    cam = None
+    _cv2 = None
+    if out in ("webcam", "both"):
+        from .webcam import VirtualCamera, rasterize
+
+        cam = VirtualCamera(webcam_size[0], webcam_size[1], fps, backend=backend)
+        try:
+            cam.open()
+        except RuntimeError as exc:
+            if out == "webcam":
+                raise
+            print(str(exc), file=sys.stderr)
+            print("Falling back to terminal output.", file=sys.stderr)
+            out = "terminal"
+            cam = None
+    elif out == "window":
+        try:
+            import cv2 as _cv2
+
+            from .webcam import rasterize
+
+            _cv2.namedWindow("termcam")
+            _cv2.destroyWindow("termcam")
+        except ImportError as exc:
+            raise RuntimeError("Window output needs OpenCV: pip install 'termcam'") from exc
+        except Exception as exc:
+            raise RuntimeError(
+                "OpenCV GUI is unavailable (a headless build is installed). "
+                "Reinstall with: pip install --force-reinstall opencv-python"
+            ) from exc
+
+    show_terminal = out in ("terminal", "both")
+    show_window = out == "window"
+    webcam_output = cam is not None
+
+    try:
+        cols, rows = os.get_terminal_size()
+    except (OSError, ValueError):
+        cols, rows = 80, 24
+    rows = max(2, int(rows) - 1)
+    if source.cols != cols or source.rows != rows:
+        source = _resized(source, cols, rows)
+
+    enable_raw_input()
+    keys = KeyReader()
+    keys.start()
+
+    style_key = initial_style if initial_style in STYLES else DEFAULT_STYLE
+    style = STYLES[style_key]()
+    variant = 0
+    flip = mirror
+
+    frame_interval = 1.0 / max(1, fps)
+    frame = None
+    sys.stdout.write(HIDE_CURSOR)
+    sys.stdout.flush()
+
+    try:
+        while True:
+            started = time.perf_counter()
+            frame = source.read()
+            if flip:
+                frame = frame.flip_h()
+            clock = time.perf_counter()
+            surface = style.process(frame, variant=variant, t=clock)
+            if webcam_output:
+                cam.send(rasterize(surface, webcam_size[0], webcam_size[1]))
+            if show_window:
+                _cv2.imshow("termcam", rasterize(surface, webcam_size[0], webcam_size[1]))
+                if _cv2.waitKey(1) & 0xFF == 27:
+                    break
+            if show_terminal:
+                sys.stdout.write(HOME)
+                sys.stdout.write(render(surface))
+                sys.stdout.flush()
+
+            key = keys.poll()
+            if key is not None:
+                key = key.lower()
+                if key in KEY_MAP:
+                    target = KEY_MAP[key]
+                    if target == style.name:
+                        variant = (variant + 1) % style.variants
+                    else:
+                        style = STYLES[target]()
+                        variant = 0
+                elif key == "m":
+                    flip = not flip
+                elif key in ("q", "\x1b"):
+                    break
+
+            elapsed = time.perf_counter() - started
+            remaining = frame_interval - elapsed
+            if remaining > 0:
+                time.sleep(remaining)
+    except (KeyboardInterrupt, RuntimeError, OSError):
+        pass
+    finally:
+        sys.stdout.write(SHOW_CURSOR + "\x1b[0m")
+        sys.stdout.flush()
+        if _cv2 is not None:
+            _cv2.destroyAllWindows()
+        if cam is not None:
+            cam.close()
+        close = getattr(source, "close", None)
+        if close is not None:
+            close()
+        restore_terminal()