Full UI rewrite: fancy alexnasa-style components, audio input, interpolation, social links

- Rewrite app.py with custom UI components (RadioAnimated, PromptBox, CameraDropdown, AudioDropUpload)
- Port ~700 lines of dark theme CSS from alexnasa/ltx-2-TURBO
- Add Image-to-Video and Interpolate modes with first/last frame support
- Add audio input support with waveform conditioning (neutral audio context pattern)
- Add duration presets (2s/3s/5s) and resolution presets (16:9/1:1/9:16) with SVG icons
- Modify distilled.py: add AudioConditionByLatent, _build_audio_conditionings_from_waveform, _create_conditionings
- Modify helpers.py: denoise_audio_video now accepts audio_conditionings parameter
- Add ZeroCollabs/ZeroHackz follow buttons in header and footer

app.py

@@ -3,6 +3,13 @@ LTX-2.3 Turbo — ZeroGPU Edition
 Generates synchronized audio-video content using Lightricks/LTX-2.3 on
 free ZeroGPU hardware via Hugging Face Spaces.
 
+UI inspired by alexnasa/ltx-2-TURBO with full feature parity for LTX-2.3:
+  - Image-to-Video mode (first frame conditioning)
+  - Interpolate mode (first + last frame)
+  - Audio input (user provides audio for lip-sync/soundtrack)
+  - Custom UI components (RadioAnimated, PromptBox, CameraDropdown, AudioDropUpload)
+  - Duration presets (2s, 3s, 5s) and resolution selector with SVG icons
+
 Architecture (following alexnasa/ltx-2-TURBO's proven ZeroGPU pattern):
   1. Vendored ltx-core and ltx-pipelines added to sys.path before any imports.
   2. Model files downloaded at module startup (CPU, no GPU lease).
@@ -32,17 +39,23 @@ sys.path.insert(0, str(_here / "packages" / "ltx-core" / "src"))
 # ───────────────────────────────────────────────────────────────────────────
 # Standard library & third-party imports
 # ───────────────────────────────────────────────────────────────────────────
+import json
 import logging
 import os
 import random
+import subprocess
 import tempfile
 import time
 import traceback
+import uuid
+from typing import Any
 
 import gradio as gr
 import numpy as np
 import spaces
 import torch
+import torch.nn.functional as F
+import torchaudio
 from huggingface_hub import hf_hub_download, snapshot_download
 
 logging.basicConfig(level=logging.INFO)
@@ -67,12 +80,68 @@ GEMMA_REPO = "google/gemma-3-12b-it-qat-q4_0-unquantized"
 CKPT_DISTILLED = "ltx-2.3-22b-distilled.safetensors"
 CKPT_UPSCALER = "ltx-2.3-spatial-upscaler-x2-1.0.safetensors"
 
-RESOLUTION_PRESETS = {
-    "16:9 (768x512)": (768, 512),
-    "1:1 (512x512)": (512, 512),
-    "9:16 (512x768)": (512, 768),
+RESOLUTION_MAP = {
+    "16:9": (768, 512),
+    "1:1": (512, 512),
+    "9:16": (512, 768),
 }
 
+
+# ───────────────────────────────────────────────────────────────────────────
+# Audio helper functions (ported from alexnasa/ltx-2-TURBO)
+# ───────────────────────────────────────────────────────────────────────────
+def _coerce_audio_path(audio_path: Any) -> str:
+    """Handle Gradio's various audio path formats (tuple, dict, string)."""
+    if isinstance(audio_path, tuple) and len(audio_path) > 0:
+        audio_path = audio_path[0]
+    if isinstance(audio_path, dict):
+        audio_path = audio_path.get("name") or audio_path.get("path")
+    if not isinstance(audio_path, (str, bytes, os.PathLike)):
+        raise TypeError(
+            f"audio_path must be a path-like, got {type(audio_path)}: {audio_path}"
+        )
+    return os.fspath(audio_path)
+
+
+def match_audio_to_duration(
+    audio_path: str,
+    target_seconds: float,
+    target_sr: int = 48000,
+    to_mono: bool = True,
+    pad_mode: str = "silence",
+    device: str = "cuda",
+):
+    """
+    Load audio, resample, (optionally) mono, then trim/pad to exactly target_seconds.
+    Returns: (waveform tensor, sample_rate)
+    """
+    audio_path = _coerce_audio_path(audio_path)
+    wav, sr = torchaudio.load(audio_path)  # [C, T] float32 CPU
+
+    if sr != target_sr:
+        wav = torchaudio.functional.resample(wav, sr, target_sr)
+        sr = target_sr
+
+    if to_mono and wav.shape[0] > 1:
+        wav = wav.mean(dim=0, keepdim=True)
+
+    target_len = int(round(target_seconds * sr))
+    cur_len = wav.shape[-1]
+
+    if cur_len > target_len:
+        wav = wav[..., :target_len]
+    elif cur_len < target_len:
+        pad_len = target_len - cur_len
+        if pad_mode == "repeat" and cur_len > 0:
+            reps = (target_len + cur_len - 1) // cur_len
+            wav = wav.repeat(1, reps)[..., :target_len]
+        else:
+            wav = F.pad(wav, (0, pad_len))
+
+    wav = wav.to(device, non_blocking=True)
+    return wav, sr
+
+
 # ───────────────────────────────────────────────────────────────────────────
 # 1) Download model files at module startup (CPU, no GPU lease)
 # ───────────────────────────────────────────────────────────────────────────
@@ -91,7 +160,6 @@ logger.info("All model files ready on disk.")
 
 # ──────────────────────────���────────────────────────────────────────────────
 # 2) Construct ModelLedger (CPU — no model weights loaded to GPU)
-#    We construct a separate ledger WITH gemma_root for text encoding.
 # ───────────────────────────────────────────────────────────────────────────
 logger.info("Constructing ModelLedger (with Gemma for text encoding)...")
 
@@ -118,7 +186,6 @@ logger.info("Text encoder loaded and ready!")
 
 # ───────────────────────────────────────────────────────────────────────────
 # 4) Construct DistilledPipeline WITHOUT text encoder (gemma_root=None)
-#    Text encoding is handled externally via encode_prompt().
 # ───────────────────────────────────────────────────────────────────────────
 logger.info("Constructing DistilledPipeline (gemma_root=None)...")
 
@@ -154,25 +221,56 @@ def calc_frames(duration: float, fps: float) -> int:
     return k * 8 + 1
 
 
+def encode_text_simple(te, prompt: str):
+    """Simple text encoding without using pipeline_utils."""
+    hidden_states, attention_mask = te.encode(prompt)
+    embeddings_processor = model_ledger.gemma_embeddings_processor()
+    result = embeddings_processor.process_hidden_states(hidden_states, attention_mask)
+    del embeddings_processor
+    return result.video_encoding, result.audio_encoding
+
+
+def apply_resolution(resolution: str):
+    w, h = RESOLUTION_MAP.get(resolution, (768, 512))
+    return int(w), int(h)
+
+
+def apply_duration(duration_str: str):
+    return int(duration_str[:-1])
+
+
+def on_mode_change(selected: str):
+    is_interpolate = selected == "Interpolate"
+    return gr.update(visible=is_interpolate)
+
+
 def get_duration(
     first_frame,
+    end_frame,
     prompt,
     duration,
+    generation_mode,
     enhance_prompt,
     seed,
     randomize_seed,
-    resolution,
+    height,
+    width,
+    audio_path,
     *args,
     **kwargs,
 ):
     """Estimate GPU lease duration for @spaces.GPU(duration=...)."""
+    extra_time = 0
+    if audio_path is not None:
+        extra_time += 10
+
     dur = float(duration)
     if dur <= 2:
-        return 120
-    elif dur <= 4:
-        return 180
+        return 120 + extra_time
+    elif dur <= 3:
+        return 150 + extra_time
     else:
-        return 240
+        return 200 + extra_time
 
 
 # ───────────────────────────────────────────────────────────────────────────
@@ -202,18 +300,7 @@ def encode_prompt(
         logger.info(f"[encode_prompt] Enhanced prompt: '{final_prompt[:120]}...'")
 
     with torch.inference_mode():
-        # Step 1: Get raw hidden states from text encoder
-        hidden_states, attention_mask = text_encoder.encode(final_prompt)
-
-        # Step 2: Process through embeddings processor to get video/audio contexts
-        embeddings_processor = model_ledger.gemma_embeddings_processor()
-        result = embeddings_processor.process_hidden_states(
-            hidden_states, attention_mask
-        )
-        del embeddings_processor
-
-        video_context = result.video_encoding
-        audio_context = result.audio_encoding
+        video_context, audio_context = encode_text_simple(text_encoder, final_prompt)
 
     embedding_data = {
         "video_context": video_context.detach().cpu(),
@@ -231,47 +318,72 @@ def encode_prompt(
 @spaces.GPU(duration=get_duration)
 def generate_video(
     first_frame,
+    end_frame,
     prompt: str,
     duration: float,
-    enhance_prompt: bool,
-    seed: int,
-    randomize_seed: bool,
-    resolution: str,
+    generation_mode: str = "Image-to-Video",
+    enhance_prompt: bool = True,
+    seed: int = 42,
+    randomize_seed: bool = True,
+    height: int = 512,
+    width: int = 768,
+    audio_path=None,
     progress=gr.Progress(track_tqdm=True),
 ):
     """
-    Full generation: encode prompt (nested GPU call) then run pipeline with
-    pre-encoded contexts.
+    Full generation: encode prompt then run pipeline with pre-encoded contexts.
+    Supports Image-to-Video, Interpolate, and audio input modes.
     """
     if not prompt or not prompt.strip():
         raise gr.Error("Please enter a prompt.")
 
     current_seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
-    width, height = RESOLUTION_PRESETS.get(resolution, (768, 512))
     num_frames = calc_frames(duration, 24.0)
     frame_rate = 24.0
 
     logger.info(
-        f"[generate_video] seed={current_seed}, {width}x{height}, "
-        f"frames={num_frames}, duration={duration}s, enhance={enhance_prompt}"
+        f"[generate_video] mode={generation_mode}, seed={current_seed}, {width}x{height}, "
+        f"frames={num_frames}, duration={duration}s, enhance={enhance_prompt}, "
+        f"audio={'yes' if audio_path else 'no'}"
     )
 
-    # --- Handle input image ---
+    # --- Handle input images ---
     images = []
     image_path_for_enhance = None
+
     if first_frame is not None:
-        tmp_dir = tempfile.mkdtemp()
-        temp_image_path = os.path.join(tmp_dir, f"input_{int(time.time())}.png")
-        if hasattr(first_frame, "save"):
-            first_frame.save(temp_image_path)
+        # first_frame is filepath from gr.Image(type="filepath")
+        if isinstance(first_frame, str):
+            img_path = first_frame
+        else:
+            tmp_dir = tempfile.mkdtemp()
+            img_path = os.path.join(tmp_dir, f"input_{int(time.time())}.png")
+            if hasattr(first_frame, "save"):
+                first_frame.save(img_path)
+            else:
+                from PIL import Image as PILImage
+
+                PILImage.open(first_frame).save(img_path)
+
+        images.append((img_path, 0, 1.0))
+        image_path_for_enhance = img_path
+
+    # Interpolation: add end frame as guiding latent
+    if generation_mode == "Interpolate" and end_frame is not None:
+        if isinstance(end_frame, str):
+            end_path = end_frame
         else:
-            from PIL import Image as PILImage
+            tmp_dir = tempfile.mkdtemp()
+            end_path = os.path.join(tmp_dir, f"end_{int(time.time())}.png")
+            if hasattr(end_frame, "save"):
+                end_frame.save(end_path)
+            else:
+                from PIL import Image as PILImage
 
-            PILImage.open(first_frame).save(temp_image_path)
-        images = [
-            ImageConditioningInput(path=temp_image_path, frame_idx=0, strength=1.0)
-        ]
-        image_path_for_enhance = temp_image_path
+                PILImage.open(end_frame).save(end_path)
+
+        end_idx = max(0, num_frames - 1)
+        images.append((end_path, end_idx, 0.5))
 
     t0 = time.time()
     try:
@@ -288,6 +400,29 @@ def generate_video(
         del embeddings
         torch.cuda.empty_cache()
 
+        # If user provided audio, use a neutral audio_context (encode empty prompt)
+        if audio_path is not None:
+            with torch.inference_mode():
+                _, neutral_audio_context = encode_text_simple(text_encoder, "")
+            del audio_context
+            audio_context = neutral_audio_context
+
+        # Prepare audio waveform if provided
+        input_waveform = None
+        input_waveform_sample_rate = None
+        if audio_path is not None:
+            video_seconds = (num_frames - 1) / frame_rate
+            input_waveform, input_waveform_sample_rate = match_audio_to_duration(
+                audio_path=audio_path,
+                target_seconds=video_seconds,
+                target_sr=48000,
+                to_mono=True,
+                pad_mode="silence",
+                device="cuda",
+            )
+
+        torch.cuda.empty_cache()
+
         # Phase 2: Run pipeline with pre-encoded contexts
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmpfile:
             output_path = tmpfile.name
@@ -305,9 +440,13 @@ def generate_video(
                 tiling_config=TilingConfig.default(),
                 video_context=video_context,
                 audio_context=audio_context,
+                input_waveform=input_waveform,
+                input_waveform_sample_rate=input_waveform_sample_rate,
             )
 
         del video_context, audio_context
+        if input_waveform is not None:
+            del input_waveform
         torch.cuda.empty_cache()
 
         elapsed = time.time() - t0
@@ -323,164 +462,1116 @@ def generate_video(
         logger.error(f"Generation failed after {elapsed:.1f}s:\n{tb}")
         raise gr.Error(f"Generation failed: {type(e).__name__}: {e}")
 
-    info_text = (
-        f"Seed: {current_seed}\n"
-        f"Resolution: {width}x{height} (upscaled from {width // 2}x{height // 2})\n"
-        f"Frames: {num_frames} @ {int(frame_rate)} fps\n"
-        f"Duration: {duration}s\n"
-        f"Pipeline: Distilled 2-stage (8+4 steps, FP8 quantized)\n"
-        f"Total time: {elapsed:.1f}s\n"
-        f"Hardware: ZeroGPU"
-    )
-
-    return output_path, info_text, current_seed
+    return str(output_path)
 
 
 # ───────────────────────────────────────────────────────────────────────────
-# UI toggle
+# Custom UI Components (ported from alexnasa/ltx-2-TURBO)
 # ───────────────────────────────────────────────────────────────────────────
-def toggle_image(mode: str):
-    return gr.update(visible=(mode == "Image to Video"))
 
 
-def on_mode_change(mode: str):
-    """Update image visibility and first_frame value based on mode."""
-    if mode == "Image to Video":
-        return gr.update(visible=True)
-    return gr.update(visible=False, value=None)
+class RadioAnimated(gr.HTML):
+    """Animated segmented radio (like iOS pill selector)."""
+
+    def __init__(self, choices, value=None, **kwargs):
+        if not choices or len(choices) < 2:
+            raise ValueError("RadioAnimated requires at least 2 choices.")
+        if value is None:
+            value = choices[0]
+
+        uid = uuid.uuid4().hex[:8]
+        group_name = f"ra-{uid}"
+
+        inputs_html = "\n".join(
+            f'<input class="ra-input" type="radio" name="{group_name}" '
+            f'id="{group_name}-{i}" value="{c}">'
+            f'<label class="ra-label" for="{group_name}-{i}">{c}</label>'
+            for i, c in enumerate(choices)
+        )
+
+        html_template = f"""
+        <div class="ra-wrap" data-ra="{uid}">
+          <div class="ra-inner">
+            <div class="ra-highlight"></div>
+            {inputs_html}
+          </div>
+        </div>
+        """
+
+        js_on_load = r"""
+        (() => {
+            const wrap = element.querySelector('.ra-wrap');
+            const inner = element.querySelector('.ra-inner');
+            const highlight = element.querySelector('.ra-highlight');
+            const inputs = Array.from(element.querySelectorAll('.ra-input'));
+            const labels = Array.from(element.querySelectorAll('.ra-label'));
+            if (!inputs.length || !labels.length) return;
+            const choices = inputs.map(i => i.value);
+            const PAD = 6;
+            let currentIdx = 0;
+            function setHighlightByIndex(idx) {
+                currentIdx = idx;
+                const lbl = labels[idx];
+                if (!lbl) return;
+                const innerRect = inner.getBoundingClientRect();
+                const lblRect = lbl.getBoundingClientRect();
+                highlight.style.width = `${lblRect.width}px`;
+                const x = (lblRect.left - innerRect.left - PAD);
+                highlight.style.transform = `translateX(${x}px)`;
+            }
+            function setCheckedByValue(val, shouldTrigger=false) {
+                const idx = Math.max(0, choices.indexOf(val));
+                inputs.forEach((inp, i) => { inp.checked = (i === idx); });
+                requestAnimationFrame(() => setHighlightByIndex(idx));
+                props.value = choices[idx];
+                if (shouldTrigger) trigger('change', props.value);
+            }
+            setCheckedByValue(props.value ?? choices[0], false);
+            inputs.forEach((inp) => {
+                inp.addEventListener('change', () => setCheckedByValue(inp.value, true));
+            });
+            window.addEventListener('resize', () => setHighlightByIndex(currentIdx));
+            let last = props.value;
+            const syncFromProps = () => {
+              if (props.value !== last) {
+                last = props.value;
+                setCheckedByValue(last, false);
+              }
+              requestAnimationFrame(syncFromProps);
+            };
+            requestAnimationFrame(syncFromProps);
+        })();
+        """
+
+        super().__init__(
+            value=value,
+            html_template=html_template,
+            js_on_load=js_on_load,
+            **kwargs,
+        )
+
+
+class PromptBox(gr.HTML):
+    """Prompt textarea with an internal footer slot for embedding dropdowns."""
+
+    def __init__(self, value="", placeholder="Describe what you want...", **kwargs):
+        uid = uuid.uuid4().hex[:8]
+
+        html_template = f"""
+        <div class="ds-card" data-ds="{uid}">
+          <div class="ds-top">
+            <textarea class="ds-textarea" rows="3" placeholder="{placeholder}"></textarea>
+            <div class="ds-footer" aria-label="prompt-footer"></div>
+          </div>
+        </div>
+        """
+
+        js_on_load = r"""
+        (() => {
+          const textarea = element.querySelector(".ds-textarea");
+          if (!textarea) return;
+          const autosize = () => {
+            textarea.style.height = "0px";
+            textarea.style.height = Math.min(textarea.scrollHeight, 240) + "px";
+          };
+          const setValue = (v, triggerChange=false) => {
+            const val = (v ?? "");
+            if (textarea.value !== val) textarea.value = val;
+            autosize();
+            props.value = textarea.value;
+            if (triggerChange) trigger("change", props.value);
+          };
+          setValue(props.value, false);
+          textarea.addEventListener("input", () => {
+            autosize();
+            props.value = textarea.value;
+            trigger("change", props.value);
+          });
+          const shouldAutoFocus = () => {
+            const ae = document.activeElement;
+            if (ae && ae !== document.body && ae !== document.documentElement) return false;
+            if (window.matchMedia && window.matchMedia("(max-width: 768px)").matches) return false;
+            return true;
+          };
+          const focusWithRetry = (tries = 30) => {
+            if (!shouldAutoFocus()) return;
+            if (document.activeElement !== textarea) textarea.focus({ preventScroll: true });
+            if (document.activeElement === textarea) return;
+            if (tries > 0) requestAnimationFrame(() => focusWithRetry(tries - 1));
+          };
+          requestAnimationFrame(() => focusWithRetry());
+          let last = props.value;
+          const syncFromProps = () => {
+            if (props.value !== last) {
+              last = props.value;
+              setValue(last, false);
+            }
+            requestAnimationFrame(syncFromProps);
+          };
+          requestAnimationFrame(syncFromProps);
+        })();
+        """
+
+        super().__init__(
+            value=value,
+            html_template=html_template,
+            js_on_load=js_on_load,
+            **kwargs,
+        )
+
+
+class CameraDropdown(gr.HTML):
+    """Custom dropdown with optional icons per item."""
+
+    def __init__(self, choices, value="None", title="Dropdown", **kwargs):
+        if not choices:
+            raise ValueError("CameraDropdown requires choices.")
+
+        norm = []
+        for c in choices:
+            if isinstance(c, dict):
+                label = str(c.get("label", c.get("value", "")))
+                val = str(c.get("value", label))
+                icon = c.get("icon", None)
+                norm.append({"label": label, "value": val, "icon": icon})
+            else:
+                s = str(c)
+                norm.append({"label": s, "value": s, "icon": None})
+
+        uid = uuid.uuid4().hex[:8]
+
+        def render_item(item):
+            icon_html = ""
+            if item["icon"]:
+                icon_html = f'<span class="cd-icn">{item["icon"]}</span>'
+            return (
+                f'<button type="button" class="cd-item" '
+                f'data-value="{item["value"]}">'
+                f'{icon_html}<span class="cd-label">{item["label"]}</span>'
+                f"</button>"
+            )
+
+        items_html = "\n".join(render_item(item) for item in norm)
+
+        html_template = f"""
+        <div class="cd-wrap" data-cd="{uid}">
+            <button type="button" class="cd-trigger" aria-haspopup="menu" aria-expanded="false">
+              <span class="cd-trigger-icon"></span>
+              <span class="cd-trigger-text"></span>
+              <span class="cd-caret">&#x25BE;</span>
+            </button>
+          <div class="cd-menu" role="menu" aria-hidden="true">
+            <div class="cd-title">{title}</div>
+            <div class="cd-items">
+              {items_html}
+            </div>
+          </div>
+        </div>
+        """
+
+        value_to_label = {it["value"]: it["label"] for it in norm}
+        value_to_icon = {it["value"]: (it["icon"] or "") for it in norm}
+
+        js_on_load = r"""
+        (() => {
+          const wrap = element.querySelector(".cd-wrap");
+          const trigger = element.querySelector(".cd-trigger");
+          const triggerIcon = element.querySelector(".cd-trigger-icon");
+          const triggerText = element.querySelector(".cd-trigger-text");
+          const menu = element.querySelector(".cd-menu");
+          const items = Array.from(element.querySelectorAll(".cd-item"));
+          if (!wrap || !trigger || !menu || !items.length) return;
+          const valueToLabel = __VALUE_TO_LABEL__;
+          const valueToIcon  = __VALUE_TO_ICON__;
+          const safeLabel = (v) => (valueToLabel && valueToLabel[v]) ? valueToLabel[v] : (v ?? "None");
+          const safeIcon  = (v) => (valueToIcon  && valueToIcon[v])  ? valueToIcon[v]  : "";
+          function closeMenu() {
+            menu.classList.remove("open");
+            trigger.setAttribute("aria-expanded", "false");
+            menu.setAttribute("aria-hidden", "true");
+          }
+          function openMenu() {
+            menu.classList.add("open");
+            trigger.setAttribute("aria-expanded", "true");
+            menu.setAttribute("aria-hidden", "false");
+          }
+          function setValue(val, shouldTrigger = false) {
+            const v = (val ?? "None");
+            props.value = v;
+            triggerText.textContent = safeLabel(v);
+            if (triggerIcon) {
+              triggerIcon.innerHTML = safeIcon(v);
+              triggerIcon.style.display = safeIcon(v) ? "inline-flex" : "none";
+            }
+            items.forEach(btn => {
+              btn.dataset.selected = (btn.dataset.value === v) ? "true" : "false";
+            });
+            if (shouldTrigger) trigger("change", props.value);
+          }
+          trigger.addEventListener("pointerdown", (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            if (menu.classList.contains("open")) closeMenu();
+            else openMenu();
+          });
+          document.addEventListener("pointerdown", (e) => {
+            if (!wrap.contains(e.target)) closeMenu();
+          }, true);
+          document.addEventListener("keydown", (e) => {
+            if (e.key === "Escape") closeMenu();
+          });
+          wrap.addEventListener("focusout", (e) => {
+            if (!wrap.contains(e.relatedTarget)) closeMenu();
+          });
+          items.forEach((btn) => {
+            btn.addEventListener("pointerdown", (e) => {
+              e.preventDefault();
+              e.stopPropagation();
+              closeMenu();
+              setValue(btn.dataset.value, true);
+            });
+          });
+          setValue((props.value ?? "None"), false);
+          let last = props.value;
+          const syncFromProps = () => {
+            if (props.value !== last) {
+              last = props.value;
+              setValue(last, false);
+            }
+            requestAnimationFrame(syncFromProps);
+          };
+          requestAnimationFrame(syncFromProps);
+        })();
+        """
+
+        js_on_load = js_on_load.replace(
+            "__VALUE_TO_LABEL__", json.dumps(value_to_label)
+        )
+        js_on_load = js_on_load.replace("__VALUE_TO_ICON__", json.dumps(value_to_icon))
+
+        super().__init__(
+            value=value,
+            html_template=html_template,
+            js_on_load=js_on_load,
+            **kwargs,
+        )
+
+
+class AudioDropUpload(gr.HTML):
+    """Custom audio drop/click UI that proxies file into a hidden gr.File component."""
+
+    def __init__(self, target_audio_elem_id: str, value=None, **kwargs):
+        uid = uuid.uuid4().hex[:8]
+
+        html_template = f"""
+        <div class="aud-wrap" data-aud="{uid}">
+          <div class="aud-drop" role="button" tabindex="0" aria-label="Upload audio">
+            <div><strong>(Optional) Drag &amp; drop an audio file here</strong></div>
+            <div class="aud-hint">...or click to browse</div>
+          </div>
+          <div class="aud-row" aria-live="polite">
+            <audio class="aud-player" controls></audio>
+            <button class="aud-remove" type="button" aria-label="Remove audio">
+              <svg width="16" height="16" viewBox="0 0 24 24" aria-hidden="true" focusable="false">
+                <path d="M18 6L6 18M6 6l12 12"
+                      stroke="currentColor" stroke-width="2.25" stroke-linecap="round"/>
+              </svg>
+            </button>
+          </div>
+          <div class="aud-filelabel"></div>
+        </div>
+        """
+
+        js_on_load = """
+        (() => {{
+          function grRoot() {{
+            const ga = document.querySelector("gradio-app");
+            return (ga && ga.shadowRoot) ? ga.shadowRoot : document;
+          }}
+          const root = grRoot();
+          const wrap = element.querySelector(".aud-wrap");
+          const drop = element.querySelector(".aud-drop");
+          const row  = element.querySelector(".aud-row");
+          const player = element.querySelector(".aud-player");
+          const removeBtn = element.querySelector(".aud-remove");
+          const label = element.querySelector(".aud-filelabel");
+          const TARGET_ID = "__TARGET_ID__";
+          let currentUrl = null;
+          function findHiddenAudioFileInput() {{
+            const host = root.querySelector("#" + CSS.escape(TARGET_ID));
+            if (!host) return null;
+            const inp = host.querySelector('input[type="file"]');
+            return inp;
+          }}
+          function showDrop() {{
+            drop.style.display = "";
+            row.style.display = "none";
+            label.style.display = "none";
+            label.textContent = "";
+          }}
+          function showPlayer(filename) {{
+            drop.style.display = "none";
+            row.style.display = "flex";
+            if (filename) {{
+              label.textContent = "Loaded: " + filename;
+              label.style.display = "block";
+            }}
+          }}
+          function clearPreview() {{
+            player.pause();
+            player.removeAttribute("src");
+            player.load();
+            if (currentUrl) {{
+              URL.revokeObjectURL(currentUrl);
+              currentUrl = null;
+            }}
+          }}
+          function clearHiddenGradioAudio() {{
+            const fileInput = findHiddenAudioFileInput();
+            if (!fileInput) return;
+            fileInput.value = "";
+            const dt = new DataTransfer();
+            fileInput.files = dt.files;
+            fileInput.dispatchEvent(new Event("input",  {{ bubbles: true }}));
+            fileInput.dispatchEvent(new Event("change", {{ bubbles: true }}));
+          }}
+          function clearAll() {{
+            clearPreview();
+            clearHiddenGradioAudio();
+            props.value = "__CLEAR__";
+            trigger("change", props.value);
+            showDrop();
+          }}
+          function loadFileToPreview(file) {{
+            if (!file) return;
+            if (!file.type || !file.type.startsWith("audio/")) {{
+              alert("Please choose an audio file.");
+              return;
+            }}
+            clearPreview();
+            currentUrl = URL.createObjectURL(file);
+            player.src = currentUrl;
+            showPlayer(file.name);
+          }}
+          function pushFileIntoHiddenGradioAudio(file) {{
+            const fileInput = findHiddenAudioFileInput();
+            if (!fileInput) {{
+              console.warn("Could not find hidden gr.File input. Check elem_id:", TARGET_ID);
+              return;
+            }}
+            fileInput.value = "";
+            const dt = new DataTransfer();
+            dt.items.add(file);
+            fileInput.files = dt.files;
+            fileInput.dispatchEvent(new Event("input",  {{ bubbles: true }}));
+            fileInput.dispatchEvent(new Event("change", {{ bubbles: true }}));
+          }}
+          function handleFile(file) {{
+            loadFileToPreview(file);
+            pushFileIntoHiddenGradioAudio(file);
+          }}
+          const localPicker = document.createElement("input");
+          localPicker.type = "file";
+          localPicker.accept = "audio/*";
+          localPicker.style.display = "none";
+          wrap.appendChild(localPicker);
+          localPicker.addEventListener("change", () => {{
+            const f = localPicker.files && localPicker.files[0];
+            if (f) handleFile(f);
+            localPicker.value = "";
+          }});
+          drop.addEventListener("click", () => localPicker.click());
+          drop.addEventListener("keydown", (e) => {{
+            if (e.key === "Enter" || e.key === " ") {{
+              e.preventDefault();
+              localPicker.click();
+            }}
+          }});
+          removeBtn.addEventListener("click", clearAll);
+          ["dragenter","dragover","dragleave","drop"].forEach(evt => {{
+            drop.addEventListener(evt, (e) => {{
+              e.preventDefault();
+              e.stopPropagation();
+            }});
+          }});
+          drop.addEventListener("dragover", () => drop.classList.add("dragover"));
+          drop.addEventListener("dragleave", () => drop.classList.remove("dragover"));
+          drop.addEventListener("drop", (e) => {{
+            drop.classList.remove("dragover");
+            const f = e.dataTransfer.files && e.dataTransfer.files[0];
+            if (f) handleFile(f);
+          }});
+          showDrop();
+          function setPreviewFromPath(path) {{
+            if (path === "__CLEAR__") path = null;
+            if (!path) {{
+              clearPreview();
+              showDrop();
+              return;
+            }}
+            let url = path;
+            if (!/^https?:\\/\\//.test(path) && !path.startsWith("gradio_api/file=") && !path.startsWith("/file=")) {{
+              url = "gradio_api/file=" + path;
+            }}
+            clearPreview();
+            player.src = url;
+            showPlayer(path.split("/").pop());
+          }}
+          let last = props.value;
+          const syncFromProps = () => {{
+            const v = props.value;
+            if (v !== last) {{
+              last = v;
+              if (!v || v === "__CLEAR__") setPreviewFromPath(null);
+              else setPreviewFromPath(String(v));
+            }}
+            requestAnimationFrame(syncFromProps);
+          }};
+          requestAnimationFrame(syncFromProps);
+        }})();
+        """
+        js_on_load = js_on_load.replace("__TARGET_ID__", target_audio_elem_id)
+
+        super().__init__(
+            value=value,
+            html_template=html_template,
+            js_on_load=js_on_load,
+            **kwargs,
+        )
 
 
 # ───────────────────────────────────────────────────────────────────────────
-# Gradio UI
+# CSS (dark theme, ported from alexnasa/ltx-2-TURBO)
 # ───────────────────────────────────────────────────────────────────────────
 CSS = """
-.gradio-container { max-width: 1200px !important; }
-.header { text-align: center; margin-bottom: 1rem; }
-.generate-btn { min-height: 50px; }
+/* ---- layout ---- */
+#controls-row {
+  display: none !important;
+  align-items: center;
+  gap: 12px;
+  flex-wrap: nowrap;
+}
+#controls-row > * {
+  flex: 0 0 auto !important;
+  width: auto !important;
+  min-width: 0 !important;
+}
+#col-container {
+  margin: 0 auto;
+  max-width: 1600px;
+}
+#step-column {
+  padding: 10px;
+  border-radius: 8px;
+  box-shadow: var(--card-shadow);
+  margin: 10px;
+}
+
+/* ---- generate button ---- */
+.button-gradient {
+  background: linear-gradient(45deg, rgb(255, 65, 108), rgb(255, 75, 43), rgb(255, 155, 0), rgb(255, 65, 108)) 0% 0% / 400% 400%;
+  border: none;
+  padding: 14px 28px;
+  font-size: 16px;
+  font-weight: bold;
+  color: white;
+  border-radius: 10px;
+  cursor: pointer;
+  transition: 0.3s ease-in-out;
+  animation: 2s linear 0s infinite normal none running gradientAnimation;
+  box-shadow: rgba(255, 65, 108, 0.6) 0px 4px 10px;
+}
+@keyframes gradientAnimation {
+  0% { background-position: 0% 50%; }
+  50% { background-position: 100% 50%; }
+  100% { background-position: 0% 50%; }
+}
+
+/* ---- mode row ---- */
+#mode-row {
+  display: flex !important;
+  justify-content: center !important;
+  align-items: center !important;
+  width: 100% !important;
+}
+#mode-row > * {
+  flex: 0 0 auto !important;
+  width: auto !important;
+  min-width: 0 !important;
+}
+#mode-row .gr-html,
+#mode-row .gradio-html,
+#mode-row .prose,
+#mode-row .block {
+  width: auto !important;
+  flex: 0 0 auto !important;
+  display: inline-block !important;
+}
+#radioanimated_mode {
+  display: inline-flex !important;
+  justify-content: center !important;
+  width: auto !important;
+}
+
+/* ---- radioanimated ---- */
+.ra-wrap { width: fit-content; }
+.ra-inner {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+  gap: 0;
+  padding: 6px;
+  background: #0b0b0b;
+  border-radius: 9999px;
+  overflow: hidden;
+  user-select: none;
+}
+.ra-input { display: none; }
+.ra-label {
+  position: relative;
+  z-index: 2;
+  padding: 10px 18px;
+  font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Arial;
+  font-size: 14px;
+  font-weight: 600;
+  color: rgba(255,255,255,0.7);
+  cursor: pointer;
+  transition: color 180ms ease;
+  white-space: nowrap;
+}
+.ra-highlight {
+  position: absolute;
+  z-index: 1;
+  top: 6px;
+  left: 6px;
+  height: calc(100% - 12px);
+  border-radius: 9999px;
+  background: #8bff97;
+  transition: transform 200ms ease, width 200ms ease;
+}
+.ra-input:checked + .ra-label { color: rgba(0,0,0,0.75); }
+
+/* ---- prompt box ---- */
+.ds-card {
+  width: 100%;
+  max-width: 720px;
+  margin: 0 auto;
+  position: relative;
+  z-index: 50;
+}
+.ds-top {
+  position: relative;
+  background: #2b2b2b;
+  border: 1px solid rgba(255,255,255,0.12);
+  border-radius: 14px;
+  overflow: visible !important;
+}
+.ds-textarea {
+  width: 100%;
+  box-sizing: border-box;
+  background: transparent !important;
+  border: none !important;
+  border-radius: 0 !important;
+  color: rgba(255,255,255,0.9);
+  padding: 14px 16px;
+  padding-bottom: 72px;
+  outline: none;
+  font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Arial;
+  font-size: 15px;
+  line-height: 1.35;
+  resize: none;
+  min-height: 210px;
+  max-height: 210px;
+  overflow-y: auto;
+  scrollbar-width: none;
+  position: relative;
+  z-index: 1;
+}
+.ds-textarea::-webkit-scrollbar { width: 0; height: 0; }
+.ds-textarea:focus,
+.ds-textarea:focus-visible { outline: none !important; box-shadow: none !important; }
+.ds-textarea { outline: none !important; }
+.ds-top:focus-within {
+  border-color: rgba(255,255,255,0.22) !important;
+  box-shadow: 0 0 0 3px rgba(255,255,255,0.06) !important;
+  border-radius: 14px !important;
+}
+.ds-top { border-radius: 14px !important; }
+.ds-top::after {
+  content: "";
+  position: absolute;
+  left: 0; right: 0; bottom: 0;
+  height: 56px;
+  background: #2b2b2b;
+  border-bottom-left-radius: 14px !important;
+  border-bottom-right-radius: 14px !important;
+  pointer-events: none;
+  z-index: 2;
+}
+.ds-footer {
+  position: absolute;
+  right: 12px;
+  bottom: 10px;
+  display: flex;
+  gap: 8px;
+  align-items: center;
+  justify-content: flex-end;
+  z-index: 20 !important;
+}
+.ds-footer .cd-trigger {
+  min-height: 32px;
+  padding: 6px 10px;
+  font-size: 12px;
+  gap: 6px;
+  border-radius: 9999px;
+}
+.ds-footer .cd-trigger-icon,
+.ds-footer .cd-icn { width: 14px; height: 14px; }
+.ds-footer .cd-trigger-icon svg,
+.ds-footer .cd-icn svg { width: 14px; height: 14px; }
+.ds-footer .cd-caret { font-size: 11px; }
+.ds-footer .cd-menu { z-index: 999999 !important; }
+
+/* ---- camera dropdown ---- */
+.cd-wrap { position: relative; display: inline-block; }
+.cd-trigger {
+  margin-top: 2px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 10px;
+  border: none;
+  box-sizing: border-box;
+  padding: 10px 18px;
+  min-height: 52px;
+  line-height: 1.2;
+  border-radius: 9999px;
+  background: #0b0b0b;
+  font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Arial;
+  font-size: 14px;
+  color: rgba(255,255,255,0.7) !important;
+  font-weight: 600 !important;
+  cursor: pointer;
+  user-select: none;
+  white-space: nowrap;
+}
+.cd-trigger .cd-trigger-text,
+.cd-trigger .cd-caret { color: rgba(255,255,255,0.7) !important; }
+.cd-caret { opacity: 0.8; font-weight: 900; }
+.cd-trigger-icon {
+  color: rgba(255,255,255,0.9);
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 18px; height: 18px;
+}
+.cd-trigger-icon svg { width: 18px; height: 18px; display: block; }
+.cd-menu {
+  position: absolute;
+  top: calc(100% + 4px);
+  left: 0;
+  min-width: 240px;
+  background: #2b2b2b !important;
+  border: 1px solid rgba(255,255,255,0.14) !important;
+  border-radius: 14px;
+  box-shadow: 0 18px 40px rgba(0,0,0,0.35);
+  padding: 10px;
+  opacity: 0;
+  transform: translateY(-6px);
+  pointer-events: none;
+  transition: opacity 160ms ease, transform 160ms ease;
+  z-index: 9999;
+}
+.cd-menu.open {
+  opacity: 1;
+  transform: translateY(0);
+  pointer-events: auto;
+}
+.cd-title {
+  font-size: 12px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: rgba(255,255,255,0.55) !important;
+  margin-bottom: 6px;
+  padding: 0 6px;
+  pointer-events: none;
+}
+.cd-items { display: flex; flex-direction: column; gap: 0px; }
+.cd-item {
+  width: 100%;
+  text-align: left;
+  border: none;
+  background: transparent;
+  color: rgba(255,255,255,0.92) !important;
+  padding: 8px 34px 8px 12px;
+  border-radius: 10px;
+  cursor: pointer;
+  font-size: 14px;
+  font-weight: 700;
+  position: relative;
+  transition: background 120ms ease;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+.cd-item * { color: rgba(255,255,255,0.92) !important; }
+.cd-item:hover { background: rgba(255,255,255,0.10) !important; }
+.cd-item::after {
+  content: "\\2713";
+  position: absolute;
+  right: 12px;
+  top: 50%;
+  transform: translateY(-50%);
+  opacity: 0;
+  transition: opacity 120ms ease;
+  color: rgba(255,255,255,0.92) !important;
+  font-weight: 900;
+}
+.cd-item[data-selected="true"]::after { opacity: 1; }
+.cd-item.selected {
+  background: transparent !important;
+  border: none !important;
+}
+.cd-icn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 18px; height: 18px;
+  flex: 0 0 18px;
+}
+.cd-icn svg { width: 18px; height: 18px; display: block; }
+.cd-icn svg * { stroke: rgba(255,255,255,0.9); }
+.cd-label { flex: 1; }
+.cd-trigger, .cd-trigger * { color: rgba(255,255,255,0.75) !important; }
+
+/* ---- AudioDropUpload ---- */
+.aud-wrap { width: 100%; max-width: 720px; }
+.aud-drop {
+  border: 2px dashed var(--body-text-color-subdued);
+  border-radius: 16px;
+  padding: 18px;
+  text-align: center;
+  cursor: pointer;
+  user-select: none;
+  color: var(--body-text-color);
+  background: var(--block-background-fill);
+}
+.aud-drop.dragover {
+  border-color: rgba(255,255,255,0.35);
+  background: rgba(255,255,255,0.06);
+}
+.aud-hint {
+  color: var(--body-text-color-subdued);
+  font-size: 0.95rem;
+  margin-top: 6px;
+}
+.aud-row {
+  display: none;
+  align-items: center;
+  gap: 10px;
+  background: #0b0b0b;
+  border-radius: 9999px;
+  padding: 8px 10px;
+}
+.aud-player {
+  flex: 1;
+  width: 100%;
+  height: 34px;
+  border-radius: 9999px;
+}
+.aud-remove {
+  appearance: none;
+  border: none;
+  background: transparent;
+  color: rgba(255,255,255);
+  cursor: pointer;
+  width: 36px; height: 36px;
+  border-radius: 9999px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0;
+  transition: background 120ms ease, color 120ms ease, opacity 120ms ease;
+  opacity: 0.9;
+  flex: 0 0 auto;
+}
+.aud-remove:hover {
+  background: rgba(255,255,255,0.08);
+  color: rgb(255,255,255);
+  opacity: 1;
+}
+.aud-filelabel {
+  margin: 10px 6px 0;
+  color: var(--body-text-color-subdued);
+  font-size: 0.95rem;
+  display: none;
+}
+#audio_input_hidden { display: none !important; }
 """
 
-with gr.Blocks(css=CSS, title="LTX-2.3 Turbo", theme=gr.themes.Soft()) as demo:
-    gr.Markdown(
+
+# ───────────────────────────────────────────────────────────────────────────
+# SVG icons for resolution dropdown
+# ───────────────────────────────────────────────────────────────────────────
+ICON_16_9 = """<svg viewBox="0 0 24 24" fill="none" aria-hidden="true">
+  <rect x="3" y="7" width="18" height="10" rx="2" stroke="currentColor" stroke-width="2"/>
+</svg>"""
+
+ICON_1_1 = """<svg viewBox="0 0 24 24" fill="none" aria-hidden="true">
+  <rect x="6" y="6" width="12" height="12" rx="2" stroke="currentColor" stroke-width="2"/>
+</svg>"""
+
+ICON_9_16 = """<svg viewBox="0 0 24 24" fill="none" aria-hidden="true">
+  <rect x="7" y="3" width="10" height="18" rx="2" stroke="currentColor" stroke-width="2"/>
+</svg>"""
+
+
+# ───────────────────────────────────────────────────────────────────────────
+# Gradio UI
+# ───────────────────────────────────────────────────────────────────────────
+with gr.Blocks(title="LTX-2.3 Turbo", css=CSS) as demo:
+    gr.HTML(
+        """
+        <div style="text-align: center;">
+            <p style="font-size:16px; display: inline; margin: 0;">
+                <strong>LTX-2.3 Turbo</strong> &mdash; 22B DiT audio-video model on free ZeroGPU
+            </p>
+            <a href="https://huggingface.co/Lightricks/LTX-2.3"
+               target="_blank" rel="noopener noreferrer"
+               style="display: inline-block; vertical-align: middle; margin-left: 0.5em;">
+                [model]
+            </a>
+            <a href="https://github.com/Lightricks/LTX-2"
+               target="_blank" rel="noopener noreferrer"
+               style="display: inline-block; vertical-align: middle; margin-left: 0.5em;">
+                [github]
+            </a>
+        </div>
+        <div style="text-align: center; margin-top: 4px;">
+            <strong>HF Space by:</strong>
+            <a href="https://huggingface.co/ZeroCollabs" target="_blank" rel="noopener noreferrer"
+               style="display: inline-block; vertical-align: middle; margin-left: 0.5em;">
+                <img src="https://img.shields.io/badge/%F0%9F%A4%97-Follow%20on%20HF-green.svg" alt="Follow on HF">
+            </a>
+            <a href="https://github.com/ZeroHackz" target="_blank" rel="noopener noreferrer"
+               style="display: inline-block; vertical-align: middle; margin-left: 0.5em;">
+                <img src="https://img.shields.io/badge/GitHub-Follow-181717?logo=github" alt="Follow on GitHub">
+            </a>
+        </div>
         """
-        # LTX-2.3 Turbo (ZeroGPU)
-        Generate synchronized **video + audio** from text or images using
-        [Lightricks/LTX-2.3](https://huggingface.co/Lightricks/LTX-2.3) —
-        a 22B parameter DiT-based audio-video foundation model.
-
-        Running on **free ZeroGPU** with FP8 quantization.
-        Distilled pipeline (8+4 denoising steps, two-stage with 2x spatial upscaling).
-        """,
-        elem_classes="header",
     )
 
-    with gr.Row():
-        # --- Left: Controls ---
-        with gr.Column(scale=1):
-            mode = gr.Radio(
-                ["Text to Video", "Image to Video"],
-                value="Text to Video",
-                label="Mode",
-            )
-            first_frame = gr.Image(
-                type="pil",
-                label="Input Image (first frame)",
-                visible=False,
-            )
-            prompt = gr.Textbox(
-                label="Prompt",
-                lines=3,
-                placeholder="Describe the scene, motion, and audio...",
-                value=(
-                    "A golden retriever puppy plays in fresh snow, "
-                    "tossing it up with its paws, soft winter sunlight, "
-                    "gentle wind sounds and playful barking"
-                ),
+    with gr.Column(elem_id="col-container"):
+        # ---- Mode selector ----
+        with gr.Row(elem_id="mode-row"):
+            radioanimated_mode = RadioAnimated(
+                choices=["Image-to-Video", "Interpolate"],
+                value="Image-to-Video",
+                elem_id="radioanimated_mode",
             )
 
-            with gr.Row():
-                resolution = gr.Dropdown(
-                    choices=list(RESOLUTION_PRESETS.keys()),
-                    value="16:9 (768x512)",
-                    label="Resolution",
+        with gr.Row():
+            # ---- Left column: controls ----
+            with gr.Column(elem_id="step-column"):
+                with gr.Row():
+                    first_frame = gr.Image(
+                        label="First Frame (Optional)",
+                        type="filepath",
+                        height=256,
+                    )
+                    end_frame = gr.Image(
+                        label="Last Frame (Optional)",
+                        type="filepath",
+                        height=256,
+                        visible=False,
+                    )
+
+                # JS relocator: moves duration & resolution dropdowns into prompt footer
+                relocate = gr.HTML(
+                    value="",
+                    html_template="<div></div>",
+                    js_on_load=r"""
+                    (() => {
+                      function moveIntoFooter() {
+                        const promptRoot = document.querySelector("#prompt_ui");
+                        if (!promptRoot) return false;
+                        const footer = promptRoot.querySelector(".ds-footer");
+                        if (!footer) return false;
+                        const dur = document.querySelector("#duration_ui .cd-wrap");
+                        const res = document.querySelector("#resolution_ui .cd-wrap");
+                        if (!dur || !res) return false;
+                        footer.appendChild(dur);
+                        footer.appendChild(res);
+                        return true;
+                      }
+                      const tick = () => {
+                        if (!moveIntoFooter()) requestAnimationFrame(tick);
+                      };
+                      requestAnimationFrame(tick);
+                    })();
+                    """,
                 )
-                duration = gr.Slider(1, 5, value=2, step=0.5, label="Duration (sec)")
 
-            with gr.Row():
-                enhance_prompt = gr.Checkbox(value=True, label="Enhance prompt")
-                randomize_seed = gr.Checkbox(value=True, label="Random seed")
+                prompt_ui = PromptBox(
+                    value="A golden retriever puppy plays in fresh snow, tossing it up with its paws, soft winter sunlight, gentle wind sounds and playful barking",
+                    elem_id="prompt_ui",
+                )
 
-            seed = gr.Slider(0, MAX_SEED, value=42, step=1, label="Seed")
+                # Hidden real audio input (backend value)
+                audio_input = gr.File(
+                    label="Audio (Optional)",
+                    file_types=["audio"],
+                    type="filepath",
+                    elem_id="audio_input_hidden",
+                )
 
-            generate_btn = gr.Button(
-                "Generate Video",
-                variant="primary",
-                size="lg",
-                elem_classes="generate-btn",
-            )
+                # Custom audio UI that feeds the hidden gr.File
+                audio_ui = AudioDropUpload(
+                    target_audio_elem_id="audio_input_hidden",
+                    elem_id="audio_ui",
+                )
 
-        # --- Right: Output ---
-        with gr.Column(scale=1):
-            output_video = gr.Video(label="Generated Video", autoplay=True)
-            run_info = gr.Textbox(label="Generation Info", lines=7, interactive=False)
-
-    # --- Events ---
-    mode.change(fn=on_mode_change, inputs=mode, outputs=[first_frame])
-
-    _inputs = [
-        first_frame,
-        prompt,
-        duration,
-        enhance_prompt,
-        seed,
-        randomize_seed,
-        resolution,
-    ]
-    _outputs = [output_video, run_info, seed]
-
-    generate_btn.click(fn=generate_video, inputs=_inputs, outputs=_outputs)
-
-    # --- Examples ---
-    gr.Examples(
-        examples=[
-            [
-                None,
-                "Aerial drone shot of a coastal city at sunset, golden light "
-                "reflecting off glass buildings, gentle ocean waves, seagulls "
-                "calling, cinematic ambient soundtrack",
-                3.0,
-                True,
-                42,
-                True,
-                "16:9 (768x512)",
-            ],
-            [
-                None,
-                "Close-up of a barista pouring latte art in slow motion, "
-                "steam rising from the cup, coffee shop ambience with soft jazz",
-                2.0,
-                True,
-                123,
-                True,
-                "1:1 (512x512)",
-            ],
-            [
-                None,
-                "A cat sits on a windowsill watching rain fall outside, "
-                "soft indoor lighting, raindrops on glass, gentle rain sounds",
-                3.0,
-                True,
-                7,
-                True,
-                "16:9 (768x512)",
-            ],
-        ],
+                # Hidden prompt textbox (synced from PromptBox)
+                prompt = gr.Textbox(
+                    label="Prompt",
+                    value="A golden retriever puppy plays in fresh snow, tossing it up with its paws, soft winter sunlight, gentle wind sounds and playful barking",
+                    lines=3,
+                    max_lines=3,
+                    visible=False,
+                )
+
+                enhance_prompt = gr.Checkbox(
+                    label="Enhance Prompt",
+                    value=True,
+                    visible=False,
+                )
+
+                with gr.Accordion("Advanced Settings", open=False, visible=False):
+                    seed = gr.Slider(
+                        label="Seed",
+                        minimum=0,
+                        maximum=MAX_SEED,
+                        value=42,
+                        step=1,
+                    )
+                    randomize_seed = gr.Checkbox(label="Randomize Seed", value=True)
+
+            # ---- Right column: output + hidden controls ----
+            with gr.Column(elem_id="step-column"):
+                output_video = gr.Video(
+                    label="Generated Video", autoplay=True, height=512
+                )
+
+                with gr.Row(elem_id="controls-row"):
+                    duration_ui = CameraDropdown(
+                        choices=["2s", "3s", "5s"],
+                        value="2s",
+                        title="Clip Duration",
+                        elem_id="duration_ui",
+                    )
+                    duration = gr.Slider(
+                        label="Duration (seconds)",
+                        minimum=1.0,
+                        maximum=5.0,
+                        value=2.0,
+                        step=0.1,
+                        visible=False,
+                    )
+
+                    resolution_ui = CameraDropdown(
+                        choices=[
+                            {"label": "16:9", "value": "16:9", "icon": ICON_16_9},
+                            {"label": "1:1", "value": "1:1", "icon": ICON_1_1},
+                            {"label": "9:16", "value": "9:16", "icon": ICON_9_16},
+                        ],
+                        value="16:9",
+                        title="Resolution",
+                        elem_id="resolution_ui",
+                    )
+
+                    width = gr.Number(
+                        label="Width", value=768, precision=0, visible=False
+                    )
+                    height = gr.Number(
+                        label="Height", value=512, precision=0, visible=False
+                    )
+
+                generate_btn = gr.Button(
+                    "Generate Video",
+                    variant="primary",
+                    elem_classes="button-gradient",
+                )
+
+    # ────────────────────────────────────────────────────────────────────
+    # Event wiring
+    # ────────────────────────────────────────────────────────────────────
+
+    # Mode selector -> show/hide end_frame
+    radioanimated_mode.change(
+        fn=on_mode_change,
+        inputs=radioanimated_mode,
+        outputs=[end_frame],
+        api_visibility="private",
+    )
+
+    # Duration dropdown -> hidden slider
+    duration_ui.change(
+        fn=apply_duration,
+        inputs=duration_ui,
+        outputs=[duration],
+        api_visibility="private",
+    )
+
+    # Resolution dropdown -> hidden width/height
+    resolution_ui.change(
+        fn=apply_resolution,
+        inputs=resolution_ui,
+        outputs=[width, height],
+        api_visibility="private",
+    )
+
+    # PromptBox -> hidden textbox
+    prompt_ui.change(
+        fn=lambda x: x,
+        inputs=prompt_ui,
+        outputs=prompt,
+        api_visibility="private",
+    )
+
+    # Audio UI clear handler
+    def on_audio_ui_change(v):
+        if v == "__CLEAR__" or v is None or v == "":
+            return None
+        return gr.update()
+
+    audio_ui.change(
+        fn=on_audio_ui_change,
+        inputs=audio_ui,
+        outputs=audio_input,
+        api_visibility="private",
+    )
+
+    # Generate button
+    generate_btn.click(
         fn=generate_video,
-        inputs=_inputs,
-        outputs=_outputs,
-        cache_examples=False,
-        label="Example Prompts",
+        inputs=[
+            first_frame,
+            end_frame,
+            prompt,
+            duration,
+            radioanimated_mode,
+            enhance_prompt,
+            seed,
+            randomize_seed,
+            height,
+            width,
+            audio_input,
+        ],
+        outputs=[output_video],
     )
 
+    # ---- Footer ----
     gr.Markdown(
         """
         ---
@@ -494,6 +1585,8 @@ with gr.Blocks(css=CSS, title="LTX-2.3 Turbo", theme=gr.themes.Soft()) as demo:
 
         Built with [Lightricks/LTX-2.3](https://huggingface.co/Lightricks/LTX-2.3)
         | [GitHub](https://github.com/Lightricks/LTX-2)
+        | Space by [ZeroCollabs](https://huggingface.co/ZeroCollabs)
+        | [GitHub](https://github.com/ZeroHackz)
         """
     )
 

packages/ltx-pipelines/src/ltx_pipelines/distilled.py

@@ -4,22 +4,28 @@
 #   - Caches _video_encoder and _transformer for reuse across calls
 #   - Supports gemma_root=None (no text encoder loaded)
 #   - Accepts output_path to write video directly from __call__
+#   - Supports input_waveform for audio conditioning (ported from alexnasa/ltx-2-TURBO)
+#   - Supports interpolation mode via _create_conditionings (first frame replace, end frame guide)
 
 import logging
 from collections.abc import Iterator
 
 import torch
+import torchaudio
 
 from ltx_core.components.diffusion_steps import EulerDiffusionStep
 from ltx_core.components.noisers import GaussianNoiser
 from ltx_core.components.protocols import DiffusionStepProtocol
+from ltx_core.conditioning import ConditioningItem, ConditioningError
 from ltx_core.loader import LoraPathStrengthAndSDOps
 from ltx_core.model.audio_vae import decode_audio as vae_decode_audio
+from ltx_core.model.audio_vae.ops import AudioProcessor
 from ltx_core.model.upsampler import upsample_video
 from ltx_core.model.video_vae import TilingConfig, get_video_chunks_number
 from ltx_core.model.video_vae import decode_video as vae_decode_video
 from ltx_core.quantization import QuantizationPolicy
-from ltx_core.types import Audio, LatentState, VideoPixelShape
+from ltx_core.tools import LatentTools
+from ltx_core.types import Audio, AudioLatentShape, LatentState, VideoPixelShape
 from ltx_pipelines.utils import ModelLedger, euler_denoising_loop
 from ltx_pipelines.utils.args import (
     ImageConditioningInput,
@@ -34,10 +40,11 @@ from ltx_pipelines.utils.constants import (
 from ltx_pipelines.utils.helpers import (
     assert_resolution,
     cleanup_memory,
-    combined_image_conditionings,
     denoise_audio_video,
     encode_prompts,
     get_device,
+    image_conditionings_by_adding_guiding_latent,
+    image_conditionings_by_replacing_latent,
     simple_denoising_func,
 )
 from ltx_pipelines.utils.media_io import encode_video
@@ -46,6 +53,51 @@ from ltx_pipelines.utils.types import PipelineComponents
 device = get_device()
 
 
+# ─── Audio conditioning class (ported from alexnasa/ltx-2-TURBO) ────────────
+class AudioConditionByLatent(ConditioningItem):
+    """
+    Conditions audio generation by injecting a full latent sequence.
+    Replaces tokens in the latent state with the provided audio latents,
+    and sets denoise strength according to the strength parameter.
+    """
+
+    def __init__(self, latent: torch.Tensor, strength: float):
+        self.latent = latent
+        self.strength = strength
+
+    def apply_to(
+        self, latent_state: LatentState, latent_tools: LatentTools
+    ) -> LatentState:
+        if not isinstance(latent_tools.target_shape, AudioLatentShape):
+            raise ConditioningError(
+                "Audio conditioning requires an audio latent target shape."
+            )
+
+        cond_batch, cond_channels, cond_frames, cond_bins = self.latent.shape
+        tgt_batch, tgt_channels, tgt_frames, tgt_bins = (
+            latent_tools.target_shape.to_torch_shape()
+        )
+
+        if (cond_batch, cond_channels, cond_frames, cond_bins) != (
+            tgt_batch,
+            tgt_channels,
+            tgt_frames,
+            tgt_bins,
+        ):
+            raise ConditioningError(
+                f"Can't apply audio conditioning item to latent with shape {latent_tools.target_shape}, expected "
+                f"shape is ({tgt_batch}, {tgt_channels}, {tgt_frames}, {tgt_bins})."
+            )
+
+        tokens = latent_tools.patchifier.patchify(self.latent)
+        latent_state = latent_state.clone()
+        latent_state.latent[:, : tokens.shape[1]] = tokens
+        latent_state.clean_latent[:, : tokens.shape[1]] = tokens
+        latent_state.denoise_mask[:, : tokens.shape[1]] = 1.0 - self.strength
+
+        return latent_state
+
+
 class DistilledPipeline:
     """
     Two-stage distilled video generation pipeline.
@@ -57,6 +109,8 @@ class DistilledPipeline:
     - Caches _video_encoder and _transformer for reuse across calls
     - Supports gemma_root=None (no text encoder loaded)
     - Accepts output_path to write video directly from __call__
+    - Supports input_waveform for audio conditioning
+    - Supports interpolation mode (first frame replace + end frame guide)
     """
 
     def __init__(
@@ -90,6 +144,180 @@ class DistilledPipeline:
         self._video_encoder = None
         self._transformer = None
 
+    def _build_audio_conditionings_from_waveform(
+        self,
+        input_waveform: torch.Tensor,
+        input_sample_rate: int,
+        num_frames: int,
+        fps: float,
+        strength: float = 1.0,
+    ) -> list[AudioConditionByLatent] | None:
+        """
+        Convert a raw waveform into audio latent conditioning for the denoiser.
+        Ported from alexnasa/ltx-2-TURBO.
+        """
+        strength = float(strength)
+        if strength <= 0.0:
+            return None
+
+        # Normalize waveform shape to (B, C, T)
+        waveform = input_waveform
+        if waveform.ndim == 1:
+            waveform = waveform.unsqueeze(0).unsqueeze(0)
+        elif waveform.ndim == 2:
+            waveform = waveform.unsqueeze(0)
+        elif waveform.ndim != 3:
+            raise ValueError(
+                f"input_waveform must be 1D/2D/3D, got shape {tuple(waveform.shape)}"
+            )
+
+        # Get audio encoder + its config
+        audio_encoder = self.model_ledger.audio_encoder()
+        target_sr = int(getattr(audio_encoder, "sample_rate"))
+        target_channels = int(getattr(audio_encoder, "in_channels", waveform.shape[1]))
+        mel_bins = int(getattr(audio_encoder, "mel_bins"))
+        mel_hop = int(getattr(audio_encoder, "mel_hop_length"))
+        n_fft = int(getattr(audio_encoder, "n_fft"))
+
+        # Match channels
+        if waveform.shape[1] != target_channels:
+            if waveform.shape[1] == 1 and target_channels > 1:
+                waveform = waveform.repeat(1, target_channels, 1)
+            elif target_channels == 1:
+                waveform = waveform.mean(dim=1, keepdim=True)
+            else:
+                waveform = waveform[:, :target_channels, :]
+                if waveform.shape[1] < target_channels:
+                    pad_ch = target_channels - waveform.shape[1]
+                    pad = torch.zeros(
+                        (waveform.shape[0], pad_ch, waveform.shape[2]),
+                        dtype=waveform.dtype,
+                    )
+                    waveform = torch.cat([waveform, pad], dim=1)
+
+        # Resample if needed (CPU float32 is safest for torchaudio)
+        waveform = waveform.to(device="cpu", dtype=torch.float32)
+        if int(input_sample_rate) != target_sr:
+            waveform = torchaudio.functional.resample(
+                waveform, int(input_sample_rate), target_sr
+            )
+
+        # Waveform -> Mel spectrogram
+        audio_processor = AudioProcessor(
+            sample_rate=target_sr,
+            mel_bins=mel_bins,
+            mel_hop_length=mel_hop,
+            n_fft=n_fft,
+        ).to(waveform.device)
+
+        mel = audio_processor.waveform_to_mel(waveform, target_sr)
+
+        # Mel -> latent (run encoder on its own device/dtype)
+        audio_params = next(audio_encoder.parameters(), None)
+        enc_device = audio_params.device if audio_params is not None else self.device
+        enc_dtype = audio_params.dtype if audio_params is not None else self.dtype
+
+        mel = mel.to(device=enc_device, dtype=enc_dtype)
+        with torch.inference_mode():
+            audio_latent = audio_encoder(mel)
+
+        # Pad/trim latent to match the target video duration
+        audio_downsample = getattr(
+            getattr(audio_encoder, "patchifier", None),
+            "audio_latent_downsample_factor",
+            4,
+        )
+        target_shape = AudioLatentShape.from_video_pixel_shape(
+            VideoPixelShape(
+                batch=audio_latent.shape[0],
+                frames=int(num_frames),
+                width=1,
+                height=1,
+                fps=float(fps),
+            ),
+            channels=audio_latent.shape[1],
+            mel_bins=audio_latent.shape[3],
+            sample_rate=target_sr,
+            hop_length=mel_hop,
+            audio_latent_downsample_factor=audio_downsample,
+        )
+        target_frames = int(target_shape.frames)
+
+        if audio_latent.shape[2] < target_frames:
+            pad_frames = target_frames - audio_latent.shape[2]
+            pad = torch.zeros(
+                (
+                    audio_latent.shape[0],
+                    audio_latent.shape[1],
+                    pad_frames,
+                    audio_latent.shape[3],
+                ),
+                device=audio_latent.device,
+                dtype=audio_latent.dtype,
+            )
+            audio_latent = torch.cat([audio_latent, pad], dim=2)
+        elif audio_latent.shape[2] > target_frames:
+            audio_latent = audio_latent[:, :, :target_frames, :]
+
+        # Move latent to pipeline device/dtype for conditioning object
+        audio_latent = audio_latent.to(device=self.device, dtype=self.dtype)
+
+        return [AudioConditionByLatent(audio_latent, strength)]
+
+    def _create_conditionings(
+        self,
+        images: list[tuple[str, int, float]],
+        height: int,
+        width: int,
+        video_encoder,
+        dtype: torch.dtype,
+    ) -> list[ConditioningItem]:
+        """
+        Create image conditionings supporting both first-frame (replace latent)
+        and end-frame (guiding latent for interpolation mode).
+
+        - frame_idx == 0 -> replace latent (strong anchor)
+        - frame_idx > 0  -> guiding latent (softer interpolation target)
+        """
+        replace_imgs = []
+        guide_imgs = []
+
+        for img in images:
+            if isinstance(img, ImageConditioningInput):
+                path, frame_idx, strength = img.path, img.frame_idx, img.strength
+            else:
+                path, frame_idx, strength = img[0], img[1], img[2]
+
+            entry = ImageConditioningInput(
+                path=path, frame_idx=frame_idx, strength=strength
+            )
+            if frame_idx == 0:
+                replace_imgs.append(entry)
+            else:
+                guide_imgs.append(entry)
+
+        conditionings = []
+        if replace_imgs:
+            conditionings += image_conditionings_by_replacing_latent(
+                images=replace_imgs,
+                height=height,
+                width=width,
+                video_encoder=video_encoder,
+                dtype=dtype,
+                device=self.device,
+            )
+        if guide_imgs:
+            conditionings += image_conditionings_by_adding_guiding_latent(
+                images=guide_imgs,
+                height=height,
+                width=width,
+                video_encoder=video_encoder,
+                dtype=dtype,
+                device=self.device,
+            )
+
+        return conditionings
+
     @torch.inference_mode()
     def __call__(
         self,
@@ -105,6 +333,9 @@ class DistilledPipeline:
         output_path: str | None = None,
         video_context: torch.Tensor | None = None,
         audio_context: torch.Tensor | None = None,
+        input_waveform: torch.Tensor | None = None,
+        input_waveform_sample_rate: int | None = None,
+        audio_strength: float = 1.0,
     ) -> tuple[Iterator[torch.Tensor], Audio] | None:
         """
         Run the two-stage distilled pipeline.
@@ -112,6 +343,11 @@ class DistilledPipeline:
         If video_context and audio_context are provided, text encoding is skipped.
         If output_path is provided, the video is written to disk and None is returned.
         Otherwise, returns (decoded_video, decoded_audio).
+
+        New audio input params:
+          input_waveform: raw waveform tensor for audio conditioning
+          input_waveform_sample_rate: sample rate of input_waveform
+          audio_strength: conditioning strength (0 = ignore, 1 = full replace)
         """
         assert_resolution(height=height, width=width, is_two_stage=True)
 
@@ -120,6 +356,21 @@ class DistilledPipeline:
         stepper = EulerDiffusionStep()
         dtype = torch.bfloat16
 
+        # Build audio conditionings from waveform if provided
+        audio_conditionings = None
+        if input_waveform is not None:
+            if input_waveform_sample_rate is None:
+                raise ValueError(
+                    "input_waveform_sample_rate must be provided when input_waveform is set."
+                )
+            audio_conditionings = self._build_audio_conditionings_from_waveform(
+                input_waveform=input_waveform,
+                input_sample_rate=int(input_waveform_sample_rate),
+                num_frames=num_frames,
+                fps=frame_rate,
+                strength=audio_strength,
+            )
+
         # Use pre-encoded contexts if provided, otherwise encode internally
         if video_context is not None and audio_context is not None:
             video_context = video_context.to(self.device)
@@ -170,18 +421,18 @@ class DistilledPipeline:
             height=height // 2,
             fps=frame_rate,
         )
-        stage_1_conditionings = combined_image_conditionings(
+        stage_1_conditionings = self._create_conditionings(
             images=images,
             height=stage_1_output_shape.height,
             width=stage_1_output_shape.width,
             video_encoder=video_encoder,
             dtype=dtype,
-            device=self.device,
         )
 
         video_state, audio_state = denoise_audio_video(
             output_shape=stage_1_output_shape,
             conditionings=stage_1_conditionings,
+            audio_conditionings=audio_conditionings,
             noiser=noiser,
             sigmas=stage_1_sigmas,
             stepper=stepper,
@@ -205,17 +456,38 @@ class DistilledPipeline:
         stage_2_output_shape = VideoPixelShape(
             batch=1, frames=num_frames, width=width, height=height, fps=frame_rate
         )
-        stage_2_conditionings = combined_image_conditionings(
-            images=images,
+        # Stage 2 uses guiding (not replacing) for first-frame images only
+        stage_2_images = []
+        for img in images:
+            if isinstance(img, ImageConditioningInput):
+                fi = img.frame_idx
+            else:
+                fi = img[1]
+            if fi == 0:
+                stage_2_images.append(
+                    ImageConditioningInput(
+                        path=img.path
+                        if isinstance(img, ImageConditioningInput)
+                        else img[0],
+                        frame_idx=0,
+                        strength=img.strength
+                        if isinstance(img, ImageConditioningInput)
+                        else img[2],
+                    )
+                )
+        stage_2_conditionings = image_conditionings_by_adding_guiding_latent(
+            images=stage_2_images,
             height=stage_2_output_shape.height,
             width=stage_2_output_shape.width,
             video_encoder=video_encoder,
             dtype=dtype,
             device=self.device,
         )
+
         video_state, audio_state = denoise_audio_video(
             output_shape=stage_2_output_shape,
             conditionings=stage_2_conditionings,
+            audio_conditionings=audio_conditionings,
             noiser=noiser,
             sigmas=stage_2_sigmas,
             stepper=stepper,

packages/ltx-pipelines/src/ltx_pipelines/utils/helpers.py

@@ -23,9 +23,18 @@ from ltx_core.model.video_vae import VideoEncoder
 from ltx_core.text_encoders.gemma import GemmaTextEncoder
 from ltx_core.text_encoders.gemma.embeddings_processor import EmbeddingsProcessorOutput
 from ltx_core.tools import AudioLatentTools, LatentTools, VideoLatentTools
-from ltx_core.types import AudioLatentShape, LatentState, VideoLatentShape, VideoPixelShape
+from ltx_core.types import (
+    AudioLatentShape,
+    LatentState,
+    VideoLatentShape,
+    VideoPixelShape,
+)
 from ltx_pipelines.utils.args import ImageConditioningInput
-from ltx_pipelines.utils.media_io import decode_image, load_image_conditioning, resize_aspect_ratio_preserving
+from ltx_pipelines.utils.media_io import (
+    decode_image,
+    load_image_conditioning,
+    resize_aspect_ratio_preserving,
+)
 from ltx_pipelines.utils.types import (
     DenoisingFunc,
     DenoisingLoopFunc,
@@ -71,7 +80,9 @@ def encode_prompts(
     text_encoder = model_ledger.text_encoder()
     if enhance_first_prompt:
         prompts = list(prompts)
-        prompts[0] = generate_enhanced_prompt(text_encoder, prompts[0], enhance_prompt_image, seed=enhance_prompt_seed)
+        prompts[0] = generate_enhanced_prompt(
+            text_encoder, prompts[0], enhance_prompt_image, seed=enhance_prompt_seed
+        )
     raw_outputs = [text_encoder.encode(p) for p in prompts]
     torch.cuda.synchronize()
     del text_encoder
@@ -173,7 +184,9 @@ def image_conditionings_by_adding_guiding_latent(
         )
         encoded_image = video_encoder(image)
         conditionings.append(
-            VideoConditionByKeyframeIndex(keyframes=encoded_image, frame_idx=img.frame_idx, strength=img.strength)
+            VideoConditionByKeyframeIndex(
+                keyframes=encoded_image, frame_idx=img.frame_idx, strength=img.strength
+            )
         )
     return conditionings
 
@@ -199,7 +212,9 @@ def noise_video_state(
         latent_channels=components.video_latent_channels,
         scale_factors=components.video_scale_factors,
     )
-    video_tools = VideoLatentTools(components.video_patchifier, video_latent_shape, output_shape.fps)
+    video_tools = VideoLatentTools(
+        components.video_patchifier, video_latent_shape, output_shape.fps
+    )
     video_state = create_noised_state(
         tools=video_tools,
         conditionings=conditionings,
@@ -265,21 +280,29 @@ def create_noised_state(
 
 
 def state_with_conditionings(
-    latent_state: LatentState, conditioning_items: list[ConditioningItem], latent_tools: LatentTools
+    latent_state: LatentState,
+    conditioning_items: list[ConditioningItem],
+    latent_tools: LatentTools,
 ) -> LatentState:
     """Apply a list of conditionings to a latent state.
     Iterates through the conditioning items and applies each one to the latent
     state in sequence. Returns the modified state with all conditionings applied.
     """
     for conditioning in conditioning_items:
-        latent_state = conditioning.apply_to(latent_state=latent_state, latent_tools=latent_tools)
+        latent_state = conditioning.apply_to(
+            latent_state=latent_state, latent_tools=latent_tools
+        )
 
     return latent_state
 
 
-def post_process_latent(denoised: torch.Tensor, denoise_mask: torch.Tensor, clean: torch.Tensor) -> torch.Tensor:
+def post_process_latent(
+    denoised: torch.Tensor, denoise_mask: torch.Tensor, clean: torch.Tensor
+) -> torch.Tensor:
     """Blend denoised output with clean state based on mask."""
-    return (denoised * denoise_mask + clean.float() * (1 - denoise_mask)).to(denoised.dtype)
+    return (denoised * denoise_mask + clean.float() * (1 - denoise_mask)).to(
+        denoised.dtype
+    )
 
 
 def modality_from_latent_state(
@@ -304,7 +327,9 @@ def modality_from_latent_state(
     )
 
 
-def timesteps_from_mask(denoise_mask: torch.Tensor, sigma: float | torch.Tensor) -> torch.Tensor:
+def timesteps_from_mask(
+    denoise_mask: torch.Tensor, sigma: float | torch.Tensor
+) -> torch.Tensor:
     """Compute timesteps from a denoise mask and sigma value.
     Multiplies the denoise mask by sigma to produce timesteps for each position
     in the latent state. Areas where the mask is 0 will have zero timesteps.
@@ -316,13 +341,18 @@ def simple_denoising_func(
     video_context: torch.Tensor, audio_context: torch.Tensor, transformer: X0Model
 ) -> DenoisingFunc:
     def simple_denoising_step(
-        video_state: LatentState, audio_state: LatentState, sigmas: torch.Tensor, step_index: int
+        video_state: LatentState,
+        audio_state: LatentState,
+        sigmas: torch.Tensor,
+        step_index: int,
     ) -> tuple[torch.Tensor, torch.Tensor]:
         sigma = sigmas[step_index]
         pos_video = modality_from_latent_state(video_state, video_context, sigma)
         pos_audio = modality_from_latent_state(audio_state, audio_context, sigma)
 
-        denoised_video, denoised_audio = transformer(video=pos_video, audio=pos_audio, perturbations=None)
+        denoised_video, denoised_audio = transformer(
+            video=pos_video, audio=pos_audio, perturbations=None
+        )
         return denoised_video, denoised_audio
 
     return simple_denoising_step
@@ -337,21 +367,32 @@ def guider_denoising_func(
     transformer: X0Model,
 ) -> DenoisingFunc:
     def guider_denoising_step(
-        video_state: LatentState, audio_state: LatentState, sigmas: torch.Tensor, step_index: int
+        video_state: LatentState,
+        audio_state: LatentState,
+        sigmas: torch.Tensor,
+        step_index: int,
     ) -> tuple[torch.Tensor, torch.Tensor]:
         sigma = sigmas[step_index]
         pos_video = modality_from_latent_state(video_state, v_context_p, sigma)
         pos_audio = modality_from_latent_state(audio_state, a_context_p, sigma)
 
-        denoised_video, denoised_audio = transformer(video=pos_video, audio=pos_audio, perturbations=None)
+        denoised_video, denoised_audio = transformer(
+            video=pos_video, audio=pos_audio, perturbations=None
+        )
         if guider.enabled():
             neg_video = modality_from_latent_state(video_state, v_context_n, sigma)
             neg_audio = modality_from_latent_state(audio_state, a_context_n, sigma)
 
-            neg_denoised_video, neg_denoised_audio = transformer(video=neg_video, audio=neg_audio, perturbations=None)
+            neg_denoised_video, neg_denoised_audio = transformer(
+                video=neg_video, audio=neg_audio, perturbations=None
+            )
 
-            denoised_video = denoised_video + guider.delta(denoised_video, neg_denoised_video)
-            denoised_audio = denoised_audio + guider.delta(denoised_audio, neg_denoised_audio)
+            denoised_video = denoised_video + guider.delta(
+                denoised_video, neg_denoised_video
+            )
+            denoised_audio = denoised_audio + guider.delta(
+                denoised_audio, neg_denoised_audio
+            )
 
         return denoised_video, denoised_audio
 
@@ -369,30 +410,54 @@ def multi_modal_guider_denoising_func(
     last_denoised_audio: torch.Tensor | None = None,
 ) -> DenoisingFunc:
     def guider_denoising_step(
-        video_state: LatentState, audio_state: LatentState, sigmas: torch.Tensor, step_index: int
+        video_state: LatentState,
+        audio_state: LatentState,
+        sigmas: torch.Tensor,
+        step_index: int,
     ) -> tuple[torch.Tensor, torch.Tensor]:
         nonlocal last_denoised_video, last_denoised_audio
 
-        if video_guider.should_skip_step(step_index) and audio_guider.should_skip_step(step_index):
+        if video_guider.should_skip_step(step_index) and audio_guider.should_skip_step(
+            step_index
+        ):
             return last_denoised_video, last_denoised_audio
 
         sigma = sigmas[step_index]
         pos_video_modality = modality_from_latent_state(
-            video_state, v_context, sigma, enabled=not video_guider.should_skip_step(step_index)
+            video_state,
+            v_context,
+            sigma,
+            enabled=not video_guider.should_skip_step(step_index),
         )
         pos_audio_modality = modality_from_latent_state(
-            audio_state, a_context, sigma, enabled=not audio_guider.should_skip_step(step_index)
+            audio_state,
+            a_context,
+            sigma,
+            enabled=not audio_guider.should_skip_step(step_index),
         )
 
         denoised_video, denoised_audio = transformer(
             video=pos_video_modality, audio=pos_audio_modality, perturbations=None
         )
         neg_denoised_video, neg_denoised_audio = 0.0, 0.0
-        if video_guider.do_unconditional_generation() or audio_guider.do_unconditional_generation():
-            if video_guider.do_unconditional_generation() and video_guider.negative_context is None:
-                raise ValueError("Negative context is required for unconditioned denoising")
-            if audio_guider.do_unconditional_generation() and audio_guider.negative_context is None:
-                raise ValueError("Negative context is required for unconditioned denoising")
+        if (
+            video_guider.do_unconditional_generation()
+            or audio_guider.do_unconditional_generation()
+        ):
+            if (
+                video_guider.do_unconditional_generation()
+                and video_guider.negative_context is None
+            ):
+                raise ValueError(
+                    "Negative context is required for unconditioned denoising"
+                )
+            if (
+                audio_guider.do_unconditional_generation()
+                and audio_guider.negative_context is None
+            ):
+                raise ValueError(
+                    "Negative context is required for unconditioned denoising"
+                )
             neg_video_modality = modality_from_latent_state(
                 video_state,
                 video_guider.negative_context
@@ -413,25 +478,39 @@ def multi_modal_guider_denoising_func(
             )
 
         ptb_denoised_video, ptb_denoised_audio = 0.0, 0.0
-        if video_guider.do_perturbed_generation() or audio_guider.do_perturbed_generation():
+        if (
+            video_guider.do_perturbed_generation()
+            or audio_guider.do_perturbed_generation()
+        ):
             perturbations = []
             if video_guider.do_perturbed_generation():
                 perturbations.append(
-                    Perturbation(type=PerturbationType.SKIP_VIDEO_SELF_ATTN, blocks=video_guider.params.stg_blocks)
+                    Perturbation(
+                        type=PerturbationType.SKIP_VIDEO_SELF_ATTN,
+                        blocks=video_guider.params.stg_blocks,
+                    )
                 )
             if audio_guider.do_perturbed_generation():
                 perturbations.append(
-                    Perturbation(type=PerturbationType.SKIP_AUDIO_SELF_ATTN, blocks=audio_guider.params.stg_blocks)
+                    Perturbation(
+                        type=PerturbationType.SKIP_AUDIO_SELF_ATTN,
+                        blocks=audio_guider.params.stg_blocks,
+                    )
                 )
             perturbation_config = PerturbationConfig(perturbations=perturbations)
             ptb_denoised_video, ptb_denoised_audio = transformer(
                 video=pos_video_modality,
                 audio=pos_audio_modality,
-                perturbations=BatchedPerturbationConfig(perturbations=[perturbation_config]),
+                perturbations=BatchedPerturbationConfig(
+                    perturbations=[perturbation_config]
+                ),
             )
 
         mod_denoised_video, mod_denoised_audio = 0.0, 0.0
-        if video_guider.do_isolated_modality_generation() or audio_guider.do_isolated_modality_generation():
+        if (
+            video_guider.do_isolated_modality_generation()
+            or audio_guider.do_isolated_modality_generation()
+        ):
             perturbations = [
                 Perturbation(type=PerturbationType.SKIP_A2V_CROSS_ATTN, blocks=None),
                 Perturbation(type=PerturbationType.SKIP_V2A_CROSS_ATTN, blocks=None),
@@ -440,21 +519,29 @@ def multi_modal_guider_denoising_func(
             mod_denoised_video, mod_denoised_audio = transformer(
                 video=pos_video_modality,
                 audio=pos_audio_modality,
-                perturbations=BatchedPerturbationConfig(perturbations=[perturbation_config]),
+                perturbations=BatchedPerturbationConfig(
+                    perturbations=[perturbation_config]
+                ),
             )
 
         if video_guider.should_skip_step(step_index):
             denoised_video = last_denoised_video
         else:
             denoised_video = video_guider.calculate(
-                denoised_video, neg_denoised_video, ptb_denoised_video, mod_denoised_video
+                denoised_video,
+                neg_denoised_video,
+                ptb_denoised_video,
+                mod_denoised_video,
             )
 
         if audio_guider.should_skip_step(step_index):
             denoised_audio = last_denoised_audio
         else:
             denoised_audio = audio_guider.calculate(
-                denoised_audio, neg_denoised_audio, ptb_denoised_audio, mod_denoised_audio
+                denoised_audio,
+                neg_denoised_audio,
+                ptb_denoised_audio,
+                mod_denoised_audio,
             )
 
         last_denoised_video = denoised_video
@@ -478,14 +565,19 @@ def multi_modal_guider_factory_denoising_func(
     sigma_vals_cached: list[float] | None = None
 
     def guider_denoising_step(
-        video_state: LatentState, audio_state: LatentState, sigmas: torch.Tensor, step_index: int
+        video_state: LatentState,
+        audio_state: LatentState,
+        sigmas: torch.Tensor,
+        step_index: int,
     ) -> tuple[torch.Tensor, torch.Tensor]:
         nonlocal last_denoised_video, last_denoised_audio, sigma_vals_cached
         if sigma_vals_cached is None:
             sigma_vals_cached = sigmas.detach().cpu().tolist()
         sigma_val = sigma_vals_cached[step_index]
         video_guider = video_guider_factory.build_from_sigma(sigma_val)
-        audio_guider = (audio_guider_factory or video_guider_factory).build_from_sigma(sigma_val)
+        audio_guider = (audio_guider_factory or video_guider_factory).build_from_sigma(
+            sigma_val
+        )
         denoise_fn = multi_modal_guider_denoising_func(
             video_guider,
             audio_guider,
@@ -495,7 +587,9 @@ def multi_modal_guider_factory_denoising_func(
             last_denoised_video=last_denoised_video,
             last_denoised_audio=last_denoised_audio,
         )
-        denoised_video, denoised_audio = denoise_fn(video_state, audio_state, sigmas, step_index)
+        denoised_video, denoised_audio = denoise_fn(
+            video_state, audio_state, sigmas, step_index
+        )
         last_denoised_video, last_denoised_audio = denoised_video, denoised_audio
         return denoised_video, denoised_audio
 
@@ -515,6 +609,7 @@ def denoise_audio_video(  # noqa: PLR0913
     noise_scale: float = 1.0,
     initial_video_latent: torch.Tensor | None = None,
     initial_audio_latent: torch.Tensor | None = None,
+    audio_conditionings: list[ConditioningItem] | None = None,
 ) -> tuple[LatentState, LatentState]:
     video_state, video_tools = noise_video_state(
         output_shape=output_shape,
@@ -529,7 +624,7 @@ def denoise_audio_video(  # noqa: PLR0913
     audio_state, audio_tools = noise_audio_state(
         output_shape=output_shape,
         noiser=noiser,
-        conditionings=[],
+        conditionings=audio_conditionings if audio_conditionings is not None else [],
         components=components,
         dtype=dtype,
         device=device,
@@ -588,7 +683,9 @@ def denoise_video_only(  # noqa: PLR0913
         initial_latent=initial_audio_latent,
     )
 
-    audio_state = replace(audio_state, denoise_mask=torch.zeros_like(audio_state.denoise_mask))
+    audio_state = replace(
+        audio_state, denoise_mask=torch.zeros_like(audio_state.denoise_mask)
+    )
 
     video_state, audio_state = denoising_loop_fn(
         sigmas,
@@ -603,7 +700,9 @@ def denoise_video_only(  # noqa: PLR0913
     return video_state
 
 
-_UNICODE_REPLACEMENTS = str.maketrans("\u2018\u2019\u201c\u201d\u2014\u2013\u00a0\u2032\u2212", "''\"\"-- '-")
+_UNICODE_REPLACEMENTS = str.maketrans(
+    "\u2018\u2019\u201c\u201d\u2014\u2013\u00a0\u2032\u2212", "''\"\"-- '-"
+)
 
 
 def clean_response(text: str) -> str: