Refactor main.py and add NUMBA_DISABLE_JIT environment variable

README.md

@@ -6,15 +6,77 @@ colorTo: green
 sdk: docker
 app_port: 7860
 ---
-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 
+# Credify 🐳
 
-install the required libraries using :  pip install -r requirements.txt                   
+[![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/abhisheksan/credify)
 
-run the app using :  uvicorn app.main:app --reload  
+Credify is a Docker-based application designed to detect tampered media and assign unique fingerprints to them.
 
-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
+## 🚀 Quick Setup
+
+### Prerequisites
+
+- Python 3.10
+- Docker
+- FFmpeg
+
+### Installation
+
+1. Clone the repository:
+   ```
+   git clone https://github.com/abhisheksharm-3/credify.git
+   cd credify/server
+   ```
+
+2. Create and activate a virtual environment:
+   ```
+   python -m venv venv
+   .\venv\Scripts\activate
+   ```
+
+3. Install required dependencies:
+   ```
+   pip install -r requirements.txt
+   ```
+
+4. Download models:
+   The `models` folder is not included in the repository due to its large size. Download the models from [this Google Drive link](https://drive.google.com/drive/folders/13ekurrSgQo6d99PCv708vQVInfWpKsno?usp=sharing) and place them in a folder named `models` within the `server` directory.
+
+5. Install FFmpeg:
+   - Open CMD and run: `winget install ffmpeg`
+   - Add the FFmpeg bin path to System Environment Variables
+   - To find the path, run: `where ffmpeg` in CMD
+
+## 🏃‍♂️ Running the Application
+
+Start the application using:
+```
+uvicorn app.main:app --reload
+```
+
+## 🐋 Docker Deployment
+
+The application is configured for Docker deployment with the following specifications:
+- App Port: 7860
+- SDK: Docker
+
+## 🎨 Theme
+
+- Color Scheme: Blue to Green
+
+## 🛠️ Troubleshooting
+
+If you encounter a path error when re-uploading the same image or audio, ensure that FFmpeg is properly installed and configured on your system as described in the installation steps.
+
+<!-- ## 📄 License
+
+[Include license information here]
+
+## 🤝 Contributing
+
+[Include contribution guidelines here]
+
+## 📞 Contact
+
+[Include contact information or support channels here] -->

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,15 +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:
@@ -71,9 +62,8 @@ async def verify_image_route(request: ContentRequest):
 @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)}")
+        raise HTTPException(status_code=500, detail=f"Error in image comparison: {str(e)}")

app/main.py

@@ -1,5 +1,4 @@
 
-import os
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
 from app.api.routes import router
@@ -9,7 +8,6 @@ from app.api.forgery_routes import router as forgery_router
 import logging
 
 app = FastAPI()
-os.environ['NUMBA_DISABLE_JIT'] = '1'
 
 @app.on_event("startup")
 async def startup_event():

app/services/video_service.py

@@ -1,95 +1,68 @@
-import cv2
-import ffmpeg
 import numpy as np
 from scipy.fftpack import dct
 import imagehash
 from PIL import Image
 import logging
-import logging
+import io
+import av
 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
+from app.utils.file_utils import download_file, remove_temp_file, get_file_content
+from app.core.firebase_config import firebase_bucket
 
-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
+        with av.open(io.BytesIO(video_bytes)) as container:
+            has_video = any(stream.type == 'video' for stream in container.streams)
+            has_audio = any(stream.type == 'audio' for stream in container.streams)
+            
+            if not has_video:
+                raise ValueError("No video stream found in the file")
+            
+            if not has_audio:
+                logger.warning("No audio stream found in the file")
+            
+            return has_audio
     except Exception as e:
-        logger.error(f"Unexpected error in validate_video_bytes: {str(e)}")
+        logger.error(f"Error validating video bytes: {str(e)}")
         return False
 
-async def extract_video_features(firebase_filename):
+async def extract_video_features(video_content):
     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)
+    try:
+        with av.open(io.BytesIO(video_content)) as container:
+            video_stream = next(s for s in container.streams if s.type == 'video')
+            features = []
+            
+            for frame in container.decode(video=0):
+                img = frame.to_image().convert('L')  # Convert to grayscale
+                resized = np.array(img.resize((32, 32)))
+                dct_frame = dct(dct(resized.T, norm='ortho').T, norm='ortho')
+                features.append(dct_frame[:8, :8].flatten())
+        
+    except Exception as e:
+        logger.error(f"Error extracting video features: {str(e)}")
+        raise
     
     logging.info("Finished extracting video features.")
