aduc-sdr

aduc_orchestrator.py

@@ -0,0 +1,140 @@
+# aduc_orchestrator.py
+# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
+#
+# Este programa é software livre: você pode redistribuí-lo e/ou modificá-lo
+# sob os termos da Licença Pública Geral Affero GNU...
+# AVISO DE PATENTE PENDENTE: Consulte NOTICE.md.
+
+import os
+import time
+import shutil
+import logging
+import gradio as gr
+from PIL import Image, ImageOps
+import subprocess
+from pathlib import Path
+import json
+
+from deformes4D_engine import Deformes4DEngine
+from ltx_manager_helpers import ltx_manager_singleton
+from gemini_helpers import gemini_singleton
+from image_specialist import image_specialist_singleton
+
+# Configuração de logging centralizada deve ser feita no app.py
+logger = logging.getLogger(__name__)
+
+class AducDirector:
+    def __init__(self, workspace_dir):
+        self.workspace_dir = workspace_dir
+        os.makedirs(self.workspace_dir, exist_ok=True)
+        self.state = {}
+        logger.info(f"O palco está pronto. Workspace em '{self.workspace_dir}'.")
+
+    def reset(self):
+        os.makedirs(self.workspace_dir, exist_ok=True)
+        self.state = {}
+        logger.info("Partitura limpa. Estado do Diretor reiniciado.")
+
+    def update_state(self, key, value):
+        log_value = value if not isinstance(value, (dict, list)) and not hasattr(value, 'shape') else f"Objeto complexo"
+        logger.info(f"Anotando na partitura: Estado '{key}' atualizado.")
+        self.state[key] = value
+
+    def get_state(self, key, default=None):
+        return self.state.get(key, default)
+
+class AducOrchestrator:
+    def __init__(self, workspace_dir: str):
+        self.director = AducDirector(workspace_dir)
+        self.editor = Deformes4DEngine(ltx_manager_singleton, workspace_dir)
+        self.painter = image_specialist_singleton
+        logger.info("Maestro ADUC está no pódio. Músicos (especialistas) prontos.")
+
+    def process_image_for_story(self, image_path: str, size: int, filename: str = None) -> str:
+        """
+        Pré-processa uma imagem de referência: converte para RGB, redimensiona para um
+        quadrado e salva no diretório de trabalho.
+        """
+        img = Image.open(image_path).convert("RGB")
+        img_square = ImageOps.fit(img, (size, size), Image.Resampling.LANCZOS)
+        
+        if filename: 
+            processed_path = os.path.join(self.director.workspace_dir, filename)
+        else: 
+            processed_path = os.path.join(self.director.workspace_dir, f"ref_processed_{int(time.time()*1000)}.png")
+            
+        img_square.save(processed_path)
+        logger.info(f"Imagem de referência processada e salva em: {processed_path}")
+        return processed_path
+
+    def task_generate_storyboard(self, prompt, num_keyframes, processed_ref_image_paths, progress):
+        logger.info(f"Ato 1, Cena 1: Roteiro. Instruindo o Roteirista (Gemini) a criar {num_keyframes} cenas a partir de: '{prompt}'")
+        progress(0.2, desc="Consultando Roteirista IA (Gemini)...")
+        storyboard = gemini_singleton.generate_storyboard(prompt, num_keyframes, processed_ref_image_paths)
+        logger.info(f"Roteirista retornou a partitura: {storyboard}")
+        self.director.update_state("storyboard", storyboard)
+        self.director.update_state("processed_ref_paths", processed_ref_image_paths)
+        return storyboard, processed_ref_image_paths[0], gr.update(visible=True, open=True)
+
+    def task_select_keyframes(self, storyboard, base_ref_paths, pool_ref_paths):
+        logger.info(f"Ato 1, Cena 2 (Alternativa): Fotografia. Instruindo o Editor (Gemini) a selecionar {len(storyboard)} keyframes de um banco de {len(pool_ref_paths)} imagens.")
+        selected_paths = gemini_singleton.select_keyframes_from_pool(storyboard, base_ref_paths, pool_ref_paths)
+        logger.info(f"Editor selecionou as seguintes cenas: {[os.path.basename(p) for p in selected_paths]}")
+        self.director.update_state("keyframes", selected_paths)
+        return selected_paths
+
+    def task_generate_keyframes(self, storyboard, initial_ref_path, global_prompt, keyframe_resolution, progress_callback_factory=None):
+        """
+        Delega a tarefa de geração de keyframes para o ImageSpecialist.
+        """
+        logger.info(f"Ato 1, Cena 2: Direção de Arte. Delegando ao Especialista de Imagem.")
+        
+        general_ref_paths = self.director.get_state("processed_ref_paths", [])
+        
+        final_keyframes = self.painter.generate_keyframes_from_storyboard(
+            storyboard=storyboard,
+            initial_ref_path=initial_ref_path,
+            global_prompt=global_prompt,
+            keyframe_resolution=int(keyframe_resolution),
+            general_ref_paths=general_ref_paths,
+            progress_callback_factory=progress_callback_factory
+        )
+        
+        self.director.update_state("keyframes", final_keyframes)
+        logger.info("Maestro: Especialista de Imagem concluiu a geração dos keyframes.")
+        return final_keyframes
+    
+    def task_produce_final_movie_with_feedback(self, keyframes, global_prompt, seconds_per_fragment, 
+                           overlap_percent, echo_frames,
+                           handler_strength, 
+                           destination_convergence_strength,
+                           base_ltx_params,
+                           video_resolution, use_continuity_director, 
+                           use_cinematographer, progress): 
+        
+        logger.info("AducOrchestrator: Delegando a produção do filme completo ao Deformes4DEngine.")
+        storyboard = self.director.get_state("storyboard", [])
+
+        for update in self.editor.generate_full_movie(
+            keyframes=keyframes, 
+            global_prompt=global_prompt, 
+            storyboard=storyboard, 
+            seconds_per_fragment=seconds_per_fragment, 
+            overlap_percent=overlap_percent, 
+            echo_frames=echo_frames, 
+            handler_strength=handler_strength, 
+            destination_convergence_strength=destination_convergence_strength,
+            base_ltx_params=base_ltx_params,
+            video_resolution=video_resolution, 
+            use_continuity_director=use_continuity_director, 
+            progress=progress
+        ):
+            if "fragment_path" in update and update["fragment_path"]:
+                yield {"fragment_path": update["fragment_path"]}
+            elif "final_path" in update and update["final_path"]:
+                final_movie_path = update["final_path"]
+                self.director.update_state("final_video_path", final_movie_path)
+                yield {"final_path": final_movie_path}
+                break
+
+        logger.info("AducOrchestrator: Produção do filme concluída e estado do diretor atualizado.")

