fix: bypass spatial VAE tiling for Wan 2.1 I2V video encode/decode

When vae_tiling is enabled, vae_encode() and decode_first_stage() use a 2D
spatial tiling path that is incompatible with the 4D video tensors produced
by the Wan video VAE.

ENCODE: vae_encode() pre-allocates its result as [W/8, H/8, z_dim, batch].
For Wan 2.1 I2V the WanVAE encoder produces [W/8, H/8, t_latent, z_dim].
Passing encode_video=false (the default) hits the tiling branch and produces
a transposed tensor instead of the correct shape, causing assertion failures.

DECODE: decode_first_stage() checks vae_tiling_params.enabled without a
!decode_video guard. The Wan video latent is fed through the 2D tiling path,
which produces all-black (zero) output frames.

Fix:
- Add encode_video=true to the Wan 2.1 I2V concat-latent encode call
- Add !decode_video guard to the tiling branch in decode_first_stage()

This allows video VAE operations to bypass tiling while keeping it enabled
for regular image inference.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: aegioscy

src/stable-diffusion.cpp

@@ -2410,17 +2410,17 @@ class StableDiffusionGGML {
         return latent_frames_to_video_frames(video_frames_to_latent_frames(frames));
     }
 
-    sd::Tensor<float> encode_to_vae_latents(const sd::Tensor<float>& x) {
-        auto latents = first_stage_model->encode(n_threads, x, vae_tiling_params, circular_x, circular_y);
+    sd::Tensor<float> encode_to_vae_latents(const sd::Tensor<float>& x, bool encode_video = false) {
+        auto latents = first_stage_model->encode(n_threads, x, vae_tiling_params, encode_video, circular_x, circular_y);
         if (latents.empty()) {
             return {};
         }
         latents = first_stage_model->vae_output_to_latents(latents, rng);
         return latents;
     }
 
-    sd::Tensor<float> encode_first_stage(const sd::Tensor<float>& x) {
-        auto latents = encode_to_vae_latents(x);
+    sd::Tensor<float> encode_first_stage(const sd::Tensor<float>& x, bool encode_video = false) {
+        auto latents = encode_to_vae_latents(x, encode_video);
         if (latents.empty()) {
             return {};
         }
@@ -4905,7 +4905,7 @@ static std::optional<ImageGenerationLatents> prepare_video_generation_latents(sd
             sd::ops::slice_assign(&image, 2, request->frames - 1, request->frames, end_image.unsqueeze(2));
         }
 
-        auto concat_latent = sd_ctx->sd->encode_first_stage(image);  // [b, c, t, h/vae_scale_factor, w/vae_scale_factor]
+        auto concat_latent = sd_ctx->sd->encode_first_stage(image, /*encode_video=*/true);  // [b, c, t, h/vae_scale_factor, w/vae_scale_factor]; encode_video bypasses spatial tiling
         if (concat_latent.empty()) {
             LOG_ERROR("failed to encode video conditioning frames");
             return std::nullopt;

src/vae.hpp

@@ -113,16 +113,19 @@ struct VAE : public GGMLRunner {
     sd::Tensor<float> encode(int n_threads,
                              const sd::Tensor<float>& x,
                              sd_tiling_params_t tiling_params,
-                             bool circular_x = false,
-                             bool circular_y = false) {
+                             bool encode_video = false,
+                             bool circular_x   = false,
+                             bool circular_y   = false) {
         int64_t t0              = ggml_time_ms();
         sd::Tensor<float> input = x;
         sd::Tensor<float> output;
         if (scale_input) {
             scale_tensor_to_minus1_1(&input);
         }
 
-        if (tiling_params.enabled) {
+        // Video VAEs produce 4D/5D tensors that the 2D spatial tiling path cannot
+        // handle correctly; bypass spatial tiling for video encode.
+        if (tiling_params.enabled && !encode_video) {
             const int scale_factor = get_scale_factor();
             int64_t W              = input.shape()[0] / scale_factor;
             int64_t H              = input.shape()[1] / scale_factor;
@@ -169,7 +172,9 @@ struct VAE : public GGMLRunner {
         sd::Tensor<float> output;
         set_tiling_params(tiling_params);
 
-        if (tiling_params.enabled) {
+        // Video VAEs produce 4D/5D tensors that the 2D spatial tiling path cannot
+        // handle correctly; bypass spatial tiling for video decode.
+        if (tiling_params.enabled && !decode_video) {
             const int scale_factor = get_scale_factor();
             int64_t W              = input.shape()[0] * scale_factor;
             int64_t H              = input.shape()[1] * scale_factor;