Refactor forgery_routes.py and routes.py

- Refactor forgery_routes.py to import Response from fastapi
- Add detect_speech function to forgery_video_utils.py
- Update supported image and video formats in routes.py
- Remove verify_image_format function from image_utils.py

app/api/forgery_routes.py

@@ -5,7 +5,8 @@ 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
+from app.utils.forgery_video_utils import extract_audio, extract_frames, compress_and_process_video, detect_speech # Adjust the import path if necessary
+
 import os
 import logging
 import traceback
@@ -45,7 +46,7 @@ async def detect_forgery(request: DetectForgeryRequest):
         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']:
+        if file_extension in ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'gif', 'tiff', 'webp']:
             logging.info(f"Processing image file: {firebase_filename}")
             return await process_image(firebase_filename)
         elif file_extension in ['mp4', 'avi', 'mov', 'flv', 'wmv']:
@@ -92,23 +93,29 @@ async def process_video(firebase_filename: str):
         logging.info(f"Video compressed: {compressed_video_filename}")
         
         audio_filename = await extract_audio(compressed_video_filename)
-        logging.info(f"Audio extracted: {audio_filename}")
-        
+        if audio_filename:
+            logging.info(f"Audio extracted successfully: {audio_filename}")
+            audio_content = get_file_content(audio_filename)
+            if detect_speech(audio_content):
+                logging.info("Speech detected in the audio")
+                results = {"audio_deepfake": audio_deepfake_service.detect_deepfake(audio_filename)}
+            else:
+                logging.info("No speech detected in the audio")
+                results = {"audio_deepfake": {"prediction": "No speech detected", "confidence": 1.0, "raw_prediction": 1.0}}
+            await remove_temp_file(audio_filename)
+            logging.info(f"Temporary audio file removed: {audio_filename}")
+        else:
+            logging.warning("No audio detected or extracted from the video")
+            results = {"audio_deepfake": {"prediction": "No audio", "confidence": 1.0, "raw_prediction": 1.0}}
+
         frames = await extract_frames(compressed_video_filename)
         logging.info(f"Frames extracted: {len(frames)} frames")
 
-        results = {
-            "audio_deepfake": None,
+        results.update({
             "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):

app/api/routes.py

@@ -4,6 +4,7 @@ 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
+import os
 
 router = APIRouter()
 
@@ -13,6 +14,18 @@ class ContentRequest(BaseModel):
 class CompareRequest(BaseModel):
     url1: str
     url2: str
+    
+SUPPORTED_VIDEO_FORMATS = ['mp4', 'avi', 'mov', 'flv', 'wmv']
+SUPPORTED_IMAGE_FORMATS = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'tiff', 'webp']
+
+def is_supported_video_format(url: str) -> bool:
+    file_extension = os.path.splitext(url)[1][1:].lower()
+    return file_extension in SUPPORTED_VIDEO_FORMATS
+
+def is_supported_image_format(url: str) -> bool:
+    file_extension = os.path.splitext(url)[1][1:].lower()
+    return file_extension in SUPPORTED_IMAGE_FORMATS
+
 @router.get("/health")
 @router.head("/health")
 async def health_check():
@@ -20,8 +33,11 @@ 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):
+    if not is_supported_video_format(request.url):
+        raise HTTPException(status_code=400, detail="Video format not supported")
     try:
         result = await video_service.fingerprint_video(request.url)
         return {"message": "Fingerprint processing completed", "result": result}
@@ -31,6 +47,8 @@ async def create_fingerprint(request: ContentRequest):
 
 @router.post("/verify_video_only")
 async def verify_video_only(request: ContentRequest):
+    if not is_supported_video_format(request.url):
+        raise HTTPException(status_code=400, detail="Video format not supported")
     try:
         result = await video_service.fingerprint_video(request.url)
         return {"message": "Video verification completed", "result": result}
@@ -40,6 +58,8 @@ async def verify_video_only(request: ContentRequest):
 
 @router.post("/verify_liveness")
 async def verify_liveness(request: ContentRequest):
+    if not is_supported_image_format(request.url):
+        raise HTTPException(status_code=400, detail="Image format not supported")
     try:
         result = await antispoof_service.verify_liveness(request.url)
         return {"message": "Liveness verification completed", "result": result}
@@ -49,6 +69,8 @@ async def verify_liveness(request: ContentRequest):
 
 @router.post("/compare_videos")
 async def compare_videos_route(request: CompareRequest):
+    if not is_supported_video_format(request.url1) or not is_supported_video_format(request.url2):
+        raise HTTPException(status_code=400, detail="Video format not supported")
     try:
         result = await video_service.compare_videos(request.url1, request.url2)
         return {"message": "Video comparison completed", "result": result}
@@ -58,6 +80,8 @@ async def compare_videos_route(request: CompareRequest):
 
 @router.post("/verify_image")
 async def verify_image_route(request: ContentRequest):
+    if not is_supported_image_format(request.url):
+        raise HTTPException(status_code=400, detail="Image format not supported")
     try:
         result = await image_service.verify_image(request.url)
         return {"message": "Image verification completed", "result": result}
@@ -67,6 +91,8 @@ async def verify_image_route(request: ContentRequest):
 
 @router.post("/compare_images")
 async def compare_images_route(request: CompareRequest):
+    if not is_supported_image_format(request.url1) or not is_supported_image_format(request.url2):
+        raise HTTPException(status_code=400, detail="Image format not supported")
     try:
         result = await compare_images(request.url1, request.url2)
         return {"message": "Image comparison completed", "result": result}

app/services/image_manipulation_service.py

@@ -16,6 +16,9 @@ class ImageManipulationService:
             self.preprocessing_params = json.load(f)
 
     def convert_to_ela_image(self, image, quality):
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
         temp_buffer = io.BytesIO()
         image.save(temp_buffer, 'JPEG', quality=quality)
         temp_buffer.seek(0)
@@ -47,11 +50,13 @@ class ImageManipulationService:
         prediction = self.model.predict(prepared_image)
         predicted_class = int(np.argmax(prediction, axis=1)[0])
         confidence = float(np.max(prediction) * 100)
+        
+        check_manipulated = bool(predicted_class == 0 and confidence > 90)
 
         result = {
             "class": self.class_names[predicted_class],
             "confidence": f"{confidence:.2f}%",
-            "is_manipulated": bool(predicted_class == 0)
+            "is_manipulated": check_manipulated
         }
 
         return result

app/services/image_service.py

@@ -1,4 +1,4 @@
-from app.utils.image_utils import verify_image_format, process_image, compare_images as compare_images_util
+from app.utils.image_utils import 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
@@ -7,7 +7,6 @@ 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}
@@ -26,10 +25,6 @@ async def compare_images(image_url1: str, image_url2: str):
         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)
         

app/utils/image_utils.py

@@ -7,15 +7,6 @@ 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)