app.py

@@ -0,0 +1,301 @@
+# app.py
+# Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
+#
+# Este programa é software livre: você pode redistribuí-lo e/ou modificá-lo
+# sob os termos da Licença Pública Geral Affero GNU como publicada pela
+# Free Software Foundation, seja a versão 3 da Licença, ou
+# (a seu critério) qualquer versão posterior.
+#
+# AVISO DE PATENTE PENDENTE: O método e sistema ADUC implementado neste 
+# software está em processo de patenteamento. Consulte NOTICE.md.
+
+import gradio as gr
+import yaml
+import logging
+import os
+import sys
+import shutil
+import time
+import json
+
+from aduc_orchestrator import AducOrchestrator
+
+# --- 1. CONFIGURAÇÃO E INICIALIZAÇÃO ---
+
+LOG_FILE_PATH = "aduc_log.txt"
+if os.path.exists(LOG_FILE_PATH):
+    os.remove(LOG_FILE_PATH)
+
+log_format = '%(asctime)s - %(levelname)s - [%(name)s:%(funcName)s] - %(message)s'
+root_logger = logging.getLogger()
+root_logger.setLevel(logging.INFO)
+root_logger.handlers.clear()
+
+stream_handler = logging.StreamHandler(sys.stdout)
+stream_handler.setLevel(logging.INFO)
+stream_handler.setFormatter(logging.Formatter(log_format))
+root_logger.addHandler(stream_handler)
+
+file_handler = logging.FileHandler(LOG_FILE_PATH, mode='w', encoding='utf-8')
+file_handler.setLevel(logging.INFO)
+file_handler.setFormatter(logging.Formatter(log_format))
+root_logger.addHandler(file_handler)
+
+logger = logging.getLogger(__name__)
+
+i18n = {}
+try:
+    with open("i18n.json", "r", encoding="utf-8") as f:
+        i18n = json.load(f)
+except FileNotFoundError:
+    logger.warning("Arquivo i18n.json não encontrado! A interface usará textos em inglês como fallback.")
+except json.JSONDecodeError:
+    logger.error("Erro ao decodificar i18n.json. Verifique a formatação do arquivo.")
+
+if 'pt' not in i18n: i18n['pt'] = i18n.get('en', {})
+if 'en' not in i18n: i18n['en'] = {}
+if 'zh' not in i18n: i18n['zh'] = i18n.get('en', {})
+
+try:
+    with open("config.yaml", 'r') as f: config = yaml.safe_load(f)
+    WORKSPACE_DIR = config['application']['workspace_dir']
+    aduc = AducOrchestrator(workspace_dir=WORKSPACE_DIR)
+    logger.info("Orquestrador ADUC e Especialistas inicializados com sucesso.")
+except Exception as e:
+    logger.error(f"ERRO CRÍTICO ao inicializar: {e}", exc_info=True)
+    exit()
+
+# --- 2. WRAPPERS DA UI ---
+
+def preprocess_base_images_wrapper(uploaded_files):
+    if not uploaded_files: return None
+    processed_paths = [aduc.process_image_for_story(f.name, 480, f"ref_processed_{i}.png") for i, f in enumerate(uploaded_files)]
+    return gr.update(value=processed_paths)
+
+def run_mode_a_wrapper(prompt, num_keyframes, ref_files, resolution_str, duration_per_fragment, progress=gr.Progress()):
+    if not ref_files: 
+        raise gr.Error("Por favor, forneça pelo menos uma imagem de referência.")
+    
+    ref_paths = [f.name for f in ref_files]
+
+    progress(0.1, desc="Gerando roteiro...")
+    storyboard, initial_ref_path, _ = aduc.task_generate_storyboard(prompt, num_keyframes, ref_paths, progress)
+    
+    resolution = int(resolution_str.split('x')[0])
+
+    def cb_factory(scene_index, total_scenes):
+        start_time = time.time()
+        total_steps = 30
+        def callback(pipe_self, step, timestep, callback_kwargs):
+            elapsed = time.time() - start_time
+            current_step = step + 1
+            if current_step > 0:
+                it_per_sec = current_step / elapsed
+                eta = (total_steps - current_step) / it_per_sec if it_per_sec > 0 else 0
+                desc = f"Keyframe {scene_index}/{total_scenes}: {int((current_step/total_steps)*100)}% | {current_step}/{total_steps} [{elapsed:.0f}s<{eta:.0f}s, {it_per_sec:.2f}it/s]"
+                progress(0.2 + (current_step / total_steps) * 0.8, desc=desc)
+            return {}
+        return callback
+    
+    final_keyframes = aduc.task_generate_keyframes(storyboard, initial_ref_path, prompt, resolution, cb_factory)
+    
+    return gr.update(value=storyboard), gr.update(value=final_keyframes), gr.update(visible=True, open=True)
+
+def run_mode_b_wrapper(prompt, num_keyframes, ref_files, progress=gr.Progress()):
+    if not ref_files or len(ref_files) < 2: 
+        raise gr.Error("Modo Fotógrafo requer pelo menos 2 imagens: uma base e uma para o banco de cenas.")
+
+    base_ref_paths = [aduc.process_image_for_story(ref_files[0].name, 480, "base_ref_processed_0.png")]
+    pool_ref_paths = [f.name for f in ref_files[1:]]
+
+    progress(0.1, desc="Gerando roteiro...")
+    storyboard, _, _ = aduc.task_generate_storyboard(prompt, num_keyframes, base_ref_paths, progress)
+    
+    progress(0.5, desc="IA (Fotógrafo) está selecionando as melhores cenas...")
+    selected_keyframes = aduc.task_select_keyframes(storyboard, base_ref_paths, pool_ref_paths)
+    
+    return gr.update(value=storyboard), gr.update(value=selected_keyframes), gr.update(visible=True, open=True)
+
+def run_video_production_wrapper(keyframes, prompt, duration, overlap_percent, echo_frames, 
+                                 handler_strength, destination_convergence_strength,
+                                 guidance, stg, rescaling, num_inference_steps,
+                                 video_resolution, use_cont, use_cine,
+                                 progress=gr.Progress()):
+    yield {
+        video_fragments_gallery: gr.update(value=None, visible=True),
+        final_video_output: gr.update(value=None, visible=True, label="🎬 Produzindo seu filme... Por favor, aguarde.")
+    }
+    
+    adv_params = {
+        "guidance_scale": guidance, "stg_scale": stg, "rescaling_scale": rescaling,
+        "num_inference_steps": num_inference_steps
+    }
+    resolution = int(video_resolution.split('x')[0])
+
+    video_fragments_so_far = []
+    final_movie_path = None
+    
+    for update in aduc.task_produce_final_movie_with_feedback(
+        keyframes, prompt, duration, overlap_percent, echo_frames, 
+        handler_strength, destination_convergence_strength,
+        adv_params, resolution, use_cont, use_cine, progress
+    ):
+        if "fragment_path" in update and update["fragment_path"]:
+            video_fragments_so_far.append(update["fragment_path"])
+            yield { video_fragments_gallery: gr.update(value=video_fragments_so_far), final_video_output: gr.update() }
+        elif "final_path" in update and update["final_path"]:
+            final_movie_path = update["final_path"]
+            break
+    
+    yield {
+        video_fragments_gallery: gr.update(),
+        final_video_output: gr.update(value=final_movie_path, label="🎉 FILME COMPLETO 🎉")
+    }
+
+def get_log_content():
+    """Função para ler e retornar o conteúdo do arquivo de log."""
+    try:
+        with open(LOG_FILE_PATH, "r", encoding="utf-8") as f:
+            return f.read()
+    except FileNotFoundError:
+        return "Arquivo de log ainda não criado. Inicie uma geração."
+
+def update_ui_language(lang_code):
+    lang_map = i18n.get(lang_code, i18n.get('en', {}))
+    # ... (a função de tradução permanece a mesma, mas está aqui para completude)
+    return {
+        title_md: gr.update(value=f"# {lang_map.get('app_title')}"),
+        subtitle_md: gr.update(value=lang_map.get('app_subtitle')),
+        lang_selector: gr.update(label=lang_map.get('lang_selector_label')),
+        step1_accordion: gr.update(label=lang_map.get('step1_accordion')),
+        prompt_input: gr.update(label=lang_map.get('prompt_label')),
+        ref_image_input: gr.update(label=lang_map.get('ref_images_label')),
+        num_keyframes_slider: gr.update(label=lang_map.get('keyframes_label')),
+        duration_per_fragment_slider: gr.update(label=lang_map.get('duration_label')),
+        storyboard_and_keyframes_button: gr.update(value=lang_map.get('storyboard_and_keyframes_button')),
+        storyboard_from_photos_button: gr.update(value=lang_map.get('storyboard_from_photos_button')),
+        storyboard_output: gr.update(label=lang_map.get('storyboard_output_label')),
+        keyframe_gallery: gr.update(label=lang_map.get('keyframes_gallery_label')),
+        step3_accordion: gr.update(label=lang_map.get('step3_accordion')),
+        step3_description_md: gr.update(value=lang_map.get('step3_description')),
+        continuity_director_checkbox: gr.update(label=lang_map.get('continuity_director_label')),
+        cinematographer_checkbox: gr.update(label=lang_map.get('cinematographer_label')),
+        echo_frames_selector: gr.update(label=lang_map.get('echo_frames_label'), info=lang_map.get('echo_frames_info')),
+        overlap_percent_slider: gr.update(label=lang_map.get('overlap_percent_label'), info=lang_map.get('overlap_percent_info')),
+        handler_strength_slider: gr.update(label=lang_map.get('handler_strength_label'), info=lang_map.get('handler_strength_info')),
+        destination_convergence_slider: gr.update(label=lang_map.get('destination_convergence_label'), info=lang_map.get('destination_convergence_info')),
+        produce_button: gr.update(value=lang_map.get('produce_button')),
+        advanced_accordion: gr.update(label=lang_map.get('advanced_accordion_label')),
+        guidance_scale_slider: gr.update(label=lang_map.get('guidance_label')),
+        stg_scale_slider: gr.update(label=lang_map.get('stg_label')),
+        rescaling_scale_slider: gr.update(label=lang_map.get('rescaling_label')),
+        num_inference_steps_slider: gr.update(label=lang_map.get('steps_label'), info=lang_map.get('steps_info')),
+        video_fragments_gallery: gr.update(label=lang_map.get('video_fragments_gallery_label')),
+        final_video_output: gr.update(label=lang_map.get('final_movie_with_audio_label')),
+        log_accordion: gr.update(label=lang_map.get('log_accordion_label')),
+        log_display: gr.update(label=lang_map.get('log_display_label')),
+        update_log_button: gr.update(value=lang_map.get('update_log_button')),
+    }
+
+# --- 4. DEFINIÇÃO DA UI ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    default_lang = i18n.get('pt', {})
+    
+    title_md = gr.Markdown(f"# {default_lang.get('app_title')}")
+    subtitle_md = gr.Markdown(default_lang.get('app_subtitle'))
+    
+    with gr.Row():
+        lang_selector = gr.Radio(["pt", "en", "zh"], value="pt", label=default_lang.get('lang_selector_label'))
+        resolution_selector = gr.Radio(["480x480", "512x736", "736x1280"], value="480x480", label="Resolução do Vídeo")
+
+    with gr.Accordion(default_lang.get('step1_accordion'), open=True) as step1_accordion:
+        prompt_input = gr.Textbox(label=default_lang.get('prompt_label'), value="A majestic lion walks across the savanna, sits down, and then roars at the setting sun.")
+        with gr.Row():
+            num_keyframes_slider = gr.Slider(minimum=3, maximum=10, value=3, step=1, label=default_lang.get('keyframes_label'), info="Mínimo de 3 para a lógica do cineasta.")
+            duration_per_fragment_slider = gr.Slider(label=default_lang.get('duration_label'), minimum=2.0, maximum=10.0, value=4.0, step=0.1)
+        ref_image_input = gr.File(label=default_lang.get('ref_images_label'), file_count="multiple", file_types=["image"])
+        with gr.Row():
+            storyboard_and_keyframes_button = gr.Button(default_lang.get('storyboard_and_keyframes_button'), variant="primary")
+            storyboard_from_photos_button = gr.Button(default_lang.get('storyboard_from_photos_button'))
+        gr.Markdown(f"*{default_lang.get('step1_mode_b_info')}*")
+        storyboard_output = gr.JSON(label=default_lang.get('storyboard_output_label'))
+        keyframe_gallery = gr.Gallery(label=default_lang.get('keyframes_gallery_label'), visible=True, object_fit="contain", height="auto", type="filepath")
+        
+    with gr.Accordion(default_lang.get('step3_accordion'), open=False, visible=False) as step3_accordion:
+        step3_description_md = gr.Markdown(default_lang.get('step3_description'))
+        with gr.Row():
+            continuity_director_checkbox = gr.Checkbox(label=default_lang.get('continuity_director_label'), value=True)
+            cinematographer_checkbox = gr.Checkbox(label=default_lang.get('cinematographer_label'), value=True, visible=False)
+        
+        gr.Markdown("--- \n**Controles de Continuidade e Edição:**")
+        with gr.Row():
+            echo_frames_selector = gr.Radio(choices=[8, 16, 24], value=8, label=default_lang.get('echo_frames_label'), info=default_lang.get('echo_frames_info'))
+            overlap_percent_slider = gr.Slider(label=default_lang.get('overlap_percent_label'), minimum=0, maximum=50, value=15, step=1, info=default_lang.get('overlap_percent_info'))
+        
+        gr.Markdown("**Controle de Influência (Convergência):**")
+        with gr.Row():
+            handler_strength_slider = gr.Slider(label=default_lang.get('handler_strength_label'), minimum=0.0, maximum=1.0, value=0.5, step=0.05, info=default_lang.get('handler_strength_info'))
+            destination_convergence_slider = gr.Slider(label=default_lang.get('destination_convergence_label'), minimum=0.0, maximum=1.0, value=0.75, step=0.05, info=default_lang.get('destination_convergence_info'))
+        
+        with gr.Accordion(default_lang.get('advanced_accordion_label'), open=False) as advanced_accordion:
+             with gr.Row():
+                guidance_scale_slider = gr.Slider(label=default_lang.get('guidance_label'), minimum=1.0, maximum=15.0, value=1.0, step=0.5)
+                stg_scale_slider = gr.Slider(label=default_lang.get('stg_label'), minimum=0.0, maximum=10.0, value=0.0, step=0.5)
+                rescaling_scale_slider = gr.Slider(label=default_lang.get('rescaling_label'), minimum=0.0, maximum=1.0, value=0.15, step=0.05)
+             with gr.Row():
+                num_inference_steps_slider = gr.Slider(label=default_lang.get('steps_label'), minimum=4, maximum=50, value=7, step=1, info=default_lang.get('steps_info'))
+        produce_button = gr.Button(default_lang.get('produce_button'), variant="primary")
+    
+    video_fragments_gallery = gr.Gallery(label=default_lang.get('video_fragments_gallery_label'), visible=False, object_fit="contain", height="auto", type="filepath")
+    final_video_output = gr.Video(label=default_lang.get('final_movie_with_audio_label'), visible=False)
+
+    with gr.Accordion("📝 Log de Geração (Detalhado)", open=False) as log_accordion:
+        log_display = gr.Textbox(label="Log da Sessão", lines=20, interactive=False, autoscroll=True)
+        update_log_button = gr.Button("Atualizar Log")
+
+    # --- 5. CONEXÕES DA UI ---
+    all_ui_components = list(update_ui_language('pt').keys())
+    lang_selector.change(fn=update_ui_language, inputs=lang_selector, outputs=all_ui_components)
+    
+    ref_image_input.upload(fn=preprocess_base_images_wrapper, inputs=ref_image_input, outputs=ref_image_input)
+
+    storyboard_and_keyframes_button.click(
+        fn=run_mode_a_wrapper, 
+        inputs=[prompt_input, num_keyframes_slider, ref_image_input, resolution_selector, duration_per_fragment_slider], 
+        outputs=[storyboard_output, keyframe_gallery, step3_accordion]
+    )
+    
+    storyboard_from_photos_button.click(
+        fn=run_mode_b_wrapper,
+        inputs=[prompt_input, num_keyframes_slider, ref_image_input],
+        outputs=[storyboard_output, keyframe_gallery, step3_accordion]
+    )
+    
+    produce_button.click(
+        fn=run_video_production_wrapper,
+        inputs=[
+            keyframe_gallery, prompt_input, duration_per_fragment_slider, 
+            overlap_percent_slider, 
+            echo_frames_selector,
+            handler_strength_slider,
+            destination_convergence_slider,
+            guidance_scale_slider, stg_scale_slider, rescaling_scale_slider,
+            num_inference_steps_slider,
+            resolution_selector, continuity_director_checkbox, cinematographer_checkbox
+        ],
+        outputs=[video_fragments_gallery, final_video_output]
+    )
+
+    update_log_button.click(
+        fn=get_log_content,
+        inputs=[],
+        outputs=[log_display]
+    )
+
+if __name__ == "__main__":
+    if os.path.exists(WORKSPACE_DIR): 
+        logger.info(f"Limpando o workspace anterior em: {WORKSPACE_DIR}")
+        shutil.rmtree(WORKSPACE_DIR)
+    os.makedirs(WORKSPACE_DIR)
+    logger.info(f"Aplicação iniciada. Lançando interface Gradio...")
+    demo.queue().launch()

