wafle-video-processor 0.1.0__tar.gz

wafle_video_processor-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: wafle-video-processor
+Version: 0.1.0
+Summary: WAFLE automatic watermark removal from videos via FFmpeg delogo. CPU-only, no GPU needed, faster than real-time.
+Author: WAFLE
+License: MIT
+Project-URL: Homepage, https://github.com/creandoaldia/web-ai-lab
+Project-URL: Documentation, https://github.com/creandoaldia/web-ai-lab#readme
+Keywords: wafle,watermark,delogo,ffmpeg,video-processing,meta-ai
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# wafle-video-processor
+
+Automatic watermark removal from videos via FFmpeg `delogo` filter.
+
+**Purpose**: Remove Meta AI / Facebook watermarks from downloaded videos.
+**Target**: Semi-transparent "Meta AI" logo, static bottom-right position.
+**Requirement**: No GPU — runs on CPU, faster than real-time.
+
+## Install
+
+```bash
+pip install wafle-video-processor
+```
+
+Requires FFmpeg in PATH:
+
+```bash
+winget install FFmpeg
+# or: https://ffmpeg.org/download.html
+```
+
+## CLI Usage
+
+```bash
+# Single file (in-place)
+wafle-video-processor remove video.mp4
+
+# Single file (new file)
+wafle-video-processor remove video.mp4 -o clean.mp4
+
+# Batch directory
+wafle-video-processor batch ./videos/ -o ./cleaned/
+
+# Custom watermark position/size
+wafle-video-processor remove video.mp4 --position bottom-right --width-pct 8 --height-pct 4
+```
+
+## Python API
+
+```python
+from waflevideoprocessor import remove_watermark, has_ffmpeg
+
+if not has_ffmpeg():
+    print("Install FFmpeg first")
+
+result = remove_watermark("video.mp4", output_path="clean.mp4")
+print(result["success"])  # True/False
+```
+
+## Integration
+
+Automatically called by `wafle-automations-meta` after each video download
+when `wafle-video-processor` is installed.
+
+## Meta AI Watermark
+
+- Semi-transparent "Meta AI" logo
+- Bottom-right corner
+- ~10% width × ~5% height
+- Static position across all free-tier videos

wafle_video_processor-0.1.0/README.md

@@ -0,0 +1,60 @@
+# wafle-video-processor
+
+Automatic watermark removal from videos via FFmpeg `delogo` filter.
+
+**Purpose**: Remove Meta AI / Facebook watermarks from downloaded videos.
+**Target**: Semi-transparent "Meta AI" logo, static bottom-right position.
+**Requirement**: No GPU — runs on CPU, faster than real-time.
+
+## Install
+
+```bash
+pip install wafle-video-processor
+```
+
+Requires FFmpeg in PATH:
+
+```bash
+winget install FFmpeg
+# or: https://ffmpeg.org/download.html
+```
+
+## CLI Usage
+
+```bash
+# Single file (in-place)
+wafle-video-processor remove video.mp4
+
+# Single file (new file)
+wafle-video-processor remove video.mp4 -o clean.mp4
+
+# Batch directory
+wafle-video-processor batch ./videos/ -o ./cleaned/
+
+# Custom watermark position/size
+wafle-video-processor remove video.mp4 --position bottom-right --width-pct 8 --height-pct 4
+```
+
+## Python API
+
+```python
+from waflevideoprocessor import remove_watermark, has_ffmpeg
+
+if not has_ffmpeg():
+    print("Install FFmpeg first")
+
+result = remove_watermark("video.mp4", output_path="clean.mp4")
+print(result["success"])  # True/False
+```
+
+## Integration
+
+Automatically called by `wafle-automations-meta` after each video download
+when `wafle-video-processor` is installed.
+
+## Meta AI Watermark
+
+- Semi-transparent "Meta AI" logo
+- Bottom-right corner
+- ~10% width × ~5% height
+- Static position across all free-tier videos

