Update api/ltx_server.py

api/ltx_server.py

@@ -398,47 +398,56 @@ class VideoService:
         return out
 
 
-    def _dividir_latentes(self, latents, num_por_chunk: int, overlap: int = 1):
+    
+    def dividir_latentes(latents, num_por_chunk: int, overlap: int = 1):
         # latents: [B, C, T, H, W]
         T = latents.shape[2]
-        L = num_por_chunk + overlap          # janela com stop exclusivo
-        stride = num_por_chunk - overlap     # avanço
-        print("================= DEBUG =================")  # debug
-        print(f"[DEBUG] T={T}  L={L}  stride={stride}")  # debug
-        print(f"[DEBUG] regra: slice [start:stop) com stop exclusivo")  # debug
+        L = num_por_chunk + overlap
+        stride = num_por_chunk - overlap
     
-        if T <= L:
-            start = max(0, T - L)
-            stop = start + L
-            chunk = latents[:, :, start:stop, :, :].clone().detach()
-            print(f"[DEBUG] único chunk: [:, :, {start}:{stop}, :, :]  len={stop-start}")  # debug
-            print("=========================================")  # debug
-            return [chunk]
+        print("================= DEBUG =================")
+        print(f"[DEBUG] T={T}  L={L}  stride={stride}")
+        print(f"[DEBUG] regra: slice [start:stop) com stop exclusivo")
     
+        chunks = []
         starts = []
         s = 0
-        while s + L <= T:
-            starts.append(s)
+        # gera janelas “naturais” com possível encurtamento quando passam de T
+        while s < T:
+            start = s
+            stop = s + L
+            if stop > T:
+                # encurta janela intermediária em vez de descartar
+                stop = T
+            # evita janela vazia
+            if start < stop:
+                starts.append((start, stop))
+            # próximo início com sobreposição de 1
             s += stride
-        if starts[-1] + L < T:
-            starts.append(T - L)
     
-        # remove duplicata contígua
-        uniq = []
-        for st in starts:
-            if not uniq or uniq[-1] != st:
-                uniq.append(st)
+            # condição de pare sem loop infinito
+            if s >= T:
+                break
     
-        chunks = []
-        for i, st in enumerate(uniq):
-            sp = st + L
+        # ancora uma janela final completa no fim [T-L:T), se necessário
+        final_start = max(0, T - L)
+        final_pair = (final_start, final_start + L)
+        if not starts or starts[-1] != final_pair:
+            # evita duplicar se já coincidiu
+            if not starts or starts[-1] != final_pair:
+                starts.append(final_pair)
+    
+        # imprime e retorna
+        out = []
+        for i, (st, sp) in enumerate(starts):
             chunk = latents[:, :, st:sp, :, :].clone().detach()
-            print(f"[DEBUG] chunk{i}: [:, :, {st}:{sp}, :, :]  len={sp-st}")  # debug
-            chunks.append(chunk)
+            print(f"[DEBUG] chunk{i}: [:, :, {st}:{sp if sp<=T else ''}, :, :]  len={sp-st}")
+            out.append(chunk)
     
-        print("=========================================")  # debug
-        return chunks
+        print("=========================================")
+        return out
 
+        
     def _get_total_frames(self, video_path: str) -> int:
         cmd = [
             "ffprobe",