app.py

import gradio as gr
import torch
from transformers import (
    BlipProcessor, 
    BlipForQuestionAnswering,
    pipeline
)
from modelscope.pipelines import pipeline as ms_pipeline
from PIL import Image
import os
import logging
import tempfile

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class MultimodalProcessor:
    def __init__(self):
        self.load_models()
        self.temp_dir = tempfile.mkdtemp()
    
    def load_models(self):
        """Charge les modèles"""
        try:
            logger.info("Chargement des modèles...")
            # BLIP pour l'analyse d'image
            self.blip_processor = BlipProcessor.from_pretrained("Salesforce/blip-vqa-base")
            self.blip_model = BlipForQuestionAnswering.from_pretrained("Salesforce/blip-vqa-base")
            
            # Whisper pour la transcription audio
            self.audio_transcriber = pipeline("automatic-speech-recognition", 
                                           model="openai/whisper-base")
            
            # ModelScope pour la génération vidéo
            self.video_pipeline = ms_pipeline(
                'text-to-video-synthesis',
                model='damo/text-to-video-synthesis'
            )
            
            logger.info("Modèles chargés avec succès")
        except Exception as e:
            logger.error(f"Erreur lors du chargement des modèles: {str(e)}")
            raise

    def analyze_image(self, image):
        """Analyse une image avec BLIP"""
        try:
            if image is None:
                return ""
            
            questions = [
                "What is in the picture?",
                "What are the main colors?",
                "What is the setting or background?"
            ]
            
            responses = {}
            for question in questions:
                inputs = self.blip_processor(images=image, text=question, return_tensors="pt")
                outputs = self.blip_model.generate(**inputs)
                answer = self.blip_processor.decode(outputs[0], skip_special_tokens=True)
                responses[question] = answer
            
            description = (
                f"This image shows {responses['What is in the picture?']}. "
                f"The main colors are {responses['What are the main colors?']}. "
                f"The setting is {responses['What is the setting or background?']}."
            )
            
            return description
        except Exception as e:
            logger.error(f"Erreur lors de l'analyse de l'image: {str(e)}")
            return "Erreur lors de l'analyse de l'image."

    def transcribe_audio(self, audio_path):
        """Transcrit un fichier audio avec Whisper"""
        try:
            if audio_path is None:
                return ""
            return self.audio_transcriber(audio_path)["text"]
        except Exception as e:
            logger.error(f"Erreur lors de la transcription audio: {str(e)}")
            return "Erreur lors de la transcription audio."

    def generate_video(self, prompt):
        """Génère une vidéo avec ModelScope"""
        try:
            if not prompt:
                return None
                
            output_path = os.path.join(self.temp_dir, "output.mp4")
            result = self.video_pipeline({
                'text': prompt,
                'output_path': output_path
            })
            
            if os.path.exists(output_path):
                return output_path
            raise Exception("La vidéo n'a pas été générée correctement")
                
        except Exception as e:
            logger.error(f"Erreur lors de la génération de vidéo: {str(e)}")
            return None

    def process_inputs(self, image, audio, text):
        """Traite les entrées multimodales"""
        try:
            combined_parts = []
            
            # Analyse de l'image si présente
            if image is not None:
                image_desc = self.analyze_image(image)
                if image_desc:
                    combined_parts.append(f"Scene: {image_desc}")
            
            # Transcription audio si présent
            if audio is not None:
                audio_text = self.transcribe_audio(audio)
                if audio_text:
                    combined_parts.append(f"Audio narration: {audio_text}")
            
            # Ajout du texte si présent
            if text:
                combined_parts.append(f"Additional context: {text}")
            
            # Création du prompt final
            if combined_parts:
                final_prompt = " ".join(combined_parts)
            else:
                final_prompt = "Empty scene with neutral background"
            
            # Génération de la vidéo
            output_video = self.generate_video(final_prompt)
            
            return output_video, final_prompt
            
        except Exception as e:
            logger.error(f"Erreur lors du traitement des entrées: {str(e)}")
            return None, "Une erreur est survenue lors du traitement des entrées."

def create_interface():
    """Crée l'interface Gradio"""
    processor = MultimodalProcessor()
    
    interface = gr.Interface(
        fn=processor.process_inputs,
        inputs=[
            gr.Image(type="pil", label="Télécharger une image"),
            gr.Audio(type="filepath", label="Télécharger un fichier audio"),
            gr.Textbox(label="Entrez du texte additionnel")
        ],
        outputs=[
            gr.Video(label="Vidéo générée"),
            gr.Textbox(label="Description utilisée")
        ],
        title="Générateur de Vidéo Multimodal",
        description="""
        Téléchargez une image, un fichier audio et/ou ajoutez du texte.
        L'application va:
        1. Analyser l'image pour en extraire une description
        2. Transcrire l'audio en texte
        3. Combiner ces éléments avec votre texte
        4. Générer une vidéo basée sur la description combinée
        """
    )
    
    return interface

if __name__ == "__main__":
    interface = create_interface()
    interface.launch()