-    return np.array(features), video_bytes
+    return np.array(features)
 
 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_content = get_file_content(firebase_filename)
         
-        video_features, _ = await extract_video_features(firebase_filename)
+        video_features = await extract_video_features(video_content)
         
-        if validate_video_bytes(io.BytesIO(video_bytes)):
-            audio_features = extract_audio_features(video_bytes)
-            audio_hashes = compute_audio_hashes(video_bytes)
+        if validate_video_bytes(video_content):
+            audio_features = extract_audio_features(video_content)
+            audio_hashes = compute_audio_hashes(video_content)
             collective_audio_hash = compute_audio_hash(audio_features)
         else:
             logging.warning("No audio stream found or invalid video. Skipping audio feature extraction.")
@@ -97,15 +70,15 @@ async def fingerprint_video(video_url):
             collective_audio_hash = None
         
         video_hash = compute_video_hash(video_features)
-        frame_hashes = compute_frame_hashes(firebase_filename)
+        frame_hashes = compute_frame_hashes(video_content)
 
         logging.info("Finished fingerprinting video.")
 
         return {
             'frame_hashes': frame_hashes,
             'audio_hashes': audio_hashes,
-            'audio_hash': str(collective_audio_hash) if collective_audio_hash else None,
-            'video_hash': str(video_hash),
+            'robust_audio_hash': str(collective_audio_hash) if collective_audio_hash else None,
+            'robust_video_hash': str(video_hash),
         }
     finally:
         if firebase_filename:
@@ -115,8 +88,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['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
+    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 if fp1['robust_audio_hash'] and fp2['robust_audio_hash'] else 0
 
     overall_similarity = (video_similarity + audio_similarity) / 2
     is_same_content = overall_similarity > 0.9  # You can adjust this threshold

app/utils/forgery_video_utils.py

@@ -1,106 +1,105 @@
-import cv2
+import av
 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
+import uuid
+from typing import List, Tuple
 
-async def extract_audio(firebase_filename):
+async def extract_audio(firebase_filename: str) -> str:
     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
+        input_container = av.open(io.BytesIO(video_content))
         
-        os.remove(temp_video_path)
+        audio_stream = next((s for s in input_container.streams if s.type == 'audio'), None)
+        if audio_stream is None:
+            logging.warning(f"No audio stream found in {firebase_filename}")
+            return None
+
+        output_container = av.open(io.BytesIO(), mode='w', format='wav')
+        output_stream = output_container.add_stream('pcm_s16le', rate=audio_stream.rate)
+
+        for frame in input_container.decode(audio_stream):
+            for packet in output_stream.encode(frame):
+                output_container.mux(packet)
+
+        # Flush the stream
+        for packet in output_stream.encode(None):
+            output_container.mux(packet)
+
+        output_container.close()
+        
+        audio_content = output_container.data.getvalue()
+        audio_filename = f"{firebase_filename}_audio.wav"
+        await upload_file_to_firebase(audio_content, audio_filename)
+        
+        return audio_filename
     except Exception as e:
         logging.error(f"Error extracting audio: {str(e)}")
     return None
 
-async def extract_frames(firebase_filename, max_frames=10):
+async def extract_frames(firebase_filename: str, max_frames: int = 10) -> List[str]:
     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
+        with av.open(io.BytesIO(video_content)) as container:
+            video_stream = container.streams.video[0]
+            duration = float(video_stream.duration * video_stream.time_base)
             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)
+                container.seek(int(i * frame_interval * av.time_base))
+                for frame in container.decode(video=0):
+                    frame_rgb = frame.to_rgb().to_ndarray()
+                    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)
+                    break  # Only take the first frame after seeking
+
+    except Exception as e:
+        logging.error(f"Error extracting frames: {str(e)}")
 
     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
+import av
+import numpy as np
+from PIL import Image
+import io
+from app.utils.file_utils import get_file_content, upload_file_to_firebase, remove_temp_file
+import logging
+import uuid
+from typing import List, Tuple
 
-    output_filename = f"{firebase_filename}_compressed.mp4"
-    with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_output:
-        output_path = temp_output.name
+# ... (previous functions remain unchanged)
 
