deepfake services

README.md

@@ -1,10 +1,12 @@
----
-title: Credify
-emoji: 💻
-colorFrom: indigo
-colorTo: red
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+use python 3.10 for this project as the audio extraction library can work with this version only
+
+create a virtual environment : .\venv\Scripts\activate 
+
+install the required libraries using :  pip install -r requirements.txt                   
+
+run the app using :  uvicorn app.main:app --reload  
+
+The issue you are facing regarding while re uploading the same image or audio the path error shows up is die to mssing ffmpeg installation on your device the solution for the same :
+- open cmd and type :  winget install ffmpeg
+- after the installation has been sucessfully done add the bin path to the System environment variables
+- if u fail to find the path just type : where ffmpeg , in cmd and you will get the path

app/api/forgery_routes.py

@@ -0,0 +1,151 @@
+from fastapi import APIRouter, HTTPException
+from app.services.image_manipulation_service import ImageManipulationService
+from app.services.face_manipulation_service import FaceManipulationService
+from app.services.audio_deepfake_service import AudioDeepfakeService
+from app.services.gan_detection_service import GANDetectionService
+from app.utils.file_utils import download_file, remove_temp_file, get_file_content
+from app.utils.forgery_image_utils import detect_face
+from app.utils.forgery_video_utils import extract_audio, extract_frames, compress_and_process_video
+import os
+import logging
+import traceback
+from pydantic import BaseModel
+
+router = APIRouter()
+
+class DetectForgeryRequest(BaseModel):
+    file_url: str
+
+# Initialize services
+image_manipulation_service = ImageManipulationService()
+face_manipulation_service = FaceManipulationService()
+audio_deepfake_service = AudioDeepfakeService()
+gan_detection_service = GANDetectionService()
+
+def parse_confidence(value):
+    if isinstance(value, str):
+        return float(value.rstrip('%')) / 100
+    return float(value)
+
+def get_file_extension(url: str) -> str:
+    _, ext = os.path.splitext(url)
+    return ext.lstrip('.').lower()
+
+@router.post("/detect_forgery")
+async def detect_forgery(request: DetectForgeryRequest):
+    file_url = request.file_url
+    logging.info(f"Received forgery detection request for file: {file_url}")
+    
+    firebase_filename = None
+    
+    try:
+        file_extension = get_file_extension(file_url)
+        logging.info(f"Detected file extension: {file_extension}")
+        
+        firebase_filename = await download_file(file_url)
+        logging.info(f"File downloaded and saved as: {firebase_filename}")
+        
+        if file_extension in ['jpg', 'jpeg', 'png', 'gif', 'bmp']:
+            logging.info(f"Processing image file: {firebase_filename}")
+            return await process_image(firebase_filename)
+        elif file_extension in ['mp4', 'avi', 'mov', 'flv', 'wmv']:
+            logging.info(f"Processing video file: {firebase_filename}")
+            return await process_video(firebase_filename)
+        else:
+            logging.error(f"Unsupported file type: {file_extension} (URL: {file_url})")
+            raise HTTPException(status_code=400, detail=f"Unsupported file type: {file_extension}")
+    
+    except Exception as e:
+        logging.error(f"Error processing file: {e}")
+        logging.error(traceback.format_exc())
+        raise HTTPException(status_code=500, detail="An error occurred while processing the file.")
+    
+    finally:
+        if firebase_filename:
+            logging.info(f"Removing temporary file: {firebase_filename}")
+            await remove_temp_file(firebase_filename)
+
+async def process_image(firebase_filename: str):
+    logging.info(f"Starting image processing for: {firebase_filename}")
+    image_content = get_file_content(firebase_filename)
+    has_face = detect_face(image_content)
+    logging.info(f"Face detection result for {firebase_filename}: {'Face detected' if has_face else 'No face detected'}")
+    results = {
+        "image_manipulation": image_manipulation_service.detect_manipulation(firebase_filename),
+        "gan_detection": gan_detection_service.detect_gan(firebase_filename)
+    }
+    logging.info(f"Image manipulation detection result: {results['image_manipulation']}")
+    logging.info(f"GAN detection result: {results['gan_detection']}")
+    if has_face:
+        results["face_manipulation"] = face_manipulation_service.detect_manipulation(firebase_filename)
+        logging.info(f"Face manipulation detection result: {results['face_manipulation']}")
+    else:
+        results["face_manipulation"] = None
+        logging.info("Face manipulation detection skipped (no face detected)")
+    logging.info(f"Image processing completed for: {firebase_filename}")
+    return results
+
+async def process_video(firebase_filename: str):
+    logging.info(f"Starting video processing for: {firebase_filename}")
+    try:
+        compressed_video_filename = await compress_and_process_video(firebase_filename)
+        logging.info(f"Video compressed: {compressed_video_filename}")
+        
+        audio_filename = await extract_audio(compressed_video_filename)
+        logging.info(f"Audio extracted: {audio_filename}")
+        
+        frames = await extract_frames(compressed_video_filename)
+        logging.info(f"Frames extracted: {len(frames)} frames")
+
+        results = {
+            "audio_deepfake": None,
+            "image_manipulation": [],
+            "face_manipulation": [],
+            "gan_detection": []
+        }
+
+        if audio_filename:
+            results["audio_deepfake"] = audio_deepfake_service.detect_deepfake(audio_filename)
+            logging.info(f"Audio deepfake detection result: {results['audio_deepfake']}")
+            await remove_temp_file(audio_filename)
+            logging.info(f"Temporary audio file removed: {audio_filename}")
+
+        face_frames = []
+        for i, frame in enumerate(frames):
+            frame_filename = frame  # Assuming extract_frames now returns a list of filenames
+            logging.info(f"Processing frame: {frame_filename}")
+            frame_content = get_file_content(frame_filename)
+            has_face = detect_face(frame_content)
+            logging.info(f"Face detection result for {frame_filename}: {'Face detected' if has_face else 'No face detected'}")
+
+            results["image_manipulation"].append(image_manipulation_service.detect_manipulation(frame_filename))
+            results["gan_detection"].append(gan_detection_service.detect_gan(frame_filename))
+
+            if has_face:
+                face_frames.append(frame_filename)
+                results["face_manipulation"].append(face_manipulation_service.detect_manipulation(frame_filename))
+            else:
+                results["face_manipulation"].append(None)
+                logging.info(f"Face manipulation detection skipped for {frame_filename} (no face detected)")
+
+            await remove_temp_file(frame_filename)
+            logging.info(f"Temporary frame file removed: {frame_filename}")
+
+        # Aggregate results
+        for key in results:
+            if key != "audio_deepfake" and results[key]:
+                valid_results = [r for r in results[key] if r is not None]
+                results[key] = {
+                    "collective_detection": any(r.get("is_manipulated", False) if isinstance(r, dict) else r for r in valid_results),
+                    "collective_confidence": sum(parse_confidence(r.get("confidence", 0)) if isinstance(r, dict) else 0 for r in valid_results) / len(valid_results) if valid_results else 0
+                }
+        logging.info(f"Aggregated results: {results}")
+
+        await remove_temp_file(compressed_video_filename)
+        logging.info(f"Temporary compressed video file removed: {compressed_video_filename}")
+        logging.info(f"Video processing completed for: {firebase_filename}")
+        return results
+    except Exception as e:
+        logging.error(f"Error processing video: {e}")
+        logging.error(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"An error occurred while processing the video: {str(e)}")

