videopython 0.3.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

videopython/base/video.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
+import json
 import subprocess
 import tempfile
 from dataclasses import dataclass
+from fractions import Fraction
 from pathlib import Path
 from typing import Literal, get_args
 
-import cv2
 import numpy as np
 from soundpython import Audio
 
@@ -15,6 +16,12 @@ from videopython.utils.common import generate_random_name
 ALLOWED_VIDEO_FORMATS = Literal["mp4", "avi", "mov", "mkv", "webm"]
 
 
+class VideoMetadataError(Exception):
+    """Raised when there's an error getting video metadata"""
+
+    pass
+
+
 @dataclass
 class VideoMetadata:
     """Class to store video metadata."""
@@ -25,37 +32,80 @@ class VideoMetadata:
     frame_count: int
     total_seconds: float
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"{self.width}x{self.height} @ {self.fps}fps, {self.total_seconds} seconds"
 
     def __repr__(self) -> str:
         return self.__str__()
 
-    def get_frame_shape(self):
+    def get_frame_shape(self) -> np.ndarray:
         """Returns frame shape."""
         return np.array((self.height, self.width, 3))
 
-    def get_video_shape(self):
+    def get_video_shape(self) -> np.ndarray:
         """Returns video shape."""
         return np.array((self.frame_count, self.height, self.width, 3))
 
+    @staticmethod
+    def _run_ffprobe(video_path: str | Path) -> dict:
+        """Run ffprobe and return parsed JSON output."""
+        cmd = [
+            "ffprobe",
+            "-v",
+            "error",
+            "-select_streams",
+            "v:0",
+            "-show_entries",
+            "stream=width,height,r_frame_rate,nb_frames",
+            "-show_entries",
+            "format=duration",
+            "-print_format",
+            "json",
+            str(video_path),
+        ]
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            return json.loads(result.stdout)
+        except subprocess.CalledProcessError as e:
+            raise VideoMetadataError(f"FFprobe error: {e.stderr}")
+        except json.JSONDecodeError as e:
+            raise VideoMetadataError(f"Error parsing FFprobe output: {e}")
+
     @classmethod
