[Feature Added] > Video Pipeline. Have to update the confidence and ai_analysis param for images, where they won't appear.

backend/app/ai/video/frame_detector.py

@@ -12,8 +12,8 @@ class FrameDetector:
 
         try:
             model_id = "prithivMLmods/Deep-Fake-Detector-Model"
-            self.processor = ViTImageProcessor.from_pretrained(model_id)
-            self.model = ViTForImageClassification.from_pretrained(model_id)
+            self.processor = AutoImageProcessor.from_pretrained(model_id)
+            self.model = AutoModelForImageClassification.from_pretrained(model_id)
             self.model = self.model.to(self.device)
             self.model.eval()
 

backend/app/api/file_routes.py

@@ -31,6 +31,8 @@ def list_user_files(
                     "size": f.filesize,
                     "status": f.status,
                     "result": f.result,
+                    "confidence": f.confidence,
+                    "ai_explanation": f.ai_explanation,
                     "uploaded_at": f.created_at
                 }
                 for f in files
@@ -57,6 +59,8 @@ def get_file(
         "size": file.filesize,
         "status": file.status,
         "result": file.result,
+        "confidence": file.confidence,
+        "ai_explanation": file.ai_explanation,
         "uploaded_at": file.created_at
     }
 

backend/app/models/file_model.py

@@ -1,4 +1,4 @@
-from sqlalchemy import Column, Integer, String, DateTime, ForeignKey
+from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Float
 from datetime import datetime, UTC
 from app.db.database import Base
 
@@ -17,5 +17,7 @@ class File(Base):
     
     status = Column(String, default="uploaded")
     result = Column(String, nullable=True)
+    confidence = Column(Float, nullable=True)
+    ai_explanation = Column(String, nullable=True)
 
     model_version_used = Column(String, nullable=True)

backend/app/security/video_validator.py

@@ -29,19 +29,23 @@ class VideoValidator:
             
             bytes_read = 0
 
-            with tempfile.NamedTemporaryFile(delete=True, suffix=ext) as temp_video:
-                while chunk := file.file.read(1024 * 1024): # Read 1 MB at a time
-                    bytes_read += len(chunk)
-                    if bytes_read > cls.MAX_FILE_BYTES:
-                        logger.warning(f"Security Alert: Blocked upload exceeding {cls.MAX_FILE_BYTES} bytes")
-                        return False, "File size exceeds the maximum allowed limit"
-
-                    temp_video.write(chunk)
+            temp_path = None
+            try:
+                with tempfile.NamedTemporaryFile(delete=False, suffix=ext) as temp_video:
+                    temp_path = temp_video.name
+                    while chunk := file.file.read(1024 * 1024): # Read 1 MB at a time
+                        bytes_read += len(chunk)
+                        if bytes_read > cls.MAX_FILE_BYTES:
+                            logger.warning(f"Security Alert: Blocked upload exceeding {cls.MAX_FILE_BYTES} bytes")
+                            return False, "File size exceeds the maximum allowed limit"
+
+                        temp_video.write(chunk)
+                    
+                    temp_video.flush()
                 
-                temp_video.flush()
+                # File is safely closed by Python now, so OpenCV can gain read-access on Windows
                 file.file.seek(0)
-
-                cap = cv2.VideoCapture(temp_video.name)
+                cap = cv2.VideoCapture(temp_path)
 
                 if not cap.isOpened():
                     logger.warning("Security Alert: OpenCV failed to open the video container. File may be corrupted or disguised.")
@@ -55,6 +59,13 @@ class VideoValidator:
                     logger.warning("Security Alert: OpenCV opened container but failed to extract any visual frames.")
                     return False, "Video contains no readable visual frames."
             
+            finally:
+                if temp_path and os.path.exists(temp_path):
+                    try:
+                        os.remove(temp_path)
+                    except:
+                        pass
+            
             return True, "Valid"
         
         except Exception as e:

backend/app/services/video_processor.py