app/api/routes.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, HTTPException, Response
+from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
 from app.services import video_service, image_service, antispoof_service
 from app.services.antispoof_service import antispoof_service
@@ -14,14 +14,6 @@ class CompareRequest(BaseModel):
     url1: str
     url2: str
 
-@router.get("/health")
-@router.head("/health")
-async def health_check():
-    """
-    Health check endpoint that responds to both GET and HEAD requests.
-    """
-    return Response(content="OK", media_type="text/plain")
-
 @router.post("/fingerprint")
 async def create_fingerprint(request: ContentRequest):
     try:

app/main.py

@@ -4,6 +4,7 @@ from fastapi.responses import JSONResponse
 from app.api.routes import router
 from app.core.logging_config import configure_logging
 from app.core.firebase_config import initialize_firebase
+from app.api.forgery_routes import router as forgery_router
 import logging
 
 app = FastAPI()
@@ -14,6 +15,7 @@ async def startup_event():
     initialize_firebase()
 
 app.include_router(router)
+app.include_router(forgery_router)
 
 @app.exception_handler(Exception)
 async def global_exception_handler(request: Request, exc: Exception):

app/services/audio_deepfake_service.py

@@ -0,0 +1,55 @@
+import numpy as np
+import librosa as lb
+from tensorflow.keras.models import load_model
+from app.utils.file_utils import get_file_content
+import io
+import logging
+
+class AudioDeepfakeService:
+    def __init__(self):
+        logging.info("Initializing AudioDeepfakeService")
+        self.model = load_model("models/DeepFakeVoiceDetector_V1.h5")
+        logging.info("AudioDeepfakeService model loaded successfully")
+
+    def create_mel_spectrogram_sample(self, audio_content, sr=22050, sample_time=1.5, n_mels=64):
+        logging.info("Creating mel spectrogram sample")
+        y, sr = lb.load(io.BytesIO(audio_content), sr=sr)
+        logging.info(f"Audio loaded with sample rate: {sr}")
+
+        sample_length = int(sr * sample_time)
+        if len(y) < sample_length:
+            logging.warning("Audio file is too short")
+            raise ValueError("Audio file is too short")
+
+        start = 0
+        end = start + sample_length
+        m = lb.feature.melspectrogram(y=y[start:end], sr=sr, n_mels=n_mels)
+        m = np.abs(m)
+        m /= 80
+        logging.info("Mel spectrogram sample created successfully")
+        return np.expand_dims(m, axis=-1)
+
+    def detect_deepfake(self, firebase_filename):
+        logging.info(f"Detecting deepfake for audio file: {firebase_filename}")
+        try:
+            audio_content = get_file_content(firebase_filename)
+            logging.info("Audio content retrieved successfully")
+            sample = self.create_mel_spectrogram_sample(audio_content)
+            logging.info("Mel spectrogram sample created")
+            prediction = self.model.predict(np.expand_dims(sample, axis=0))[0][0]
+            logging.info(f"Raw prediction: {prediction}")
+
+            result = "Fake" if prediction > 0.5 else "Real"
+            confidence = prediction if prediction > 0.5 else 1 - prediction
+
+            result_dict = {
+                "prediction": result,
+                "confidence": float(confidence),
+                "raw_prediction": float(prediction)
+            }
+            logging.info(f"Deepfake detection result: {result_dict}")
+            return result_dict
+
+        except Exception as e:
+            logging.error(f"Error processing audio: {str(e)}")
+            raise ValueError(f"Error processing audio: {str(e)}")

