Update deformes4D_engine.py

deformes4D_engine.py

@@ -125,33 +125,37 @@ class Deformes4DEngine:
                             video_resolution: int, use_continuity_director: bool, 
                             progress: gr.Progress = gr.Progress()):
         
-        # --- Lógica de Controle Dinâmico (Estratégia de Cauda Longa Refinada) ---
-        
+        # --- [INÍCIO] Lógica de Controle Dinâmico Baseada em Dois Sliders ---
+
+        # 1. Calcular o total de chunks a serem gerados a partir dos segundos
         total_chunks_gerados = max(5, int(round(seconds_per_fragment * 24 / 8)))
-        video_chunk_count = max(1, int(round(total_chunks_gerados * (1 - (trim_percent / 100)))))
 
-        # Regra de segurança: garantir que o vídeo não invada o espaço do handler
-        if video_chunk_count > total_chunks_gerados - 2:
-            video_chunk_count = total_chunks_gerados - 2
-            logger.warning(f"Contagem de chunks de vídeo ajustada para {video_chunk_count} para não sobrepor o handler.")
+        # 2. Calcular o número de chunks a podar com base na porcentagem, com mínimo de 4
+        trim_chunks = max(4, int(round(total_chunks_gerados * (trim_percent / 100))))
+        
+        # Regra de segurança para evitar que a poda consuma o vídeo inteiro
+        if trim_chunks >= total_chunks_gerados:
+            trim_chunks = total_chunks_gerados - 1
+            logger.warning(f"A poda ({trim_percent}%) era muito grande. Ajustada para {trim_chunks} chunks para deixar 1 chunk de vídeo.")
 
-        # Definição das fatias com base na sua lógica corrigida
-        VIDEO_SLICE = slice(0, video_chunk_count)
-        ECO_SLICE = slice(video_chunk_count - 1, video_chunk_count + 1)
-        HANDLER_SLICE = slice(total_chunks_gerados - 2, total_chunks_gerados)
+        # 3. Definir fatias e alvos com base nos cálculos
+        VIDEO_CHUNK_COUNT = total_chunks_gerados - trim_chunks
+        
+        HANDLER_CHUNK_INDICES = slice(total_chunks_gerados - 2, total_chunks_gerados)
+        ECO_CHUNK_INDICES = slice(total_chunks_gerados - 4, total_chunks_gerados - 2)
         
-        # O ponto de aplicação do handler agora é fixo para maior estabilidade
         HANDLER_FRAME_TARGET = (trim_chunks - 2) * 8
         FRAMES_TO_GENERATE = (total_chunks_gerados - 1) * 8 + 1
         DESTINATION_FRAME_TARGET = FRAMES_TO_GENERATE - 1
 
         logger.info("="*60)
-        logger.info("MODO DE GERAÇÃO: Estratégia de Guias Imutáveis")
-        logger.info(f"  - Geração Bruta: {total_chunks_gerados} chunks")
-        logger.info(f"  - Clipe Final: Chunks {VIDEO_SLICE.start} a {VIDEO_SLICE.stop-1} ({video_chunk_count} chunks)")
-        logger.info(f"  - Guia Eco (Memória): Chunks {ECO_SLICE.start} a {ECO_SLICE.stop-1}")
-        logger.info(f"  - Guia Handler (Evolução): Chunks {HANDLER_SLICE.start} a {HANDLER_SLICE.stop-1}")
-        logger.info(f"  - Ponto de Aplicação do Handler: Frame {HANDLER_FRAME_TARGET}")
+        logger.info("MODO DE GERAÇÃO: Estratégia de Cauda Longa Dinâmica")
+        logger.info(f"  - Duração Solicitada: {seconds_per_fragment}s -> Geração Bruta: {total_chunks_gerados} chunks")
+        logger.info(f"  - Poda Solicitada: {trim_percent}% -> Chunks de Poda (Cauda): {trim_chunks}")
+        logger.info(f"  - Clipe Final por Fragmento: {VIDEO_CHUNK_COUNT} chunks")
+        logger.info(f"  - Guia de Eco (Memória): Chunks {ECO_CHUNK_INDICES.start}-{ECO_CHUNK_INDICES.stop-1}")
+        logger.info(f"  - Guia de Handler (Evolução): Chunks {HANDLER_CHUNK_INDICES.start}-{HANDLER_CHUNK_INDICES.stop-1}")
+        logger.info(f"  - PONTO DE APLICAÇÃO DO HANDLER (DINÂMICO): Frame {HANDLER_FRAME_TARGET}")
         logger.info("="*60)
         
         base_ltx_params = {"guidance_scale": 1.0, "stg_scale": 0.0, "rescaling_scale": 0.15, "num_inference_steps": 20}
@@ -202,11 +206,11 @@ class Deformes4DEngine:
             new_full_latents = self._generate_latent_tensor_internal(conditioning_items, current_ltx_params, target_resolution_tuple, FRAMES_TO_GENERATE)
             logger.info(f"  [1. GERAÇÃO] Tensor latente bruto gerado com shape: {new_full_latents.shape}.")
 
-            eco_latent_for_next_loop = new_full_latents[:, :, ECO_SLICE, :, :].clone()
-            handler_latent_for_next_loop = new_full_latents[:, :, HANDLER_SLICE, :, :].clone()
+            eco_latent_for_next_loop = new_full_latents[:, :, ECO_CHUNK_INDICES, :, :].clone()
+            handler_latent_for_next_loop = new_full_latents[:, :, HANDLER_CHUNK_INDICES, :, :].clone()
             logger.info(f"  [GUIAS] Guias para a próxima iteração extraídas. Eco shape: {eco_latent_for_next_loop.shape}, Handler shape: {handler_latent_for_next_loop.shape}.")
 
-            latents_for_video = new_full_latents[:, :, VIDEO_SLICE, :, :]
+            latents_for_video = new_full_latents[:, :, :VIDEO_CHUNK_COUNT, :, :]
             logger.info(f"  [2. EDIÇÃO] Tensor final para vídeo extraído com {latents_for_video.shape[2]} chunks.")
 
             base_name = f"fragment_{i}_{int(time.time())}"