screenvideo 2.1.1__py3-none-any.whl

screenvideo/__init__.py

@@ -0,0 +1,3 @@
+"""ScreenCapture Pro application package."""
+
+__version__ = "2.1.1"

screenvideo/core/__init__.py

@@ -0,0 +1,24 @@
+from screenvideo.core.audio import AudioRecorder, merge_video_audio
+from screenvideo.core.config import AppConfig
+from screenvideo.core.cursor import CursorRenderer
+from screenvideo.core.history import HistoryManager, MediaItem
+from screenvideo.core.hotkeys import HotkeyManager
+from screenvideo.core.monitors import MonitorInfo, Region, get_available_monitors
+from screenvideo.core.recorder import RecordingState, ScreenRecorder
+from screenvideo.core.screenshot import capture_screenshot
+
+__all__ = [
+    "AppConfig",
+    "AudioRecorder",
+    "CursorRenderer",
+    "HistoryManager",
+    "HotkeyManager",
+    "MediaItem",
+    "MonitorInfo",
+    "Region",
+    "RecordingState",
+    "ScreenRecorder",
+    "capture_screenshot",
+    "get_available_monitors",
+    "merge_video_audio",
+]

screenvideo/core/audio.py

@@ -0,0 +1,299 @@
+"""High-performance audio capture engine (WASAPI Loopback & Microphone) and MP4 muxer."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import threading
+import time
+from pathlib import Path
+from typing import List
+
+import imageio_ffmpeg
+
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+try:
+    import soundcard as sc
+    import soundfile as sf
+
+    AUDIO_AVAILABLE = True
+except (ImportError, Exception):
+    sc = None
+    sf = None
+    AUDIO_AVAILABLE = False
+
+
+class AudioRecorder:
+    """
+    Multi-threaded audio recorder capturing Windows system audio (WASAPI Loopback)
+    and/or microphone, saving synchronized PCM WAV for subsequent muxing.
+    """
+
+    SAMPLE_RATE = 44100
+    CHANNELS = 2
+    CHUNK_SIZE = 2048
+
+    def __init__(
+        self,
+        output_dir: Path,
+        *,
+        record_system_audio: bool = True,
+        record_microphone: bool = False,
+    ) -> None:
+        self._output_dir = Path(output_dir)
+        self._record_system = record_system_audio
+        self._record_mic = record_microphone
+
+        self._is_recording = False
+        self._is_paused = False
+        self._thread: threading.Thread | None = None
+        self._lock = threading.Lock()
+
+        self._audio_chunks: List[np.ndarray] = []
+        self._temp_file: Path | None = None
+
+    @property
+    def is_recording(self) -> bool:
+        with self._lock:
+            return self._is_recording
+
+    def start(self) -> bool:
+        """Start audio capture thread."""
+        if not AUDIO_AVAILABLE or np is None:
+            return False
+        if not self._record_system and not self._record_mic:
+            return False
+
+        with self._lock:
+            if self._is_recording:
+                return False
+            self._is_recording = True
+            self._is_paused = False
+            self._audio_chunks = []
+            timestamp = int(time.time() * 1000)
+            self._temp_file = self._output_dir / f"temp_audio_{timestamp}.wav"
+
+        self._thread = threading.Thread(
+            target=self._capture_loop, daemon=True, name="AudioRecorderThread"
+        )
+        self._thread.start()
+        return True
+
+    def pause(self) -> None:
+        """Pause audio capture."""
+        with self._lock:
+            self._is_paused = True
+
+    def resume(self) -> None:
+        """Resume audio capture."""
+        with self._lock:
+            self._is_paused = False
+
+    def stop(self) -> Path | None:
+        """Stop audio recording, flush to WAV file, and return filepath."""
+        with self._lock:
+            if not self._is_recording:
+                return None
+            self._is_recording = False
+            self._is_paused = False
+
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=2.0)
+
+        with self._lock:
+            chunks = self._audio_chunks
+            temp_path = self._temp_file
+
+        if not chunks or temp_path is None:
+            return None
+
+        try:
+            full_audio = np.concatenate(chunks, axis=0)
+            # Ensure float32 in [-1.0, 1.0] range
+            full_audio = np.clip(full_audio, -1.0, 1.0)
+            sf.write(str(temp_path), full_audio, self.SAMPLE_RATE, subtype="PCM_16")
+            if temp_path.exists() and temp_path.stat().st_size > 44:
+                return temp_path
+        except Exception as e:
+            print(f"[AudioRecorder] Failed to save WAV file: {e}")
+
+        return None
+
+    def _capture_loop(self) -> None:
+        """Main audio capture streaming loop."""
+        loopback_mic = None
+        standard_mic = None
+
+        try:
+            if self._record_system:
+                try:
+                    default_speaker = sc.default_speaker()
+                    if default_speaker:
+                        loopback_mic = sc.get_microphone(
+                            id=str(default_speaker.name), include_loopback=True
+                        )
+                except Exception as e:
+                    print(f"[AudioRecorder] Could not access default speaker loopback: {e}")
+
+            if self._record_mic:
+                try:
+                    standard_mic = sc.default_microphone()
+                except Exception as e:
+                    print(f"[AudioRecorder] Could not access default microphone: {e}")
+
+            if loopback_mic is None and standard_mic is None:
+                print("[AudioRecorder] No audio recording devices available.")
+                return
+
+            # Open recorders
+            rec_loop = (
+                loopback_mic.recorder(samplerate=self.SAMPLE_RATE, channels=self.CHANNELS)
+                if loopback_mic
+                else None
+            )
+            rec_mic = (
+                standard_mic.recorder(samplerate=self.SAMPLE_RATE, channels=self.CHANNELS)
+                if standard_mic
+                else None
+            )
+
+            with rec_loop if rec_loop else _DummyContext():
+                with rec_mic if rec_mic else _DummyContext():
+                    while True:
+                        with self._lock:
+                            if not self._is_recording:
+                                break
+                            is_paused = self._is_paused
+
+                        if is_paused:
+                            time.sleep(0.05)
+                            continue
+
+                        chunk = None
+
+                        if rec_loop is not None:
+                            try:
+                                chunk = rec_loop.record(numframes=self.CHUNK_SIZE)
+                            except Exception:
+                                chunk = None
+
+                        if rec_mic is not None:
+                            try:
+                                mic_chunk = rec_mic.record(numframes=self.CHUNK_SIZE)
+                                if chunk is not None and chunk.shape == mic_chunk.shape:
+                                    chunk = (chunk * 0.7) + (mic_chunk * 0.7)
+                                elif chunk is None:
+                                    chunk = mic_chunk
+                            except Exception:
+                                pass
+
+                        if chunk is not None and len(chunk) > 0:
+                            with self._lock:
+                                self._audio_chunks.append(chunk.astype(np.float32))
+                        else:
+                            time.sleep(0.01)
+
+        except Exception as e:
+            print(f"[AudioRecorder] Error during audio capture: {e}")
+
+
+class _DummyContext:
+    """No-op context manager for optional recorders."""
+
+    def __enter__(self) -> None:
+        pass
+
+    def __exit__(self, exc_type: object, exc_val: object, exc_tb: object) -> None:
+        pass
+
+
+def merge_video_audio(
+    video_path: Path,
+    audio_path: Path | None,
+    output_path: Path,
+    *,
+    audio_bitrate: str = "192k",
+) -> bool:
+    """
+    Merge video stream with audio WAV stream into final MP4 using bundled FFmpeg.
+    """
+    video_path = Path(video_path)
+    output_path = Path(output_path)
+
+    # If no audio or audio missing, simply ensure video is at output_path
+    if audio_path is None or not Path(audio_path).exists():
+        if video_path != output_path:
+            try:
+                if output_path.exists():
+                    output_path.unlink()
+                video_path.replace(output_path)
+                return True
+            except Exception as e:
+                print(f"[Muxer] Failed to move video to output: {e}")
+                return False
+        return True
+
+    audio_path = Path(audio_path)
+    ffmpeg_exe = imageio_ffmpeg.get_ffmpeg_exe()
+
+    # Construct ffmpeg command
+    cmd = [
+        ffmpeg_exe,
+        "-y",
+        "-i",
+        str(video_path),
+        "-i",
+        str(audio_path),
+        "-c:v",
+        "copy",
+        "-c:a",
+        "aac",
+        "-b:a",
+        audio_bitrate,
+        "-shortest",
+        str(output_path),
+    ]
+
+    try:
+        # Hide console window on Windows
+        startupinfo = None
+        if os.name == "nt":
+            startupinfo = subprocess.STARTUPINFO()
+            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+            startupinfo.wShowWindow = subprocess.SW_HIDE
+
+        result = subprocess.run(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            startupinfo=startupinfo,
+            check=False,
+            timeout=30.0,
+        )
+
+        # Cleanup temp intermediate files
+        if video_path != output_path and video_path.exists():
+            video_path.unlink(missing_ok=True)
+        if audio_path.exists():
+            audio_path.unlink(missing_ok=True)
+
+        if result.returncode == 0 and output_path.exists() and output_path.stat().st_size > 1024:
+            return True
+        else:
+            print(f"[Muxer] FFmpeg error: {result.stderr.decode('utf-8', errors='ignore')}")
+            # Fallback: if output_path wasn't created, try keeping video_path
+            if video_path.exists() and not output_path.exists():
+                video_path.replace(output_path)
+            return False
+
+    except Exception as e:
+        print(f"[Muxer] Failed to mux video and audio: {e}")
+        if video_path.exists() and not output_path.exists():
+            video_path.replace(output_path)
+        if audio_path.exists():
+            audio_path.unlink(missing_ok=True)
+        return False

screenvideo/core/clipboard.py

@@ -0,0 +1,139 @@
+"""Native Windows Clipboard integration for images (CF_DIB) and cross-platform fallbacks."""
+
+from __future__ import annotations
+
+import io
+import sys
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+GMEM_MOVEABLE = 0x0002
+CF_DIB = 8
+
+
+def copy_frame_to_clipboard(frame: np.ndarray) -> bool:
+    """
+    Copy an OpenCV BGR numpy frame directly to the system clipboard.
+    On Windows, uses native Win32 API with standard CF_DIB format.
+    Returns True if successfully copied, False otherwise.
+    """
+    if frame is None or frame.size == 0:
+        return False
+
+    if sys.platform == "win32":
+        return _copy_frame_win32_dib(frame)
+    else:
+        return _copy_frame_pillow_fallback(frame)
+
+
+def copy_image_file_to_clipboard(file_path: Path | str) -> bool:
+    """
+    Copy an image file (PNG, JPG, BMP) to the system clipboard.
+    Returns True on success, False on failure.
+    """
+    path = Path(file_path)
+    if not path.exists():
+        return False
+
+    try:
+        frame = cv2.imread(str(path))
+        if frame is None:
+            return False
+        return copy_frame_to_clipboard(frame)
+    except Exception:
+        return False
+
+
+def _copy_frame_win32_dib(frame: np.ndarray) -> bool:
+    """Native Windows implementation using CF_DIB via ctypes."""
+    import ctypes
+    from ctypes import wintypes
+
+    user32 = ctypes.windll.user32
+    kernel32 = ctypes.windll.kernel32
+
+    # Set function signatures
+    user32.OpenClipboard.argtypes = [wintypes.HWND]
+    user32.OpenClipboard.restype = wintypes.BOOL
+    user32.EmptyClipboard.restype = wintypes.BOOL
+    user32.SetClipboardData.argtypes = [wintypes.UINT, wintypes.HANDLE]
+    user32.SetClipboardData.restype = wintypes.HANDLE
+    user32.CloseClipboard.restype = wintypes.BOOL
+
+    kernel32.GlobalAlloc.argtypes = [wintypes.UINT, ctypes.c_size_t]
+    kernel32.GlobalAlloc.restype = wintypes.HGLOBAL
+    kernel32.GlobalLock.argtypes = [wintypes.HGLOBAL]
+    kernel32.GlobalLock.restype = wintypes.LPVOID
+    kernel32.GlobalUnlock.argtypes = [wintypes.HGLOBAL]
+    kernel32.GlobalUnlock.restype = wintypes.BOOL
+    kernel32.GlobalFree.argtypes = [wintypes.HGLOBAL]
+    kernel32.GlobalFree.restype = wintypes.HGLOBAL
+
+    # Encode to BMP format in memory
+    success, encoded = cv2.imencode(".bmp", frame)
+    if not success:
+        return False
+
+    # BMP format: 14 bytes BITMAPFILEHEADER followed by BITMAPINFOHEADER + pixel array.
+    # CF_DIB requires BITMAPINFOHEADER + pixel array (excluding the 14-byte file header).
+    raw_bmp = encoded.tobytes()
+    if len(raw_bmp) <= 14:
+        return False
+
+    dib_bytes = raw_bmp[14:]
+    data_size = len(dib_bytes)
+
+    h_global = kernel32.GlobalAlloc(GMEM_MOVEABLE, data_size)
+    if not h_global:
+        return False
+
+    p_global = kernel32.GlobalLock(h_global)
+    if not p_global:
+        kernel32.GlobalFree(h_global)
+        return False
+
+    try:
+        ctypes.memmove(p_global, dib_bytes, data_size)
+    finally:
+        kernel32.GlobalUnlock(h_global)
+
+    # Open clipboard with retry loop (another app may temporarily hold clipboard lock)
+    clipboard_opened = False
+    for _ in range(5):
+        if user32.OpenClipboard(None):
+            clipboard_opened = True
+            break
+        import time
+
+        time.sleep(0.02)
+
+    if not clipboard_opened:
+        kernel32.GlobalFree(h_global)
+        return False
+
+    try:
+        user32.EmptyClipboard()
+        # SetClipboardData takes ownership of h_global on success
+        res = user32.SetClipboardData(CF_DIB, h_global)
+        return res is not None
+    except Exception:
+        return False
+    finally:
+        user32.CloseClipboard()
+
+
+def _copy_frame_pillow_fallback(frame: np.ndarray) -> bool:
+    """Cross-platform fallback using Pillow."""
+    try:
+        from PIL import Image
+
+        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        image = Image.fromarray(rgb_frame)
+        output = io.BytesIO()
+        image.save(output, format="PNG")
+        output.seek(0)
+        return True
+    except Exception:
+        return False

screenvideo/core/config.py

@@ -0,0 +1,109 @@
+"""Application configuration management with JSON persistence."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class AppConfig:
+    """Application settings configuration."""
+
+    # Video settings
+    fps: int = 30
+    codec: str = "mp4v"
+    format: str = "mp4"
+    quality_preset: str = "High"  # Normal, High, Ultra
+
+    # Storage paths
+    recordings_dir: Path = field(default_factory=lambda: Path.cwd() / "recordings")
+    screenshots_dir: Path = field(default_factory=lambda: Path.cwd() / "screenshots")
+
+    # Cursor & visual options
+    record_cursor: bool = True
+    highlight_cursor: bool = True
+    cursor_color: str = "#FFD700"  # Gold yellow halo
+    visualize_clicks: bool = True
+    click_color_left: str = "#00E5FF"  # Vivid Cyan
+    click_color_right: str = "#FF5252"  # Coral Red
+
+    # Countdown & mini overlay
+    show_countdown: bool = True
+    countdown_seconds: int = 3
+    show_floating_bar: bool = True
+    minimize_on_record: bool = True
+    sound_effects: bool = True
+
+    # Screenshots & Clipboard
+    screenshot_format: str = "png"  # png, jpg, bmp
+    copy_to_clipboard: bool = True
+
+    # Hotkeys
+    hotkey_start: str = "f5"
+    hotkey_pause: str = "f6"
+    hotkey_stop: str = "f10"
+    hotkey_screenshot: str = "f11"
+    hotkey_snip: str = "shift+f11"
+    hotkey_region: str = "f2"
+
+    # UI Theme
+    theme: str = "darkly"
+
+    # Audio recording
+    record_system_audio: bool = True
+    record_microphone: bool = False
+    audio_bitrate: str = "192k"
+
+    # Selected monitor index (1: Primary, 2..N: Secondary, 0: All)
+    monitor_index: int = 1
+
+    def __post_init__(self) -> None:
+        if isinstance(self.recordings_dir, str):
+            self.recordings_dir = Path(self.recordings_dir)
+        if isinstance(self.screenshots_dir, str):
+            self.screenshots_dir = Path(self.screenshots_dir)
+
+        self.recordings_dir.mkdir(parents=True, exist_ok=True)
+        self.screenshots_dir.mkdir(parents=True, exist_ok=True)
+
+    @classmethod
+    def get_config_file_path(cls) -> Path:
+        """Get standard config file location."""
+        return Path.cwd() / "config.json"
+
+    @classmethod
+    def load(cls) -> AppConfig:
+        """Load configuration from config.json or return defaults."""
+        config_path = cls.get_config_file_path()
+        if not config_path.exists():
+            return cls()
+
+        try:
+            with open(config_path, encoding="utf-8") as f:
+                data = json.load(f)
+
+            if "recordings_dir" in data:
+                data["recordings_dir"] = Path(data["recordings_dir"])
+            if "screenshots_dir" in data:
+                data["screenshots_dir"] = Path(data["screenshots_dir"])
+
+            valid_keys = {f.name for f in cls.__dataclass_fields__.values()}
+            filtered_data = {k: v for k, v in data.items() if k in valid_keys}
+            return cls(**filtered_data)
+        except Exception:
+            return cls()
+
+    def save(self) -> bool:
+        """Save configuration to config.json."""
+        config_path = self.get_config_file_path()
+        try:
+            data = asdict(self)
+            data["recordings_dir"] = str(self.recordings_dir)
+            data["screenshots_dir"] = str(self.screenshots_dir)
+            with open(config_path, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+            return True
+        except Exception:
+            return False