app/services/face_manipulation_service.py

@@ -0,0 +1,66 @@
+import torch
+import json
+from pathlib import Path
+from PIL import Image
+from transformers import ViTForImageClassification, ViTImageProcessor
+from app.utils.file_utils import get_file_content
+import io
+import logging
+
+class FaceManipulationService:
+    def __init__(self):
+        logging.info("Initializing FaceManipulationService")
+        self.device = torch.device('cpu')
+        logging.info(f"Using device: {self.device}")
+
+        model_config = json.loads(Path("models/deepfake_model_config.json").read_text())
+        self.image_params = json.loads(Path("models/deepfake_image_params.json").read_text())
+        label_mappings = json.loads(Path("models/deepfake_label_mappings.json").read_text())
+        logging.info("Configuration files loaded successfully")
+
+        self.model = ViTForImageClassification.from_pretrained("models/deepfake_model", num_labels=model_config["num_labels"])
+        self.model.load_state_dict(torch.load("models/deepfake_model.pth", map_location=self.device))
+        self.model.to(self.device)
+        self.model.eval()
+        logging.info("Face manipulation detection model loaded and set to evaluation mode")
+
+        self.id2label = {int(k): v for k, v in label_mappings["id2label"].items()}
+        logging.info(f"Label mappings: {self.id2label}")
+
+        self.processor = ViTImageProcessor(
+            size=self.image_params["size"],
+            image_mean=self.image_params["mean"],
+            image_std=self.image_params["std"]
+        )
+        logging.info("Image processor initialized")
+
+    def predict_image(self, firebase_filename):
+        logging.info(f"Predicting image manipulation for: {firebase_filename}")
+        image_content = get_file_content(firebase_filename)
+        logging.info("Image content retrieved successfully")
+        image = Image.open(io.BytesIO(image_content))
+        logging.info(f"Image opened. Size: {image.size}, Mode: {image.mode}")
+        inputs = self.processor(images=image, return_tensors="pt").to(self.device)
+        logging.info("Image processed and inputs prepared")
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+        logging.info("Model inference completed")
+        probs = outputs.logits.softmax(1)
+        pred_class = probs.argmax().item()
+        confidence = probs[0][pred_class].item()
+        predicted_label = self.id2label[pred_class]
+        logging.info(f"Prediction: Class {pred_class}, Label: {predicted_label}, Confidence: {confidence}")
+        return predicted_label, confidence
+
+    def detect_manipulation(self, firebase_filename):
+        logging.info(f"Detecting face manipulation for: {firebase_filename}")
+        label, confidence = self.predict_image(firebase_filename)
+        is_deepfake = label == "Fake"
+
+        result = {
+            "is_deepfake": is_deepfake,
+            "confidence": float(confidence),
+            "predicted_label": label
+        }
+        logging.info(f"Face manipulation detection result: {result}")
+        return result