-    def from_path(cls, video_path: str) -> VideoMetadata:
-        """Creates VideoMetadata object from video file."""
-        video = cv2.VideoCapture(video_path)
-        frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
-        fps = round(video.get(cv2.CAP_PROP_FPS), 2)
-        height = round(video.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        width = round(video.get(cv2.CAP_PROP_FRAME_WIDTH))
-        total_seconds = round(frame_count / fps, 2)
-
-        return cls(
-            height=height,
-            width=width,
-            fps=fps,
-            frame_count=frame_count,
-            total_seconds=total_seconds,
-        )
+    def from_path(cls, video_path: str | Path) -> VideoMetadata:
+        """Creates VideoMetadata object from video file using ffprobe."""
+        if not Path(video_path).exists():
+            raise FileNotFoundError(f"Video file not found: {video_path}")
+
+        probe_data = cls._run_ffprobe(video_path)
+
+        try:
+            stream_info = probe_data["streams"][0]
+
+            width = int(stream_info["width"])
+            height = int(stream_info["height"])
+
+            try:
+                fps_fraction = Fraction(stream_info["r_frame_rate"])
+                fps = float(fps_fraction)
+            except (ValueError, ZeroDivisionError):
+                raise VideoMetadataError(f"Invalid frame rate: {stream_info['r_frame_rate']}")
+
+            if "nb_frames" in stream_info and stream_info["nb_frames"].isdigit():
+                frame_count = int(stream_info["nb_frames"])
+            else:
+                duration = float(probe_data["format"]["duration"])
+                frame_count = int(round(duration * fps))
+
+            total_seconds = round(frame_count / fps, 2)
+
+            return cls(height=height, width=width, fps=fps, frame_count=frame_count, total_seconds=total_seconds)
+
+        except KeyError as e:
+            raise VideoMetadataError(f"Missing required metadata field: {e}")
+        except Exception as e:
+            raise VideoMetadataError(f"Error extracting video metadata: {e}")
 
     @classmethod
     def from_video(cls, video: Video) -> VideoMetadata:
@@ -63,15 +113,10 @@ class VideoMetadata:
         frame_count, height, width, _ = video.frames.shape
         total_seconds = round(frame_count / video.fps, 2)
 
-        return cls(
-            height=height,
-            width=width,
-            fps=video.fps,
-            frame_count=frame_count,
-            total_seconds=total_seconds,
-        )
+        return cls(height=height, width=width, fps=video.fps, frame_count=frame_count, total_seconds=total_seconds)
 
     def can_be_merged_with(self, other_format: VideoMetadata) -> bool:
+        """Check if videos can be merged."""
         return (
             self.height == other_format.height
             and self.width == other_format.width
@@ -79,14 +124,7 @@ class VideoMetadata:
         )
 
     def can_be_downsampled_to(self, target_format: VideoMetadata) -> bool:
-        """Checks if video can be downsampled to `target_format`.
-
-        Args:
-            target_format: Desired video format.
-
-        Returns:
-            True if video can be downsampled to `target_format`, False otherwise.
-        """
+        """Checks if video can be downsampled to target_format."""
         return (
             self.height >= target_format.height
             and self.width >= target_format.width
@@ -96,53 +134,174 @@ class VideoMetadata:
 
 
 class Video:
-    def __init__(self):
-        self.fps = None
-        self.frames = None
-        self.audio = None
+    def __init__(self, frames: np.ndarray, fps: int | float, audio: Audio | None = None):
+        self.frames = frames
+        self.fps = fps
+        if audio:
+            self.audio = audio
+        else:
+            self.audio = Audio.create_silent(
+                duration_seconds=round(self.total_seconds, 2), stereo=True, sample_rate=44100
+            )
 
     @classmethod
-    def from_path(cls, path: str) -> Video:
-        new_vid = cls()
-        new_vid.frames, new_vid.fps = cls._load_video_from_path(path)
-
+    def from_path(
+        cls, path: str, read_batch_size: int = 100, start_second: float | None = None, end_second: float | None = None
+    ) -> Video:
         try:
-            new_vid.audio = Audio.from_file(path)
-        except Exception as e:
-            print(f"No audio found for `{path}`, adding silent track!")
-            new_vid.audio = Audio.create_silent(
-                duration_seconds=round(new_vid.total_seconds, 2), stereo=True, sample_rate=44100
+            # Get video metadata using VideoMetadata.from_path
+            metadata = VideoMetadata.from_path(path)
+
+            width = metadata.width
+            height = metadata.height
+            fps = metadata.fps
+            total_frames = metadata.frame_count
+            total_duration = metadata.total_seconds
+
+            # Validate time bounds
+            if start_second is not None and start_second < 0:
+                raise ValueError("start_second must be non-negative")
+            if end_second is not None and end_second > total_duration:
+                raise ValueError(f"end_second ({end_second}) exceeds video duration ({total_duration})")
+            if start_second is not None and end_second is not None and start_second >= end_second:
+                raise ValueError("start_second must be less than end_second")
+
+            # Calculate frame indices for the desired segment
+            start_frame = int(start_second * fps) if start_second is not None else 0
+            end_frame = int(end_second * fps) if end_second is not None else total_frames
+
+            # Ensure we don't exceed bounds
+            start_frame = max(0, start_frame)
+            end_frame = min(total_frames, end_frame)
+            segment_frames = end_frame - start_frame
+
+            # Set up FFmpeg command for raw video extraction with time bounds
+            ffmpeg_cmd = [
+                "ffmpeg",
+                "-i",
+                path,
+            ]
+
+            # Add seek and duration options if specified
+            if start_second is not None:
+                ffmpeg_cmd.extend(["-ss", str(start_second)])
+            if end_second is not None and start_second is not None:
+                duration = end_second - start_second
+                ffmpeg_cmd.extend(["-t", str(duration)])
+            elif end_second is not None:
+                ffmpeg_cmd.extend(["-t", str(end_second)])
+
+            ffmpeg_cmd.extend(
+                [
+                    "-f",
+                    "rawvideo",
+                    "-pix_fmt",
+                    "rgb24",
+                    "-vsync",
+                    "0",
+                    "-vcodec",
+                    "rawvideo",
+                    "-y",
+                    "pipe:1",
+                ]
+            )
+
+            # Start FFmpeg process
+            process = subprocess.Popen(
+                ffmpeg_cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                bufsize=10**8,  # Use large buffer
             )
-        return new_vid
+
+            # Calculate frame size in bytes
+            frame_size = width * height * 3  # 3 bytes per pixel for RGB
+
+            # Pre-allocate numpy array for segment frames
+            frames = np.empty((segment_frames, height, width, 3), dtype=np.uint8)
+
+            # Read frames in batches
+            frames_read = 0
+            for frame_idx in range(0, segment_frames, read_batch_size):
+                batch_end = min(frame_idx + read_batch_size, segment_frames)
+                batch_size = batch_end - frame_idx
+
+                # Read batch of frames
+                raw_data = process.stdout.read(frame_size * batch_size)  # type: ignore
+                if not raw_data:
+                    break
+
+                # Convert raw bytes to numpy array and reshape
+                batch_frames = np.frombuffer(raw_data, dtype=np.uint8)
+
+                # Handle case where we might get fewer frames than expected
+                actual_frames = len(batch_frames) // (height * width * 3)
+                if actual_frames > 0:
+                    batch_frames = batch_frames[: actual_frames * height * width * 3]
+                    batch_frames = batch_frames.reshape(-1, height, width, 3)
+
+                    # Store batch in pre-allocated array
+                    end_idx = frame_idx + actual_frames
+                    frames[frame_idx:end_idx] = batch_frames
+                    frames_read += actual_frames
+                else:
+                    break
+
+            # Clean up FFmpeg process
+            process.stdout.close()  # type: ignore
+            process.stderr.close()  # type: ignore
+            process.wait()
+
+            if process.returncode != 0:
+                stderr_output = process.stderr.read().decode() if process.stderr else "Unknown error"
+                raise ValueError(f"FFmpeg error: {stderr_output}")
+
+            # Trim frames array if we read fewer frames than expected
+            if frames_read < segment_frames:
+                frames = frames[:frames_read]  # type: ignore[assignment]
+
+            # Load audio for the specified segment
+            try:
+                audio = Audio.from_file(path)
+                # Slice audio to match the video segment
+                if start_second is not None or end_second is not None:
+                    audio_start = start_second if start_second is not None else 0
+                    audio_end = end_second if end_second is not None else audio.metadata.duration_seconds
+                    audio = audio.slice(start_seconds=audio_start, end_seconds=audio_end)
+            except Exception:
+                print(f"No audio found for `{path}`, adding silent track!")
+                # Create silent audio for the segment duration
+                segment_duration = len(frames) / fps
+                audio = Audio.create_silent(duration_seconds=round(segment_duration, 2), stereo=True, sample_rate=44100)
+
+            return cls(frames=frames, fps=fps, audio=audio)
+
+        except VideoMetadataError as e:
+            raise ValueError(f"Error getting video metadata: {e}")
+        except subprocess.CalledProcessError as e:
+            raise ValueError(f"Error processing video file: {e}")
+        except Exception as e:
+            raise ValueError(f"Error loading video: {e}")
 
     @classmethod
     def from_frames(cls, frames: np.ndarray, fps: float) -> Video:
-        new_vid = cls()
         if frames.ndim != 4:
             raise ValueError(f"Unsupported number of dimensions: {frames.shape}!")
         elif frames.shape[-1] == 4:
             frames = frames[:, :, :, :3]
         elif frames.shape[-1] != 3:
             raise ValueError(f"Unsupported number of dimensions: {frames.shape}!")
-        new_vid.frames = frames
-        new_vid.fps = fps
-        new_vid.audio = Audio.create_silent(
-            duration_seconds=round(new_vid.total_seconds, 2), stereo=True, sample_rate=44100
-        )
-        return new_vid
+        return cls(frames=frames, fps=fps)
 
     @classmethod
     def from_image(cls, image: np.ndarray, fps: float = 24.0, length_seconds: float = 1.0) -> Video:
-        new_vid = cls()
         if len(image.shape) == 3:
             image = np.expand_dims(image, axis=0)
-        new_vid.frames = np.repeat(image, round(length_seconds * fps), axis=0)
-        new_vid.fps = fps
-        new_vid.audio = Audio.create_silent(duration_seconds=length_seconds, stereo=True, sample_rate=44100)
-        return new_vid
+        frames = np.repeat(image, round(length_seconds * fps), axis=0)
+        return cls(frames=frames, fps=fps)
 
     def copy(self) -> Video:
-        copied = Video().from_frames(self.frames.copy(), self.fps)
+        copied = Video.from_frames(self.frames.copy(), self.fps)
         copied.audio = self.audio  # Audio objects are immutable, no need to copy
         return copied
 
@@ -168,6 +327,19 @@ class Video:
         return split_videos
 
     def save(self, filename: str | Path | None = None, format: ALLOWED_VIDEO_FORMATS = "mp4") -> Path:
+        """Save video to file with optimized performance.
+
+        Args:
+            filename: Output filename. If None, generates random name
+            format: Output format (mp4, avi, mov, mkv, webm)
+
+        Returns:
+            Path to saved video file
+
+        Raises:
+            RuntimeError: If video is not loaded
+            ValueError: If format is not supported
+        """
         if not self.is_loaded():
             raise RuntimeError("Video is not loaded, cannot save!")
 
@@ -182,80 +354,71 @@ class Video:
             filename = Path(filename).with_suffix(f".{format}")
             filename.parent.mkdir(parents=True, exist_ok=True)
 
-        with tempfile.TemporaryDirectory() as temp_dir:
-            temp_dir_path = Path(temp_dir)
-
-            # Save frames as images
-            for i, frame in enumerate(self.frames):
-                frame_path = temp_dir_path / f"frame_{i:04d}.png"
-                cv2.imwrite(str(frame_path), cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))
-
-            # Calculate exact video duration
-            video_duration = len(self.frames) / self.fps
-
-            # Ensure audio duration matches video duration
-            if (
-                abs(self.audio.metadata.duration_seconds - video_duration) > 0.001
-            ):  # Small threshold for float comparison
-                if self.audio.metadata.duration_seconds < video_duration:
-                    # Create silent audio for the remaining duration
-                    remaining_duration = video_duration - self.audio.metadata.duration_seconds
-                    silent_audio = Audio.create_silent(
-                        duration_seconds=remaining_duration,
-                        stereo=(self.audio.metadata.channels == 2),
-                        sample_rate=self.audio.metadata.sample_rate,
-                        sample_width=self.audio.metadata.sample_width,
-                    )
-                    # Concatenate original audio with silent padding
-                    padded_audio = self.audio.concat(silent_audio)
-                else:
-                    # Trim audio to match video duration
-                    padded_audio = self.audio.slice(end_seconds=video_duration)
-            else:
-                padded_audio = self.audio
+        # Create a temporary raw video file
+        with tempfile.NamedTemporaryFile(suffix=".raw") as raw_video:
+            # Convert frames to raw video data
+            raw_data = self.frames.astype(np.uint8).tobytes()
+            raw_video.write(raw_data)
+            raw_video.flush()
 
             # Save audio to temporary WAV file
-            temp_audio = temp_dir_path / "temp_audio.wav"
-            padded_audio.save(str(temp_audio), format="wav")
-
-            # Construct FFmpeg command with explicit duration
-            ffmpeg_command = [
-                "ffmpeg",
-                "-y",
-                "-framerate",
-                str(self.fps),  # Use -framerate instead of -r for input
-                "-i",
-                str(temp_dir_path / "frame_%04d.png"),
-                "-i",
-                str(temp_audio),
-                "-c:v",
-                "libx264",
-                "-preset",
-                "medium",
-                "-crf",
-                "23",
-                "-c:a",
-                "aac",  # Use AAC instead of copy for more reliable audio
-                "-b:a",
-                "192k",
-                "-pix_fmt",
-                "yuv420p",
-                "-map",
-                "0:v:0",  # Map video from first input
-                "-map",
-                "1:a:0",  # Map audio from second input
-                "-vsync",
-                "cfr",  # Force constant frame rate
-                str(filename),
-            ]
-
-            try:
-                subprocess.run(ffmpeg_command, check=True, capture_output=True, text=True)
-                return filename
-            except subprocess.CalledProcessError as e:
-                print(f"Error saving video: {e}")
-                print(f"FFmpeg stderr: {e.stderr}")
-                raise
+            with tempfile.NamedTemporaryFile(suffix=".wav") as temp_audio:
+                self.audio.save(temp_audio.name, format="wav")
+
+                # Calculate exact duration
+                duration = len(self.frames) / self.fps
+
+                # Construct FFmpeg command for maximum performance
+                ffmpeg_command = [
+                    "ffmpeg",
+                    "-y",
+                    # Raw video input settings
+                    "-f",
+                    "rawvideo",
+                    "-pixel_format",
+                    "rgb24",
+                    "-video_size",
+                    f"{self.frame_shape[1]}x{self.frame_shape[0]}",
+                    "-framerate",
+                    str(self.fps),
+                    "-i",
+                    raw_video.name,
+                    # Audio input
+                    "-i",
+                    temp_audio.name,
+                    # Video encoding settings
+                    "-c:v",
+                    "libx264",
+                    "-preset",
+                    "ultrafast",  # Fastest encoding
+                    "-tune",
+                    "zerolatency",  # Reduce encoding latency
+                    "-crf",
+                    "23",  # Reasonable quality/size tradeoff
+                    # Audio settings
+                    "-c:a",
+                    "aac",
+                    "-b:a",
+                    "192k",
+                    # Output settings
+                    "-pix_fmt",
+                    "yuv420p",
+                    "-movflags",
+                    "+faststart",  # Enable fast start for web playback
+                    "-t",
+                    str(duration),
+                    "-vsync",
+                    "cfr",
+                    str(filename),
+                ]
+
+                try:
+                    subprocess.run(ffmpeg_command, check=True, capture_output=True, text=True)
+                    return filename
+                except subprocess.CalledProcessError as e:
+                    print(f"Error saving video: {e}")
+                    print(f"FFmpeg stderr: {e.stderr}")
+                    raise
 
     def add_audio(self, audio: Audio, overlay: bool = True) -> None:
         if self.audio.is_silent:
@@ -269,7 +432,7 @@ class Video:
         try:
             new_audio = Audio.from_file(path)
             self.add_audio(new_audio, overlay)
-        except Exception as e:
+        except Exception:
             print(f"Audio file `{path}` not found or invalid, skipping!")
 
     def __add__(self, other: Video) -> Video:
@@ -305,29 +468,6 @@ class Video:
         sliced.audio = self.audio.slice(start_seconds=audio_start, end_seconds=audio_end)
         return sliced
 
-    @staticmethod
-    def _load_video_from_path(path: str) -> tuple[np.ndarray, float]:
-        cap = cv2.VideoCapture(path)
-        if not cap.isOpened():
-            raise ValueError(f"Unable to open video file: {path}")
-
-        fps = cap.get(cv2.CAP_PROP_FPS)
-        frames = []
-
-        while True:
-            ret, frame = cap.read()
-            if not ret:
-                break
-            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            frames.append(frame)
-
-        cap.release()
-
-        if not frames:
-            raise ValueError(f"No frames could be read from the video file: {path}")
-
-        return np.array(frames), fps
-
     @property
     def video_shape(self) -> tuple[int, int, int, int]:
         return self.frames.shape

videopython/utils/__init__.py

@@ -0,0 +1,3 @@
+from videopython.utils.text import AnchorPoint, ImageText, TextAlign
+
+__all__ = ["AnchorPoint", "ImageText", "TextAlign"]