Upload 2 files

app.py

@@ -0,0 +1,1394 @@
+"""
+Streamlit Web Interface for DeepFake Detection System
+Main application file with all pages and features
+"""
+
+# CRITICAL: Set up Python path FIRST (before any other imports)
+import os
+import sys
+project_root = os.path.dirname(os.path.abspath(__file__))
+if project_root not in sys.path:
+    sys.path.insert(0, project_root)
+print(f"✓ Project root added to path: {project_root}")
+print(f"✓ Python path: {sys.path[:3]}")
+
+# Now import standard libraries
+import streamlit as st
+import subprocess
+import numpy as np
+from PIL import Image
+import tempfile
+import time
+from datetime import datetime
+import cv2
+
+# Import detection modules (now path is set correctly)
+from detection.image_detection import ImageDeepFakeDetector
+from detection.video_detection import VideoDeepFakeDetector
+from detection.audio_detection import AudioDeepFakeDetector
+from detection.webcam_detection import WebcamDeepFakeDetector
+
+# Import analysis modules
+from analysis.heatmap_visualization import HeatmapVisualizer
+
+# Import authentication
+from auth.login import AuthenticationManager
+
+# Import report generation
+from reports.generate_report import PDFReportGenerator
+
+
+# Page configuration
+st.set_page_config(
+    page_title="DeepFake Detection System",
+    page_icon="🔍",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS
+st.markdown("""
+    <style>
+    .main-header {
+        font-size: 3rem;
+        font-weight: bold;
+        color: #1a1a2e;
+        text-align: center;
+        margin-bottom: 1rem;
+    }
+    .sub-header {
+        font-size: 1.2rem;
+        color: #666666;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    .result-box {
+        padding: 1rem;
+        border-radius: 0.5rem;
+        margin: 1rem 0;
+    }
+    .fake-result {
+        background-color: #ffe6e6;
+        border-left: 5px solid #ff4444;
+    }
+    .real-result {
+        background-color: #e6ffe6;
+        border-left: 5px solid #44ff44;
+    }
+    .metric-card {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 1rem;
+        border-radius: 0.5rem;
+        color: white;
+        text-align: center;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+
+# Initialize session state
+if 'authenticated' not in st.session_state:
+    st.session_state.authenticated = False
+if 'current_user' not in st.session_state:
+    st.session_state.current_user = None
+if 'detectors' not in st.session_state:
+    st.session_state.detectors = {}
+
+
+def initialize_detectors():
+    """Initialize detection models"""
+    if not st.session_state.detectors:
+        with st.spinner("Loading AI models..."):
+            try:
+                st.session_state.detectors['image'] = ImageDeepFakeDetector()
+                st.session_state.detectors['video'] = VideoDeepFakeDetector(
+                    model_path='models/video_model_fast.h5', 
+                    img_size=(224, 224), 
+                    max_frames=30
+                )
+                st.session_state.detectors['audio'] = AudioDeepFakeDetector(
+                    model_path='models/audio_model.h5',
+                    sr=16000,
+                    duration=5
+                )
+                st.session_state.detectors['heatmap'] = HeatmapVisualizer()
+                
+                # Store model info for display
+                st.session_state.model_info = {
+                    'video': {
+                        'path': 'video_model_fast.h5',
+                        'frames': 30,
+                        'note': 'Optimized for speed with calibration'
+                    },
+                    'audio': {
+                        'path': 'audio_model.h5',
+                        'duration': '5 seconds',
+                        'note': 'Calibrated for reduced false positives'
+                    }
+                }
+                
+                st.success("✓ All models loaded successfully!")
+            except Exception as e:
+                st.warning(f"⚠ Some models could not be loaded: {e}")
+
+
+def login_page():
+    """Login and registration page"""
+    auth = AuthenticationManager()
+    
+    col1, col2, col3 = st.columns([1, 2, 1])
+    
+    with col2:
+        st.markdown("<h1 class='main-header'>🔐 User Authentication</h1>", unsafe_allow_html=True)
+        
+        tab1, tab2 = st.tabs(["Login", "Register"])
+        
+        with tab1:
+            st.subheader("Login to Your Account")
+            username = st.text_input("Username", key="login_username")
+            password = st.text_input("Password", type="password", key="login_password")
+            
+            if st.button("Login", type="primary", use_container_width=True):
+                success, message, user = auth.login(username, password)
+                
+                if success:
+                    st.session_state.authenticated = True
+                    st.session_state.current_user = user
+                    st.success(message)
+                    time.sleep(1)
+                    st.rerun()
+                else:
+                    st.error(message)
+        
+        with tab2:
+            st.subheader("Create New Account")
+            new_username = st.text_input("Choose Username", key="reg_username")
+            new_email = st.text_input("Email Address", key="reg_email")
+            new_password = st.text_input("Password", type="password", key="reg_password")
+            confirm_password = st.text_input("Confirm Password", type="password", key="reg_confirm")
+            
+            if st.button("Register", type="primary", use_container_width=True):
+                success, message, user_id = auth.register(
+                    new_username, new_email, new_password, confirm_password
+                )
+                
+                if success:
+                    st.success(message)
+                    st.info("Please login with your credentials")
+                else:
+                    st.error(message)
+
+
+def main_app():
+    """Main application interface"""
+    auth = AuthenticationManager()
+    
+    # Sidebar navigation
+    with st.sidebar:
+        st.title("🎯 Navigation")
+        
+        # User info
+        if st.session_state.current_user:
+            st.success(f"👤 {st.session_state.current_user['username']}")
+            if st.button("Logout", use_container_width=True):
+                st.session_state.authenticated = False
+                st.session_state.current_user = None
+                st.rerun()
+        
+        st.divider()
+        
+        # Navigation menu
+        pages = {
+            "🏠 Home": home_page,
+            "🖼️ Image Detection": image_detection_page,
+            "🎥 Video Detection": video_detection_page,
+            "🎵 Audio Detection": audio_detection_page,
+            "📹 Webcam Detection": webcam_detection_page,
+            "📊 Detection History": history_page,
+            "📥 Download Reports": reports_page
+        }
+        
+        selected_page = st.radio("Navigate", list(pages.keys()), index=0)
+        
+        st.divider()
+        
+        # Quick stats
+        if st.session_state.current_user:
+            st.subheader("📈 Your Statistics")
+            try:
+                stats = auth.get_user_statistics(st.session_state.current_user['id'])
+                if stats and stats.get('total_detections', 0) > 0:
+                    st.metric("Total Detections", stats['total_detections'])
+                    st.metric("Fake Detected", stats['fake_count'])
+                    st.metric("Accuracy Rate", f"{stats['average_confidence']*100:.1f}%")
+                else:
+                    st.info("No detections yet. Start analyzing to see your statistics!")
+            except Exception as e:
+                st.error(f"Error loading statistics: {e}")
+    
+    # Main content
+    page_func = pages[selected_page]
+    page_func()
+
+
+def home_page():
+    """Home page"""
+    st.markdown("<h1 class='main-header'>🔍 DeepFake Detection System</h1>", unsafe_allow_html=True)
+    st.markdown("<p class='sub-header'>AI-Powered Media Authentication Platform | Military-Grade Encryption | Instant Response</p>", unsafe_allow_html=True)
+    
+    # Hero section
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.markdown("""
+        ### 🎯 What We Do
+        Advanced deepfake detection using cutting-edge AI to identify manipulated images, videos, and audio with 90%+ accuracy.
+        """)
+    
+    with col2:
+        st.markdown("""
+        ### 🛡️ Features
+        - Multi-modal detection (Image/Video/Audio)
+        - Real-time webcam analysis
+        - Facial landmark analysis
+        - Lip-sync verification
+        - Eye blink detection
+        - PDF report generation
+        """)
+    
+    with col3:
+        st.markdown("""
+        ### 💡 Technology
+        - CNN + ResNet50 for images
+        - CNN + LSTM for videos
+        - Mel Spectrogram CNN for audio
+        - Grad-CAM heatmaps
+        - FaceNet embeddings
+        """)
+    
+    st.divider()
+    
+    # Quick actions
+    st.subheader("🚀 Quick Start")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        if st.button("🖼️ Detect Image", use_container_width=True, type="primary"):
+            st.session_state.selected_page = "🖼️ Image Detection"
+    
+    with col2:
+        if st.button("🎥 Detect Video", use_container_width=True, type="primary"):
+            st.session_state.selected_page = "🎥 Video Detection"
+    
+    with col3:
+        if st.button("🎵 Detect Audio", use_container_width=True, type="primary"):
+            st.session_state.selected_page = "🎵 Audio Detection"
+    
+    st.divider()
+    
+    # Model information
+    st.subheader("📊 Model Performance")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.metric("Image Detection Accuracy", "92-96%", delta="High Confidence")
+    
+    with col2:
+        st.metric("Video Detection Accuracy", "90%+", delta="Temporal Analysis")
+    
+    with col3:
+        st.metric("Audio Detection Accuracy", "91%+", delta="Spectrogram Analysis")
+    
+    # Information
+    with st.expander("ℹ️ How It Works"):
+        st.markdown("""
+        ### DeepFake Detection Process
+        
+        1. **Upload Media**: Submit your image, video, or audio file
+        2. **Preprocessing**: Our system normalizes and prepares the input
+        3. **Feature Extraction**: AI models extract relevant features
+        4. **Analysis**: Multiple detection algorithms analyze the content
+        5. **Results**: Get instant results with confidence scores
+        6. **Report**: Download detailed PDF analysis report
+        
+        ### Technologies Used
+        
+        - **Convolutional Neural Networks (CNN)**: For spatial feature detection
+        - **Long Short-Term Memory (LSTM)**: For temporal pattern analysis in videos
+        - **Facial Landmark Detection**: 68-point facial analysis
+        - **Grad-CAM**: Visualization of manipulated regions
+        - **Mel Spectrograms**: Audio frequency analysis
+        """)
+
+
+def image_detection_page():
+    """Image deepfake detection page"""
+    st.markdown("<h1 class='main-header'>🖼️ Image DeepFake Detection</h1>", unsafe_allow_html=True)
+    
+    initialize_detectors()
+    
+    # File uploader
+    uploaded_file = st.file_uploader(
+        "Upload an image to analyze",
+        type=['jpg', 'jpeg', 'png'],
+        help="Supported formats: JPG, JPEG, PNG"
+    )
+    
+    if uploaded_file:
+        # Display uploaded image
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            image = Image.open(uploaded_file)
+            st.image(image, caption="Uploaded Image", use_container_width=True)
+        
+        with col2:
+            with st.spinner("🔍 Analyzing image..."):
+                # Save to temp file
+                with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as tmp_file:
+                    tmp_file.write(uploaded_file.getvalue())
+                    tmp_path = tmp_file.name
+                
+                # Perform detection
+                detector = st.session_state.detectors.get('image')
+                
+                if detector and detector.model:
+                    result = detector.detect(tmp_path)
+                    
+                    if result['success']:
+                        # Display result
+                        prediction = result['prediction']
+                        confidence = result['confidence'] * 100
+                        
+                        if prediction == 'Fake':
+                            st.error(f"❌ DEEPFAKE DETECTED\n\nConfidence: {confidence:.1f}%")
+                        else:
+                            st.success(f"✅ AUTHENTIC IMAGE\n\nConfidence: {confidence:.1f}%")
+                        
+                        # Detailed metrics
+                        st.json({
+                            "Prediction": prediction,
+                            "Confidence": f"{confidence:.2f}%",
+                            "Real Probability": f"{result['real_probability']*100:.2f}%",
+                            "Fake Probability": f"{result['fake_probability']*100:.2f}%"
+                        })
+                        
+                        # Generate heatmap
+                        if st.button("Generate Heatmap", type="primary"):
+                            with st.spinner("Creating visualization..."):
+                                heatmap_result = st.session_state.detectors['heatmap'].generate_grad_cam(tmp_path)
+                                
+                                if heatmap_result['success']:
+                                    st.image(heatmap_result['overlay'], 
+                                           caption="Grad-CAM Heatmap (Red = Manipulated)",
+                                           use_container_width=True)
+                                    
+                                    # Show manipulation details
+                                    manip_info = heatmap_result['manipulation_regions']
+                                    st.write(f"**Manipulation Severity:** {manip_info['severity'].upper()}")
+                                    st.write(f"**Affected Area:** {manip_info['manipulation_ratio']*100:.1f}%")
+                        
+                        # Save to history
+                        if st.session_state.current_user:
+                            from auth.database import DatabaseManager
+                            db = DatabaseManager()
+                            
+                            db.add_detection_record(
+                                user_id=st.session_state.current_user['id'],
+                                file_name=uploaded_file.name,
+                                file_type='image',
+                                prediction=prediction,
+                                confidence=result['confidence'],
+                                is_fake=(prediction == 'Fake'),
+                                file_path=tmp_path,
+                                analysis_details=str(result)
+                            )
+                        
+                        # Download report
+                        if st.button("📥 Download PDF Report"):
+                            generator = PDFReportGenerator()
+                            
+                            with tempfile.NamedTemporaryFile(suffix='.pdf', delete=False) as pdf_file:
+                                report_path = generator.generate_report(
+                                    detection_result=result,
+                                    user_info=st.session_state.current_user,
+                                    save_path=pdf_file.name
+                                )
+                                
+                                if report_path:
+                                    with open(report_path, 'rb') as f:
+                                        st.download_button(
+                                            label="Download Report",
+                                            data=f.read(),
+                                            file_name=f"deepfake_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf",
+                                            mime="application/pdf"
+                                        )
+                    else:
+                        st.error(f"Detection failed: {result.get('error', 'Unknown error')}")
+                else:
+                    st.warning("⚠ Image detection model not loaded. Please train the model first.")
+                
+                # Cleanup
+                os.unlink(tmp_path)
+    
+    else:
+        st.info("👆 Upload an image to begin analysis")
+        
+        # Sample information
+        st.markdown("""
+        ### What to Look For
+        
+        DeepFake images often show:
+        - Unnatural skin textures
+        - Inconsistent lighting
+        - Blurred boundaries
+        - Asymmetric facial features
+        - Strange artifacts around edges
+        
+        ### Supported Formats
+        - **JPG/JPEG**: Most common image format
+        - **PNG**: Lossless compression
+        - Maximum size: 10MB
+        """)
+
+
+def video_detection_page():
+    """Video deepfake detection page"""
+    st.markdown("<h1 class='main-header'>🎥 Video DeepFake Detection</h1>", unsafe_allow_html=True)
+    
+    initialize_detectors()
+    
+    uploaded_file = st.file_uploader(
+        "Upload a video to analyze",
+        type=['mp4', 'avi', 'mov'],
+        help="Supported formats: MP4, AVI, MOV"
+    )
+    
+    if uploaded_file:
+        st.video(uploaded_file)
+        
+        if st.button("🔍 Analyze Video", type="primary"):
+            with st.spinner("Processing video... This may take a few minutes."):
+                # Save to temp file
+                with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as tmp_file:
+                    tmp_file.write(uploaded_file.getvalue())
+                    tmp_path = tmp_file.name
+                
+                detector = st.session_state.detectors.get('video')
+                
+                if detector and detector.model:
+                    result = detector.detect(tmp_path)
+                    
+                    if result['success']:
+                        prediction = result['prediction']
+                        confidence = result['confidence'] * 100
+                        
+                        if prediction == 'Fake':
+                            st.error(f"❌ DEEPFAKE VIDEO DETECTED\n\nConfidence: {confidence:.1f}%")
+                        else:
+                            st.success(f"✅ AUTHENTIC VIDEO\n\nConfidence: {confidence:.1f}%")
+                        
+                        st.json({
+                            "Prediction": prediction,
+                            "Confidence": f"{confidence:.2f}%",
+                            "Frames Analyzed": result.get('frames_analyzed', 'N/A'),
+                            "Real Probability": f"{result['real_probability']*100:.2f}%",
+                            "Fake Probability": f"{result['fake_probability']*100:.2f}%"
+                        })
+                        
+                        # Save to history
+                        if st.session_state.current_user:
+                            from auth.database import DatabaseManager
+                            db = DatabaseManager()
+                            
+                            db.add_detection_record(
+                                user_id=st.session_state.current_user['id'],
+                                file_name=uploaded_file.name,
+                                file_type='video',
+                                prediction=prediction,
+                                confidence=result['confidence'],
+                                is_fake=(prediction == 'Fake')
+                            )
+                    else:
+                        st.error(f"Detection failed: {result.get('error', 'Unknown error')}")
+                
+                os.unlink(tmp_path)
+    
+    else:
+        st.info("👆 Upload a video to begin analysis")
+
+
+def audio_detection_page():
+    """Audio deepfake detection page"""
+    st.markdown("<h1 class='main-header'>🎵 Audio DeepFake Detection</h1>", unsafe_allow_html=True)
+    
+    initialize_detectors()
+    
+    uploaded_file = st.file_uploader(
+        "Upload an audio file to analyze",
+        type=['wav', 'mp3', 'flac'],
+        help="Supported formats: WAV, MP3, FLAC"
+    )
+    
+    if uploaded_file:
+        st.audio(uploaded_file)
+        
+        if st.button("🔍 Analyze Audio", type="primary"):
+            with st.spinner("Analyzing audio spectrogram..."):
+                with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as tmp_file:
+                    tmp_file.write(uploaded_file.getvalue())
+                    tmp_path = tmp_file.name
+                
+                detector = st.session_state.detectors.get('audio')
+                
+                if detector and detector.model:
+                    result = detector.detect(tmp_path)
+                    
+                    if result['success']:
+                        prediction = result['prediction']
+                        confidence = result['confidence'] * 100
+                        
+                        if prediction == 'Fake':
+                            st.error(f"❌ SYNTHETIC AUDIO DETECTED\n\nConfidence: {confidence:.1f}%")
+                        else:
+                            st.success(f"✅ AUTHENTIC AUDIO\n\nConfidence: {confidence:.1f}%")
+                        
+                        st.json({
+                            "Prediction": prediction,
+                            "Confidence": f"{confidence:.2f}%",
+                            "Duration": f"{result.get('duration_analyzed', 'N/A')} seconds",
+                            "Sample Rate": f"{result.get('sample_rate', 'N/A')} Hz"
+                        })
+                        
+                        # Save to history
+                        if st.session_state.current_user:
+                            from auth.database import DatabaseManager
+                            db = DatabaseManager()
+                            
+                            db.add_detection_record(
+                                user_id=st.session_state.current_user['id'],
+                                file_name=uploaded_file.name,
+                                file_type='audio',
+                                prediction=prediction,
+                                confidence=result['confidence'],
+                                is_fake=(prediction == 'Fake')
+                            )
+                    else:
+                        st.error(f"Detection failed: {result.get('error', 'Unknown error')}")
+                
+                os.unlink(tmp_path)
+    
+    else:
+        st.info("👆 Upload audio to begin analysis")
+
+
+def webcam_detection_page():
+    """Webcam detection page"""
+    st.markdown("<h1 class='main-header'>📹 Real-Time Webcam Detection</h1>", unsafe_allow_html=True)
+    
+    initialize_detectors()
+    
+    st.info("📹 Choose detection mode below")
+    
+    # Mode selection
+    detection_mode = st.radio(
+        "Select Detection Mode:",
+        ["📸 Photo Capture", "🎥 Live Video Streaming"],
+        horizontal=True
+    )
+    
+    if detection_mode == "📸 Photo Capture":
+        st.success("**Photo Mode**: Take a single picture for analysis")
+        
+        # Use Streamlit's native webcam input
+        img_file_buffer = st.camera_input("Take a picture")
+    
+        if img_file_buffer is not None:
+            with st.spinner("Analyzing frame..."):
+                try:
+                    from PIL import Image
+                    import numpy as np
+                    import cv2
+                    
+                    image = Image.open(img_file_buffer)
+                    image_np = np.array(image)
+                    image_bgr = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
+                    
+                    if 'detectors' in st.session_state and 'image' in st.session_state.detectors:
+                        detector = st.session_state.detectors['image']
+                        result = detector.detect(image_bgr)
+                        
+                        if result['success']:
+                            col1, col2 = st.columns(2)
+                            
+                            with col1:
+                                st.image(image_np, caption="Captured Frame", width=400)
+                            
+                            with col2:
+                                if result['is_fake']:
+                                    st.error(f"**⚠ FAKE Detected**")
+                                    st.metric("Fake Probability", f"{result['fake_probability']*100:.1f}%")
+                                else:
+                                    st.success(f"**✓ REAL Verified**")
+                                    st.metric("Real Probability", f"{result['real_probability']*100:.1f}%")
+                                
+                                st.metric("Confidence", f"{result['confidence']*100:.1f}%")
+                                st.caption(f"Raw Score: {result.get('raw_score', 'N/A')}")
+                                if 'reliability' in result:
+                                    rel_badge = "🔴" if result['reliability'] == 'low' else "🟡" if result['reliability'] == 'medium' else "🟢"
+                                    st.caption(f"Reliability: {rel_badge} {result['reliability'].upper()}")
+                            
+                            from auth.database import DatabaseManager
+                            db = DatabaseManager()
+                            db.add_detection_record(
+                                user_id=st.session_state.current_user['id'],
+                                file_name="webcam_capture.jpg",
+                                file_type="webcam",
+                                prediction=result['prediction'],
+                                confidence=result['confidence'],
+                                is_fake=result['is_fake']
+                            )
+                        else:
+                            st.error(f"Detection failed: {result.get('error', 'Unknown error')}")
+                    else:
+                        st.error("Detector not initialized. Please refresh the page.")
+                except Exception as e:
+                    st.error(f"Error processing frame: {str(e)}")
+    
+    elif detection_mode == "🎥 Live Video Streaming":
+        st.success("**Live Mode**: Automatic real-time streaming with instant analysis!")
+        
+        # Try enhanced webcam streaming first
+        try:
+            from utils.webcam_streamer import run_enhanced_webcam_detection
+            
+            # Get detector
+            detector = None
+            if 'detectors' in st.session_state and 'image' in st.session_state.detectors:
+                detector = st.session_state.detectors['image']
+            
+            run_enhanced_webcam_detection(detector=detector)
+            
+        except Exception as e:
+            st.warning(f"⚠️ Enhanced streaming unavailable: {e}")
+            st.info("Falling back to standard auto-capture mode...")
+            
+            # Fallback to existing auto-capture code
+            import time
+            from PIL import Image
+            import numpy as np
+            import cv2
+            
+            # Initialize detector
+            if 'detectors' not in st.session_state:
+                initialize_detectors()
+            
+            # State management
+            if 'auto_stream_active' not in st.session_state:
+                st.session_state.auto_stream_active = False
+            if 'session_start_time' not in st.session_state:
+                st.session_state.session_start_time = 0
+            
+            # Control panel
+            start_col, stop_col = st.columns([3, 1])
+            
+            with start_col:
+                start_btn = st.button("🎬 START AUTO LIVE STREAMING", type="primary", use_container_width=True, disabled=st.session_state.auto_stream_active)
+            
+            with stop_col:
+                stop_btn = st.button("⏹️ STOP", use_container_width=True, disabled=not st.session_state.auto_stream_active)
+            
+            # Handle start
+            if start_btn:
+                st.session_state.auto_stream_active = True
+                st.session_state.session_start_time = int(time.time())
+                st.session_state.last_capture = 0
+                st.session_state.frame_num = 0
+                st.rerun()
+            
+            # Handle stop
+            if stop_btn:
+                st.session_state.auto_stream_active = False
+                st.info("⏹️ Streaming stopped")
+                st.rerun()
+        
+        # Main auto-streaming logic
+        if st.session_state.auto_stream_active:
+            # Calculate elapsed time
+            elapsed = int(time.time() - st.session_state.session_start_time)
+            current_time = time.time()
+            
+            # Status bar
+            status_col = st.columns([3, 1])[0]
+            with status_col:
+                st.info(f"🔴 LIVE | Running for {elapsed}s | Auto-capturing every 2 seconds")
+            
+            # Check if it's time to capture (every 2 seconds)
+            should_capture = (current_time - st.session_state.get('last_capture', 0)) >= 2.0
+            
+            if should_capture:
+                # Update last capture time
+                st.session_state.last_capture = current_time
+                st.session_state.frame_num += 1
+                
+                # Capture container
+                capture_container = st.container()
+                
+                with capture_container:
+                    # Use camera input but hide it visually while keeping functionality
+                    st.markdown("### 📹 Live Frame Capture")
+                    
+                    # Create a unique key for each auto-capture
+                    cam_key = f"auto_capture_{st.session_state.frame_num}"
+                    
+                    # Hide the ugly "Take a photo" text with custom CSS
+                    st.markdown("""
+                        <style>
+                        div[data-testid="stFileUploader"] {display: none;}
+                        button[kind="fileInput"] {display: none;}
+                        </style>
+                    """, unsafe_allow_html=True)
+                    
+                    # Create hidden camera input
+                    cam_placeholder = st.empty()
+                    with cam_placeholder:
+                        cam_buffer = st.camera_input(
+                            label="",  # Empty label!
+                            key=cam_key,
+                            label_visibility="hidden"  # Hide completely!
+                        )
+                    
+                    # Auto-trigger camera after 0.5 seconds
+                    if cam_buffer is None:
+                        time.sleep(0.5)
+                        st.rerun()
+                    
+                    if cam_buffer is not None:
+                        # Process this frame IMMEDIATELY
+                        image = Image.open(cam_buffer)
+                        image_np = np.array(image)
+                        image_bgr = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
+                        
+                        # Display frame
+                        st.image(image_np, caption=f"📹 Auto-Captured Frame #{st.session_state.frame_num} at {time.strftime('%H:%M:%S')}", width=700)
+                        
+                        # RUN DETECTION INSTANTLY
+                        if 'detectors' in st.session_state and 'image' in st.session_state.detectors:
+                            detector = st.session_state.detectors['image']
+                            result = detector.detect(image_bgr)
+                            
+                            if result['success']:
+                                # SHOW RESULTS IMMEDIATELY
+                                result_cols = st.columns([2, 1])
+                                
+                                with result_cols[0]:
+                                    if result['is_fake']:
+                                        st.error(f"""
+                                        **⚠️ FAKE DETECTED!**
+                                        
+                                        Confidence: **{result['confidence']*100:.1f}%**
+                                        Fake Probability: {result['fake_probability']*100:.1f}%
+                                        """)
+                                    else:
+                                        st.success(f"""
+                                        **✓ REAL VERIFIED!**
+                                        
+                                        Confidence: **{result['confidence']*100:.1f}%**
+                                        Real Probability: {result['real_probability']*100:.1f}%
+                                        """)
+                                
+                                with result_cols[1]:
+                                    st.metric("Confidence", f"{result['confidence']*100:.1f}%")
+                                    
+                                    if 'reliability' in result:
+                                        rel_badge = "🔴" if result['reliability'] == 'low' else "🟡" if result['reliability'] == 'medium' else "🟢"
+                                        st.caption(f"{rel_badge} {result['reliability'].upper()}")
+                                
+                                # Auto-save to history
+                                try:
+                                    from auth.database import DatabaseManager
+                                    db = DatabaseManager()
+                                    db.add_detection_record(
+                                        user_id=st.session_state.current_user['id'],
+                                        file_name=f"auto_live_{st.session_state.frame_num}_{int(current_time)}.jpg",
+                                        file_type="webcam_auto_stream",
+                                        prediction=result['prediction'],
+                                        confidence=result['confidence'],
+                                        is_fake=result['is_fake']
+                                    )
+                                except Exception as save_err:
+                                    pass
+                                
+                                # Countdown to next capture
+                                st.info(f"⏱️ Next auto-capture in 2 seconds... (Frame #{st.session_state.frame_num})")
+                                
+                                # Trigger next frame after delay
+                                time.sleep(2.0)
+                                st.rerun()
+                            else:
+                                st.warning(f"⚠️ Detection failed: {result.get('error', 'Unknown error')}")
+                                time.sleep(2.0)
+                                st.rerun()
+                        else:
+                            st.error("❌ Detector not initialized - please refresh the page")
+                            time.sleep(2.0)
+                            st.rerun()
+                    else:
+                        # First time activation - waiting for camera
+                        st.info("📷 **Camera is activating...** Please allow camera access in your browser, then click the capture button that appears.")
+                        time.sleep(1.0)
+                        st.rerun()
+            else:
+                # Waiting between captures
+                countdown = int(2.0 - (current_time - st.session_state.get('last_capture', 0)))
+                st.info(f"⏳ Next auto-capture in {countdown} second(s)...")
+                time.sleep(0.5)
+                st.rerun()
+        
+        else:
+            # Not streaming
+            st.info("👆 Click '🎬 START AUTO LIVE STREAMING' to begin automatic real-time detection")
+            
+            st.markdown("""
+            ---
+            #### ✨ What Happens When You Start:
+            
+            1. **Camera activates automatically** (browser will ask for permission)
+            2. **Auto-captures every 2 seconds** - NO manual clicking needed!
+            3. **Instant AI analysis** on every captured frame
+            4. **Results display immediately** - Fake/Real with confidence %
+            5. **Auto-saves to history** - Every detection logged
+            6. **Continuous operation** until you click Stop
+            
+            **Just position your face and watch it work!**
+            """)
+        
+    with st.expander("ℹ️ How to use webcam detection"):
+        st.markdown("""
+        ### Instructions
+        
+        1. Click "Allow" when prompted for camera permissions
+        2. Position your face in the frame
+        3. Click "Take a picture"
+        4. Wait for the AI analysis
+        5. View results instantly
+        
+        ### Tips for Best Results
+        
+        - Good lighting (face should be well-lit)
+        - Face the camera directly
+        - Remove glasses/masks if possible
+        - Keep still while capturing
+        - High resolution preferred
+        
+        ### Understanding Results
+        
+        - **🟢 High Reliability** (>70% confidence): Trust the prediction
+        - **🟡 Medium Reliability** (55-70%): Consider other evidence
+        - **🔴 Low Reliability** (<55%): Model is uncertain, manual review recommended
+        
+        **Note**: This uses the same AI model as image detection, trained on available DeepFake datasets.
+        """)
+
+
+def social_media_page():
+    """Social media detection page"""
+    st.markdown("<h1 class='main-header'>🌐 Social Media Verification</h1>", unsafe_allow_html=True)
+    
+    st.info("🔗 Paste a social media URL to analyze the media content")
+    
+    # Initialize detector if not already done
+    if 'social_detector' not in st.session_state:
+        try:
+            image_detector = st.session_state.detectors.get('image')
+            video_detector = st.session_state.detectors.get('video')
+            audio_detector = st.session_state.detectors.get('audio')
+            
+            st.session_state.social_detector = SocialMediaDeepFakeDetector(
+                image_detector=image_detector,
+                video_detector=video_detector,
+                audio_detector=audio_detector
+            )
+        except Exception as e:
+            st.error(f"Error initializing social media detector: {e}")
+            return
+    
+    url = st.text_input("Social Media URL", placeholder="https://twitter.com/... or https://youtube.com/... or https://facebook.com/...")
+    
+    if url:
+        if st.button("🔍 Analyze URL", type="primary"):
+            with st.spinner("Downloading and analyzing media from URL..."):
+                try:
+                    # Detect platform
+                    from urllib.parse import urlparse
+                    parsed = urlparse(url)
+                    domain = parsed.netloc.lower()
+                    
+                    platform_name = "Direct URL"
+                    platform_emoji = "🔗"
+                    
+                    if 'youtube.com' in domain or 'youtu.be' in domain:
+                        platform_name = "YouTube"
+                        platform_emoji = "📺"
+                        result = st.session_state.social_detector.verify_youtube_video(url)
+                    elif 'twitter.com' in domain or 'x.com' in domain:
+                        platform_name = "Twitter/X"
+                        platform_emoji = "🐦"
+                        result = st.session_state.social_detector.verify_twitter_media(url)
+                    elif 'instagram.com' in domain:
+                        platform_name = "Instagram"
+                        platform_emoji = "📸"
+                        result = st.session_state.social_detector.verify_instagram_media(url)
+                    elif 'facebook.com' in domain or 'fb.com' in domain or 'fb.watch' in domain:
+                        platform_name = "Facebook"
+                        platform_emoji = "📘"
+                        result = st.session_state.social_detector.verify_facebook_media(url)
+                    elif 'github.com' in domain:
+                        platform_name = "GitHub"
+                        platform_emoji = "🐙"
+                        result = st.session_state.social_detector.verify_github_content(url)
+                    elif 'whatsapp.com' in domain:
+                        platform_name = "WhatsApp"
+                        platform_emoji = "📱"
+                        result = st.session_state.social_detector.verify_whatsapp_media(url)
+                    else:
+                        result = st.session_state.social_detector.detect_from_url(url)
+                    
+                    # Display results
+                    if result.get('success'):
+                        st.success(f"✅ Analysis Complete - {platform_emoji} {platform_name}")
+                        
+                        # Show prediction
+                        is_fake = result.get('is_fake', False)
+                        confidence = result.get('confidence', 0) * 100
+                        
+                        if is_fake:
+                            st.error(f"🚨 **FAKE** Detected (Confidence: {confidence:.1f}%)")
+                        else:
+                            st.success(f"✓ **REAL** Content (Confidence: {confidence:.1f}%)")
+                        
+                        # Show additional info
+                        col1, col2, col3 = st.columns(3)
+                        with col1:
+                            st.metric("Platform", f"{platform_emoji} {platform_name}")
+                        with col2:
+                            st.metric("Media Type", result.get('media_type', 'Unknown'))
+                        with col3:
+                            reliability = "High" if confidence > 70 else "Medium" if confidence > 55 else "Low"
+                            st.metric("Reliability", reliability)
+                        
+                        # Save to history if user is logged in
+                        if st.session_state.current_user:
+                            from auth.database import DetectionHistoryManager
+                            db_manager = DetectionHistoryManager()
+                            db_manager.add_detection(
+                                username=st.session_state.current_user,
+                                file_name=url[:50] + "...",
+                                file_type=result.get('media_type', 'unknown'),
+                                prediction="Fake" if is_fake else "Real",
+                                confidence=confidence / 100,
+                                source_url=url
+                            )
+                            st.success("✓ Result saved to your detection history")
+                        
+                    else:
+                        error_msg = result.get('error', 'Unknown error')
+                        st.error(f"❌ Analysis Failed: {error_msg}")
+                        
+                        # Provide specific troubleshooting based on error
+                        if 'download' in error_msg.lower() or 'failed to download' in error_msg.lower():
+                            st.warning("""
+                            **💡 Download Failed - Common Causes:**
+                            
+                            1. **Private Content** - Account/post is private (not public)
+                            2. **Invalid URL** - URL is broken or doesn't exist
+                            3. **Network Issue** - Check internet connection
+                            4. **Rate Limited** - Too many requests, wait and try again
+                            5. **Platform Blocking** - Site is blocking automated access
+                            
+                            **✅ Quick Fixes:**
+                            - ✓ Verify URL opens in browser
+                            - ✓ Ensure account is PUBLIC
+                            - ✓ Try a different URL
+                            - ✓ Check console output for detailed error
+                            - ✓ See TROUBLESHOOTING_DOWNLOAD_ERRORS.md for help
+                            """)
+                        elif 'timeout' in error_msg.lower():
+                            st.warning("""
+                            **⏱️ Request Timed Out**
+                            
+                            The server took too long to respond. This can happen with:
+                            - Slow internet connection
+                            - Overloaded servers
+                            - Very large files
+                            
+                            **Try:**
+                            - Check your internet speed
+                            - Wait a moment and try again
+                            - Use a different URL
+                            """)
+                        elif '403' in error_msg or 'forbidden' in error_msg.lower():
+                            st.warning("""
+                            **🚫 Access Denied (403 Forbidden)**
+                            
+                            The platform is blocking access. This happens with:
+                            - Private accounts
+                            - Region-locked content
+                            - Automated access detection
+                            
+                            **Solutions:**
+                            - Use public content only
+                            - Configure API keys for better access
+                            - Try from different network
+                            """)
+                        elif '404' in error_msg or 'not found' in error_msg.lower():
+                            st.warning("""
+                            **❌ Content Not Found (404)**
+                            
+                            The URL doesn't point to valid content:
+                            - Post/video may be deleted
+                            - URL has typo
+                            - Content was never there
+                            
+                            **Check:**
+                            - Open URL in browser first
+                            - Verify username/post ID
+                            - Use "Share" button to copy correct URL
+                            """)
+                        else:
+                            st.warning("""
+                            **💡 Troubleshooting Tips:**
+                            
+                            1. Check that the URL is correct and complete
+                            2. Verify the content is publicly accessible
+                            3. Try opening the URL in your browser first
+                            4. Check the console output for detailed error messages
+                            5. Review TROUBLESHOOTING_DOWNLOAD_ERRORS.md for solutions
+                            
+                            **Test with known working URLs:**
+                            - YouTube: https://youtube.com/watch?v=dQw4w9WgXcQ
+                            - GitHub: https://github.com/octocat/Spoon-Knife/blob/main/LICENSE
+                            """)
+                    
+                except Exception as e:
+                    error_details = str(e)
+                    st.error(f"❌ Error during analysis: {error_details}")
+                    
+                    # Show helpful debugging info
+                    with st.expander("🔍 View Detailed Error Information"):
+                        import traceback
+                        st.code(traceback.format_exc())
+                        
+                        st.markdown("""
+                        **What to do next:**
+                        
+                        1. Copy this error message
+                        2. Check console output for more details
+                        3. Verify your URL is correct and public
+                        4. Try a different URL to test
+                        5. See TROUBLESHOOTING_DOWNLOAD_ERRORS.md for solutions
+                        """)
+    
+    # Information section
+    st.markdown("---")
+    st.subheader("ℹ️ Platform Support")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.markdown("""
+        ### 🐦 Twitter/X
+        - Tweet images
+        - Tweet videos
+        - GIFs
+        
+        **API Status**: Optional
+        """)
+    
+    with col2:
+        st.markdown("""
+        ### 📺 YouTube
+        - Regular videos
+        - Shorts
+        - Video links
+        
+        **API Status**: Optional (uses yt-dlp)
+        """)
+    
+    with col3:
+        st.markdown("""
+        ### 📸 Instagram
+        - Posts
+        - Images
+        - Videos
+        - Reels
+        
+        **API Status**: Optional
+        """)
+    
+    col4, col5, col6 = st.columns(3)
+    
+    with col4:
+        st.markdown("""
+        ### 📘 Facebook
+        - Post images
+        - Videos
+        - Public content
+        
+        **API Status**: Optional
+        """)
+    
+    with col5:
+        st.markdown("""
+        ### 🐙 GitHub
+        - Repository images
+        - Media files
+        - Release assets
+        
+        **API Status**: Optional
+        """)
+    
+    with col6:
+        st.markdown("""
+        ### 📱 WhatsApp
+        - Media links
+        - Shared content
+        
+        **API Status**: Optional
+        """)
+    
+    # API Configuration Guide
+    with st.expander("🔑 Configure API Keys (Optional but Recommended)"):
+        st.markdown("""
+        ### API Configuration Guide
+        
+        For best results, configure the following API keys:
+        
+        #### 1. Twitter/X API
+        1. Go to [Twitter Developer Portal](https://developer.twitter.com/)
+        2. Create a project and app
+        3. Generate Bearer Token
+        4. Set environment variable: `TWITTER_API_KEY`
+        
+        #### 2. YouTube Data API
+        1. Go to [Google Cloud Console](https://console.cloud.google.com/)
+        2. Create a new project
+        3. Enable YouTube Data API v3
+        4. Create API Key
+        5. Set environment variable: `YOUTUBE_API_KEY`
+        
+        #### 3. Instagram Basic Display API
+        1. Go to [Facebook Developers](https://developers.facebook.com/)
+        2. Create an app
+        3. Add Instagram Basic Display product
+        4. Generate Access Token
+        5. Set environment variable: `INSTAGRAM_TOKEN`
+        
+        ---
+        
+        ### Using Environment Variables
+        
+        **Option 1: Create `.env` file** (Recommended)
+        
+        Create a file named `.env` in the project root:
+        
+        ```env
+        TWITTER_API_KEY=your_twitter_key_here
+        YOUTUBE_API_KEY=your_youtube_key_here
+        INSTAGRAM_TOKEN=your_instagram_token_here
+        ```
+        
+        **Option 2: Set via Command Line**
+        
+        Windows PowerShell:
+        ```powershell
+        $env:TWITTER_API_KEY="your_key_here"
+        $env:YOUTUBE_API_KEY="your_key_here"
+        $env:INSTAGRAM_TOKEN="your_token_here"
+        ```
+        
+        Linux/Mac:
+        ```bash
+        export TWITTER_API_KEY="your_key_here"
+        export YOUTUBE_API_KEY="your_key_here"
+        export INSTAGRAM_TOKEN="your_token_here"
+        ```
+        
+        **Note**: The system can work without API keys using direct download methods,
+        but some platforms may have restrictions. API keys provide more reliable access.
+        """)
+    
+    with st.expander("ℹ️ How to use social media detection"):
+        st.markdown("""
+        ### Instructions
+        
+        1. **Copy URL**: Copy the link from Twitter, YouTube, or Instagram
+        2. **Paste URL**: Paste it in the text field above
+        3. **Analyze**: Click "Analyze URL" button
+        4. **Wait**: System will download and analyze the content
+        5. **Results**: View the AI analysis results
+        
+        ### Tips for Best Results
+        
+        - Use public posts (not private accounts)
+        - Ensure the URL points directly to a post with media
+        - For Twitter, use tweets that contain images/videos
+        - For YouTube, any public video URL works
+        - For Instagram, use public posts only
+        
+        ### Understanding Results
+        
+        - **🟢 High Reliability** (>70% confidence): Trust the prediction
+        - **🟡 Medium Reliability** (55-70%): Consider other evidence
+        - **🔴 Low Reliability** (<55%): Model is uncertain, manual review recommended
+        
+        ### Supported Formats
+        
+        **Images**: JPG, PNG, BMP, GIF
+        **Videos**: MP4, AVI, MOV, MKV, WebM
+        **Audio**: WAV, MP3, FLAC (extracted from videos)
+        """)
+
+
+def history_page():
+    """Detection history page"""
+    st.markdown("<h1 class='main-header'>📊 Detection History</h1>", unsafe_allow_html=True)
+    
+    if not st.session_state.current_user:
+        st.warning("Please login to view your detection history")
+        return
+    
+    from auth.database import DatabaseManager
+    db = DatabaseManager()
+    
+    # Get user history
+    history = db.get_user_detection_history(st.session_state.current_user['id'], limit=100)
+    
+    # Display statistics FIRST (even if no history)
+    stats = db.get_detection_statistics(st.session_state.current_user['id'])
+    
+    if stats:
+        st.subheader("📈 Your Analytics Dashboard")
+        
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            st.metric("Total Detections", stats['total_detections'])
+        
+        with col2:
+            st.metric("Fake Detected", stats['fake_count'])
+        
+        with col3:
+            st.metric("Real Verified", stats['real_count'])
+        
+        with col4:
+            st.metric("Avg Confidence", f"{stats['average_confidence']*100:.1f}%")
+        
+        # Show breakdown by file type
+        if stats.get('by_file_type'):
+            st.write("**Detections by Type:**")
+            type_cols = st.columns(len(stats['by_file_type']))
+            for i, (file_type, count) in enumerate(stats['by_file_type'].items()):
+                with type_cols[i]:
+                    icon = "🖼️" if file_type == 'image' else "🎥" if file_type == 'video' else "🎤"
+                    st.metric(label=icon, value=count, delta=file_type.title())
+        
+        st.divider()
+    
+    # Search and filter
+    search_term = st.text_input("🔍 Search by filename", "")
+    
+    if search_term and history:
+        history = db.search_detections(st.session_state.current_user['id'], search_term)
+    
+    # Display as table
+    if history:
+        st.write(f"**{len(history)} detections found**")
+        
+        for record in history:
+            with st.expander(f"{record['file_name']} - {record['prediction']} ({record['created_at']})"):
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.write(f"**File Type:** {record['file_type']}")
+                    st.write(f"**Prediction:** {record['prediction']}")
+                    st.write(f"**Confidence:** {record['confidence']*100:.1f}%")
+                
+                with col2:
+                    status = "❌ Fake" if record['is_fake'] else "✅ Real"
+                    st.write(f"**Status:** {status}")
+                    st.write(f"**Date:** {record['created_at']}")
+                    
+                    # Add download button if file exists
+                    if record.get('file_path') and os.path.exists(record['file_path']):
+                        with open(record['file_path'], 'rb') as f:
+                            st.download_button(
+                                label="📥 Download File",
+                                data=f.read(),
+                                file_name=record['file_name'],
+                                mime="application/octet-stream"
+                            )
+    else:
+        st.info("📭 No detections found. Start analyzing media to build your history!")
+        st.markdown("""
+        **How to get started:**
+        1. Go to **Image Detection** and upload an image
+        2. Or try **Video Detection** with a video file
+        3. Or analyze **Audio** files
+        4. Your detection history will appear here automatically
+        """)
+
+
+def reports_page():
+    """Reports download page"""
+    st.markdown("<h1 class='main-header'>📥 Download Reports</h1>", unsafe_allow_html=True)
+    
+    if not st.session_state.current_user:
+        st.warning("Please login to access your reports")
+        return
+    
+    from auth.database import DatabaseManager
+    db = DatabaseManager()
+    
+    reports = db.get_user_reports(st.session_state.current_user['id'])
+    
+    if reports:
+        st.write(f"**{len(reports)} reports available**")
+        
+        for report in reports:
+            col1, col2, col3 = st.columns([3, 2, 1])
+            
+            with col1:
+                st.write(f"**{report['generated_at']}**")
+            
+            with col2:
+                st.write(f"Detection #{report['detection_id']}")
+            
+            with col3:
+                if os.path.exists(report['report_path']):
+                    with open(report['report_path'], 'rb') as f:
+                        st.download_button(
+                            label="📥 Download",
+                            data=f.read(),
+                            file_name=f"report_{report['id']}.pdf",
+                            mime="application/pdf"
+                        )
+                else:
+                    st.write("File not found")
+    else:
+        st.info("No reports generated yet. Generate reports from the detection pages.")
+
+
+def main():
+    """Main application entry point"""
+    
+    if not st.session_state.authenticated:
+        login_page()
+    else:
+        main_app()
+
+
+if __name__ == "__main__":
+    main()

requirements-minimal.txt

@@ -0,0 +1,42 @@
+# Memory-Optimized Requirements for Deployment
+# Uses lighter alternatives and defers heavy imports
+
+# Core - Lightweight base
+numpy==1.23.5
+pandas==1.5.3
+Pillow==9.5.0
+scipy==1.10.1
+
+# OpenCV - Headless version (smaller)
+opencv-python-headless==4.7.0.72
+
+# Scikit-learn (needed but smaller than TF)
+scikit-learn==1.2.2
+
+# Streamlit
+streamlit==1.28.0
+
+# Visualization (lightweight)
+matplotlib==3.7.1
+seaborn==0.12.2
+plotly==5.15.0
+
+# Utilities
+bcrypt==4.0.1
+tqdm==4.65.0
+python-dotenv==1.0.0
+
+# Image handling
+imageio==2.28.1
+
+# Video processing (deferred import)
+ffmpeg-python==0.2.0
+
+# PDF generation
+reportlab==4.0.0
+
+# Security
+PyJWT==2.6.0
+
+# NOTE: TensorFlow/Keras installed separately with memory limits
+# tensorflow==2.12.0  # Install during runtime, not build