app/services/gan_detection_service.py

@@ -0,0 +1,30 @@
+import numpy as np
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing import image
+from app.utils.file_utils import get_file_content
+import io
+
+class GANDetectionService:
+    def __init__(self):
+        self.model = load_model('models/gan_model.h5')
+
+    def load_and_preprocess_image(self, image_content, target_size=(256, 256)):
+        img = image.load_img(io.BytesIO(image_content), target_size=target_size)
+        img_array = image.img_to_array(img)
+        img_array = img_array / 255.0
+        img_array = np.expand_dims(img_array, axis=0)
+        return img_array
+
+    def detect_gan(self, firebase_filename):
+        image_content = get_file_content(firebase_filename)
+        img_array = self.load_and_preprocess_image(image_content)
+        prediction = self.model.predict(img_array)
+
+        real_confidence = float(prediction[0][0] * 100)
+        fake_confidence = float((1 - prediction[0][0]) * 100)
+
+        return {
+            "is_gan": fake_confidence > real_confidence,
+            "real_confidence": real_confidence,
+            "fake_confidence": fake_confidence
+        }

app/services/image_manipulation_service.py

@@ -0,0 +1,57 @@
+import tensorflow as tf
+import numpy as np
+from PIL import Image, ImageChops, ImageEnhance
+import json
+from app.utils.file_utils import get_file_content
+import io
+
+class ImageManipulationService:
+    def __init__(self):
+        self.model = tf.keras.models.load_model('models/image_manipulation_detection_model.h5')
+
+        with open('models/img_manipulation_class_names.json', 'r') as f:
+            self.class_names = json.load(f)
+
+        with open('models/img_man_preprocessing_params.json', 'r') as f:
+            self.preprocessing_params = json.load(f)
+
+    def convert_to_ela_image(self, image, quality):
+        temp_buffer = io.BytesIO()
+        image.save(temp_buffer, 'JPEG', quality=quality)
+        temp_buffer.seek(0)
+        temp_image = Image.open(temp_buffer)
+
+        ela_image = ImageChops.difference(image, temp_image)
+
+        extrema = ela_image.getextrema()
+        max_diff = max([ex[1] for ex in extrema])
+        if max_diff == 0:
+            max_diff = 1
+        scale = 255.0 / max_diff
+
+        ela_image = ImageEnhance.Brightness(ela_image).enhance(scale)
+
+        return ela_image
+
+    def prepare_image(self, image_content):
+        image = Image.open(io.BytesIO(image_content))
+        ela_image = self.convert_to_ela_image(image, quality=90)
+        ela_image = ela_image.resize((128, 128))
+        return np.array(ela_image).flatten() / 255.0
+
+    def detect_manipulation(self, firebase_filename):
+        image_content = get_file_content(firebase_filename)
+        prepared_image = self.prepare_image(image_content)
+        prepared_image = prepared_image.reshape(-1, 128, 128, 3)
+
+        prediction = self.model.predict(prepared_image)
+        predicted_class = int(np.argmax(prediction, axis=1)[0])
+        confidence = float(np.max(prediction) * 100)
+
+        result = {
+            "class": self.class_names[predicted_class],
+            "confidence": f"{confidence:.2f}%",
+            "is_manipulated": bool(predicted_class == 0)
+        }
+
+        return result

