feat: impelement randomization chunk timestamps

services/compress/encoder.py

@@ -10,7 +10,7 @@ from utils.processing_utils import (
     should_skip_encoding,
     encode_scene_with_size_check,
     analyze_input_compression,
-    # classify_scene_from_path 
+    classify_scene_from_path 
 )
 from utils.encode_video import encode_video
 from utils.classify_scene import load_scene_classifier_model, CombinedModel
@@ -137,13 +137,15 @@ def ai_encoding(scene_metadata, config, resources, target_vmaf=None, logging_ena
     current_codec = original_video_metadata.get('codec', original_codec)
     config_codec = config.get('video_processing', {}).get('codec', 'auto')
     
+    # Define codec upgrade map outside the conditional blocks
+    codec_upgrade_map = {'h264': 'libsvtav1', 'hevc': 'libsvtav1', 'vp9': 'libsvtav1', 'av1': 'libsvtav1'}
+    
     if target_codec_from_part1 and target_codec_from_part1 != 'auto':
         codec = target_codec_from_part1
     elif config_codec != 'auto':
         codec = config_codec
     else:
-        codec_upgrade_map = {'h264': 'av1_nvenc', 'hevc': 'av1_nvenc', 'vp9': 'av1_nvenc', 'av1': 'av1_nvenc'}
-        codec = codec_upgrade_map.get(current_codec.lower(), 'av1_nvenc')
+        codec = codec_upgrade_map.get(current_codec.lower(), 'libsvtav1')
 
     if logging_enabled:
         print(f"   🎥 Selected Codec: {codec}")
@@ -155,7 +157,7 @@ def ai_encoding(scene_metadata, config, resources, target_vmaf=None, logging_ena
     scene_type = 'default'
     confidence_score = 0.0
     try:        
-        classification_result = classify_scene_from_path(
+        scene_type, detailed_results = classify_scene_from_path(
             scene_path=scene_path,
             temp_dir=temp_dir,
             scene_classifier_model=resources['scene_classifier_model'],
@@ -164,8 +166,7 @@ def ai_encoding(scene_metadata, config, resources, target_vmaf=None, logging_ena
             class_mapping=resources['class_mapping'],
             logging_enabled=logging_enabled
         )
-        scene_type = classification_result.get('scene_type', 'default')
-        confidence_score = classification_result.get('confidence_score', 0.0)
+        confidence_score = detailed_results.get('confidence_score', 0.0)
 
         if logging_enabled:
             print(f"   🎭 Scene classified as: '{scene_type}' (Confidence: {confidence_score:.2f})")
@@ -293,7 +294,7 @@ if __name__ == '__main__':
             'original_video_metadata': {
                 'path': 'original_video.mp4',
                 'codec': 'h264',
-                'target_codec': 'av1_nvenc',
+                'target_codec': 'libsvtav1',
             }
         }
         

services/compress/scene_detector.py

@@ -398,7 +398,7 @@ if __name__ == '__main__':
         'path': short_video,
         'codec': 'h264',
         'original_codec': 'h264',
-        'target_codec': 'av1_nvenc',  # ✅ NEW: Target codec for encoding
+        'target_codec': 'libsvtav1',  # ✅ NEW: Target codec for encoding
         'duration': 15.0,
         'was_reencoded': False,
         'encoding_time': 0,
@@ -437,7 +437,7 @@ if __name__ == '__main__':
         'path': 'test_lossless_converted.mkv',
         'codec': 'ffv1',
         'original_codec': 'rawvideo',
-        'target_codec': 'av1_nvenc',  # ✅ Target for final encoding
+        'target_codec': 'libsvtav1',  # ✅ Target for final encoding
         'duration': 120.0,
         'was_reencoded': True,
         'encoding_time': 5.2,

services/compress/utils/encoder_configs.py

@@ -6,6 +6,10 @@ ENCODER_SETTINGS = {
         "codec": "libsvtav1", "preset": "8", "crf": 30, "keyint": 50,
         # Add SVT-AV1 specific AQ if needed, e.g., --enable-variance-boost
     },
+    "libsvtav1": {
+        "codec": "libsvtav1", "preset": "8", "crf": 30, "keyint": 50,
+        # SVT-AV1 encoder settings
+    },
     "av1_nvenc": {
         "codec": "av1_nvenc", "preset": "p6", "cq": 30, "keyint": 50, 'pix_fmt': 'yuv420p' # Default AQ settings for NVENC AV1
     },
@@ -128,8 +132,8 @@ SCENE_SPECIFIC_PARAMS = {
 # --- START: New Configuration for Quality Parameter Mapping ---
 
 # Define which codec's CQ scale your VMAF prediction model was trained on.
-# Example: If your model predicts CQ values suitable for AV1_NVENC.
-MODEL_CQ_REFERENCE_CODEC = "av1_nvenc" # IMPORTANT: User must set this correctly
+# Example: If your model predicts CQ values suitable for libsvtav1.
+MODEL_CQ_REFERENCE_CODEC = "libsvtav1" # IMPORTANT: User must set this correctly
 
 # Define anchor points for mapping the model's reference CQ (from MODEL_CQ_REFERENCE_CODEC)
 # to other codecs' quality parameters.
@@ -140,23 +144,23 @@ MODEL_CQ_REFERENCE_CODEC = "av1_nvenc" # IMPORTANT: User must set this correctly
 # 'anchor_points': A list of [model_ref_cq_value, target_codec_param_value] pairs.
 #                  These points define the mapping relationship.
 QUALITY_MAPPING_ANCHORS = {
-    # Example: If MODEL_CQ_REFERENCE_CODEC is "AV1_NVENC"
-    "libaom-av1": { # Mapping AV1_NVENC CQ to libaom-av1 CRF
+    # Example: If MODEL_CQ_REFERENCE_CODEC is "libsvtav1"
+    "libaom-av1": { # Mapping libsvtav1 CQ to libaom-av1 CRF
         "model_ref_cq_range": [10, 63], # Expected input range from your AV1 model
         "target_param_type": "crf",
         "target_param_range": [10, 63], # Typical CRF range for libaom-av1
-        "anchor_points": [ # [model_av1_nvenc_cq, libaom_av1_crf]
+        "anchor_points": [ # [model_libsvtav1_cq, libaom_av1_crf]
             [20, 22], # Lower CQ (better quality) maps to lower CRF
             [30, 32], # Medium CQ maps to medium CRF
             [40, 42], # Higher CQ (lower quality) maps to higher CRF
             [50, 52]
         ]
     },
-    "H264": { # Mapping AV1_NVENC CQ to libx264 CRF
+    "H264": { # Mapping libsvtav1 CQ to libx264 CRF
         "model_ref_cq_range": [10, 63],
         "target_param_type": "crf",
         "target_param_range": [0, 51],  # Typical CRF range for libx264
-        "anchor_points": [ # [model_av1_nvenc_cq, libx264_crf]
+        "anchor_points": [ # [model_libsvtav1_cq, libx264_crf]
             [20, 18],
             [30, 23],
             [40, 28],
@@ -164,22 +168,22 @@ QUALITY_MAPPING_ANCHORS = {
         ]
     },
 
-    "HEVC_NVENC": { # Mapping AV1_NVENC CQ to HEVC_NVENC CQ
+    "HEVC_NVENC": { # Mapping libsvtav1 CQ to HEVC_NVENC CQ
         "model_ref_cq_range": [10, 63],
         "target_param_type": "cq",
         "target_param_range": [10, 51], # Typical CQ range for NVENC HEVC
-        "anchor_points": [ # [model_av1_nvenc_cq, hevc_nvenc_cq]
+        "anchor_points": [ # [model_libsvtav1_cq, hevc_nvenc_cq]
             [20, 19], # Might be slightly different scale or perception
             [30, 25],
             [40, 31],
             [50, 37]
         ]
     },
-    "libx265": { # Mapping AV1_NVENC CQ to libx265 CRF
+    "libx265": { # Mapping libsvtav1 CQ to libx265 CRF
         "model_ref_cq_range": [10, 63],
         "target_param_type": "crf",
         "target_param_range": [0, 51], # Typical CRF range for libx265
-        "anchor_points": [ # [model_av1_nvenc_cq, libx265_crf]
+        "anchor_points": [ # [model_libsvtav1_cq, libx265_crf]
             [20, 20],
             [30, 26],
             [40, 32],

services/compress/utils/processing_utils.py

@@ -6,6 +6,7 @@ import gc
 import subprocess
 import json
 import numpy as np
+import shutil
 import sys
 # Adjust sys.path to allow imports from the 'utils' directory
 # This assumes check_hardware.py is in src/utilities/
@@ -1127,3 +1128,162 @@ def safe_log_message(message, level="info"):
             print(message)
     else:
         print(message)
+
+
+def classify_scene_from_path(scene_path, temp_dir, scene_classifier_model, available_metrics, 
+                           device='cpu', class_mapping=None, logging_enabled=True, 
+                           num_frames=3, metrics_scaler=None):
+    """
+    Classify a scene directly from video path - wrapper around classify_scene_with_model
+    
+    Args:
+        scene_path: Path to the video file
+        temp_dir: Temporary directory for frame extraction
+        scene_classifier_model: Trained scene classifier model
+        available_metrics: List of available metrics for the model
+        device: Device to run inference on ('cpu' or 'cuda')
+        class_mapping: Class mapping dictionary (optional)
+        logging_enabled: Whether to enable logging
+        num_frames: Number of frames to extract for classification
+        metrics_scaler: Metrics scaler (optional)
+        
+    Returns:
+        tuple: (classification_label, detailed_results)
+        Same format as classify_scene_with_model
+    """
+    try:
+        # Step 1: Extract frames from the video
+        if logging_enabled:
+            print(f"Extracting {num_frames} frames from {scene_path}")
+        
+        # Create temp directory for this specific classification
+        import tempfile
+        frame_temp_dir = os.path.join(temp_dir, f"frames_{int(time.time())}")
+        os.makedirs(frame_temp_dir, exist_ok=True)
+        
+        # For full video, extract frames from beginning to end
+        # We need to get video duration first
+        try:
+            import subprocess
+            # Get video duration using ffprobe
+            cmd = [
+                'ffprobe', '-v', 'quiet', '-show_entries', 'format=duration',
+                '-of', 'default=noprint_wrappers=1:nokey=1', scene_path
+            ]
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            duration = float(result.stdout.strip())
+            
+            # Extract frames from start to end
+            frame_paths = extract_frames_from_scene(
+                video_path=scene_path,
+                start_time=0.0,
+                end_time=duration,
+                num_frames=num_frames,
+                output_dir=frame_temp_dir
+            )
+        except Exception as e:
+            if logging_enabled:
+                print(f"Warning: Could not get video duration, using fallback frame extraction: {e}")
+            # Fallback: extract frames without specific timing
+            frame_paths = []
+            for i in range(num_frames):
+                output_frame = os.path.join(frame_temp_dir, f"frame_{i}.jpg")
+                cmd = [
+                    'ffmpeg', '-y', '-i', scene_path,
+                    '-vf', f'select=eq(n\\,{i * 10})',  # Extract every 10th frame
+                    '-frames:v', '1', '-q:v', '2',
+                    '-hide_banner', '-loglevel', 'error',
+                    output_frame
+                ]
+                try:
+                    subprocess.run(cmd, check=True, capture_output=True)
+                    if os.path.exists(output_frame) and os.path.getsize(output_frame) > 0:
+                        frame_paths.append(output_frame)
+                except:
+                    continue
+        
+        if not frame_paths:
+            if logging_enabled:
+                print("Warning: No frames could be extracted from video")
+            return "unclear", {
+                'confidence_score': 0.0,
+                'prob_screen_content': 0.0,
+                'prob_animation': 0.0,
+                'prob_faces': 0.0,
+                'prob_gaming': 0.0,
+                'prob_other': 0.0,
+                'prob_unclear': 1.0,
+                'frame_predictions': [],
+                'error': 'Frame extraction failed'
+            }
+        
+        # Step 2: Extract video features
+        if logging_enabled:
+            print(f"Extracting video features from {scene_path}")
+        
+        try:
+            # Try to import and use analyze_video_fast
+            from analyze_video_fast import analyze_video_fast
+            video_features = analyze_video_fast(scene_path, logging_enabled=False)
+            
+            if not video_features or 'error' in video_features:
+                # Create default video features if extraction fails
+                if logging_enabled:
+                    print("Warning: Video feature extraction failed, using defaults")
+                video_features = {}
+                for metric in available_metrics:
+                    video_features[metric] = 0.5  # Default neutral values
+        except ImportError:
+            if logging_enabled:
+                print("Warning: analyze_video_fast not available, using default features")
+            # Create default video features
+            video_features = {}
+            for metric in available_metrics:
+                video_features[metric] = 0.5  # Default neutral values
+        
+        # Step 3: Classify using existing function
+        classification_label, detailed_results = classify_scene_with_model(
+            frame_paths=frame_paths,
+            video_features=video_features,
+            scene_classifier=scene_classifier_model,
+            metrics_scaler=metrics_scaler,
+            available_metrics=available_metrics,
+            device=device,
+            logging_enabled=logging_enabled
+        )
+        
+        # Cleanup temporary frames
+        try:
+            # You need to import shutil at the top of your file:
+            # 
+            shutil.rmtree(frame_temp_dir)
+        except Exception as e:
+            if logging_enabled:
+                print(f"Warning: Could not cleanup temp frames: {e}")
+        print("--------------------------------")
+        print(f"Classification label: {classification_label}")
+        print(f"Detailed results: {detailed_results}")
+        return classification_label, detailed_results
+        
+    except Exception as e:
+        if logging_enabled:
+            print(f"Error in classify_scene_from_path: {e}")
+        
+        # Cleanup on error
+        try:
+            if 'frame_temp_dir' in locals():
+                shutil.rmtree(frame_temp_dir)
+        except:
+            pass
+        
+        return "unclear", {
+            'confidence_score': 0.0,
+            'prob_screen_content': 0.0,
+            'prob_animation': 0.0,
+            'prob_faces': 0.0,
+            'prob_gaming': 0.0,
+            'prob_other': 0.0,
+            'prob_unclear': 1.0,
+            'frame_predictions': [],
+            'error': str(e)
+        }

services/compress/video_preprocessor.py

@@ -40,7 +40,7 @@ def pre_processing(video_path, target_quality='Medium',codec='auto', max_duratio
     
     # ✅ CODEC HANDLING: Resolve auto codec selection
     if codec.lower() == 'auto':
-        target_codec = 'av1_nvenc'  # Default to AV1 for best quality
+        target_codec = 'libsvtav1'  # Default to SVT-AV1 for best quality
         
     else:
         target_codec = codec
@@ -185,7 +185,7 @@ if __name__ == '__main__':
     # Test with different quality levels and codec options
     test_cases = [
         ('High', 'auto'),
-        ('Medium', 'av1_nvenc'),
+        ('Medium', 'libsvtav1'),
         ('Low', 'libx264'),
         ('Medium', 'auto')  # Test auto-detection
     ]
@@ -233,7 +233,7 @@ if __name__ == '__main__':
         video_path=lossless_video,
         target_quality='High',
         max_duration=7200,
-        codec='av1_nvenc'  # Test with specific codec
+        codec='libsvtav1'  # Test with specific codec
     )
     
     if result:

services/video_scheduler/video_utils.py

@@ -354,74 +354,106 @@ def download_trim_downscale_video(
 
     def generate_chunk_timestamps(total_duration, clip_duration):
         """
-        Generate chunk timestamps using sliding window approach to maximize chunks per video.
-        This reduces API requests by extracting many overlapping chunks from each downloaded video.
+        Generate chunk timestamps using randomized approach to maximize chunks per video.
+        This reduces API requests by extracting many overlapping chunks from each downloaded video
+        while using randomized start points to avoid predictable patterns.
         
         Strategy:
-        - 5s clips: Slide by 1s intervals (1-6s, 2-7s, 3-8s, etc.)
-        - 10s clips: Slide by 2s intervals (0-10s, 2-12s, 4-14s, etc.)  
-        - 20s clips: Slide by 3s intervals (0-20s, 3-23s, 6-26s, etc.)
+        - Uses random start points within safe zones to avoid predictable patterns
+        - Maintains reasonable overlap between chunks for continuity
+        - Adapts to different clip durations with appropriate randomization ranges
         """
         chunks = []
         
-        # Define slide intervals for each clip duration
-        slide_intervals = {
-            1: 0.5,   # For 1s clips, slide by 0.5s
-            2: 0.5,   # For 2s clips, slide by 0.5s  
-            3: 1,     # For 3s clips, slide by 1s
-            4: 1,     # For 4s clips, slide by 1s
-            5: 1,     # For 5s clips, slide by 1s
-            10: 2,    # For 10s clips, slide by 2s
-            20: 3     # For 20s clips, slide by 3s
+        # Define safe zones and overlap ranges for each clip duration
+        # Safe zones avoid very beginning/end of video where quality might be poor
+        safe_zone_configs = {
+            1: {"safe_start": 0.2, "safe_end_ratio": 0.8, "min_overlap": 0.3, "max_overlap": 0.7},
+            2: {"safe_start": 0.3, "safe_end_ratio": 0.85, "min_overlap": 0.5, "max_overlap": 1.0},
+            3: {"safe_start": 0.4, "safe_end_ratio": 0.9, "min_overlap": 0.8, "max_overlap": 1.5},
+            4: {"safe_start": 0.5, "safe_end_ratio": 0.9, "min_overlap": 1.0, "max_overlap": 2.0},
+            5: {"safe_start": 0.5, "safe_end_ratio": 0.9, "min_overlap": 1.0, "max_overlap": 2.5},
+            10: {"safe_start": 0.5, "safe_end_ratio": 0.9, "min_overlap": 2.0, "max_overlap": 4.0},
+            20: {"safe_start": 0.5, "safe_end_ratio": 0.9, "min_overlap": 3.0, "max_overlap": 6.0}
         }
         
-        slide_interval = slide_intervals.get(clip_duration, 1)
+        config = safe_zone_configs.get(clip_duration, {
+            "safe_start": 0.5, "safe_end_ratio": 0.9, "min_overlap": 1.0, "max_overlap": 2.0
+        })
         
-        # Calculate maximum number of chunks we can extract
-        max_chunks_possible = int((total_duration - clip_duration) / slide_interval) + 1
+        # Calculate safe zone boundaries
+        safe_start = config["safe_start"]
+        safe_end = total_duration * config["safe_end_ratio"]
+        min_overlap = config["min_overlap"]
+        max_overlap = config["max_overlap"]
         
         # Set reasonable limits to avoid over-extraction from one video
         max_chunks_per_video = {
-            1: min(20, max_chunks_possible),   # Max 20 chunks for 1s clips
-            2: min(15, max_chunks_possible),   # Max 15 chunks for 2s clips
-            3: min(12, max_chunks_possible),   # Max 12 chunks for 3s clips
-            4: min(10, max_chunks_possible),   # Max 10 chunks for 4s clips
-            5: min(8, max_chunks_possible),    # Max 8 chunks for 5s clips
-            10: min(6, max_chunks_possible),   # Max 6 chunks for 10s clips
-            20: min(4, max_chunks_possible)    # Max 4 chunks for 20s clips
+            1: 20,   # Max 20 chunks for 1s clips
+            2: 15,   # Max 15 chunks for 2s clips
+            3: 12,   # Max 12 chunks for 3s clips
+            4: 10,   # Max 10 chunks for 4s clips
+            5: 8,    # Max 8 chunks for 5s clips
+            10: 6,   # Max 6 chunks for 10s clips
+            20: 4    # Max 4 chunks for 20s clips
         }
         
-        max_chunks = max_chunks_per_video.get(clip_duration, max_chunks_possible)
+        max_chunks = max_chunks_per_video.get(clip_duration, 8)
         
         # Ensure we have enough video duration
         if total_duration < clip_duration:
             return [(0, 0, min(total_duration, clip_duration))]
         
-        # Generate sliding window chunks
-        current_start = 0
+        # Ensure safe zone is valid
+        if safe_end - safe_start < clip_duration:
+            # If safe zone is too small, use the entire video
+            safe_start = 0
+            safe_end = total_duration
+        
+        # Generate randomized chunks
         chunk_index = 0
+        last_end = safe_start
         
-        while (current_start + clip_duration <= total_duration and 
-               chunk_index < max_chunks):
+        while chunk_index < max_chunks:
+            # Calculate the maximum start time for this chunk
+            max_start = min(safe_end - clip_duration, last_end + max_overlap)
             
-            end_time = current_start + clip_duration
-            chunks.append((chunk_index, current_start, end_time))
+            # If we can't fit another chunk, break
+            if max_start < last_end - min_overlap:
+                break
             
-            current_start += slide_interval
+            # Generate random start time within valid range
+            min_start = max(safe_start, last_end - min_overlap)
+            if min_start >= max_start:
+                break
+                
+            start_time = random.uniform(min_start, max_start)
+            end_time = start_time + clip_duration
+            
+            # Ensure we don't exceed video duration
+            if end_time > total_duration:
+                end_time = total_duration
+                start_time = end_time - clip_duration
+                if start_time < 0:
+                    start_time = 0
+            
+            chunks.append((chunk_index, start_time, end_time))
+            
+            last_end = end_time
             chunk_index += 1
         
-        # Add one final chunk from the end if we have remaining duration
+        # Add one final chunk from the end if we have remaining duration and space
         if (chunk_index < max_chunks and 
             total_duration > clip_duration and 
-            current_start < total_duration - 2):  # At least 2s remaining
+            total_duration - clip_duration > last_end - min_overlap):
             
             final_start = total_duration - clip_duration
             # Only add if it doesn't overlap too much with the last chunk
-            if not chunks or final_start - chunks[-1][1] >= slide_interval:
+            if not chunks or final_start - chunks[-1][1] >= min_overlap:
                 chunks.append((chunk_index, final_start, total_duration))
         
-        safe_print(f"Generated {len(chunks)} chunks for {clip_duration}s duration from {total_duration:.1f}s video")
-        safe_print(f"Chunk extraction details: slide_interval={slide_interval}s, max_chunks={max_chunks}")
+        safe_print(f"Generated {len(chunks)} randomized chunks for {clip_duration}s duration from {total_duration:.1f}s video")
+        safe_print(f"Randomization details: safe_zone={safe_start:.1f}s-{safe_end:.1f}s, overlap_range={min_overlap:.1f}s-{max_overlap:.1f}s, max_chunks={max_chunks}")
         
         return chunks