audio_specialist.py

@@ -0,0 +1,141 @@
+# audio_specialist.py (Versão final para áudio dinâmico por fragmento)
+# Especialista ADUC para geração de áudio, com gerenciamento de memória GPU.
+
+import torch
+import logging
+import subprocess
+import os
+import time
+import yaml
+import gc
+from pathlib import Path
+import gradio as gr
+
+# Importa as classes e funções necessárias do MMAudio
+try:
+    from mmaudio.eval_utils import ModelConfig, all_model_cfg, generate as mmaudio_generate, load_video, make_video
+    from mmaudio.model.flow_matching import FlowMatching
+    from mmaudio.model.networks import MMAudio, get_my_mmaudio
+    from mmaudio.model.utils.features_utils import FeaturesUtils
+    from mmaudio.model.sequence_config import SequenceConfig
+except ImportError:
+    raise ImportError("MMAudio não foi encontrado. Por favor, instale-o a partir do GitHub: git+https://github.com/hkchengrex/MMAudio.git")
+
+logger = logging.getLogger(__name__)
+
+class AudioSpecialist:
+    def __init__(self, workspace_dir):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.cpu_device = torch.device("cpu")
+        self.dtype = torch.bfloat16 if self.device == "cuda" else torch.float32
+        self.workspace_dir = workspace_dir
+        
+        self.model_config: ModelConfig = all_model_cfg['large_44k_v2']
+        self.net: MMAudio = None
+        self.feature_utils: FeaturesUtils = None
+        self.seq_cfg: SequenceConfig = None
+        
+        self._load_models_to_cpu()
+
+    def _load_models_to_cpu(self):
+        try:
+            logger.info("Verificando e baixando modelos MMAudio, se necessário...")
+            self.model_config.download_if_needed()
+            
+            self.seq_cfg = self.model_config.seq_cfg
+            
+            logger.info(f"Carregando modelo MMAudio: {self.model_config.model_name} para a CPU...")
+            self.net = get_my_mmaudio(self.model_config.model_name).eval()
+            self.net.load_weights(torch.load(self.model_config.model_path, map_location=self.cpu_device, weights_only=True))
+            
+            logger.info("Carregando utilitários de features do MMAudio para a CPU...")
+            self.feature_utils = FeaturesUtils(
+                tod_vae_ckpt=self.model_config.vae_path,
+                synchformer_ckpt=self.model_config.synchformer_ckpt,
+                enable_conditions=True,
+                mode=self.model_config.mode,
+                bigvgan_vocoder_ckpt=self.model_config.bigvgan_16k_path,
+                need_vae_encoder=False
+            )
+            self.feature_utils = self.feature_utils.eval()
+            self.net.to(self.cpu_device)
+            self.feature_utils.to(self.cpu_device)
+            logger.info("Especialista de áudio pronto na CPU.")
+        except Exception as e:
+            logger.error(f"Falha ao carregar modelos de áudio: {e}", exc_info=True)
+            self.net = None
+
+    def to_gpu(self):
+        if self.device == 'cpu': return
+        logger.info(f"Movendo especialista de áudio para a GPU ({self.device})...")
+        self.net.to(self.device, self.dtype)
+        self.feature_utils.to(self.device, self.dtype)
+
+    def to_cpu(self):
+        if self.device == 'cpu': return
+        logger.info("Descarregando especialista de áudio da GPU...")
+        self.net.to(self.cpu_device)
+        self.feature_utils.to(self.cpu_device)
+        gc.collect()
+        if torch.cuda.is_available(): torch.cuda.empty_cache()
+
+    def generate_audio_for_video(self, video_path: str, prompt: str, negative_prompt: str, duration_seconds: float) -> str:
+        if self.net is None:
+            raise gr.Error("Modelo MMAudio não está carregado. Não é possível gerar áudio.")
+
+        logger.info("------------------------------------------------------")
+        logger.info("--- Gerando Áudio para Fragmento de Vídeo ---")
+        logger.info(f"--- Vídeo Fragmento: {os.path.basename(video_path)}")
+        logger.info(f"--- Duração: {duration_seconds:.2f}s")
+        logger.info(f"--- Prompt (Descrição da Cena): '{prompt}'")
+        
+        if duration_seconds < 1:
+            logger.warning("Fragmento muito curto (<1s). Retornando vídeo silencioso.")
+            logger.info("------------------------------------------------------")
+            return video_path
+
+        if self.device == 'cpu':
+            logger.warning("Gerando áudio na CPU. Isso pode ser muito lento.")
+
+        try:
+            self.to_gpu()
+            with torch.no_grad():
+                rng = torch.Generator(device=self.device).manual_seed(int(time.time()))
+                fm = FlowMatching(min_sigma=0, inference_mode='euler', num_steps=25)
+                
+                video_info = load_video(Path(video_path), duration_seconds)
+                self.seq_cfg.duration = video_info.duration_sec
+                self.net.update_seq_lengths(self.seq_cfg.latent_seq_len, self.seq_cfg.clip_seq_len, self.seq_cfg.sync_seq_len)
+                
+                audios = mmaudio_generate(
+                    clip_video=video_info.clip_frames.unsqueeze(0),
+                    sync_video=video_info.sync_frames.unsqueeze(0),
+                    text=[prompt],
+                    negative_text=[negative_prompt],
+                    feature_utils=self.feature_utils,
+                    net=self.net,
+                    fm=fm,
+                    rng=rng,
+                    cfg_strength=4.5
+                )
+                audio_waveform = audios.float().cpu()[0]
+                
+                fragment_name = Path(video_path).stem
+                output_video_path = os.path.join(self.workspace_dir, f"{fragment_name}_com_audio.mp4")
+                
+                make_video(video_info, Path(output_video_path), audio_waveform, sampling_rate=self.seq_cfg.sampling_rate)
+                logger.info(f"--- Fragmento com áudio salvo em: {os.path.basename(output_video_path)}")
+                logger.info("------------------------------------------------------")
+                return output_video_path
+        finally:
+            self.to_cpu()
+
+# Singleton instantiation
+try:
+    with open("config.yaml", 'r') as f:
+        config = yaml.safe_load(f)
+    WORKSPACE_DIR = config['application']['workspace_dir']
+    audio_specialist_singleton = AudioSpecialist(workspace_dir=WORKSPACE_DIR)
+except Exception as e:
+    logger.error(f"Não foi possível inicializar o AudioSpecialist: {e}")
+    audio_specialist_singleton = None

