endoreg-db 0.8.4.4__py3-none-any.whl → 0.8.8.0__py3-none-any.whl

endoreg_db/utils/video/ffmpeg_wrapper.py

@@ -1,13 +1,14 @@
-import os
-import subprocess
 import json
 import logging
+import os
+import shutil
+import subprocess
 from functools import lru_cache
 from pathlib import Path
-from typing import List, Dict, Optional, Tuple
+from typing import Dict, List, Optional, Tuple
+
 import cv2
 from tqdm import tqdm
-import shutil
 
 logger = logging.getLogger("ffmpeg_wrapper")
 
@@ -28,13 +29,9 @@ def _resolve_ffmpeg_executable() -> Optional[str]:
 
     # 2) Django settings overrides (if Django is configured)
     try:
-        from django.conf import settings  # type: ignore
+        from django.conf import settings
 
-        env_candidates.extend(
-            getattr(settings, attr)
-            for attr in ("FFMPEG_EXECUTABLE", "FFMPEG_BINARY", "FFMPEG_PATH")
-            if hasattr(settings, attr)
-        )
+        env_candidates.extend(getattr(settings, attr) for attr in ("FFMPEG_EXECUTABLE", "FFMPEG_BINARY", "FFMPEG_PATH") if hasattr(settings, attr))
     except Exception:
         # Django might not be configured for every consumer
         pass
@@ -76,35 +73,27 @@ def _resolve_ffmpeg_executable() -> Optional[str]:
 
     return None
 
+
 def _detect_nvenc_support() -> bool:
     """
     Detect if NVIDIA NVENC hardware acceleration is available.
-    
+
     Returns:
         True if NVENC is available, False otherwise
     """
     try:
         # Test NVENC availability with a minimal command (minimum size for NVENC)
-        cmd = [
-            'ffmpeg', '-f', 'lavfi', '-i', 'testsrc=duration=1:size=256x256:rate=1',
-            '-c:v', 'h264_nvenc', '-preset', 'p1', '-f', 'null', '-'
-        ]
-        
-        result = subprocess.run(
-            cmd, 
-            capture_output=True, 
-            text=True, 
-            timeout=15,
-            check=False
-        )
-        
+        cmd = ["ffmpeg", "-f", "lavfi", "-i", "testsrc=duration=1:size=256x256:rate=1", "-c:v", "h264_nvenc", "-preset", "p1", "-f", "null", "-"]
+
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=15, check=False)
+
         if result.returncode == 0:
             logger.debug("NVENC h264 encoding test successful")
             return True
         else:
             logger.debug(f"NVENC test failed: {result.stderr}")
             return False
-            
+
     except (subprocess.TimeoutExpired, FileNotFoundError) as e:
         logger.debug(f"NVENC detection failed: {e}")
         return False
@@ -112,129 +101,132 @@ def _detect_nvenc_support() -> bool:
         logger.warning(f"Unexpected error during NVENC detection: {e}")
         return False
 
+
 def _get_preferred_encoder() -> Dict[str, str]:
     """
     Get the preferred video encoder configuration based on available hardware.
-    
+
     Returns:
         Dictionary with encoder configuration
     """
     global _nvenc_available, _preferred_encoder
-    
+
     if _nvenc_available is None:
         _nvenc_available = _detect_nvenc_support()
-        
+
     if _preferred_encoder is None:
         if _nvenc_available:
             _preferred_encoder = {
-                'name': 'h264_nvenc',
-                'preset_param': '-preset',
-                'preset_value': 'p4',  # Medium quality/speed for NVENC
-                'quality_param': '-cq',
-                'quality_value': '20',  # NVENC CQ mode
-                'type': 'nvenc',
-                'fallback_preset': 'p1'  # Fastest NVENC preset for fallback
+                "name": "h264_nvenc",
+                "preset_param": "-preset",
+                "preset_value": "p4",  # Medium quality/speed for NVENC
+                "quality_param": "-cq",
+                "quality_value": "20",  # NVENC CQ mode
+                "type": "nvenc",
+                "fallback_preset": "p1",  # Fastest NVENC preset for fallback
             }
             logger.info("Hardware acceleration: NVENC available")
         else:
             _preferred_encoder = {
-                'name': 'libx264',
-                'preset_param': '-preset',
-                'preset_value': 'medium',  # CPU preset
-                'quality_param': '-crf',
-                'quality_value': '23',  # CPU CRF mode
-                'type': 'cpu',
-                'fallback_preset': 'ultrafast'  # Fastest CPU preset for fallback
+                "name": "libx264",
+                "preset_param": "-preset",
+                "preset_value": "medium",  # CPU preset
+                "quality_param": "-crf",
+                "quality_value": "23",  # CPU CRF mode
+                "type": "cpu",
+                "fallback_preset": "ultrafast",  # Fastest CPU preset for fallback
             }
             logger.info("Hardware acceleration: NVENC not available, using CPU")
-            
+
     return _preferred_encoder
 
-def _build_encoder_args(quality_mode: str = 'balanced', 
-                       fallback: bool = False,
-                       custom_crf: Optional[int] = None) -> Tuple[List[str], str]:
+
+def _build_encoder_args(quality_mode: str = "balanced", fallback: bool = False, custom_crf: Optional[int] = None) -> Tuple[List[str], str]:
     """
     Build encoder command arguments based on available hardware and quality requirements.
-    
+
     Args:
         quality_mode: 'fast', 'balanced', or 'quality'
         fallback: Whether to use fallback settings for compatibility
         custom_crf: Override quality setting (for backward compatibility)
-        
+
     Returns:
         Tuple of (encoder_args, encoder_type)
     """
     encoder = _get_preferred_encoder()
-    
-    if encoder['type'] == 'nvenc':
+
+    if encoder["type"] == "nvenc":
         # NVIDIA NVENC configuration
         if fallback:
-            preset = encoder['fallback_preset']  # p1 - fastest
-            quality = '28'  # Lower quality for speed
-        elif quality_mode == 'fast':
-            preset = 'p2'  # Faster preset
-            quality = '25'
-        elif quality_mode == 'quality':
-            preset = 'p6'  # Higher quality preset
-            quality = '18'
+            preset = encoder["fallback_preset"]  # p1 - fastest
+            quality = "28"  # Lower quality for speed
+        elif quality_mode == "fast":
+            preset = "p2"  # Faster preset
+            quality = "25"
+        elif quality_mode == "quality":
+            preset = "p6"  # Higher quality preset
+            quality = "18"
         else:  # balanced
-            preset = encoder['preset_value']  # p4
-            quality = encoder['quality_value']  # 20
-        
+            preset = encoder["preset_value"]  # p4
+            quality = encoder["quality_value"]  # 20
+
         # Override with custom CRF if provided (for backward compatibility)
         if custom_crf is not None:
             quality = str(custom_crf)
-        
+
         return [
-            '-c:v', encoder['name'],
-            encoder['preset_param'], preset,
-            encoder['quality_param'], quality,
-            '-gpu', '0',  # Use first GPU
-            '-rc', 'vbr',  # Variable bitrate
-            '-profile:v', 'high'
-        ], encoder['type']
+            "-c:v",
+            encoder["name"],
+            encoder["preset_param"],
+            preset,
+            encoder["quality_param"],
+            quality,
+            "-gpu",
+            "0",  # Use first GPU
+            "-rc",
+            "vbr",  # Variable bitrate
+            "-profile:v",
+            "high",
+        ], encoder["type"]
     else:
         # CPU libx264 configuration
         if fallback:
-            preset = encoder['fallback_preset']  # ultrafast
-            quality = '28'  # Lower quality for speed
-        elif quality_mode == 'fast':
-            preset = 'faster'
-            quality = '20'
-        elif quality_mode == 'quality':
-            preset = 'slow'
-            quality = '18'
+            preset = encoder["fallback_preset"]  # ultrafast
+            quality = "28"  # Lower quality for speed
+        elif quality_mode == "fast":
+            preset = "faster"
+            quality = "20"
+        elif quality_mode == "quality":
+            preset = "slow"
+            quality = "18"
         else:  # balanced
-            preset = encoder['preset_value']  # medium
-            quality = encoder['quality_value']  # 23
-        
+            preset = encoder["preset_value"]  # medium
+            quality = encoder["quality_value"]  # 23
+
         # Override with custom CRF if provided (for backward compatibility)
         if custom_crf is not None:
             quality = str(custom_crf)
-        
-        return [
-            '-c:v', encoder['name'],
-            encoder['preset_param'], preset,
-            encoder['quality_param'], quality,
-            '-profile:v', 'high'
-        ], encoder['type']
+
+        return ["-c:v", encoder["name"], encoder["preset_param"], preset, encoder["quality_param"], quality, "-profile:v", "high"], encoder["type"]
+
 
 def is_ffmpeg_available() -> bool:
     """
     Checks whether the FFmpeg executable is available in the system's PATH.
-    
+
     Returns:
         True if FFmpeg is found in the PATH; otherwise, False.
     """
     return _resolve_ffmpeg_executable() is not None
 
