Update api/ltx_server.py

api/ltx_server.py

@@ -398,53 +398,45 @@ class VideoService:
         return out
 
 
-    def _dividir_latentes_por_tamanho(self, latents_brutos, num_latente_por_chunk: int, overlap: int = 1):
-        """
-        Divide o tensor de latentes em chunks com tamanho definido em número de latentes.
-        
-        Args:
-            latents_brutos: tensor [B, C, T, H, W]
-            num_latente_por_chunk: número de latentes por chunk
-            overlap: número de frames que se sobrepõem entre chunks
-        
-        Returns:
-            List[tensor]: lista de chunks cloneados
-        """
-        sum_latent = latents_brutos.shape[2]
-        chunks = []
+    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
     
-        if num_latente_por_chunk >= sum_latent:
-            return [latents_brutos]
+        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]
     
-        n_chunks = (sum_latent) // num_latente_por_chunk 
-        steps = sum_latent//n_chunks
-        print("================PODA CAUSAL=================")
-        print(f"[DEBUG] TOTAL LATENTES = {sum_latent}")
-        print(f"[DEBUG] Num LATENTES por chunk = {num_latente_por_chunk}")
-        print(f"[DEBUG] Número de chunks = {n_chunks}")
-
-
-        
-        if n_chunks > 1:
-            start = 0 
-            i = 0
-            end=1
-            while i < n_chunks:
-                start += end
-                end = start+num_latente_por_chunk
-                if end+3>=sum_latent-1:
-                    end = (sum_latent-1)
-                    i = n_chunks
-                else:
-                    i += 1
-                chunk = latents_brutos[:, :, start-1:end, :, :].clone().detach()
-                chunks.append(chunk)
-                print(f"[DEBUG] chunk{i}[:, :, {start-1}:{end}, :, :] = {chunk.shape[2]}")
-        else:
-            print(f"[DEBUG] numero chunks minimo")
-            print(f"[DEBUG] latents_brutos[:, :, :, :, :] = {latents_brutos.shape[2]}")
-            chunks.append(latents_brutos)
-        print("================PODA CAUSAL=================")
+        starts = []
+        s = 0
+        while s + L <= T:
+            starts.append(s)
+            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)
+    
+        chunks = []
+        for i, st in enumerate(uniq):
+            sp = st + L
+            chunk = latents[:, :, st:sp, :, :].clone().detach()
+            print(f"[DEBUG] chunk{i}: [:, :, {st}:{sp}, :, :]  len={sp-st}")  # debug
+            chunks.append(chunk)
+    
+        print("=========================================")  # debug
         return chunks
 
     def _get_total_frames(self, video_path: str) -> int: