setup

.gitignore

@@ -0,0 +1,176 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+# End of https://www.toptal.com/developers/gitignore/api/python

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.10.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . /code/
+
+# Expose the secret FIREBASE_KEY_BASE64 at buildtime and save it as a file
+RUN --mount=type=secret,id=FIREBASE_KEY_BASE64,mode=0444,required=true \
+    cat /run/secrets/FIREBASE_KEY_BASE64 | base64 -d > /code/firebase_key.json
+
+# Set the Google Application Credentials environment variable
+ENV GOOGLE_APPLICATION_CREDENTIALS="/code/firebase_key.json"
+
+# The FIREBASE_STORAGE_BUCKET will be available at runtime as an environment variable
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README copy.md

@@ -0,0 +1,12 @@
+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/routes.py

@@ -0,0 +1,78 @@
+from fastapi import APIRouter, HTTPException, Response
+from pydantic import BaseModel
+from app.services import video_service, image_service, antispoof_service
+from app.services.antispoof_service import antispoof_service
+from app.services.image_service import compare_images
+import logging
+
+router = APIRouter()
+
+class ContentRequest(BaseModel):
+    url: str
+
+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:
+        result = await video_service.fingerprint_video(request.url)
+        return {"message": "Fingerprint processing completed", "result": result}
+    except Exception as e:
+        logging.error(f"Error in fingerprint processing: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error in fingerprint processing: {str(e)}")
+
+@router.post("/verify_video_only")
+async def verify_video_only(request: ContentRequest):
+    try:
+        result = await video_service.fingerprint_video(request.url)
+        return {"message": "Video verification completed", "result": result}
+    except Exception as e:
+        logging.error(f"Error in video verification: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error in video verification: {str(e)}")
+
+@router.post("/verify_liveness")
+async def verify_liveness(request: ContentRequest):
+    try:
+        result = await antispoof_service.verify_liveness(request.url)
+        return {"message": "Liveness verification completed", "result": result}
+    except Exception as e:
+        logging.error(f"Error in liveness verification: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error in liveness verification: {str(e)}")
+
+@router.post("/compare_videos")
+async def compare_videos_route(request: CompareRequest):
+    try:
+        result = await video_service.compare_videos(request.url1, request.url2)
+        return {"message": "Video comparison completed", "result": result}
+    except Exception as e:
+        logging.error(f"Error in video comparison: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error in video comparison: {str(e)}")
+
+@router.post("/verify_image")
+async def verify_image_route(request: ContentRequest):
+    try:
+        result = await image_service.verify_image(request.url)
+        return {"message": "Image verification completed", "result": result}
+    except Exception as e:
+        logging.error(f"Error in image verification: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error in image verification: {str(e)}")
+
+@router.post("/compare_images")
+async def compare_images_route(request: CompareRequest):
+    try:
+        # Call the image comparison service with the URLs from the request body
+        result = await compare_images(request.url1, request.url2)
+        return {"message": "Image comparison completed", "result": result}
+    except Exception as e:
+        logging.error(f"Error in image comparison: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error in image comparison: {str(e)}")

app/core/config.py

@@ -0,0 +1,11 @@
+import os
+from pathlib import Path
+
+# Base directory of the project
+BASE_DIR = Path(__file__).resolve().parent.parent.parent
+
+
+# Anti-spoofing model and config paths
+MODEL_PATH = os.path.join(BASE_DIR, "models", "mobilenetv2_spoof_model.h5")
+CONFIG_PATH = os.path.join(BASE_DIR, "models", "model_config.json")
+

app/core/firebase_config.py