wafle_video_processor-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wafle-video-processor"
+version = "0.1.0"
+description = "WAFLE automatic watermark removal from videos via FFmpeg delogo. CPU-only, no GPU needed, faster than real-time."
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "WAFLE"}]
+requires-python = ">=3.10"
+keywords = ["wafle", "watermark", "delogo", "ffmpeg", "video-processing", "meta-ai"]
+
+[project.urls]
+Homepage = "https://github.com/creandoaldia/web-ai-lab"
+Documentation = "https://github.com/creandoaldia/web-ai-lab#readme"
+
+[project.scripts]
+wafle-video-processor = "waflevideoprocessor.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["waflevideoprocessor*"]

wafle_video_processor-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

wafle_video_processor-0.1.0/src/wafle_video_processor.egg-info/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: wafle-video-processor
+Version: 0.1.0
+Summary: WAFLE automatic watermark removal from videos via FFmpeg delogo. CPU-only, no GPU needed, faster than real-time.
+Author: WAFLE
+License: MIT
+Project-URL: Homepage, https://github.com/creandoaldia/web-ai-lab
+Project-URL: Documentation, https://github.com/creandoaldia/web-ai-lab#readme
+Keywords: wafle,watermark,delogo,ffmpeg,video-processing,meta-ai
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# wafle-video-processor
+
+Automatic watermark removal from videos via FFmpeg `delogo` filter.
+
+**Purpose**: Remove Meta AI / Facebook watermarks from downloaded videos.
+**Target**: Semi-transparent "Meta AI" logo, static bottom-right position.
+**Requirement**: No GPU — runs on CPU, faster than real-time.
+
+## Install
+
+```bash
+pip install wafle-video-processor
+```
+
+Requires FFmpeg in PATH:
+
+```bash
+winget install FFmpeg
+# or: https://ffmpeg.org/download.html
+```
+
+## CLI Usage
+
+```bash
+# Single file (in-place)
+wafle-video-processor remove video.mp4
+
+# Single file (new file)
+wafle-video-processor remove video.mp4 -o clean.mp4
+
+# Batch directory
+wafle-video-processor batch ./videos/ -o ./cleaned/
+
+# Custom watermark position/size
+wafle-video-processor remove video.mp4 --position bottom-right --width-pct 8 --height-pct 4
+```
+
+## Python API
+
+```python
+from waflevideoprocessor import remove_watermark, has_ffmpeg
+
+if not has_ffmpeg():
+    print("Install FFmpeg first")
+
+result = remove_watermark("video.mp4", output_path="clean.mp4")
+print(result["success"])  # True/False
+```
+
+## Integration
+
+Automatically called by `wafle-automations-meta` after each video download
+when `wafle-video-processor` is installed.
+
+## Meta AI Watermark
+
+- Semi-transparent "Meta AI" logo
+- Bottom-right corner
+- ~10% width × ~5% height
+- Static position across all free-tier videos

wafle_video_processor-0.1.0/src/wafle_video_processor.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/wafle_video_processor.egg-info/PKG-INFO
+src/wafle_video_processor.egg-info/SOURCES.txt
+src/wafle_video_processor.egg-info/dependency_links.txt
+src/wafle_video_processor.egg-info/entry_points.txt
+src/wafle_video_processor.egg-info/top_level.txt
+src/waflevideoprocessor/__init__.py
+src/waflevideoprocessor/__main__.py
+src/waflevideoprocessor/cli.py
+src/waflevideoprocessor/processor.py

wafle_video_processor-0.1.0/src/wafle_video_processor.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

wafle_video_processor-0.1.0/src/wafle_video_processor.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+wafle-video-processor = waflevideoprocessor.cli:main

wafle_video_processor-0.1.0/src/wafle_video_processor.egg-info/top_level.txt

@@ -0,0 +1 @@
+waflevideoprocessor

wafle_video_processor-0.1.0/src/waflevideoprocessor/__init__.py

@@ -0,0 +1,12 @@
+"""WAFLE Video Processor — automatic watermark removal via FFmpeg delogo.
+
+Removes Meta AI / Facebook watermarks from downloaded videos using
+FFmpeg's delogo filter. CPU-only, no GPU required, faster than real-time.
+
+Meta watermark: semi-transparent, static position bottom-right.
+"""
+
+__version__ = "0.1.0"
+__description__ = "WAFLE automatic watermark removal via FFmpeg delogo"
+
+from .processor import remove_watermark, stream_remove_watermark, batch_remove_watermarks, has_ffmpeg, WatermarkPosition

wafle_video_processor-0.1.0/src/waflevideoprocessor/__main__.py

@@ -0,0 +1,5 @@
+"""Entry point for `python -m waflevideoprocessor`."""
+import sys
+from .cli import main
+
+sys.exit(main())

wafle_video_processor-0.1.0/src/waflevideoprocessor/cli.py

@@ -0,0 +1,165 @@
+"""CLI interface for wafle-video-processor."""
+
+import sys
+import argparse
+import logging
+from pathlib import Path
+from . import __version__, __description__
+from .processor import (
+    remove_watermark,
+    stream_remove_watermark,
+    batch_remove_watermarks,
+    has_ffmpeg,
+    WatermarkPosition,
+)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="wafle-video-processor",
+        description=__description__,
+    )
+    parser.add_argument("--version", action="version", version=__version__)
+
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    # Single file
+    single = sub.add_parser("remove", help="Remove watermark from a single video")
+    single.add_argument("input", help="Input video file")
+    single.add_argument("-o", "--output", help="Output video file (default: overwrite input)")
+    single.add_argument(
+        "--position", choices=[p.value for p in WatermarkPosition],
+        default="bottom-right", help="Watermark position (default: bottom-right)",
+    )
+    single.add_argument("--width-pct", type=float, default=10,
+                        help="Logo width as %% of video width (default: 10)")
+    single.add_argument("--height-pct", type=float, default=5,
+                        help="Logo height as %% of video height (default: 5)")
+    single.add_argument("--margin-pct", type=float, default=2,
+                        help="Margin as %% of shortest side (default: 2)")
+    single.add_argument("--overwrite", action="store_true", help="Overwrite output if exists")
+    single.add_argument("--verbose", action="store_true", help="Verbose FFmpeg output")
+
+    # Stream from URL
+    stream = sub.add_parser("stream", help="Download from URL and remove watermark in a single streaming pass")
+    stream.add_argument("url", help="Video URL to download and process")
+    stream.add_argument("-o", "--output", required=True, help="Output video file path")
+    stream.add_argument("--width", type=int, default=1920, help="Video width in pixels (default: 1920)")
+    stream.add_argument("--height", type=int, default=1080, help="Video height in pixels (default: 1080)")
+    stream.add_argument("--position", choices=[p.value for p in WatermarkPosition],
+                        default="bottom-right")
+    stream.add_argument("--width-pct", type=float, default=10)
+    stream.add_argument("--height-pct", type=float, default=5)
+    stream.add_argument("--margin-pct", type=float, default=2)
+    stream.add_argument("--overwrite", action="store_true")
+    stream.add_argument("--verbose", action="store_true")
+
+    # Batch directory
+    batch = sub.add_parser("batch", help="Remove watermarks from all videos in a directory")
+    batch.add_argument("input_dir", help="Directory with video files")
+    batch.add_argument("-o", "--output-dir", help="Output directory (default: in-place)")
+    batch.add_argument("--pattern", default="*.mp4",
+                       help="Glob pattern for video files (default: *.mp4)")
+    batch.add_argument("--position", choices=[p.value for p in WatermarkPosition],
+                       default="bottom-right")
+    batch.add_argument("--width-pct", type=float, default=10)
+    batch.add_argument("--height-pct", type=float, default=5)
+    batch.add_argument("--margin-pct", type=float, default=2)
+    batch.add_argument("--overwrite", action="store_true")
+    batch.add_argument("--verbose", action="store_true")
+
+    return parser
+
+
+def main(argv: list = None) -> int:
+    if argv is None:
+        argv = sys.argv[1:]
+
+    # Always allow --help and --version without ffmpeg
+    if argv and argv[0] in ("--help", "-h", "--version"):
+        parser = build_parser()
+        args = parser.parse_args(argv)
+        return 0
+
+    if not has_ffmpeg():
+        print("ERROR: FFmpeg not found in PATH.", file=sys.stderr)
+        print("Install it with:  winget install FFmpeg", file=sys.stderr)
+        print("Or download from: https://ffmpeg.org/download.html", file=sys.stderr)
+        return 1
+
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    log_level = logging.INFO if args.verbose else logging.WARNING
+    logging.basicConfig(level=log_level, format="%(levelname)s: %(message)s")
+
+    position = WatermarkPosition(args.position)
+    verbosity = "info" if args.verbose else "error"
+
+    if args.command == "stream":
+        result = stream_remove_watermark(
+            args.url, args.output,
+            position=position,
+            width_pct=args.width_pct,
+            height_pct=args.height_pct,
+            margin_pct=args.margin_pct,
+            width=args.width,
+            height=args.height,
+            overwrite=args.overwrite,
+            verbosity=verbosity,
+        )
+        if result["success"]:
+            print(f"OK: {result['output_path']}")
+            print(f"  delogo: x={result['delogo_params']['x']} "
+                  f"y={result['delogo_params']['y']} "
+                  f"w={result['delogo_params']['w']} "
+                  f"h={result['delogo_params']['h']}")
+            print(f"  bytes: {result.get('bytes_processed', '?')}")
+            return 0
+        else:
+            print(f"ERROR: {result.get('error', 'Unknown error')}", file=sys.stderr)
+            return 1
+
+    elif args.command == "remove":
+        result = remove_watermark(
+            args.input, args.output,
+            position=position,
+            width_pct=args.width_pct,
+            height_pct=args.height_pct,
+            margin_pct=args.margin_pct,
+            overwrite=args.overwrite,
+            verbosity=verbosity,
+        )
+        if result["success"]:
+            print(f"OK: {result['output_path']}")
+            print(f"  delogo: x={result['delogo_params']['x']} "
+                  f"y={result['delogo_params']['y']} "
+                  f"w={result['delogo_params']['w']} "
+                  f"h={result['delogo_params']['h']}")
+            return 0
+        else:
+            print(f"ERROR: {result.get('error', 'Unknown error')}", file=sys.stderr)
+            return 1
+
+    elif args.command == "batch":
+        results = batch_remove_watermarks(
+            args.input_dir, args.output_dir, args.pattern,
+            position=position,
+            width_pct=args.width_pct,
+            height_pct=args.height_pct,
+            margin_pct=args.margin_pct,
+            overwrite=args.overwrite,
+            verbosity=verbosity,
+        )
+        success = sum(1 for r in results if r.get("success"))
+        failed = [r for r in results if not r.get("success")]
+        print(f"Processed: {success} OK, {len(failed)} failed")
+        for f in failed:
+            print(f"  FAIL: {f.get('input_path', '?')} — {f.get('error', '')}")
+        return 1 if failed else 0
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

