Upload 2 files

app.py

@@ -0,0 +1,43 @@
+
+import gradio as gr
+import os
+from video_analyzer_keyframes import VideoSceneAnalyzer
+import shutil
+
+def process_video_keyframes(video_file):
+    video_path = video_file
+    output_dir = "output"
+
+    if not os.path.exists(video_path):
+        return "❌ Erro: vídeo não encontrado.", None
+
+    try:
+        analyzer = VideoSceneAnalyzer(video_path)
+        if not analyzer.load_video():
+            return "❌ Erro ao carregar vídeo", None
+
+        analyzer.extract_keyframes()
+        result_file = analyzer.save_results()
+        analyzer.cleanup()
+
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+        shutil.copy(result_file, os.path.join(output_dir, os.path.basename(result_file)))
+
+        return f"✅ Análise por quadros-chave concluída! Resultados salvos em: {result_file}", os.path.join(output_dir, os.path.basename(result_file))
+    except Exception as e:
+        return f"❌ Erro inesperado: {e}", None
+
+with gr.Blocks(title="🎬 Veo3 Keyframe Prompt Generator") as demo:
+    gr.Markdown("## 🎞️ Geração de prompts cinematográficos a partir de quadros-chave do vídeo")
+
+    with gr.Row():
+        video_input = gr.Video(label="📹 Envie seu vídeo (MP4)")
+
+    submit_btn = gr.Button("🚀 Analisar quadros-chave")
+    output_text = gr.Textbox(label="📝 Resultado")
+    output_file = gr.File(label="📄 JSON com prompts", visible=True)
+
+    submit_btn.click(fn=process_video_keyframes, inputs=[video_input], outputs=[output_text, output_file])
+
+demo.launch()

video_analyzer_keyframes.py

@@ -0,0 +1,120 @@
+
+import moviepy.editor as mp
+import cv2
+import numpy as np
+from PIL import Image
+import os
+import json
+from datetime import datetime
+from transformers import BlipProcessor, BlipForConditionalGeneration
+import torch
+
+# BLIP setup
+blip_processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
+blip_model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
+
+class VideoSceneAnalyzer:
+    def __init__(self, video_path, scene_duration=8):
+        self.video_path = video_path
+        self.scene_duration = scene_duration
+        self.clip = None
+        self.video_info = {}
+        self.scenes = []
+
+    def load_video(self):
+        try:
+            self.clip = mp.VideoFileClip(self.video_path)
+            self.video_info = {
+                'duration': self.clip.duration,
+                'fps': self.clip.fps,
+                'size': self.clip.size,
+                'aspect_ratio': self.clip.size[0] / self.clip.size[1],
+                'total_frames': int(self.clip.duration * self.clip.fps)
+            }
+            print(f"✅ Vídeo carregado: {self.video_info}")
+            return True
+        except Exception as e:
+            print(f"❌ Erro ao carregar vídeo: {e}")
+            return False
+
+    def describe_image_and_generate_prompt(self, frame, scene_number):
+        temp_img_path = f"temp_scene_{scene_number:02d}.jpg"
+        Image.fromarray(np.uint8(frame)).save(temp_img_path)
+        image = Image.open(temp_img_path).convert("RGB")
+        inputs = blip_processor(images=image, return_tensors="pt")
+        out = blip_model.generate(**inputs)
+        caption = blip_processor.decode(out[0], skip_special_tokens=True).strip().capitalize()
+
+        descricao = f"Imagem da cena {scene_number}: {caption}."
+        prompt = (
+            f"A cinematic, naturalistic shot showing: {caption}. "
+            "Captured with shallow depth of field, soft natural light, and handheld motion. "
+            "Realistic skin texture, clean background separation, true-to-life tone. "
+            "--ar 16:9 --v 6 --style photorealistic --quality 2"
+        )
+        negative_prompt = "--no (CGI skin, artificial lighting, cartoon textures, overexposed highlights, static pose, low detail)"
+        return descricao, prompt, negative_prompt
+
+    def extract_keyframes(self, threshold=30.0):
+        print("🔍 Iniciando extração de quadros-chave inteligentes...")
+        output_dir = f"keyframes_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        os.makedirs(output_dir, exist_ok=True)
+
+        cap = cv2.VideoCapture(self.video_path)
+        prev_frame = None
+        saved_count = 0
+        success, frame = cap.read()
+
+        while success:
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            if prev_frame is None:
+                diff = float('inf')
+            else:
+                diff = np.mean(cv2.absdiff(gray, prev_frame))
+
+            if prev_frame is None or diff > threshold:
+                timestamp = cap.get(cv2.CAP_PROP_POS_MSEC) / 1000.0
+                img_path = os.path.join(output_dir, f"keyframe_{saved_count+1:02d}.jpg")
+                Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)).save(img_path)
+                descricao, prompt, negative_prompt = self.describe_image_and_generate_prompt(
+                    cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), saved_count + 1
+                )
+                scene_info = {
+                    'scene_number': saved_count + 1,
+                    'time': timestamp,
+                    'image_path': img_path,
+                    'descricao_detalhada': descricao,
+                    'prompt_ia': prompt,
+                    'negative_prompt': negative_prompt
+                }
+                self.scenes.append(scene_info)
+                saved_count += 1
+                print(f"✅ Keyframe {saved_count} salvo (diferença: {diff:.2f})")
+
+            prev_frame = gray
+            success, frame = cap.read()
+
+        cap.release()
+        print(f"🎞️ {saved_count} quadros-chave extraídos com sucesso.")
+        return True
+
+    def save_results(self, output_file=None):
+        if not output_file:
+            output_file = f"video_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+
+        results = {
+            'video_info': self.video_info,
+            'analysis_type': "keyframe_extraction",
+            'scenes': self.scenes,
+            'generated_at': datetime.now().isoformat()
+        }
+
+        with open(output_file, 'w', encoding='utf-8') as f:
+            json.dump(results, f, indent=2, ensure_ascii=False)
+
+        print(f"💾 Resultados salvos em: {output_file}")
+        return output_file
+
+    def cleanup(self):
+        if self.clip:
+            self.clip.close()