app/services/video_service.py

@@ -115,8 +115,8 @@ async def compare_videos(video_url1, video_url2):
     fp1 = await fingerprint_video(video_url1)
     fp2 = await fingerprint_video(video_url2)
 
-    video_similarity = 1 - (imagehash.hex_to_hash(fp1['robust_video_hash']) - imagehash.hex_to_hash(fp2['robust_video_hash'])) / 64.0
-    audio_similarity = 1 - (imagehash.hex_to_hash(fp1['robust_audio_hash']) - imagehash.hex_to_hash(fp2['robust_audio_hash'])) / 64.0
+    video_similarity = 1 - (imagehash.hex_to_hash(fp1['video_hash']) - imagehash.hex_to_hash(fp2['video_hash'])) / 64.0
+    audio_similarity = 1 - (imagehash.hex_to_hash(fp1['audio_hash']) - imagehash.hex_to_hash(fp2['audio_hash'])) / 64.0
 
     overall_similarity = (video_similarity + audio_similarity) / 2
     is_same_content = overall_similarity > 0.9  # You can adjust this threshold

app/utils/file_utils.py

@@ -52,4 +52,15 @@ def get_file_stream(filename: str) -> io.BytesIO:
         return io.BytesIO(content)
     except Exception as e:
         logging.error(f"Error getting file stream from Firebase: {str(e)}")
+        raise
+    
+
+async def upload_file_to_firebase(file_content: bytes, filename: str) -> str:
+    try:
+        blob = firebase_bucket.blob(filename)
+        blob.upload_from_string(file_content, content_type='application/octet-stream')
+        logging.info(f"File uploaded to Firebase: {filename}")
+        return filename
+    except Exception as e:
+        logging.error(f"Error uploading file to Firebase: {str(e)}")
         raise

app/utils/forgery_image_utils.py

@@ -0,0 +1,47 @@
+import cv2
+import numpy as np
+from typing import Union
+from PIL import Image
+from io import BytesIO
+import imghdr
+from fastapi import HTTPException
+from app.utils.file_utils import get_file_content
+
+SUPPORTED_IMAGE_FORMATS = ['.jpg', '.jpeg', '.png', '.bmp', '.gif', '.tiff', '.webp']
+
+def verify_image_format(firebase_filename: str):
+    content = get_file_content(firebase_filename)
+    file_ext = '.' + (imghdr.what(BytesIO(content)) or '')
+    if file_ext not in SUPPORTED_IMAGE_FORMATS:
+        raise HTTPException(status_code=400, detail=f"Unsupported image format. Supported formats are: {', '.join(SUPPORTED_IMAGE_FORMATS)}")
+
+def preprocess_image(image: Union[str, np.ndarray, Image.Image], hash_size: int = 32) -> np.ndarray:
+    if isinstance(image, str):
+        content = get_file_content(image)
+        img = Image.open(BytesIO(content))
+        img = strip_metadata(img)
+        image = np.array(img)
+    elif isinstance(image, Image.Image):
+        image = strip_metadata(image)
+        image = np.array(image)
+    
+    if len(image.shape) == 3:
+        image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    
+    image = cv2.resize(image, (hash_size, hash_size), interpolation=cv2.INTER_AREA)
+    image = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX)
+    return image
+
+def strip_metadata(img: Image.Image) -> Image.Image:
+    data = list(img.getdata())
+    img_without_exif = Image.new(img.mode, img.size)
+    img_without_exif.putdata(data)
+    return img_without_exif
+
+def detect_face(image_content: bytes) -> bool:
+    nparr = np.frombuffer(image_content, np.uint8)
+    img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
+    return len(faces) > 0