wafle_video_processor-0.1.0/src/waflevideoprocessor/processor.py

@@ -0,0 +1,347 @@
+"""Core FFmpeg delogo logic for automatic watermark removal.
+
+Meta AI watermark characteristics:
+  - Semi-transparent "Meta AI" logo
+  - Static position: bottom-right corner
+  - Size: approximately 10% width x 5% height
+  - Constant across all generated videos (free tier)
+
+No GPU needed — FFmpeg delogo is CPU-only, faster than real-time.
+"""
+
+import io
+import json
+import logging
+import subprocess
+import shutil
+from enum import Enum
+from pathlib import Path
+from typing import Optional, List, Union, Callable
+
+logger = logging.getLogger("wafle-video-processor")
+
+
+class WatermarkPosition(Enum):
+    BOTTOM_RIGHT = "bottom-right"
+    BOTTOM_LEFT = "bottom-left"
+    TOP_RIGHT = "top-right"
+    TOP_LEFT = "top-left"
+    CUSTOM = "custom"
+
+
+# Default Meta AI watermark parameters (bottom-right, 10% width × 5% height)
+DEFAULT_META_WATERMARK = {
+    "position": WatermarkPosition.BOTTOM_RIGHT,
+    "width_pct": 10,
+    "height_pct": 5,
+    "margin_pct": 2,
+}
+
+
+def has_ffmpeg() -> bool:
+    """Check if ffmpeg is available in PATH."""
+    return shutil.which("ffmpeg") is not None
+
+
+def _compute_delogo_params(
+    video_path: Path,
+    position: WatermarkPosition,
+    width_pct: float,
+    height_pct: float,
+    margin_pct: float,
+) -> dict:
+    """Use ffprobe to get video dimensions and compute delogo coordinates.
+
+    Meta AI videos are typically 1080p or 720p.
+    delogo filter syntax: delogo=x:y:w:h
+    """
+    ffprobe = shutil.which("ffprobe") or str(Path(shutil.which("ffmpeg")).parent / "ffprobe")
+    try:
+        result = subprocess.run(
+            [ffprobe, "-v", "quiet", "-print_format", "json", "-show_streams",
+             str(video_path)],
+            capture_output=True, text=True, timeout=30,
+        )
+        data = json.loads(result.stdout)
+        width, height = 0, 0
+        for stream in data.get("streams", []):
+            if stream.get("codec_type") == "video":
+                width = stream.get("width", 0)
+                height = stream.get("height", 0)
+                break
+        if not width or not height:
+            raise ValueError(f"Could not detect video dimensions for {video_path}")
+    except Exception as e:
+        logger.warning(f"ffprobe failed, falling back to 1920x1080: {e}")
+        width, height = 1920, 1080
+
+    logo_w = max(int(width * width_pct / 100), 20)
+    logo_h = max(int(height * height_pct / 100), 10)
+    margin = max(int(min(width, height) * margin_pct / 100), 5)
+
+    positions = {
+        WatermarkPosition.BOTTOM_RIGHT: (width - logo_w - margin, height - logo_h - margin),
+        WatermarkPosition.BOTTOM_LEFT: (margin, height - logo_h - margin),
+        WatermarkPosition.TOP_RIGHT: (width - logo_w - margin, margin),
+        WatermarkPosition.TOP_LEFT: (margin, margin),
+    }
+
+    if position == WatermarkPosition.CUSTOM:
+        raise ValueError("Use custom_x and custom_y for WatermarkPosition.CUSTOM")
+
+    x, y = positions[position]
+    return {"x": x, "y": y, "w": logo_w, "h": logo_h, "width": width, "height": height}
+
+
+def remove_watermark(
+    input_path: Union[str, Path],
+    output_path: Optional[Union[str, Path]] = None,
+    position: WatermarkPosition = WatermarkPosition.BOTTOM_RIGHT,
+    width_pct: float = 10,
+    height_pct: float = 5,
+    margin_pct: float = 2,
+    overwrite: bool = False,
+    verbosity: str = "error",
+) -> dict:
+    """Remove watermark from video using FFmpeg delogo filter.
+
+    Args:
+        input_path: Path to input video file.
+        output_path: Output path. If None, overwrites input (in-place).
+        position: Watermark position (default: BOTTOM_RIGHT).
+        width_pct: Logo width as percentage of video width (default: 10).
+        height_pct: Logo height as percentage of video height (default: 5).
+        margin_pct: Margin as percentage of shortest side (default: 2).
+        overwrite: Overwrite output file if exists (default: False).
+        verbosity: FFmpeg log level: "error", "warning", "info", "quiet" (default: "error").
+
+    Returns:
+        dict with keys: success, input_path, output_path, delogo_params, ffmpeg_cmd
+    """
+    if not has_ffmpeg():
+        return {"success": False, "error": "FFmpeg not found in PATH. Install it first: winget install FFmpeg"}
+    ffmpeg = shutil.which("ffmpeg")
+    input_path = Path(input_path)
+
+    if not input_path.exists():
+        return {"success": False, "error": f"Input file not found: {input_path}"}
+
+    # If no output path, create a temp file then replace input
+    in_place = output_path is None
+    if in_place:
+        temp_output = input_path.with_suffix(f".clean{input_path.suffix}")
+        out_path = temp_output
+    else:
+        out_path = Path(output_path)
+
+    if out_path.exists() and not overwrite:
+        return {"success": False, "error": f"Output exists and overwrite=False: {out_path}"}
+
+    params = _compute_delogo_params(input_path, position, width_pct, height_pct, margin_pct)
+    delogo_expr = f"delogo=x={params['x']}:y={params['y']}:w={params['w']}:h={params['h']}"
+
+    cmd = [
+        ffmpeg, "-y" if overwrite else "-n",
+        "-i", str(input_path),
+        "-vf", delogo_expr,
+        "-c:a", "copy",
+        "-progress", "pipe:1",
+        "-v", verbosity,
+        str(out_path),
+    ]
+
+    logger.info(f"Running: {' '.join(cmd)}")
+    logger.info(f"delogo region: x={params['x']}, y={params['y']}, w={params['w']}, h={params['h']}")
+
+    try:
+        process = subprocess.run(
+            cmd, capture_output=True, text=True, timeout=600,
+        )
+        if process.returncode != 0:
+            return {
+                "success": False,
+                "error": f"FFmpeg exited with code {process.returncode}",
+                "stderr": process.stderr[-500:],
+                "input_path": str(input_path),
+            }
+
+        # If in-place, replace original with clean version
+        if in_place:
+            input_path.unlink()
+            temp_output.rename(input_path)
+            out_path = input_path
+
+        return {
+            "success": True,
+            "input_path": str(input_path),
+            "output_path": str(out_path),
+            "delogo_params": params,
+            "ffmpeg_cmd": " ".join(cmd),
+        }
+    except subprocess.TimeoutExpired:
+        return {"success": False, "error": "FFmpeg timed out (>10min)"}
+    except Exception as e:
+        return {"success": False, "error": str(e), "input_path": str(input_path)}
+
+
+def stream_remove_watermark(
+    video_url: str,
+    output_path: Union[str, Path],
+    downloader: Optional[Callable] = None,
+    position: WatermarkPosition = WatermarkPosition.BOTTOM_RIGHT,
+    width_pct: float = 10,
+    height_pct: float = 5,
+    margin_pct: float = 2,
+    width: int = 1920,
+    height: int = 1080,
+    overwrite: bool = False,
+    verbosity: str = "error",
+) -> dict:
+    """Download video from URL and remove watermark in a single streaming pass.
+
+    Watermarked data is piped through FFmpeg delogo in-memory — the
+    watermarked version NEVER touches disk. Only the clean file is saved.
+
+    Args:
+        video_url: URL of the video to download and process.
+        output_path: Where to save the clean video.
+        downloader: Optional callable that returns a file-like iterator of bytes.
+                    If None, uses requests.get(video_url, stream=True).
+        position: Watermark position (default: BOTTOM_RIGHT).
+        width_pct: Logo width as percentage of video width (default: 10).
+        height_pct: Logo height as percentage of video height (default: 5).
+        margin_pct: Margin as percentage of shortest side (default: 2).
+        width: Video width in pixels (default: 1920). Used when ffprobe can't probe the stream.
+        height: Video height in pixels (default: 1080).
+        overwrite: Overwrite output if exists (default: False).
+        verbosity: FFmpeg log level (default: "error").
+
+    Returns:
+        dict with keys: success, output_path, delogo_params, ffmpeg_cmd
+    """
+    if not has_ffmpeg():
+        return {"success": False, "error": "FFmpeg not found in PATH. Install it first: winget install FFmpeg"}
+    ffmpeg = shutil.which("ffmpeg")
+    output_path = Path(output_path)
+
+    if output_path.exists() and not overwrite:
+        return {"success": False, "error": f"Output exists and overwrite=False: {output_path}"}
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Compute delogo params using default or provided dimensions
+    logo_w = max(int(width * width_pct / 100), 20)
+    logo_h = max(int(height * height_pct / 100), 10)
+    margin = max(int(min(width, height) * margin_pct / 100), 5)
+
+    positions = {
+        WatermarkPosition.BOTTOM_RIGHT: (width - logo_w - margin, height - logo_h - margin),
+        WatermarkPosition.BOTTOM_LEFT: (margin, height - logo_h - margin),
+        WatermarkPosition.TOP_RIGHT: (width - logo_w - margin, margin),
+        WatermarkPosition.TOP_LEFT: (margin, margin),
+    }
+    if position == WatermarkPosition.CUSTOM:
+        raise ValueError("Use custom_x and custom_y for WatermarkPosition.CUSTOM")
+
+    x, y = positions[position]
+    params = {"x": x, "y": y, "w": logo_w, "h": logo_h, "width": width, "height": height}
+
+    delogo_expr = f"delogo=x={x}:y={y}:w={logo_w}:h={logo_h}"
+    cmd = [
+        ffmpeg, "-y",
+        "-i", "pipe:0",
+        "-vf", delogo_expr,
+        "-c:a", "copy",
+        "-progress", "pipe:1",
+        "-v", verbosity,
+        str(output_path),
+    ]
+
+    logger.info(f"Streaming delogo: {delogo_expr}")
+    logger.info(f"FFmpeg cmd: {' '.join(cmd)}")
+
+    try:
+        # Default downloader uses requests
+        if downloader is None:
+            import requests
+            resp = requests.get(video_url, timeout=120, stream=True,
+                                headers={"User-Agent": "Mozilla/5.0"})
+            resp.raise_for_status()
+
+            def _default_downloader():
+                for chunk in resp.iter_content(chunk_size=8192):
+                    if chunk:
+                        yield chunk
+
+            source_iter = _default_downloader()
+        else:
+            source_iter = downloader()
+
+        proc = subprocess.Popen(
+            cmd, stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+        )
+
+        total = 0
+        for chunk in source_iter:
+            proc.stdin.write(chunk)
+            total += len(chunk)
+        proc.stdin.close()
+
+        stdout, stderr = proc.communicate(timeout=600)
+
+        if proc.returncode != 0:
+            return {
+                "success": False,
+                "error": f"FFmpeg exited with code {proc.returncode}",
+                "stderr": stderr.decode("utf-8", errors="replace")[-500:],
+                "input_url": video_url,
+            }
+
+        return {
+            "success": True,
+            "output_path": str(output_path),
+            "delogo_params": params,
+            "ffmpeg_cmd": " ".join(cmd),
+            "bytes_processed": total,
+        }
+    except subprocess.TimeoutExpired:
+        return {"success": False, "error": "FFmpeg timed out (>10min)"}
+    except Exception as e:
+        return {"success": False, "error": str(e), "input_url": video_url}
+
+
+def batch_remove_watermarks(
+    input_dir: Union[str, Path],
+    output_dir: Optional[Union[str, Path]] = None,
+    pattern: str = "*.mp4",
+    **kwargs,
+) -> List[dict]:
+    """Remove watermarks from all matching videos in a directory.
+
+    Args:
+        input_dir: Directory containing videos.
+        output_dir: Output directory (default: same as input, in-place).
+        pattern: Glob pattern for video files (default: "*.mp4").
+        **kwargs: Passed to remove_watermark().
+
+    Returns:
+        List of result dicts, one per file.
+    """
+    input_dir = Path(input_dir)
+    if not input_dir.exists():
+        return [{"success": False, "error": f"Directory not found: {input_dir}"}]
+
+    results = []
+    videos = sorted(input_dir.glob(pattern))
+    if not videos:
+        return [{"success": False, "error": f"No videos matching '{pattern}' in {input_dir}"}]
+
+    for video in videos:
+        out = None
+        if output_dir:
+            out = Path(output_dir) / video.name
+        result = remove_watermark(video, output_path=out, **kwargs)
+        results.append(result)
+
+    return results