Add new muxtools

Author: WOSSFOSS

pyproject.toml

@@ -6,6 +6,7 @@ readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
     "aiohttp>=3.13.0",
+    "opencv-python>=4.13.0.90",
     "pydantic>=2.12.0",
     "typer>=0.17.4",
 ]

src/__init__.py

@@ -1,3 +1,4 @@
-from .app import app as app
-from .backup import find_hardlinks  # noqa: F401
-from .jellyfin import add_all_subdirectories_to_library  # noqa: F401
+from .app import app as app  # noqa: F401
+from .backup import *  # noqa: F401,F403
+from .jellyfin import *  # noqa: F401,F403
+from .muxtools import *  # noqa: F401,F403

src/muxtools/__init__.py

@@ -0,0 +1,2 @@
+from .find_change_from_start import find_change_from_start as find_change_from_start
+from .create_offset_mkv import create_offset_mkv as create_offset_mkv

src/muxtools/create_offset_mkv.py

@@ -0,0 +1,91 @@
+import asyncio
+from typing import Annotated
+
+from typer import Argument
+from ..app import app
+from .find_change_from_start import find_change_from_start_inner
+
+
+async def create_offset_mkv_inner(bd_path: str, target_path: str, output_path: str):
+    bd_offset_frame, bd_fps = find_change_from_start_inner(bd_path)
+    if bd_offset_frame == -1:
+        raise ValueError("No significant change found in BD video.")
+    bd_offset_seconds = bd_offset_frame / bd_fps
+    target_offset_frame, target_fps = find_change_from_start_inner(target_path)
+    if target_offset_frame == -1:
+        raise ValueError("No significant change found in target video.")
+    target_offset_seconds = target_offset_frame / target_fps
+    # Positive if BD starts later, negative if earlier
+    offset_seconds = round(bd_offset_seconds - target_offset_seconds, 5)
+    print(
+        f"Calculated offset: {offset_seconds} seconds, adjusting all non-video streams accordingly."
+    )
+    ffmpeg_command = [
+        "ffmpeg",
+        "-y",
+        "-loglevel",
+        "quiet",
+        "-itsoffset",
+        str(offset_seconds),
+        "-i",
+        target_path,
+        "-map",
+        "0",
+        "-map",
+        "-0:v",  # Exclude original video stream
+        "-map_metadata",
+        "0",
+        "-c",
+        "copy",
+        output_path,
+    ]
+    proc = await asyncio.create_subprocess_exec(
+        *ffmpeg_command, stdout=asyncio.subprocess.PIPE
+    )
+    await proc.communicate()
+    if proc.returncode != 0:
+        raise RuntimeError(f"ffmpeg command failed with return code {proc.returncode}")
+
+
+@app.command()
+def create_offset_mkv(
+    bd_path: Annotated[
+        str,
+        Argument(
+            help="Path to the Blu-ray video file to analyze for offset.",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            resolve_path=True,
+        ),
+    ],
+    target_path: Annotated[
+        str,
+        Argument(
+            help="Path to the target video file to adjust.",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            resolve_path=True,
+        ),
+    ],
+    output_path: Annotated[
+        str,
+        Argument(
+            help="Path to save the output MKV file with adjusted timing.",
+        ),
+    ],
+):
+    """Create an MKV file with adjusted timing based on offset from Blu-ray video.
+
+    :param bd_path: Path to the Blu-ray video file to analyze for offset.
+    :param target_path: Path to the target video file to adjust.
+    :param output_path: Path to save the output MKV file with adjusted timing.
+    """
+    asyncio.run(
+        create_offset_mkv_inner(
+            bd_path=bd_path, target_path=target_path, output_path=output_path
+        )
+    )

src/muxtools/find_change_from_start.py