app/utils/forgery_video_utils.py

@@ -0,0 +1,138 @@
+import cv2
+import numpy as np
+from moviepy.editor import VideoFileClip
+from PIL import Image
+import io
+from app.utils.file_utils import get_file_content, upload_file_to_firebase, remove_temp_file
+import subprocess
+import tempfile
+import os
+import logging
+
+async def extract_audio(firebase_filename):
+    try:
+        video_content = get_file_content(firebase_filename)
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_video:
+            temp_video.write(video_content)
+            temp_video_path = temp_video.name
+
+        with VideoFileClip(temp_video_path) as video:
+            if video.audio is not None:
+                audio_filename = f"{firebase_filename}_audio.wav"
+                with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as temp_audio:
+                    video.audio.write_audiofile(temp_audio.name, logger=None)
+                    temp_audio_path = temp_audio.name
+
+                with open(temp_audio_path, 'rb') as audio_file:
+                    audio_content = audio_file.read()
+                
+                await upload_file_to_firebase(audio_content, audio_filename)
+                os.remove(temp_audio_path)
+                os.remove(temp_video_path)
+                return audio_filename
+        
+        os.remove(temp_video_path)
+    except Exception as e:
+        logging.error(f"Error extracting audio: {str(e)}")
+    return None
+
+async def extract_frames(firebase_filename, max_frames=10):
+    frames = []
+    video_content = get_file_content(firebase_filename)
+    
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_video:
+        temp_video.write(video_content)
+        temp_video_path = temp_video.name
+
+    try:
+        with VideoFileClip(temp_video_path) as video:
+            duration = video.duration
+            frame_interval = duration / max_frames
+
+            for i in range(max_frames):
+                t = i * frame_interval
+                frame = video.get_frame(t)
+                frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                frame_image = Image.fromarray(frame_rgb)
+                
+                frame_filename = f"{firebase_filename}_frame_{i}.jpg"
+                frame_byte_arr = io.BytesIO()
+                frame_image.save(frame_byte_arr, format='JPEG')
+                frame_byte_arr = frame_byte_arr.getvalue()
+                
+                await upload_file_to_firebase(frame_byte_arr, frame_filename)
+                frames.append(frame_filename)
+
+    finally:
+        os.remove(temp_video_path)
+
+    return frames
+
+async def compress_and_process_video(firebase_filename, target_size_mb=50, max_duration=60):
+    video_content = get_file_content(firebase_filename)
+    
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_video:
+        temp_video.write(video_content)
+        input_path = temp_video.name
+
+    output_filename = f"{firebase_filename}_compressed.mp4"
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_output:
+        output_path = temp_output.name
+
+    try:
+        probe_cmd = ['ffprobe', '-v', 'error', '-select_streams', 'v:0',
+                     '-show_entries', 'stream=width,height,duration,bit_rate',
+                     '-of', 'json', input_path]
+
+        result = subprocess.run(probe_cmd, capture_output=True, text=True)
+        video_info = eval(result.stdout)['streams'][0]
+
+        width = video_info.get('width', 1280)
+        height = video_info.get('height', 720)
+        duration = float(video_info.get('duration', '0'))
+        original_bitrate = int(video_info.get('bit_rate', '0'))
+
+        if duration <= 0:
+            logging.warning(f"Invalid video duration ({duration}). Using 1 second as default.")
+            duration = 1
+
+        duration = min(duration, max_duration)
+
+        target_size_bits = target_size_mb * 8 * 1024 * 1024
+        target_bitrate = int(target_size_bits / duration)
+
+        if width > height:
+            new_width = min(width, 1280)
+            new_height = int((new_width / width) * height)
+        else:
+            new_height = min(height, 720)
+            new_width = int((new_height / height) * width)
+
+        new_width = new_width - (new_width % 2)
+        new_height = new_height - (new_height % 2)
+
+        cmd = [
+            'ffmpeg', '-y', '-i', input_path,
+            '-c:v', 'libx264', '-preset', 'faster',
+            '-crf', '23',
+            '-b:v', f'{target_bitrate}',
+            '-maxrate', f'{int(1.5*target_bitrate)}',
+            '-bufsize', f'{2*target_bitrate}',
+            '-vf', f'scale={new_width}:{new_height}',
+            '-t', str(duration),
+            '-c:a', 'aac', '-b:a', '128k',
+            output_path
+        ]
+
+        subprocess.run(cmd, check=True, capture_output=True)
+
+        with open(output_path, 'rb') as compressed_video:
+            compressed_content = compressed_video.read()
+        
+        await upload_file_to_firebase(compressed_content, output_filename)
+
+    finally:
+        os.remove(input_path)
+        os.remove(output_path)
+
+    return output_filename