@@ -0,0 +1,41 @@
+import os
+import base64
+import json
+from firebase_admin import credentials, initialize_app, storage
+from dotenv import load_dotenv
+
+load_dotenv()
+
+_firebase_app = None
+_firebase_bucket = None
+
+def initialize_firebase():
+    global _firebase_app, _firebase_bucket
+    
+    if _firebase_app is not None:
+        return _firebase_bucket
+    
+    firebase_key_base64 = os.getenv('FIREBASE_KEY_BASE64')
+    if not firebase_key_base64:
+        raise ValueError("Environment variable FIREBASE_KEY_BASE64 is not set or is empty")
+
+    try:
+        print("Decoding Firebase key...")
+        firebase_key_json = base64.b64decode(firebase_key_base64).decode('utf-8')
+        firebase_key_dict = json.loads(firebase_key_json)
+        
+        print("Initializing Firebase...")
+        cred = credentials.Certificate(firebase_key_dict)
+        
+        # Initialize Firebase with a unique name if needed
+        _firebase_app = initialize_app(cred, {
+            'storageBucket': os.getenv('FIREBASE_STORAGE_BUCKET')
+        })
+        
+        _firebase_bucket = storage.bucket(app=_firebase_app)
+        print("Firebase initialized successfully.")
+        return _firebase_bucket
+    except Exception as e:
+        raise RuntimeError(f"Error initializing Firebase: {e}")
+
+firebase_bucket = initialize_firebase()

app/core/logging_config.py

@@ -0,0 +1,5 @@
+import logging
+
+def configure_logging():
+    logging.basicConfig(level=logging.INFO,
+                        format='%(asctime)s - %(levelname)s - %(message)s')

app/main.py

@@ -0,0 +1,28 @@
+
+from fastapi import FastAPI, Request
+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
+import logging
+
+app = FastAPI()
+
+@app.on_event("startup")
+async def startup_event():
+    configure_logging()
+    initialize_firebase()
+
+app.include_router(router)
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    logging.error(f"Unhandled exception: {str(exc)}", exc_info=True)
+    return JSONResponse(
+        status_code=500,
+        content={"message": "An unexpected error occurred. Please try again later."}
+    )
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")

app/services/antispoof_service.py

@@ -0,0 +1,62 @@
+import logging
+from app.core.config import MODEL_PATH, CONFIG_PATH
+from app.utils.file_utils import download_file, remove_temp_file
+from fastapi import HTTPException
+from app.core.firebase_config import firebase_bucket
+from io import BytesIO
+from PIL import Image
+import tensorflow as tf
+import json
+import numpy as np
+
+class AntispoofService:
+    def __init__(self):
+        self.model = None
+        self.config = None
+        self.load_model_and_config()
+
+    def load_model_and_config(self):
+        try:
+            self.model = tf.keras.models.load_model(MODEL_PATH)
+            with open(CONFIG_PATH, "r") as config_file:
+                self.config = json.load(config_file)
+            logging.info("Model and configuration loaded successfully.")
+        except Exception as e:
+            logging.error(f"Error loading model or config: {str(e)}")
+            raise
+
+    async def verify_liveness(self, image_url: str):
+        if self.model is None or self.config is None:
+            raise ValueError("Model or configuration not loaded")
+
+        firebase_filename = None
+        try:
+            firebase_filename = await download_file(image_url)
+            
+            blob = firebase_bucket.blob(firebase_filename)
+            image_bytes = blob.download_as_bytes()
+            
+            image = Image.open(BytesIO(image_bytes))
+            image = image.resize((self.config["img_width"], self.config["img_height"]))
+            image_array = np.array(image) / 255.0
+            image_array = np.expand_dims(image_array, axis=0)
+
+            prediction = self.model.predict(image_array)[0][0]
+
+            is_real = bool(prediction <= self.config["threshold"])
+            result = "Real" if is_real else "Spoof"
+
+            return {
+                "image_url": image_url,
+                "prediction_score": float(prediction),
+                "is_real": is_real,
+                "result": result
+            }
+        except Exception as e:
+            logging.error(f"Error processing image: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Error processing image: {str(e)}")
+        finally:
+            if firebase_filename:
+                await remove_temp_file(firebase_filename)
+
+antispoof_service = AntispoofService()

