initial commit

.gitignore

@@ -0,0 +1,46 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+.vscode/
+.idea/
+*.swp
+*.swo
+
+.DS_Store
+Thumbs.db
+
+/tmp/
+*.tmp
+*.temp
+
+/models/
+/cache/
+
+.env.local
+secrets.py

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.10-slim
+
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+RUN mkdir -p /tmp/ad_processing /tmp/ad_cache
+
+EXPOSE 7860
+
+ENV GRADIO_SERVER_NAME=0.0.0.0
+ENV GRADIO_SERVER_PORT=7860
+
+CMD ["python", "app.py"]

README.md

@@ -11,3 +11,45 @@ license: mit
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# 🎬 Enhanced AI Ad Completion Tool
+
+Transform your videos into professional commercials using AI! This tool combines multiple videos, generates new content using Stable Video Diffusion, and creates polished ads with intelligent prompt generation powered by Google's Gemini API.
+
+## Features
+
+- 🎥 **Dual Video Upload**: Combine 1 or 2 videos seamlessly
+- 🤖 **AI Video Generation**: Create new content using Stable Video Diffusion
+- 🧠 **Gemini Integration**: Intelligent prompt generation based on video analysis
+- 🎨 **Professional Processing**: Color grading, smooth transitions, and effects
+- ⚡ **Smart Fallbacks**: Reliable processing even when AI models fail
+- 🎯 **Flexible Duration**: Extend videos to your target length
+
+## How to Use
+
+1. **Upload Videos**: Add your primary video (required) and optionally a secondary video
+2. **Set Duration**: Choose your target duration (10-45 seconds)
+3. **Configure AI**: Enable/disable AI video generation
+4. **Process**: Click "Create Enhanced Ad" and wait for processing
+5. **Download**: Get your professionally enhanced commercial!
+
+## API Requirements
+
+- **Gemini API Key**: Get your free API key from [Google AI Studio](https://makersuite.google.com/app/apikey)
+- **GPU Access**: HF Spaces provides free GPU access for video generation
+
+## Technical Details
+
+- **Video Analysis**: OpenCV + MediaPipe + Whisper
+- **AI Generation**: Stable Video Diffusion XL
+- **Prompt Enhancement**: Google Gemini 1.5 Flash
+- **Processing**: MoviePy + FFmpeg
+- **Interface**: Gradio 4.44.0
+
+## Development
+
+Built with modern AI technologies for maximum quality and reliability. The tool automatically handles various video formats, resolutions, and provides intelligent fallbacks.
+
+## License
+
+Apache 2.0 - Feel free to use and modify!

app.py

@@ -0,0 +1,151 @@
+import gradio as gr
+import os
+import warnings
+warnings.filterwarnings('ignore')
+
+from src.pipeline import EnhancedAdPipeline
+from config.settings import UI_CONFIG
+
+def create_interface():
+    pipeline = EnhancedAdPipeline()
+    
+    def process_videos_ui(video1, video2, target_duration, use_ai, gemini_key, progress=gr.Progress()):
+        if video1 is None:
+            return None, "❌ Please upload at least the first video"
+        
+        try:
+            if gemini_key and gemini_key.strip():
+                pipeline.set_gemini_key(gemini_key.strip())
+            
+            progress(0.1, desc="🔍 Analyzing videos...")
+            
+            result = pipeline.process_videos(video1, video2, target_duration, use_ai, progress)
+            
+            if result['success']:
+                progress(1.0, desc="🎉 Complete!")
+                
+                status = f"✅ Video processing successful!\n"
+                status += f"📊 Original duration: {result.get('original_duration', 0):.1f}s\n"
+                if result.get('second_video'):
+                    status += f"📊 Second video included\n"
+                if result.get('ai_generated'):
+                    status += "🤖 AI-generated extension added\n"
+                status += f"🎯 Final duration: ~{target_duration}s"
+                
+                return result['output_video'], status
+            else:
+                return None, f"❌ Error: {result.get('error', 'Unknown error')}"
+                
+        except Exception as e:
+            return None, f"❌ Error: {str(e)}"
+    
+    with gr.Blocks(**UI_CONFIG) as app:
+        
+        gr.Markdown("""
+        
+        🎬 Enhanced AI Ad Completion Tool
+        
+        
+        **Transform your videos into professional commercials using AI!**
+        
+        ✨ **Features:** Dual video upload • AI video generation • Gemini-powered prompts • Professional processing
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📹 Video Inputs")
+                
+                video1_input = gr.Video(
+                    label="🎬 Primary Video (Required)",
+                    format="mp4"
+                )
+                
+                video2_input = gr.Video(
+                    label="🎬 Secondary Video (Optional)",
+                    format="mp4"
+                )
+                
+                gr.Markdown("### ⚙️ Settings")
+                
+                duration_slider = gr.Slider(
+                    minimum=10,
+                    maximum=45,
+                    value=20,
+                    step=1,
+                    label="🎯 Target Duration (seconds)"
+                )
+                
+                ai_toggle = gr.Checkbox(
+                    value=True,
+                    label="🤖 Use AI Video Generation",
+                    info="Generate new content using AI (requires GPU)"
+                )
+                
+                gemini_key_input = gr.Textbox(
+                    label="🔑 Gemini API Key (Optional)",
+                    placeholder="Enter your Gemini API key for better prompts",
+                    type="password"
+                )
+                
+                process_btn = gr.Button(
+                    "🚀 Create Enhanced Ad",
+                    variant="primary",
+                    size="lg"
+                )
+                
+                gr.Markdown("""
+                ### 📋 How to Use:
+                1. **Upload primary video** (your main content)
+                2. **Optional**: Upload second video to combine
+                3. **Set target duration** for final output
+                4. **Optional**: Add Gemini API key for better prompts
+                5. **Enable AI generation** for new content
+                6. **Click "Create Enhanced Ad"**
+                
+                **Get Gemini API Key:** [Google AI Studio](https://makersuite.google.com/app/apikey) (Free)
+                """)
+                
+            with gr.Column(scale=2):
+                gr.Markdown("### 🎉 Output")
+                
+                video_output = gr.Video(
+                    label="Enhanced Ad Video",
+                    format="mp4"
+                )
+                
+                status_output = gr.Textbox(
+                    label="📋 Processing Status",
+                    interactive=False,
+                    lines=6
+                )
+                
+                gr.Markdown("""
+                ### 🎨 What This Tool Does:
+                
+                **🔍 Video Analysis:**
+                - Extracts key frames and visual elements
+                - Transcribes audio content using Whisper
+                - Analyzes color palette and scene classification
+                
+                **🤖 AI Enhancement:**
+                - Uses Gemini API for intelligent prompt generation
+                - Generates new video content with Stable Video Diffusion
+                - Applies professional color grading and effects
+                
+                **🎬 Smart Processing:**
+                - Combines multiple videos with smooth transitions
+                - Extends to target duration intelligently
+                - Preserves audio quality throughout
+                """)
+        
+        process_btn.click(
+            fn=process_videos_ui,
+            inputs=[video1_input, video2_input, duration_slider, ai_toggle, gemini_key_input],
+            outputs=[video_output, status_output]
+        )
+    
+    return app
+
+if __name__ == "__main__":
+    app = create_interface()
+    app.launch(server_name="0.0.0.0", server_port=7860, share=True)

config/settings.py

@@ -0,0 +1,36 @@
+import os
+
+DEVICE = "cuda" if os.environ.get('CUDA_AVAILABLE') == 'true' else "cpu"
+
+MODEL_CONFIG = {
+    'whisper_model': 'tiny',
+    'svd_model': 'stabilityai/stable-video-diffusion-img2vid-xt',
+    'torch_dtype': 'float16' if DEVICE == 'cuda' else 'float32',
+}
+
+PROCESSING_CONFIG = {
+    'max_frames': 25,
+    'generation_steps': 8,
+    'guidance_scale': 3.0,
+    'fps': 24,
+    'default_resolution': (1024, 576),
+    'fallback_resolution': (512, 320),
+}
+
+UI_CONFIG = {
+    'title': "Enhanced AI Ad Tool",
+    'theme': "soft",
+    'css': """
+    .gradio-container {
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    }
+    """
+}
+
+PATHS = {
+    'temp_dir': '/tmp/ad_processing',
+    'cache_dir': '/tmp/ad_cache',
+}
+
+os.makedirs(PATHS['temp_dir'], exist_ok=True)
+os.makedirs(PATHS['cache_dir'], exist_ok=True)

requirements.txt

@@ -0,0 +1,16 @@
+gradio==4.44.0
+torch==2.1.0
+torchvision==0.16.0
+torchaudio==2.1.0
+diffusers==0.24.0
+transformers==4.36.0
+accelerate==0.25.0
+opencv-python==4.8.1.78
+Pillow==10.1.0
+moviepy==1.0.3
+requests==2.31.0
+openai-whisper==20231117
+google-generativeai==0.3.2
+imageio[ffmpeg]==2.33.1
+scikit-learn==1.3.2
+numpy==1.24.3

src/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

src/pipeline.py

@@ -0,0 +1,74 @@
+from .video_analyzer import VideoAnalyzer
+from .prompt_generator import PromptGenerator
+from .video_generator import VideoGenerator
+from .video_processor import VideoProcessor
+import os
+
+class EnhancedAdPipeline:
+    def __init__(self):
+        self.analyzer = VideoAnalyzer()
+        self.prompt_gen = PromptGenerator()
+        self.video_gen = VideoGenerator()
+        self.processor = VideoProcessor()
+    
+    def set_gemini_key(self, key):
+        self.prompt_gen.set_api_key(key)
+    
+    def process_videos(self, video1_path, video2_path, target_duration, use_ai, progress=None):
+        if progress:
+            progress(0.1, desc="Analyzing first video...")
+        
+        analysis1 = self.analyzer.analyze_video(video1_path)
+        if not analysis1:
+            return {'success': False, 'error': 'Failed to analyze first video'}
+        
+        if progress:
+            progress(0.3, desc="Merging videos...")
+        
+        merged_video = self.processor.merge_videos(video1_path, video2_path, target_duration)
+        if not merged_video:
+            return {'success': False, 'error': 'Failed to merge videos'}
+        
+        current_duration = analysis1['duration']
+        if video2_path and os.path.exists(video2_path):
+            analysis2 = self.analyzer.analyze_video(video2_path)
+            if analysis2:
+                current_duration += analysis2['duration']
+        
+        final_video = merged_video
+        ai_generated = False
+        
+        if use_ai and current_duration < target_duration and analysis1.get('last_frame') is not None:
+            if progress:
+                progress(0.5, desc="Generating AI prompt...")
+            
+            prompt = self.prompt_gen.generate_video_prompt(analysis1, target_duration)
+            
+            if progress:
+                progress(0.6, desc="Generating AI video...")
+            
+            ai_frames = self.video_gen.generate_video(
+                analysis1['last_frame'], 
+                prompt, 
+                duration=min(3, target_duration - current_duration)
+            )
+            
+            if ai_frames:
+                if progress:
+                    progress(0.8, desc="Adding AI extension...")
+                
+                extended_video = self.processor.add_ai_extension(merged_video, ai_frames, target_duration)
+                if extended_video:
+                    final_video = extended_video
+                    ai_generated = True
+        
+        if progress:
+            progress(0.95, desc="Finalizing...")
+        
+        return {
+            'success': True,
+            'output_video': final_video,
+            'original_duration': analysis1['duration'],
+            'second_video': video2_path is not None,
+            'ai_generated': ai_generated
+        }

src/prompt_generator.py

@@ -0,0 +1,67 @@
+import google.generativeai as genai
+from config.settings import PROCESSING_CONFIG
+
+class PromptGenerator:
+    def __init__(self):
+        self.model = None
+        self.gemini_key = None
+    
+    def set_api_key(self, key):
+        if key and key.strip():
+            try:
+                genai.configure(api_key=key.strip())
+                self.model = genai.GenerativeModel('gemini-1.5-flash')
+                self.gemini_key = key.strip()
+            except:
+                self.model = None
+    
+    def generate_video_prompt(self, analysis, target_duration):
+        if not self.model or not analysis:
+            return self._fallback_prompt(analysis)
+        
+        try:
+            context = f"""
+Video Analysis:
+- Duration: {analysis.get('duration', 0):.1f}s
+- Transcript: {analysis.get('transcript', 'No audio')}
+- Scene type: {analysis.get('scene_type', 'unknown')}
+- Colors: {', '.join(analysis.get('dominant_colors', [])[:3])}
+
+Target: {target_duration}s commercial
+
+Generate a creative prompt for Stable Video Diffusion to extend this commercial.
+Keep it under 100 words, focus on visual elements, camera movement, and commercial appeal.
+"""
+            
+            response = self.model.generate_content(context)
+            prompt = response.text.strip()
+            
+            if len(prompt) > 20:
+                return prompt
+            else:
+                return self._fallback_prompt(analysis)
+                
+        except Exception as e:
+            return self._fallback_prompt(analysis)
+    
+    def _fallback_prompt(self, analysis):
+        if not analysis:
+            return "professional commercial product showcase, smooth camera movement, high quality, cinematic lighting"
+        
+        scene_type = analysis.get('scene_type', 'product')
+        transcript = analysis.get('transcript', '').lower()
+        
+        prompts = {
+            'lifestyle': "vibrant lifestyle commercial, people enjoying, dynamic movement, warm lighting",
+            'tech': "sleek tech commercial, modern interface, clean design, professional lighting", 
+            'product': "premium product showcase, elegant presentation, studio lighting"
+        }
+        
+        base_prompt = prompts.get(scene_type, prompts['product'])
+        
+        if 'outdoor' in transcript:
+            base_prompt += ", outdoor setting"
+        elif 'indoor' in transcript:
+            base_prompt += ", indoor environment"
+            
+        return base_prompt + ", commercial quality, smooth transitions"

src/video_analyzer.py

@@ -0,0 +1,75 @@
+import cv2
+import numpy as np
+import whisper
+from sklearn.cluster import KMeans
+
+class VideoAnalyzer:
+    def __init__(self):
+        self.whisper_model = None
+        try:
+            self.whisper_model = whisper.load_model("tiny")
+        except:
+            pass
+    
+    def analyze_video(self, video_path):
+        try:
+            cap = cv2.VideoCapture(video_path)
+            fps = cap.get(cv2.CAP_PROP_FPS) or 24
+            frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            duration = frame_count / fps
+            
+            frames = []
+            for idx in [0, frame_count//4, frame_count//2, 3*frame_count//4, frame_count-1]:
+                cap.set(cv2.CAP_PROP_POS_FRAMES, min(idx, frame_count-1))
+                ret, frame = cap.read()
+                if ret:
+                    frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+            
+            cap.release()
+            
+            transcript = ""
+            if self.whisper_model:
+                try:
+                    result = self.whisper_model.transcribe(video_path)
+                    transcript = result["text"].strip()
+                except:
+                    pass
+            
+            colors = ['#808080']
+            if frames:
+                try:
+                    all_pixels = []
+                    for frame in frames[:3]:
+                        resized = cv2.resize(frame, (50, 50))
+                        pixels = resized.reshape(-1, 3)
+                        all_pixels.extend(pixels[::5])
+                    
+                    if all_pixels:
+                        kmeans = KMeans(n_clusters=5, random_state=42, n_init=10)
+                        kmeans.fit(all_pixels)
+                        colors = [f"#{r:02x}{g:02x}{b:02x}" for r, g, b in kmeans.cluster_centers_.astype(int)]
+                except:
+                    pass
+            
+            scene_type = "product"
+            if transcript:
+                transcript_lower = transcript.lower()
+                if any(word in transcript_lower for word in ['happy', 'fun', 'joy', 'celebration']):
+                    scene_type = "lifestyle"
+                elif any(word in transcript_lower for word in ['tech', 'innovation', 'digital']):
+                    scene_type = "tech"
+            
+            return {
+                'duration': duration,
+                'fps': fps,
+                'resolution': (width, height),
+                'frames': frames,
+                'last_frame': frames[-1] if frames else None,
+                'transcript': transcript,
+                'dominant_colors': colors,
+                'scene_type': scene_type
+            }
+        except Exception as e:
+            return None

src/video_generator.py

@@ -0,0 +1,55 @@
+import torch
+from diffusers import StableVideoDiffusionPipeline
+from PIL import Image
+import numpy as np
+from config.settings import DEVICE, MODEL_CONFIG, PROCESSING_CONFIG
+
+class VideoGenerator:
+    def __init__(self):
+        self.pipeline = None
+        self._load_models()
+    
+    def _load_models(self):
+        if DEVICE == "cuda":
+            try:
+                self.pipeline = StableVideoDiffusionPipeline.from_pretrained(
+                    MODEL_CONFIG['svd_model'],
+                    torch_dtype=torch.float16,
+                    variant="fp16"
+                )
+                self.pipeline.to("cuda")
+                self.pipeline.enable_model_cpu_offload()
+            except Exception as e:
+                print(f"Failed to load SVD: {e}")
+    
+    def generate_video(self, image, prompt, duration=2):
+        if not self.pipeline:
+            return None
+        
+        try:
+            if isinstance(image, np.ndarray):
+                if image.dtype == np.float32:
+                    image = (image * 255).astype(np.uint8)
+                image = Image.fromarray(image)
+            
+            image = image.resize(PROCESSING_CONFIG['default_resolution'])
+            
+            num_frames = min(PROCESSING_CONFIG['max_frames'], int(duration * PROCESSING_CONFIG['fps']))
+            
+            frames = self.pipeline(
+                image,
+                height=PROCESSING_CONFIG['default_resolution'][1],
+                width=PROCESSING_CONFIG['default_resolution'][0],
+                num_frames=num_frames,
+                decode_chunk_size=8,
+                motion_bucket_id=127,
+                fps=7,
+                noise_aug_strength=0.02,
+                num_inference_steps=PROCESSING_CONFIG['generation_steps']
+            ).frames[0]
+            
+            return [np.array(frame) for frame in frames]
+            
+        except Exception as e:
+            print(f"Video generation failed: {e}")
+            return None

src/video_processor.py

@@ -0,0 +1,110 @@
+import moviepy.editor as mp
+import numpy as np
+import os
+from config.settings import PATHS, PROCESSING_CONFIG
+
+class VideoProcessor:
+    def __init__(self):
+        pass
+    
+    def merge_videos(self, video1_path, video2_path=None, target_duration=20):
+        try:
+            clips = []
+            total_duration = 0
+            
+            clip1 = mp.VideoFileClip(video1_path)
+            clips.append(clip1)
+            total_duration += clip1.duration
+            
+            if video2_path and os.path.exists(video2_path):
+                clip2 = mp.VideoFileClip(video2_path)
+                clips.append(clip2.crossfadein(0.5))
+                total_duration += clip2.duration
+            
+            if len(clips) > 1:
+                merged = mp.concatenate_videoclips(clips, method="compose")
+            else:
+                merged = clips[0]
+            
+            if total_duration < target_duration:
+                extend_time = target_duration - total_duration
+                if extend_time > 0:
+                    loop_times = int(extend_time / merged.duration) + 1
+                    extended = mp.concatenate_videoclips([merged] * (loop_times + 1))
+                    merged = extended.subclip(0, target_duration)
+            elif total_duration > target_duration:
+                merged = merged.subclip(0, target_duration)
+            
+            merged = self._apply_effects(merged)
+            
+            output_path = os.path.join(PATHS['temp_dir'], f"merged_{hash(video1_path)}.mp4")
+            merged.write_videofile(
+                output_path, 
+                fps=PROCESSING_CONFIG['fps'],
+                codec='libx264',
+                audio_codec='aac',
+                temp_audiofile=os.path.join(PATHS['temp_dir'], 'temp_audio.m4a'),
+                remove_temp=True,
+                logger=None,
+                verbose=False
+            )
+            
+            for clip in clips:
+                clip.close()
+            merged.close()
+            
+            return output_path
+            
+        except Exception as e:
+            print(f"Video merge failed: {e}")
+            return None
+    
+    def add_ai_extension(self, video_path, ai_frames, target_duration):
+        if not ai_frames or not video_path:
+            return video_path
+        
+        try:
+            main_clip = mp.VideoFileClip(video_path)
+            
+            frame_array = np.array(ai_frames)
+            ai_clip = mp.ImageSequenceClip([frame for frame in frame_array], fps=PROCESSING_CONFIG['fps'])
+            
+            ai_clip = ai_clip.resize(main_clip.size)
+            
+            combined = mp.concatenate_videoclips([main_clip, ai_clip.crossfadein(0.3)])
+            
+            if combined.duration > target_duration:
+                combined = combined.subclip(0, target_duration)
+            
+            output_path = os.path.join(PATHS['temp_dir'], f"extended_{hash(video_path)}.mp4")
+            combined.write_videofile(
+                output_path,
+                fps=PROCESSING_CONFIG['fps'], 
+                codec='libx264',
+                temp_audiofile=os.path.join(PATHS['temp_dir'], 'temp_audio2.m4a'),
+                remove_temp=True,
+                logger=None,
+                verbose=False
+            )
+            
+            main_clip.close()
+            ai_clip.close()
+            combined.close()
+            
+            return output_path
+            
+        except Exception as e:
+            print(f"AI extension failed: {e}")
+            return video_path
+    
+    def _apply_effects(self, clip):
+        try:
+            def color_correct(get_frame, t):
+                frame = get_frame(t)
+                enhanced = np.clip(frame * 1.05 + 2, 0, 255)
+                enhanced[:, :, 0] = np.clip(enhanced[:, :, 0] * 1.02, 0, 255)
+                return enhanced.astype(np.uint8)
+            
+            return clip.fl(color_correct)
+        except:
+            return clip

utils/effects.py

@@ -0,0 +1,33 @@
+import numpy as np
+import cv2
+
+class ColorGrading:
+    def apply_commercial_grade(self, clip):
+        def color_grade(get_frame, t):
+            frame = get_frame(t)
+            enhanced = np.clip(frame * 1.05 + 3, 0, 255)
+            enhanced = self._temperature_adjust(enhanced)
+            return enhanced.astype(np.uint8)
+        return clip.fl(color_grade)
+    
+    def _temperature_adjust(self, frame):
+        frame[:, :, 0] = np.clip(frame[:, :, 0] * 1.02, 0, 255)
+        frame[:, :, 2] = np.clip(frame[:, :, 2] * 0.98, 0, 255)
+        return frame
+
+class TransitionEffects:
+    def crossfade(self, clip, duration):
+        return clip.crossfadein(duration)
+    
+    def slow_zoom(self, clip, zoom_factor=0.05):
+        def zoom_effect(get_frame, t):
+            frame = get_frame(t)
+            progress = t / clip.duration
+            current_zoom = 1 + progress * zoom_factor
+            h, w = frame.shape[:2]
+            new_h, new_w = int(h / current_zoom), int(w / current_zoom)
+            start_y = (h - new_h) // 2
+            start_x = (w - new_w) // 2
+            cropped = frame[start_y:start_y + new_h, start_x:start_x + new_w]
+            return cv2.resize(cropped, (w, h))
+        return clip.fl(zoom_effect)

utils/helpers.py

@@ -0,0 +1,21 @@
+import cv2
+import os
+
+def get_video_info(video_path):
+    try:
+        cap = cv2.VideoCapture(video_path)
+        fps = cap.get(cv2.CAP_PROP_FPS) or 24
+        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        duration = frame_count / fps if fps > 0 else 0
+        cap.release()
+        return {'fps': fps, 'duration': duration, 'resolution': (width, height), 'frame_count': frame_count}
+    except:
+        return None
+
+def validate_video_file(video_path):
+    if not video_path or not os.path.exists(video_path):
+        return False
+    info = get_video_info(video_path)
+    return info is not None and info['duration'] > 0