Update api/ltx_server.py

api/ltx_server.py

@@ -639,7 +639,17 @@ class VideoService:
         
         conditioning_items = []
         if mode == "image-to-video":
-            # ... (lógica de preparação de conditioning_items como antes)
+            start_tensor = self._prepare_conditioning_tensor(start_image_filepath, height, width, padding_values)
+            conditioning_items.append(ConditioningItem(start_tensor, 0, 1.0))
+            if middle_image_filepath and middle_frame_number is not None:
+                middle_tensor = self._prepare_conditioning_tensor(middle_image_filepath, height, width, padding_values)
+                safe_middle_frame = max(0, min(int(middle_frame_number), actual_num_frames - 1))
+                conditioning_items.append(ConditioningItem(middle_tensor, safe_middle_frame, float(middle_image_weight)))
+            if end_image_filepath:
+                end_tensor = self._prepare_conditioning_tensor(end_image_filepath, height, width, padding_values)
+                last_frame_index = actual_num_frames - 1
+                conditioning_items.append(ConditioningItem(end_tensor, last_frame_index, float(end_image_weight)))
+            print(f"[DEBUG] Conditioning items: {len(conditioning_items)}")
 
         call_kwargs = {
             "prompt": prompt, "negative_prompt": negative_prompt,
@@ -732,31 +742,67 @@ class VideoService:
             print("\n--- INICIANDO ETAPA FINAL: DECODIFICAÇÃO E MONTAGEM ---")
             
             latents_cpu = latents.detach().to("cpu", non_blocking=True)
-            del latents; gc.collect(); torch.cuda.empty_cache()
-
+            torch.cuda.empty_cache()
+            try:
+                torch.cuda.ipc_collect()
+            except Exception:
+                pass
+                
+            latents_parts = self._dividir_latentes_por_tamanho(latents_cpu,4,1)
+            
             temp_dir = tempfile.mkdtemp(prefix="ltxv_"); self._register_tmp_dir(temp_dir)
             results_dir = "/app/output"; os.makedirs(results_dir, exist_ok=True)
-            
-            # (A lógica de divisão de latentes e concatenação com fade que você já tem vai aqui)
-            latents_parts = self._dividir_latentes_por_tamanho(latents_cpu, 4, 1) # Exemplo de divisão
+
             partes_mp4 = []
-            for i, part_latents in enumerate(latents_parts):
-                output_part_path = os.path.join(temp_dir, f"part_{i}.mp4")
-                pixel_tensor = vae_manager_singleton.decode(part_latents.to(self.device), decode_timestep=0.05)
-                video_encode_tool_singleton.save_video_from_tensor(pixel_tensor, output_part_path, fps=FPS)
-                partes_mp4.append(output_part_path)
-
-            final_concat_path = os.path.join(results_dir, f"concat_fim_{used_seed}.mp4")
-            if len(partes_mp4) > 1:
-                 # Sua lógica de _gerar_lista_com_transicoes e _concat_mp4s_no_reencode
-                 # ...
-                 pass # Substitua pelo seu código
+            par = 0
+            
+            for latents in latents_parts:
+                print(f"[DEBUG] Partição {par}: {tuple(latents.shape)}")
+       
+                par = par + 1
+                output_video_path = os.path.join(temp_dir, f"output_{used_seed}_{par}.mp4")
+                final_output_path = None
+    
+                print("[DEBUG] Decodificando bloco de latentes com VAE → tensor de pixels...")
+                # Usar manager com timestep por item; previne target_shape e rota NoneType.decode
+                pixel_tensor = vae_manager_singleton.decode(
+                    latents.to(self.device, non_blocking=True),
+                    decode_timestep=float(self.config.get("decode_timestep", 0.05))
+                )
+                log_tensor_info(pixel_tensor, "Pixel tensor (VAE saída)")
+    
+                print("[DEBUG] Codificando MP4 a partir do tensor de pixels (bloco inteiro)...")
+                video_encode_tool_singleton.save_video_from_tensor(
+                    pixel_tensor,
+                    output_video_path,
+                    fps=call_kwargs["frame_rate"],
+                    progress_callback=progress_callback
+                )
+    
+                candidate = os.path.join(results_dir, f"output_par_{par}.mp4")
+                try:
+                    shutil.move(output_video_path, candidate)
+                    final_output_path = candidate
+                    print(f"[DEBUG] MP4 parte {par} movido para {final_output_path}")
+                    partes_mp4.append(final_output_path)
+                    
+                except Exception as e:
+                    final_output_path = output_video_path
+                    print(f"[DEBUG] Falha no move; usando tmp como final: {e}")
+
+            total_partes = len(partes_mp4)
+            if (total_partes>1):
+                final_vid = os.path.join(results_dir, f"concat_fim_{used_seed}.mp4")
+                partes_mp4_fade = self._gerar_lista_com_transicoes(pasta=results_dir, video_paths=partes_mp4, crossfade_frames=8)
+                self._concat_mp4s_no_reencode(partes_mp4_fade, final_vid)
             else:
-                 shutil.copy(partes_mp4[0], final_concat_path)
+                final_vid = partes_mp4[0]
+            
             
             self._log_gpu_memory("Fim da Geração")
-            return final_concat_path, used_seed
+            return final_vid, used_seed
             
+
         except Exception as e:
             print("[DEBUG] EXCEÇÃO NA GERAÇÃO:")
             print("".join(traceback.format_exception(type(e), e, e.__traceback__)))
@@ -788,4 +834,4 @@ class VideoService:
                 print(f"[DEBUG] finalize() no finally falhou: {e}")
 
 print("Criando instância do VideoService. O carregamento do modelo começará agora...")
-video_generation_service = VideoService(
+video_generation_service = VideoService()