app/services/audio_service.py

@@ -0,0 +1,85 @@
+import logging
+import numpy as np
+import librosa
+import imagehash
+from PIL import Image
+import logging
+import io
+from pydub import AudioSegment
+
+import ffmpeg
+import numpy as np
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+def extract_audio_features(video_bytes):
+    logger.info("Extracting audio features")
+    try:
+        # Attempt to extract audio using pydub
+        try:
+            logger.info("Attempting to extract audio using pydub")
+            audio = AudioSegment.from_file(io.BytesIO(video_bytes), format="mp4")
+            audio = audio.set_channels(1).set_frame_rate(44100)
+            samples = audio.get_array_of_samples()
+            audio_array = np.array(samples).astype(np.float32) / 32768.0
+        except Exception as pydub_error:
+            logger.warning(f"Pydub extraction failed: {str(pydub_error)}. Attempting ffmpeg extraction.")
+            
+            # Fallback to ffmpeg if pydub fails
+            try:
+                out, _ = (
+                    ffmpeg
+                    .input('pipe:0')
+                    .output('pipe:1', format='f32le', acodec='pcm_f32le', ac=1, ar='44100')
+                    .run(input=video_bytes, capture_stdout=True, capture_stderr=True)
+                )
+                audio_array = np.frombuffer(out, np.float32)
+            except ffmpeg.Error as ffmpeg_error:
+                logger.error(f"FFmpeg extraction failed: {ffmpeg_error.stderr.decode()}")
+                raise
+
+        # Extract MFCC features
+        mfcc = librosa.feature.mfcc(y=audio_array, sr=44100, n_mfcc=13)
+        
+        logger.info("Audio features extracted successfully")
+        return mfcc
+
+    except Exception as e:
+        logger.error(f"Error extracting audio features: {str(e)}", exc_info=True)
+        raise
+    
+def compute_audio_hash(features):
+    logging.info("Computing audio hash.")
+    if features is None:
+        return None
+    # Ensure the features are properly shaped for hashing
+    features_2d = features.reshape(features.shape[0], -1)
+    features_2d = (features_2d - np.min(features_2d)) / (np.max(features_2d) - np.min(features_2d))
+    features_2d = (features_2d * 255).astype(np.uint8)
+    return imagehash.phash(Image.fromarray(features_2d))
+
+def compute_audio_hashes(video_bytes):
+    logger.info("Computing audio hashes")
+    try:
+        out, _ = (
+            ffmpeg
+            .input('pipe:0')
+            .output('pipe:1', format='f32le', acodec='pcm_f32le', ac=1, ar='44100')
+            .run(input=video_bytes, capture_stdout=True, capture_stderr=True)
+        )
+        
+        audio_array = np.frombuffer(out, np.float32)
+        mfccs = librosa.feature.mfcc(y=audio_array, sr=44100, n_mfcc=13)
+        
+        audio_hashes = []
+        for mfcc in mfccs.T:
+            audio_hash = imagehash.average_hash(Image.fromarray(mfcc.reshape(13, 1)))
+            audio_hashes.append(str(audio_hash))
+        
+        logger.info("Finished computing audio hashes.")
+        return audio_hashes
+    except ffmpeg.Error as e:
+        logger.error(f"FFmpeg error in compute_audio_hashes: {e.stderr.decode()}")
+        raise
+    except Exception as e:
+        logger.error(f"Error in compute_audio_hashes: {str(e)}", exc_info=True)
+        raise

app/services/image_service.py

