| import argparse |
| import logging |
| from pathlib import Path |
|
|
| import torch |
|
|
| from ltx_core.components.noisers import GaussianNoiser |
| from ltx_core.loader import LTXV_LORA_COMFY_RENAMING_MAP, LoraPathStrengthAndSDOps |
| from ltx_core.model.video_vae import TilingConfig, get_video_chunks_number |
| from ltx_core.quantization import QuantizationPolicy |
| from ltx_core.types import SpatioTemporalScaleFactors, VideoPixelShape |
| from ltx_pipelines.utils.args import resolve_path |
| from ltx_pipelines.utils.blocks import ( |
| DiffusionStage, |
| ImageConditioner, |
| PromptEncoder, |
| VideoDecoder, |
| VideoUpsampler, |
| benchmark_stage, |
| ) |
| from ltx_pipelines.utils.constants import STAGE_2_DISTILLED_SIGMAS |
| from ltx_pipelines.utils.denoisers import SimpleDenoiser |
| from ltx_pipelines.utils.helpers import get_device, video_latent_from_file |
| from ltx_pipelines.utils.media_io import encode_video, get_videostream_metadata |
| from ltx_pipelines.utils.types import ModalitySpec, OffloadMode |
|
|
|
|
| def _snap_frames_to_8k1(frames: int) -> int: |
| time_scale = SpatioTemporalScaleFactors.default().time |
| return ((frames - 1) // time_scale) * time_scale + 1 |
|
|
|
|
| def _align_down(value: int, divisor: int = 32) -> int: |
| aligned = value // divisor * divisor |
| if aligned <= 0: |
| raise ValueError(f"Cannot align non-positive dimension {value}") |
| return aligned |
|
|
|
|
| class VideoRefinerUpscalePipeline: |
| """Video-to-video x2 spatial upscaling followed by distilled-LoRA refinement.""" |
|
|
| def __init__( |
| self, |
| checkpoint_path: str, |
| distilled_lora: LoraPathStrengthAndSDOps, |
| spatial_upsampler_path: str, |
| gemma_root: str, |
| device: torch.device | None = None, |
| quantization: QuantizationPolicy | None = None, |
| torch_compile: bool = False, |
| offload_mode: OffloadMode = OffloadMode.NONE, |
| ) -> None: |
| self.device = device or get_device() |
| self.dtype = torch.bfloat16 |
| self.prompt_encoder = PromptEncoder( |
| checkpoint_path, gemma_root, self.dtype, self.device, offload_mode=offload_mode |
| ) |
| self.image_conditioner = ImageConditioner(checkpoint_path, self.dtype, self.device) |
| self.upsampler = VideoUpsampler(checkpoint_path, spatial_upsampler_path, self.dtype, self.device) |
| self.stage = DiffusionStage( |
| checkpoint_path, |
| self.dtype, |
| self.device, |
| loras=(distilled_lora,), |
| quantization=quantization, |
| torch_compile=torch_compile, |
| offload_mode=offload_mode, |
| ) |
| self.video_decoder = VideoDecoder(checkpoint_path, self.dtype, self.device) |
|
|
| @torch.inference_mode() |
| def __call__( |
| self, |
| input_video: str, |
| output_path: str, |
| prompt: str, |
| seed: int, |
| start_frame: int = 0, |
| max_frames: int | None = None, |
| max_batch_size: int = 1, |
| transformer: object | None = None, |
| ) -> tuple[VideoPixelShape, VideoPixelShape]: |
| source_shape = get_videostream_metadata(input_video) |
| if start_frame < 0: |
| raise ValueError(f"start_frame must be non-negative, got {start_frame}") |
| frames = max(source_shape.frames - start_frame, 0) |
| if max_frames is not None: |
| frames = min(frames, max_frames) |
| frames = _snap_frames_to_8k1(frames) |
| if frames < 1: |
| raise ValueError( |
| f"No usable frames after start_frame={start_frame} and snapping frame count from " |
| f"{source_shape.frames}" |
| ) |
|
|
| input_shape = VideoPixelShape( |
| batch=1, |
| frames=frames, |
| width=_align_down(source_shape.width), |
| height=_align_down(source_shape.height), |
| fps=source_shape.fps, |
| ) |
| output_shape = VideoPixelShape( |
| batch=1, |
| frames=frames, |
| width=input_shape.width * 2, |
| height=input_shape.height * 2, |
| fps=input_shape.fps, |
| ) |
|
|
| generator = torch.Generator(device=self.device).manual_seed(seed) |
| noiser = GaussianNoiser(generator=generator) |
| (ctx,) = self.prompt_encoder([prompt]) |
| video_context = ctx.video_encoding |
|
|
| initial_latent = self.image_conditioner( |
| lambda enc: video_latent_from_file( |
| video_encoder=enc, |
| file_path=input_video, |
| output_shape=input_shape, |
| dtype=self.dtype, |
| device=self.device, |
| start_time=start_frame / input_shape.fps, |
| max_duration=frames / input_shape.fps, |
| ) |
| ) |
| if initial_latent is None: |
| raise RuntimeError(f"Failed to encode input video: {input_video}") |
|
|
| upscaled_latent = self.upsampler(initial_latent) |
| sigmas = STAGE_2_DISTILLED_SIGMAS.to(dtype=torch.float32, device=self.device) |
|
|
| with benchmark_stage("video_refiner_x2"): |
| stage_kwargs = { |
| "denoiser": SimpleDenoiser(v_context=video_context, a_context=None), |
| "sigmas": sigmas, |
| "noiser": noiser, |
| "width": output_shape.width, |
| "height": output_shape.height, |
| "frames": output_shape.frames, |
| "fps": output_shape.fps, |
| "video": ModalitySpec( |
| context=video_context, |
| noise_scale=sigmas[0].item(), |
| initial_latent=upscaled_latent, |
| ), |
| "audio": None, |
| "max_batch_size": max_batch_size, |
| } |
| if transformer is None: |
| video_state, _ = self.stage(**stage_kwargs) |
| else: |
| video_state, _ = self.stage.run(transformer=transformer, **stage_kwargs) |
|
|
| if video_state is None: |
| raise RuntimeError("Refiner did not produce a video latent") |
|
|
| tiling_config = TilingConfig.default() |
| video_chunks_number = get_video_chunks_number(output_shape.frames, tiling_config) |
| video = self.video_decoder(video_state.latent, tiling_config, generator) |
| Path(output_path).parent.mkdir(parents=True, exist_ok=True) |
| encode_video( |
| video=video, |
| fps=round(output_shape.fps), |
| audio=None, |
| output_path=output_path, |
| video_chunks_number=video_chunks_number, |
| ) |
| return input_shape, output_shape |
|
|
|
|
| def _parse_quantization(name: str | None, checkpoint_path: str) -> QuantizationPolicy | None: |
| if name is None or name == "none": |
| return None |
| if name == "fp8-cast": |
| return QuantizationPolicy.fp8_cast() |
| if name == "fp8-scaled-mm": |
| return QuantizationPolicy.fp8_scaled_mm(checkpoint_path) |
| raise ValueError(f"Unsupported quantization policy: {name}") |
|
|
|
|
| def main() -> None: |
| logging.getLogger().setLevel(logging.INFO) |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--checkpoint-path", type=resolve_path, required=True) |
| parser.add_argument("--gemma-root", type=resolve_path, required=True) |
| parser.add_argument("--spatial-upsampler-path", type=resolve_path, required=True) |
| parser.add_argument("--distilled-lora-path", type=resolve_path, required=True) |
| parser.add_argument("--distilled-lora-strength", type=float, default=0.8) |
| parser.add_argument("--input-video", type=resolve_path, required=True) |
| parser.add_argument("--output-path", type=resolve_path, required=True) |
| parser.add_argument("--prompt", default="high quality video, sharp details") |
| parser.add_argument("--seed", type=int, default=10) |
| parser.add_argument("--start-frame", type=int, default=0) |
| parser.add_argument("--max-frames", type=int) |
| parser.add_argument("--max-batch-size", type=int, default=1) |
| parser.add_argument("--offload", dest="offload_mode", type=OffloadMode, default=OffloadMode.NONE) |
| parser.add_argument("--quantization", choices=("none", "fp8-cast", "fp8-scaled-mm"), default="none") |
| parser.add_argument("--compile", action="store_true") |
| args = parser.parse_args() |
|
|
| pipeline = VideoRefinerUpscalePipeline( |
| checkpoint_path=args.checkpoint_path, |
| distilled_lora=LoraPathStrengthAndSDOps( |
| path=args.distilled_lora_path, |
| strength=args.distilled_lora_strength, |
| sd_ops=LTXV_LORA_COMFY_RENAMING_MAP, |
| ), |
| spatial_upsampler_path=args.spatial_upsampler_path, |
| gemma_root=args.gemma_root, |
| quantization=_parse_quantization(args.quantization, args.checkpoint_path), |
| torch_compile=args.compile, |
| offload_mode=args.offload_mode, |
| ) |
| input_shape, output_shape = pipeline( |
| input_video=args.input_video, |
| output_path=args.output_path, |
| prompt=args.prompt, |
| seed=args.seed, |
| start_frame=args.start_frame, |
| max_frames=args.max_frames, |
| max_batch_size=args.max_batch_size, |
| ) |
| print( |
| f"Refined frame {args.start_frame}: {input_shape.width}x{input_shape.height}/{input_shape.frames}f " |
| f"-> {output_shape.width}x{output_shape.height}/{output_shape.frames}f" |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