models/DeepFakeVoiceDetector_V1.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e6b46662643d50c4f91d1bb2efe2e1df5dad9e7aef9ac77ea1f0b3950c7a4f68
+size 7820664

models/deepfake_image_params.json

@@ -0,0 +1 @@
+{"size": 224, "mean": [0.5, 0.5, 0.5], "std": [0.5, 0.5, 0.5]}

models/deepfake_label_mappings.json

@@ -0,0 +1 @@
+{"id2label": {"0": "Real", "1": "Fake"}, "label2id": {"Real": 0, "Fake": 1}}

models/deepfake_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8bd4c50ebcf3f3c63c8ba47279a46154b40c8951024ce2d84bb5bf48d12c8787
+size 343268125

models/deepfake_model/config.json

@@ -0,0 +1,32 @@
+{
+  "_name_or_path": "dima806/deepfake_vs_real_image_detection",
+  "architectures": [
+    "ViTForImageClassification"
+  ],
+  "attention_probs_dropout_prob": 0.0,
+  "encoder_stride": 16,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.0,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "Real",
+    "1": "Fake"
+  },
+  "image_size": 224,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "Fake": 1,
+    "Real": 0
+  },
+  "layer_norm_eps": 1e-12,
+  "model_type": "vit",
+  "num_attention_heads": 12,
+  "num_channels": 3,
+  "num_hidden_layers": 12,
+  "patch_size": 16,
+  "problem_type": "single_label_classification",
+  "qkv_bias": true,
+  "torch_dtype": "float32",
+  "transformers_version": "4.44.2"
+}

models/deepfake_model/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b38e7d3de2be44b224cb4cffe881a0c4b75f7283c5d4a2017fbadd58bd41fdef
+size 343223968

models/deepfake_model_config.json

@@ -0,0 +1 @@
+{"num_labels": 2, "model_name": "dima806/deepfake_vs_real_image_detection"}

models/gan_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0390eddbacc1eae4337957da885070ce66151b7870bdfb22bc6ed28854bb89e2
+size 183006752

models/image_manipulation_detection_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:24752f81e5da1362b4690b12d434e80d2b8e2953836617456fcbcc65bed836f6
+size 354282808

models/img_man_preprocessing_params.json

@@ -0,0 +1 @@
+{"image_size": [128, 128], "ela_quality": 90}

models/img_manipulation_class_names.json

@@ -0,0 +1 @@
+["fake", "real"]

requirements.txt

@@ -1,17 +1,21 @@
 aiohttp==3.10.5
-fastapi==0.109.2
-# ffmpeg==1.4
-ffmpeg-python==0.2.0
+fastapi==0.115.0
+#ffmpeg==1.4
+ffmpeg_python==0.2.0
 firebase_admin==6.5.0
-imagehash==4.3.1
+ImageHash==4.3.1
 librosa==0.10.2.post1
-numpy>=1.23.5,<2.0.0
+moviepy==1.0.3
+numpy==2.1.1
+opencv_python==4.10.0.84
+opencv_python_headless==4.10.0.84
 Pillow==10.4.0
-pydantic==2.6.1
+pydantic==2.9.2
 pydub==0.25.1
 python-dotenv==1.0.1
 scipy==1.14.1
-tensorflow==2.15.0
+tensorflow==2.17.0
+tensorflow_intel==2.17.0
+torch==2.4.1
+transformers==4.44.2
 uvicorn==0.30.6
-opencv-python==4.8.0.74
-python-magic==0.4.27