@@ -0,0 +1,86 @@
+import time
+import logging
+import os
+from sqlalchemy.orm import Session
+from app.models.file_model import File
+from app.ai.video.frame_extractor import extract_frames
+from app.ai.video.frame_detector import analyze_frame
+from app.ai.video.motion_detector import compute_motion_anomaly
+from app.ai.video.noise_entropy_detector import compute_noise_entropy_anomaly
+from app.ai.video.metadata_analyzer import analyze_metadata
+from app.ai.video.aggregator import aggregate_scores
+
+logger = logging.getLogger(__name__)
+
+def process_video_pipeline(file_id: int, file_path: str, db: Session):
+    start_time = time.time()
+    logger.info(f"Starting Video Pipeline for file_id: {file_id}")
+
+    try:
+        db_file = db.query(File).filter(File.id == file_id).first()
+        if not db_file:
+            logger.error(f"File ID {file_id} not found in DB.")
+            return
+        
+        md_score, md_dict = analyze_metadata(file_path)
+
+        frame_scores = []
+        motion_scores = []
+        noise_scores = []
+
+        previous_frame = None
+
+        for frame in extract_frames(file_path, sample_rate=15, max_frames=50):
+            
+            # Module A: ViT Image Forensic Analysis
+            f_score = analyze_frame(frame)
+            frame_scores.append(f_score)
+
+            # Module B: Microscopic Silicon Noise Analysis
+            n_score = compute_noise_entropy_anomaly(frame)
+            if n_score is not None:
+                noise_scores.append(n_score)
+            
+            # Module C: Farneback Optical Flow
+            if previous_frame is not None:
+                m_score = compute_motion_anomaly(previous_frame, frame)
+                
+                if m_score is not None:
+                    motion_scores.append(m_score)
+            
+            previous_frame = frame
+        
+        avg_motion = sum(motion_scores)/len(motion_scores) if motion_scores else None
+        avg_noise = sum(noise_scores)/len(noise_scores) if noise_scores else None
+
+
+        final_verdict = aggregate_scores(
+            frame_scores=frame_scores,
+            motion_score=avg_motion,
+            noise_score=avg_noise,
+            metadata_score=md_score
+        )
+
+        db_file.status = "Completed"
+        db_file.result = f"{final_verdict['label']} ({final_verdict['probability']*100:.1f}%)"
+        db_file.confidence = final_verdict['probability']
+        db_file.ai_explanation = final_verdict['explanation']
+
+        db.commit()
+
+        elapsed = time.time() - start_time
+        logger.info(f"Successfully processed video {file_id} in {elapsed:.2f} seconds.")
+        logger.info(f"Verdict: {db_file.result}")
+    
+    except Exception as e:
+        logger.error(f"FATAL Pipeline Crash for file_id {file_id}: {str(e)}")
+
+        try:
+            db_file = db.query(File).filter(File.id == file_id).first()
+
+            if db_file:
+                db_file.status = "Failed"
+                db_file.result = str(e)
+                db.commit()
+        except:
+            pass

backend/app/utils/file_handler.py

@@ -26,8 +26,10 @@ def validate_file(file: UploadFile):
         if not is_valid:
             raise HTTPException(status_code=400, detail=validation_reason)
         
+        file.file.seek(0) # CRITICAL: Reset the pointer after Video validation reads it!
         return file.size or 0
     
+    file.file.seek(0)
     file_bytes = file.file.read()
     size = len(file_bytes)
 

backend/app/worker/tasks.py

@@ -41,7 +41,14 @@ def process_file_task(self, file_id: int):
 
     logger.info(f"Starting Celery worker process for file_id: {file_id}")
     try:
-        process_file(file_id, db)
+        from app.models.file_model import File
+        db_file = db.query(File).filter(File.id == file_id).first()
+        
+        if db_file and db_file.filetype and db_file.filetype.startswith('video/'):
+            from app.services.video_processor import process_video_pipeline
+            process_video_pipeline(file_id, db_file.filepath, db)
+        else:
+            process_file(file_id, db)
 
         job.status = "COMPLETED"
         job.finished_at = datetime.now(UTC)