+
 def check_ffmpeg_availability():
     """
     Verifies that FFmpeg is installed and available in the system's PATH.
-    
+
     Raises:
         FileNotFoundError: If FFmpeg is not found.
-        
+
     Returns:
         True if FFmpeg is available.
     """
@@ -245,10 +237,11 @@ def check_ffmpeg_availability():
     # logger.info("FFmpeg is available.") # Caller can log if needed
     return True
 
+
 def get_stream_info(file_path: Path) -> Optional[Dict]:
     """
     Retrieves video stream information from a file using ffprobe.
-    
+
     Runs ffprobe to extract stream metadata in JSON format from the specified video file. Returns a dictionary with stream information, or None if the file does not exist or if an error occurs during execution or parsing.
     """
     if not file_path.exists():
@@ -257,8 +250,10 @@ def get_stream_info(file_path: Path) -> Optional[Dict]:
 
     command = [
         "ffprobe",
-        "-v", "quiet",
-        "-print_format", "json",
+        "-v",
+        "quiet",
+        "-print_format",
+        "json",
         "-show_streams",
         str(file_path),
     ]
@@ -276,7 +271,7 @@ def get_stream_info(file_path: Path) -> Optional[Dict]:
         return None
 
 
-def assemble_video_from_frames( # Renamed from assemble_video
+def assemble_video_from_frames(  # Renamed from assemble_video
     frame_paths: List[Path],
     output_path: Path,
     fps: float,
@@ -302,7 +297,7 @@ def assemble_video_from_frames( # Renamed from assemble_video
             logger.error("Error reading first frame to determine dimensions: %s", e, exc_info=True)
             return None
 
-    fourcc = cv2.VideoWriter_fourcc(*"mp4v") # type: ignore
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
     output_path.parent.mkdir(parents=True, exist_ok=True)
     video_writer = cv2.VideoWriter(str(output_path), fourcc, fps, (width, height))
 
@@ -343,7 +338,7 @@ def transcode_video(
 ) -> Optional[Path]:
     """
     Transcodes a video file using FFmpeg with automatic hardware acceleration.
-    
+
     Args:
         input_path: Source video file path
         output_path: Output video file path
@@ -355,7 +350,7 @@ def transcode_video(
         extra_args: Additional FFmpeg arguments
         quality_mode: Quality mode ('fast', 'balanced', 'quality')
         force_cpu: Force CPU encoding even if NVENC is available
-        
+
     Returns:
         Path to transcoded video or None if failed
     """
@@ -371,8 +366,8 @@ def transcode_video(
             # Force CPU encoding
             encoder_args, encoder_type = _build_encoder_args(quality_mode, fallback=False, custom_crf=crf)
             # Override to use CPU encoder
-            encoder_args[1] = 'libx264'  # Replace encoder name
-            encoder_args[3] = 'medium' if preset == "auto" else preset  # Replace preset
+            encoder_args[1] = "libx264"  # Replace encoder name
+            encoder_args[3] = "medium" if preset == "auto" else preset  # Replace preset
             if crf is not None:
                 encoder_args[5] = str(crf)  # Replace quality value
         else:
@@ -381,28 +376,33 @@ def transcode_video(
     else:
         # Manual codec/preset specification (backward compatibility)
         encoder_args = [
-            '-c:v', codec,
-            '-preset', preset,
-            '-crf' if codec == 'libx264' else '-cq', str(crf if crf is not None else 23),
+            "-c:v",
+            codec,
+            "-preset",
+            preset,
+            "-crf" if codec == "libx264" else "-cq",
+            str(crf if crf is not None else 23),
         ]
-        encoder_type = 'nvenc' if 'nvenc' in codec else 'cpu'
+        encoder_type = "nvenc" if "nvenc" in codec else "cpu"
 
     # Build complete command
     command = [
         "ffmpeg",
-        "-i", str(input_path),
+        "-i",
+        str(input_path),
         *encoder_args,
-        "-c:a", audio_codec,
-        "-b:a", audio_bitrate,
+        "-c:a",
+        audio_codec,
+        "-b:a",
+        audio_bitrate,
         "-y",  # Overwrite output file if it exists
     ]
-    
+
     if extra_args:
         command.extend(extra_args)
     command.append(str(output_path))
 
-    logger.info("Starting transcoding: %s -> %s (using %s)", 
-                input_path.name, output_path.name, encoder_type)
+    logger.info("Starting transcoding: %s -> %s (using %s)", input_path.name, output_path.name, encoder_type)
     logger.debug("FFmpeg command: %s", " ".join(command))
 
     try:
@@ -420,18 +420,14 @@ def transcode_video(
             logger.info("Transcoding finished successfully: %s", output_path)
             return output_path
         else:
-            logger.error("FFmpeg transcoding failed for %s with return code %d.", 
-                        input_path.name, process.returncode)
+            logger.error("FFmpeg transcoding failed for %s with return code %d.", input_path.name, process.returncode)
             logger.error("FFmpeg stderr:\n%s", stderr_output)
-            
+
             # Try fallback to CPU if NVENC failed
-            if encoder_type == 'nvenc' and not force_cpu:
+            if encoder_type == "nvenc" and not force_cpu:
                 logger.warning("NVENC transcoding failed, trying CPU fallback...")
-                return _transcode_video_fallback(
-                    input_path, output_path, audio_codec, audio_bitrate, 
-                    extra_args, quality_mode, crf
-                )
-            
+                return _transcode_video_fallback(input_path, output_path, audio_codec, audio_bitrate, extra_args, quality_mode, crf)
+
             # Clean up potentially corrupted output file
             if output_path.exists():
                 try:
@@ -447,18 +443,13 @@ def transcode_video(
         logger.error("Error during transcoding of %s: %s", input_path.name, e, exc_info=True)
         return None
 
+
 def _transcode_video_fallback(
-    input_path: Path,
-    output_path: Path,
-    audio_codec: str,
-    audio_bitrate: str,
-    extra_args: Optional[List[str]],
-    quality_mode: str,
-    custom_crf: Optional[int]
+    input_path: Path, output_path: Path, audio_codec: str, audio_bitrate: str, extra_args: Optional[List[str]], quality_mode: str, custom_crf: Optional[int]
 ) -> Optional[Path]:
     """
     Fallback transcoding using CPU encoding.
-    
+
     Args:
         input_path: Source video file path
         output_path: Output video file path
@@ -467,7 +458,7 @@ def _transcode_video_fallback(
         extra_args: Additional FFmpeg arguments
         quality_mode: Quality mode
         custom_crf: Custom CRF value
-        
+
     Returns:
         Path to transcoded video or None if failed
     """
@@ -475,24 +466,27 @@ def _transcode_video_fallback(
         # Build CPU encoder arguments
         encoder_args, _ = _build_encoder_args(quality_mode, fallback=True, custom_crf=custom_crf)
         # Force CPU encoder
-        encoder_args[1] = 'libx264'
-        
+        encoder_args[1] = "libx264"
+
         command = [
             "ffmpeg",
-            "-i", str(input_path),
+            "-i",
+            str(input_path),
             *encoder_args,
-            "-c:a", audio_codec,
-            "-b:a", audio_bitrate,
+            "-c:a",
+            audio_codec,
+            "-b:a",
+            audio_bitrate,
             "-y",
         ]
-        
+
         if extra_args:
             command.extend(extra_args)
         command.append(str(output_path))
 
         logger.info("CPU fallback transcoding: %s -> %s", input_path.name, output_path.name)
         logger.debug("Fallback FFmpeg command: %s", " ".join(command))
-        
+
         process = subprocess.Popen(command, stderr=subprocess.PIPE, text=True, universal_newlines=True)
         stderr_output = ""
         if process.stderr:
@@ -508,7 +502,7 @@ def _transcode_video_fallback(
             logger.error("CPU fallback transcoding also failed for %s", input_path.name)
             logger.error("Fallback stderr:\n%s", stderr_output)
             return None
-            
+
     except Exception as e:
         logger.error("Error during CPU fallback transcoding: %s", e, exc_info=True)
         return None
@@ -551,12 +545,13 @@ def _transcode_video_fallback(
         logger.error("Error during transcoding of %s: %s", input_path.name, e, exc_info=True)
         return None
 
+
 def transcode_videofile_if_required(
     input_path: Path,
     output_path: Path,
     required_codec: str = "h264",
-    required_pixel_format: str = "yuv420p", # Changed default from yuvj420p
-    **transcode_options # Pass other options to transcode_video
+    required_pixel_format: str = "yuv420p",  # Changed default from yuvj420p
+    **transcode_options,  # Pass other options to transcode_video
 ) -> Optional[Path]:
     """
     Checks if a video needs transcoding based on codec and pixel format,
@@ -578,7 +573,7 @@ def transcode_videofile_if_required(
     codec_name = video_stream.get("codec_name")
     pixel_format = video_stream.get("pix_fmt")
     # Check color range as well, default is usually 'tv' (limited)
-    color_range = video_stream.get("color_range", "tv") # Default to tv if not specified
+    color_range = video_stream.get("color_range", "tv")  # Default to tv if not specified
 
     needs_transcoding = False
     transcode_reason = []
@@ -597,44 +592,44 @@ def transcode_videofile_if_required(
     if needs_transcoding:
         logger.info("Transcoding %s to %s due to: %s", input_path.name, output_path.name, "; ".join(transcode_reason))
         # Ensure codec and pixel format are set in options if not already present
-        transcode_options.setdefault('codec', 'libx264' if required_codec == 'h264' else required_codec)
-        transcode_options.setdefault('extra_args', [])
+        transcode_options.setdefault("codec", "libx264" if required_codec == "h264" else required_codec)
+        transcode_options.setdefault("extra_args", [])
 
         # Ensure pixel format and color range are correctly set in extra_args
-        extra_args = transcode_options['extra_args']
-        if '-pix_fmt' not in extra_args:
-            extra_args.extend(['-pix_fmt', required_pixel_format])
+        extra_args = transcode_options["extra_args"]
+        if "-pix_fmt" not in extra_args:
+            extra_args.extend(["-pix_fmt", required_pixel_format])
         else:
             # If pix_fmt is already set, ensure it's the required one
             try:
-                pix_fmt_index = extra_args.index('-pix_fmt')
+                pix_fmt_index = extra_args.index("-pix_fmt")
                 if extra_args[pix_fmt_index + 1] != required_pixel_format:
                     logger.warning("Overriding existing -pix_fmt '%s' with '%s'", extra_args[pix_fmt_index + 1], required_pixel_format)
                     extra_args[pix_fmt_index + 1] = required_pixel_format
             except (ValueError, IndexError):
-                 # Should not happen if '-pix_fmt' is in extra_args, but handle defensively
-                 logger.error("Error processing existing -pix_fmt argument. Appending required format.")
-                 extra_args.extend(['-pix_fmt', required_pixel_format])
+                # Should not happen if '-pix_fmt' is in extra_args, but handle defensively
+                logger.error("Error processing existing -pix_fmt argument. Appending required format.")
+                extra_args.extend(["-pix_fmt", required_pixel_format])
 
-
-        if '-color_range' not in extra_args:
-             # Add color range 'pc' (which corresponds to 2 or 'jpeg') for yuv420p
-            extra_args.extend(['-color_range', 'pc'])
+        if "-color_range" not in extra_args:
+            # Add color range 'pc' (which corresponds to 2 or 'jpeg') for yuv420p
+            extra_args.extend(["-color_range", "pc"])
         else:
             # If color_range is already set, ensure it's 'pc'
-             try:
-                color_range_index = extra_args.index('-color_range')
-                if extra_args[color_range_index + 1] != 'pc':
+            try:
+                color_range_index = extra_args.index("-color_range")
+                if extra_args[color_range_index + 1] != "pc":
                     logger.warning("Overriding existing -color_range '%s' with 'pc'", extra_args[color_range_index + 1])
-                    extra_args[color_range_index + 1] = 'pc'
-             except (ValueError, IndexError):
-                 logger.error("Error processing existing -color_range argument. Appending 'pc'.")
-                 extra_args.extend(['-color_range', 'pc'])
-
+                    extra_args[color_range_index + 1] = "pc"
+            except (ValueError, IndexError):
+                logger.error("Error processing existing -color_range argument. Appending 'pc'.")
+                extra_args.extend(["-color_range", "pc"])
 
         return transcode_video(input_path, output_path, **transcode_options)
     else:
-        logger.info("Video %s already meets requirements (%s, %s, color_range=pc). No transcoding needed.", input_path.name, required_codec, required_pixel_format)
+        logger.info(
+            "Video %s already meets requirements (%s, %s, color_range=pc). No transcoding needed.", input_path.name, required_codec, required_pixel_format
+        )
         # If no transcoding is needed, should we copy/link or just return the original path?
         # For simplicity, let's assume the caller handles the file location.
         # If the output_path is different, we might need to copy.
@@ -648,15 +643,10 @@ def transcode_videofile_if_required(
             except Exception as e:
                 logger.error("Failed to copy %s to %s: %s", input_path.name, output_path.name, e)
                 return None
-        return input_path # Return original path if no copy needed
+        return input_path  # Return original path if no copy needed
 
-def extract_frames(
-    video_path: Path,
-    output_dir: Path,
-    quality: int,
-    ext: str = "jpg",
-    fps: Optional[float] = None
-) -> List[Path]:
+
+def extract_frames(video_path: Path, output_dir: Path, quality: int, ext: str = "jpg", fps: Optional[float] = None) -> List[Path]:
     """
     Extracts frames from a video file using FFmpeg.
 
@@ -681,9 +671,11 @@ def extract_frames(
     output_pattern = output_dir / f"frame_%07d.{ext}"
 
     cmd = [
-        ffmpeg_executable, # Use the found executable path
-        "-i", str(video_path),
-        "-qscale:v", str(quality), # Video quality scale
+        ffmpeg_executable,  # Use the found executable path
+        "-i",
+        str(video_path),
+        "-qscale:v",
+        str(quality),  # Video quality scale
     ]
 
     if fps is not None:
@@ -713,27 +705,27 @@ def extract_frames(
         logger.error("An unexpected error occurred during FFmpeg execution: %s", e, exc_info=True)
         return []
 
-
     # Collect paths of extracted frames
     extracted_files = sorted(output_dir.glob(f"frame_*.{ext}"))
     return extracted_files
 
+
 def extract_frame_range(
     video_path: Path,
     output_dir: Path,
     start_frame: int,
-    end_frame: int, # Exclusive end frame number
+    end_frame: int,  # Exclusive end frame number
     quality: int,
     ext: str = "jpg",
 ) -> List[Path]:
     """
     Extracts a specific range of frames from a video using FFmpeg.
-    
+
     Frames from start_frame (inclusive) to end_frame (exclusive) are saved as images
     in the output directory, following the naming pattern 'frame_%07d.ext'. The
     function ensures only the requested frames are returned, and cleans up partial
     results on failure.
-    
+
     Args:
         video_path: Path to the input video file.
         output_dir: Directory where extracted frames will be saved.
@@ -741,10 +733,10 @@ def extract_frame_range(
         end_frame: Index at which to stop extraction (exclusive, 0-based).
         quality: JPEG quality factor (1-31, lower is better).
         ext: File extension for output images (e.g., 'jpg', 'png').
-    
+
     Returns:
         List of Paths to the extracted frame image files within the specified range.
-    
+
     Raises:
         FileNotFoundError: If the FFmpeg executable is not found.
         ValueError: If start_frame is greater than or equal to end_frame.
@@ -767,15 +759,19 @@ def extract_frame_range(
     # Use select filter for precise frame range extraction
     # 'select' uses 0-based indexing 'n'
     # We want frames where start_frame <= n < end_frame
-    select_filter = f"select='between(n,{start_frame},{end_frame-1})'"
+    select_filter = f"select='between(n,{start_frame},{end_frame - 1})'"
 
     cmd = [
         ffmpeg_executable,
-        "-i", str(video_path),
-        "-vf", select_filter,
-        "-vsync", "vfr", # Variable frame rate sync to handle selected frames
-        "-qscale:v", str(quality),
-        "-copyts", # Attempt to copy timestamps if needed, might not be accurate with select
+        "-i",
+        str(video_path),
+        "-vf",
+        select_filter,
+        "-vsync",
+        "vfr",  # Variable frame rate sync to handle selected frames
+        "-qscale:v",
+        str(quality),
+        "-copyts",  # Attempt to copy timestamps if needed, might not be accurate with select
         str(output_pattern),
     ]
 
@@ -819,17 +815,17 @@ def extract_frame_range(
             # This might happen if ffmpeg fails silently for some frames or if the video ends early.
             logger.warning("Expected frame file %s not found after extraction.", frame_file)
 
-
     logger.info("Found %d extracted frame files in range [%d, %d) for video %s.", len(extracted_files), start_frame, end_frame, video_path.name)
     return extracted_files
 
+
 __all__ = [
-    "is_ffmpeg_available", # ADDED
-    "check_ffmpeg_availability", # ADDED
+    "is_ffmpeg_available",  # ADDED
+    "check_ffmpeg_availability",  # ADDED
     "get_stream_info",
-    "assemble_video_from_frames", # Updated name
+    "assemble_video_from_frames",  # Updated name
     "transcode_video",
     "transcode_videofile_if_required",
     "extract_frames",
-    "extract_frame_range", # Add new function to __all__
+    "extract_frame_range",  # Add new function to __all__
 ]