Fixed SeedVR2＆VideoHelperSuite to generate a large size video clip.

def get_supported_compute_dtype(debug=None) -> torch.dtype:
    """
    Compute capability-based detection method
    """
    if torch.cuda.is_available():
        major, minor = torch.cuda.get_device_capability()
        if major < 8:  # Compute capability below 8.0
            return torch.float16
        return torch.bfloat16  # Compute capability 8.0 or higher
    return torch.float16

'compute_dtype': get_supported_compute_dtype(debug),  # Dynamically determined by function call

def _probe_bfloat16_support() -> bool:
    """
    Runtime probe method: Actually attempts computation to verify CUBLAS support
    """
    if not torch.cuda.is_available():
        return True
    try:
        a = torch.randn(8, 8, dtype=torch.bfloat16, device='cuda:0')
        _ = torch.matmul(a, a)  # Actually attempts computation
        del a
        return True
    except RuntimeError as e:
        if "CUBLAS_STATUS_NOT_SUPPORTED" in str(e):
            return False
        raise

BFLOAT16_SUPPORTED = _probe_bfloat16_support()  # Executed once at module import
COMPUTE_DTYPE = torch.bfloat16 if BFLOAT16_SUPPORTED else torch.float16  # Stored as constant

from ..optimization.compatibility import COMPUTE_DTYPE, BFLOAT16_SUPPORTED
# ...
'compute_dtype': COMPUTE_DTYPE,  # Uses constant

ctx['final_video'] = torch.empty((total_frames, true_h, true_w, C), 
                                 dtype=ctx['compute_dtype'],  # BFloat16
                                 device=target_device)

# Force float16 if compute type is bfloat16 to ensure NumPy compatibility in downstream nodes
# while maintaining memory efficiency (float32 would double memory usage)
storage_dtype = torch.float16 if ctx['compute_dtype'] == torch.bfloat16 else ctx['compute_dtype']
ctx['final_video'] = torch.empty((total_frames, true_h, true_w, C), dtype=storage_dtype, device=target_device)

sample = manage_tensor(
    tensor=sample,
    target_device=target_device,
    tensor_name=f"sample_{decode_idx+1}",
    dtype=ctx['compute_dtype'],  # Could be BFloat16
    debug=debug,
    reason="writing to final_video",
    indent_level=1
)
ctx['final_video'][write_start:write_end] = sample

# Move sample to target device and write directly to final_video
# Use final_video's dtype (storage_dtype) instead of compute_dtype to ensure consistency
# This prevents BFloat16 from being written to final_video when storage_dtype is Float16
target_dtype = ctx['final_video'].dtype
sample = manage_tensor(
    tensor=sample,
    target_device=target_device,
    tensor_name=f"sample_{decode_idx+1}",
    dtype=target_dtype,  # Match final_video's dtype (Float16)
    debug=debug,
    reason="writing to final_video",
    indent_level=1
)

sample = manage_tensor(
    tensor=sample,
    target_device=ctx['final_video'].device,
    tensor_name=f"sample_{info_idx+1}_final",
    dtype=ctx['compute_dtype'],  # Could be BFloat16
    debug=debug,
    reason="writing processed result to final_video",
    indent_level=1
)

# Use final_video's dtype (storage_dtype) instead of compute_dtype to ensure consistency
# This prevents BFloat16 from being written to final_video when storage_dtype is Float16
target_dtype = ctx['final_video'].dtype
sample = manage_tensor(
    tensor=sample,
    target_device=ctx['final_video'].device,
    tensor_name=f"sample_{info_idx+1}_final",
    dtype=target_dtype,  # Match final_video's dtype (Float16)
    debug=debug,
    reason="writing processed result to final_video",
    indent_level=1
)

# Ensure CPU tensor in float32 for maximum ComfyUI compatibility
if torch.is_tensor(sample):
    if sample.is_cuda or sample.is_mps:
        sample = sample.cpu()  # First move to CPU (still BFloat16)
    if sample.dtype != torch.float32:
        src_dtype = sample.dtype
        try:
            sample = sample.to(torch.float32)  # Then convert to Float32 (on CPU)
            debug.log(f"Converted output from {src_dtype} to float32", category="precision")
        except Exception as e:
            debug.log(f"Could not convert to float32: {e}. Output is {src_dtype}, compatibility with other nodes not guaranteed", 
                      level="WARNING", category="precision", force=True)

# Ensure CPU tensor in float32 for maximum ComfyUI compatibility
if torch.is_tensor(sample):
    # Convert to float32 on GPU first (more memory efficient) before moving to CPU
    if sample.dtype != torch.float32:
        src_dtype = sample.dtype
        try:
            sample = sample.to(torch.float32)  # First convert to Float32 (on GPU)
            debug.log(f"Converted output from {src_dtype} to float32", category="precision")
        except Exception as e:
            debug.log(f"Could not convert to float32: {e}. Output is {src_dtype}, compatibility with other nodes not guaranteed", 
                      level="WARNING", category="precision", force=True)
    # Move to CPU after conversion (avoids temporary 2x memory on CPU)
    if sample.is_cuda or sample.is_mps:
        sample = sample.cpu()  # Then move to CPU

def tensor_to_int(tensor, bits):
    tensor = tensor.cpu().numpy() * (2**bits-1) + 0.5  # Error if BFloat16
    return np.clip(tensor, 0, (2**bits-1))

def tensor_to_int(tensor, bits):
    # BFloat16 is not supported by NumPy, convert to float32 if needed
    # (SeedVR2 already converts to Float16, so this path should rarely be taken)
    if tensor.dtype == torch.bfloat16:
        tensor = tensor.float()  # Convert BFloat16 to Float32
    tensor = tensor.cpu().numpy() * (2**bits-1) + 0.5
    return np.clip(tensor, 0, (2**bits-1))