@@ -0,0 +1,125 @@
+import cv2
+
+from typing import Annotated
+
+from typer import Argument, Option
+from ..app import app
+
+
+def find_change_from_start_inner(
+    video_path, threshold=0, min_changed_pixels=50
+) -> tuple[int, float]:
+    """
+    Consumes video one frame at a time to find where it diverges from Frame 1.
+
+    Args:
+        video_path (str): Path to video file.
+        threshold (int): Sensitivity (0-255). Lower = detects subtle changes.
+                         Higher = ignores compression artifacts.
+        min_changed_pixels (int): How many pixels must change to trigger detection.
+
+    Returns:
+        tuple[int, float]: Frame number where change is detected and FPS of the video.
+                           Returns -1 if no significant change is found.
+    """
+
+    # 1. Open the video stream
+    cap = cv2.VideoCapture(video_path)
+
+    try:
+        if not cap.isOpened():
+            raise FileNotFoundError(f"Could not open video file: {video_path}")
+
+        # 2. Read Frame 1 (The Reference)
+        ret, frame1 = cap.read()
+        if not ret:
+            raise ValueError("Video file is empty or unreadable.")
+
+        # Convert to grayscale to reduce complexity and ignore color noise
+        frame1_gray = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
+
+        # Optional: Apply slight blur to reduce compression artifact noise
+        frame1_gray = cv2.GaussianBlur(frame1_gray, (21, 21), 0)
+
+        frame_count = 1
+        fps = cap.get(cv2.CAP_PROP_FPS)
+
+        # 3. Loop through the stream one frame at a time
+        while True:
+            # returns (bool, numpy_array)
+            ret, current_frame = cap.read()
+
+            # If no frame is returned, we reached the end of the video
+            if not ret:
+                return -1, fps  # No significant change found
+
+            frame_count += 1
+
+            # Convert current frame to grayscale
+            current_gray = cv2.cvtColor(current_frame, cv2.COLOR_BGR2GRAY)
+            current_gray = cv2.GaussianBlur(current_gray, (21, 21), 0)
+
+            # 4. Compute Absolute Difference between Frame 1 and Current Frame
+            # This creates an image where black pixels means "no change"
+            # and white pixels means "change"
+            delta = cv2.absdiff(frame1_gray, current_gray)
+
+            # 5. Apply Threshold
+            # Any pixel difference < threshold becomes 0 (black).
+            # Any pixel difference > threshold becomes 255 (white).
+            thresh_img = cv2.threshold(delta, threshold, 255, cv2.THRESH_BINARY)[1]
+
+            # 6. Check if enough pixels have changed
+            # We count the white pixels in the threshold image
+            changed_pixels = cv2.countNonZero(thresh_img)
+
+            if changed_pixels > min_changed_pixels:
+                # Optional: Save the frame to verify
+                # cv2.imwrite(f"change_detected_frame_{frame_count}.jpg", current_frame)
+                return frame_count, fps
+
+    # 7. Release resources
+    finally:
+        cap.release()
+
+
+@app.command()
+def find_change_from_start(
+    video_path: Annotated[
+        str,
+        Argument(
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            resolve_path=True,
+            help="Path to the video file to analyze.",
+        ),
+    ],
+    threshold: int = Option(
+        default=0,
+        help="Sensitivity (0-255). Lower = detects subtle changes. Higher = ignores compression artifacts.",
+    ),
+    min_changed_pixels: int = Option(
+        default=50,
+        help="How many pixels must change to trigger detection.",
+    ),
+):
+    """Find where a video diverges from its first frame.
+
+    :param video_path: Path to the video file to analyze.
+    :param threshold: Sensitivity (0-255). Lower = detects subtle changes. Higher = ignores compression artifacts.
+    :param min_changed_pixels: How many pixels must change to trigger detection.
+    """
+    frame_diff_at, fps = find_change_from_start_inner(
+        video_path=video_path,
+        threshold=threshold,
+        min_changed_pixels=min_changed_pixels,
+    )
+    frame_diff_at_secs = frame_diff_at / fps if frame_diff_at != -1 else -1
+    if frame_diff_at == -1:
+        print("No significant change detected in the video.")
+    else:
+        print(
+            f"Significant change detected at frame {frame_diff_at} ({frame_diff_at_secs} seconds)."
+        )