+async def compress_and_process_video(firebase_filename: str, target_size_mb: int = 50, max_duration: int = 60) -> str:
+    video_content = get_file_content(firebase_filename)
+    
     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
-
+        input_container = av.open(io.BytesIO(video_content))
+        video_stream = input_container.streams.video[0]
+        audio_stream = next((s for s in input_container.streams if s.type == 'audio'), None)
+
+        # Get video information
+        width = video_stream.width
+        height = video_stream.height
+        duration = float(video_stream.duration * video_stream.time_base)
         duration = min(duration, max_duration)
+        frame_rate = video_stream.average_rate
 
+        # Calculate target bitrate
         target_size_bits = target_size_mb * 8 * 1024 * 1024
         target_bitrate = int(target_size_bits / duration)
 
+        # Adjust dimensions
         if width > height:
             new_width = min(width, 1280)
             new_height = int((new_width / width) * height)
@@ -111,28 +110,49 @@ async def compress_and_process_video(firebase_filename, target_size_mb=50, max_d
         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()
+        output_buffer = io.BytesIO()
+        output_container = av.open(output_buffer, mode='w', format='mp4')
+        output_video_stream = output_container.add_stream('libx264', rate=frame_rate)
+        output_video_stream.width = new_width
+        output_video_stream.height = new_height
+        output_video_stream.pix_fmt = 'yuv420p'
+        output_video_stream.bit_rate = target_bitrate
+
+        if audio_stream:
+            output_audio_stream = output_container.add_stream('aac', rate=audio_stream.rate)
+            output_audio_stream.bit_rate = 128000  # 128k bitrate for audio
+
+        for frame in input_container.decode(video=0):
+            if frame.time > duration:
+                break
+            new_frame = frame.reformat(width=new_width, height=new_height, format='yuv420p')
+            for packet in output_video_stream.encode(new_frame):
+                output_container.mux(packet)
+
+        if audio_stream:
+            for frame in input_container.decode(audio=0):
+                if frame.time > duration:
+                    break
+                for packet in output_audio_stream.encode(frame):
+                    output_container.mux(packet)
+
+        # Flush streams
+        for packet in output_video_stream.encode(None):
+            output_container.mux(packet)
+        if audio_stream:
+            for packet in output_audio_stream.encode(None):
+                output_container.mux(packet)
+
+        # Close the output container
+        output_container.close()
         
+        # Get the compressed content
+        compressed_content = output_buffer.getvalue()
+        output_filename = f"{firebase_filename}_compressed.mp4"
         await upload_file_to_firebase(compressed_content, output_filename)
 
-    finally:
-        os.remove(input_path)
-        os.remove(output_path)
+        return output_filename
 
-    return output_filename
+    except Exception as e:
+        logging.error(f"Error compressing and processing video: {str(e)}")
+        raise

app/utils/hash_utils.py

@@ -1,39 +1,30 @@
-import cv2
 import numpy as np
 import imagehash
 from PIL import Image
 import logging
-from app.utils.file_utils import get_file_stream
+import io
+import av
 
 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):
+def compute_frame_hashes(video_content):
     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)
+    try:
+        with av.open(io.BytesIO(video_content)) as container:
+            video_stream = next(s for s in container.streams if s.type == 'video')
+            frame_hashes = []
+            
+            for frame in container.decode(video=0):
+                img = frame.to_image().convert('L')  # Convert to grayscale
+                img_hash = imagehash.average_hash(img)
+                frame_hashes.append(str(img_hash))
+        
+    except Exception as e:
+        logging.error(f"Error computing frame hashes: {str(e)}")
+        raise
     
     logging.info("Finished computing frame hashes.")
     return frame_hashes

requirements.txt

@@ -1,12 +1,12 @@
 aiohttp==3.10.5
+av==13.0.0
 fastapi==0.115.0
-ffmpeg==1.4
+#ffmpeg==1.4
 ffmpeg_python==0.2.0
 firebase_admin==6.5.0
 ImageHash==4.3.1
 librosa==0.10.2.post1
-moviepy==1.0.3
-numpy>=1.23.5,<2.0.0
+numpy==2.1.1
 opencv_python==4.10.0.84
 opencv_python_headless==4.10.0.84
 Pillow==10.4.0