config.yaml

@@ -0,0 +1,24 @@
+# config.yaml
+# Configuração central para a aplicação Deformes4D e seus especialistas.
+
+application:
+  workspace_dir: "deformes_workspace"
+
+# Configuração para Hugging Face Spaces
+sdk: gradio
+app_file: app.py
+
+specialists:
+  flux:
+    # Define quantas GPUs o pool do Flux deve tentar alocar.
+    # Se não houver GPUs suficientes, o hardware_manager lançará um erro.
+    # Se 0, usará a CPU.
+    gpus_required: 2
+  
+  ltx:
+    # Define quantas GPUs o pool do LTX deve tentar alocar.
+    gpus_required: 2
+    
+    # Aponta para o arquivo de configuração específico do modelo LTX.
+    # Alterado para usar o modelo 0.9.8-dev.
+    config_file: "configs/ltxv-13b-0.9.8-distilled.yaml"

deformes4D_engine.py

@@ -1,6 +1,7 @@
 # deformes4D_engine.py
 # Copyright (C) 4 de Agosto de 2025  Carlos Rodrigues dos Santos
 #
+#
 # MODIFICATIONS FOR ADUC-SDR:
 # Copyright (C) 2025 Carlos Rodrigues dos Santos. All rights reserved.
 #
@@ -8,9 +9,6 @@
 # video fragment generation, latent manipulation, and dynamic editing, 
 # governed by the ADUC orchestrator.
 # This component is licensed under the GNU Affero General Public License v3.0.
-#
-# AVISO DE PATENTE PENDENTE: O método e sistema ADUC implementado neste 
-# software está em processo de patenteamento. Consulte NOTICE.md.
 
 import os
 import time

packages.txt

@@ -0,0 +1 @@
+ffmpeg