@@ -0,0 +1,46 @@
+from app.utils.image_utils import verify_image_format, process_image, compare_images as compare_images_util
+from fastapi import HTTPException
+import logging
+from app.utils.file_utils import download_file, remove_temp_file
+
+async def verify_image(image_url: str):
+    firebase_filename = None
+    try:
+        firebase_filename = await download_file(image_url)
+        verify_image_format(firebase_filename)
+        
+        image_hash = process_image(firebase_filename)
+        return {"image_hash": image_hash}
+    except Exception as e:
+        logging.error(f"Error verifying image: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Error verifying image: {str(e)}")
+    finally:
+        if firebase_filename:
+            await remove_temp_file(firebase_filename)
+
+async def compare_images(image_url1: str, image_url2: str):
+    firebase_filename1 = None
+    firebase_filename2 = None
+    try:
+        # Download the files from their URLs and store them in Firebase
+        firebase_filename1 = await download_file(image_url1)
+        firebase_filename2 = await download_file(image_url2)
+        
+        # Verify the image format for both images
+        verify_image_format(firebase_filename1)
+        verify_image_format(firebase_filename2)
+        
+        # Compare the images using the utility function
+        comparison_result = compare_images_util(firebase_filename1, firebase_filename2)
+        
+        # Return the comparison result
+        return comparison_result
+    except Exception as e:
+        logging.error(f"Error comparing images: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Error comparing images: {str(e)}")
+    finally:
+        # Remove temporary files from Firebase after processing
+        if firebase_filename1:
+            await remove_temp_file(firebase_filename1)
+        if firebase_filename2:
+            await remove_temp_file(firebase_filename2)

app/services/video_service.py

@@ -0,0 +1,131 @@
+import cv2
+import ffmpeg
+import numpy as np
+from scipy.fftpack import dct
+import imagehash
+from PIL import Image
+import logging
+import logging
+from app.utils.hash_utils import compute_video_hash, compute_frame_hashes
+from app.services.audio_service import extract_audio_features, compute_audio_hash, compute_audio_hashes
+from app.utils.file_utils import download_file, remove_temp_file, get_file_stream
+import io
+
+import tempfile
+import os
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+def validate_video_bytes(video_bytes):
+    try:
+        # If video_bytes is already a BytesIO object, use it directly
+        # Otherwise, create a new BytesIO object from the bytes
+        if not isinstance(video_bytes, io.BytesIO):
+            video_bytes = io.BytesIO(video_bytes)
+        
+        # Reset the BytesIO object to the beginning
+        video_bytes.seek(0)
+        
+        # Create a temporary file to store the video data
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_file:
+            temp_file.write(video_bytes.read())
+            temp_file_path = temp_file.name
+
+        # Use ffprobe to get video information
+        probe = ffmpeg.probe(temp_file_path)
+        
+        # Clean up the temporary file
+        os.unlink(temp_file_path)
+        
+        # Check for audio stream
+        audio_stream = next((stream for stream in probe['streams'] if stream['codec_type'] == 'audio'), None)
+        
+        if audio_stream is None:
+            logger.warning("No audio stream found in the file")
+            return False
+        return True
+    except ffmpeg.Error as e:
+        logger.error(f"Error validating video bytes: {e.stderr.decode()}")
+        return False
+    except Exception as e:
+        logger.error(f"Unexpected error in validate_video_bytes: {str(e)}")
+        return False
+
+async def extract_video_features(firebase_filename):
+    logging.info("Extracting video features")
+    video_stream = get_file_stream(firebase_filename)
+    video_bytes = video_stream.getvalue()
+    
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_file:
+        temp_file.write(video_bytes)
+        temp_file_path = temp_file.name
+
+    cap = cv2.VideoCapture(temp_file_path)
+    
+    features = []
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        resized = cv2.resize(gray, (32, 32))
+        dct_frame = dct(dct(resized.T, norm='ortho').T, norm='ortho')
+        features.append(dct_frame[:8, :8].flatten())
+    
+    cap.release()
+    os.unlink(temp_file_path)
+    
+    logging.info("Finished extracting video features.")
+    return np.array(features), video_bytes
+
+async def fingerprint_video(video_url):
+    logging.info(f"Fingerprinting video: {video_url}")
+    firebase_filename = None
+    try:
+        firebase_filename = await download_file(video_url)
+        video_stream = get_file_stream(firebase_filename)
+        video_bytes = video_stream.getvalue()
+        
+        video_features, _ = await extract_video_features(firebase_filename)
+        
+        if validate_video_bytes(io.BytesIO(video_bytes)):
+            audio_features = extract_audio_features(video_bytes)
+            audio_hashes = compute_audio_hashes(video_bytes)
+            collective_audio_hash = compute_audio_hash(audio_features)
+        else:
+            logging.warning("No audio stream found or invalid video. Skipping audio feature extraction.")
+            audio_hashes = []
+            collective_audio_hash = None
+        
+        video_hash = compute_video_hash(video_features)
+        frame_hashes = compute_frame_hashes(firebase_filename)
+
+        logging.info("Finished fingerprinting video.")
+
+        return {
+            'frame_hashes': frame_hashes,
+            'audio_hashes': audio_hashes,
+            'robust_audio_hash': str(collective_audio_hash) if collective_audio_hash else None,
+            'robust_video_hash': str(video_hash),
+        }
+    finally:
+        if firebase_filename:
+            await remove_temp_file(firebase_filename)
+
+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
+
+    overall_similarity = (video_similarity + audio_similarity) / 2
+    is_same_content = overall_similarity > 0.9  # You can adjust this threshold
+
+    logging.info(f"Comparison result - Video Similarity: {video_similarity}, Audio Similarity: {audio_similarity}, Overall Similarity: {overall_similarity}, Is Same Content: {is_same_content}")
+
+    return {
+        "video_similarity": video_similarity,
+        "audio_similarity": audio_similarity,
+        "overall_similarity": overall_similarity,
+        "is_same_content": is_same_content
+    }

app/utils/file_utils.py

@@ -0,0 +1,55 @@
+import aiohttp
+import uuid 
+import logging
+from urllib.parse import urlparse
+from app.core.firebase_config import firebase_bucket
+import io
+
+async def download_file(url: str) -> str:
+    parsed_url = urlparse(url)
+    file_extension = parsed_url.path.split('.')[-1]
+    
+    if not file_extension:
+        file_extension = 'tmp'
+
+    filename = f"{uuid.uuid4()}.{file_extension}"
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as response:
+                if response.status != 200:
+                    raise Exception(f"Failed to download file: HTTP {response.status}")
+                
+                content = await response.read()
+                blob = firebase_bucket.blob(filename)
+                blob.upload_from_string(content, content_type=response.headers.get('content-type'))
+
+        logging.info(f"File downloaded and saved to Firebase: {filename}")
+        return filename
+    except Exception as e:
+        logging.error(f"Error downloading file: {str(e)}")
+        raise
+
+async def remove_temp_file(filename: str):
+    try:
+        blob = firebase_bucket.blob(filename)
+        blob.delete()
+        logging.info(f"Temporary file deleted from Firebase: {filename}")
+    except Exception as e:
+        logging.error(f"Error deleting temporary file from Firebase: {str(e)}")
+
+def get_file_content(filename: str) -> bytes:
+    try:
+        blob = firebase_bucket.blob(filename)
+        return blob.download_as_bytes()
+    except Exception as e:
+        logging.error(f"Error getting file content from Firebase: {str(e)}")
+        raise
+
+def get_file_stream(filename: str) -> io.BytesIO:
+    try:
+        content = get_file_content(filename)
+        return io.BytesIO(content)
+    except Exception as e:
+        logging.error(f"Error getting file stream from Firebase: {str(e)}")
+        raise

app/utils/hash_utils.py

@@ -0,0 +1,39 @@
+import cv2
+import numpy as np
+import imagehash
+from PIL import Image
+import logging
+from app.utils.file_utils import get_file_stream
+
+def compute_video_hash(features):
+    logging.info("Computing video hash.")
+    return imagehash.phash(Image.fromarray(np.mean(features, axis=0).reshape(8, 8)))
+
+import tempfile
+import os
+
+def compute_frame_hashes(firebase_filename):
+    logging.info("Computing frame hashes")
+    video_stream = get_file_stream(firebase_filename)
+    video_bytes = video_stream.getvalue()
+    
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_file:
+        temp_file.write(video_bytes)
+        temp_file_path = temp_file.name
+
+    cap = cv2.VideoCapture(temp_file_path)
+    
+    frame_hashes = []
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        img_hash = imagehash.average_hash(Image.fromarray(gray))
+        frame_hashes.append(str(img_hash))
+    
+    cap.release()
+    os.unlink(temp_file_path)
+    
+    logging.info("Finished computing frame hashes.")
+    return frame_hashes

app/utils/image_utils.py

@@ -0,0 +1,92 @@
+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(filename: str):
+    content = get_file_content(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 perceptual_image_hash(image: Union[str, np.ndarray, Image.Image], hash_size: int = 32) -> str:
+    processed_image = preprocess_image(image, hash_size)
+    dct = cv2.dct(np.float32(processed_image))
+    dct_low = dct[:8, :8]
+    median = np.median(dct_low[1:])
+    
+    hash_value = ''
+    for i in range(8):
+        for j in range(8):
+            hash_value += '1' if dct_low[i, j] > median else '0'
+    
+    return hash_value
+
+def hamming_distance(hash1: str, hash2: str) -> int:
+    return sum(c1 != c2 for c1, c2 in zip(hash1, hash2))
+
+def are_images_similar(hash1: str, hash2: str, threshold: int = 5) -> bool:
+    distance = hamming_distance(hash1, hash2)
+    return distance <= threshold
+
+def process_image(filename: str):
+    try:
+        content = get_file_content(filename)
+        img = Image.open(BytesIO(content))
+        image_hash = perceptual_image_hash(img)
+        
+        return image_hash
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error processing image: {str(e)}")
+
+def compare_images(filename1: str, filename2: str):
+    try:
+        content1 = get_file_content(filename1)
+        content2 = get_file_content(filename2)
+        img1 = Image.open(BytesIO(content1))
+        img2 = Image.open(BytesIO(content2))
+        hash1 = perceptual_image_hash(img1)
+        hash2 = perceptual_image_hash(img2)
+        
+        are_similar = are_images_similar(hash1, hash2)
+        distance = hamming_distance(hash1, hash2)
+        
+        return {
+            "image1_hash": hash1,
+            "image2_hash": hash2,
+            "are_similar": are_similar,
+            "hamming_distance": distance
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error comparing images: {str(e)}")

models/mobilenetv2_spoof_model.h5

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

models/model_config.json

@@ -0,0 +1 @@
+{"img_width": 224, "img_height": 224, "class_labels": {"real": 0, "spoof": 1}, "threshold": 0.5}

render.yaml

@@ -0,0 +1,11 @@
+services:
+  - type: web
+    name: credify
+    env: python
+    buildCommand: |
+      apt-get update && apt-get install -y ffmpeg
+      chmod +x $(which ffmpeg)
+      ffmpeg -version
+      pip install --upgrade pip
+      pip install --use-pep517 -r requirements.txt
+    startCommand: uvicorn app.main:app --host 0.0.0.0 --port $PORT

requirements.txt

@@ -0,0 +1,17 @@
+aiohttp==3.10.5
+fastapi==0.109.2
+# ffmpeg==1.4
+ffmpeg-python==0.2.0
+firebase_admin==6.5.0
+imagehash==4.3.1
+librosa==0.10.2.post1
+numpy>=1.23.5,<2.0.0
+Pillow==10.4.0
+pydantic==2.6.1
+pydub==0.25.1
+python-dotenv==1.0.1
+scipy==1.14.1
+tensorflow==2.15.0
+uvicorn==0.30.6
+opencv-python==4.8.0.74
+python-magic==0.4.27