api: generate_inpaint mask_soft_s — the kept context fades out of the conditioning before the mask edge instead of stopping at a wall

README.md

@@ -118,7 +118,7 @@ Argument order matters (positional):
 
 - `/generate` — `token, model_variant, prompt, negative_prompt, seconds, steps, cfg_scale, seed`
 - `/generate_a2a` — `token, model_variant, init_audio, prompt, negative_prompt, init_noise_level, seconds, steps, cfg_scale, seed`
-- `/generate_inpaint` — `token, model_variant, inpaint_audio, prompt, negative_prompt, mask_start_s, mask_end_s, seconds, steps, cfg_scale, seed, init_noise_level` — keeps `inpaint_audio` outside `[mask_start_s, mask_end_s]` and regenerates inside (mask_end_s 0 = to the end). Continuation: pass the previous chunk's last N seconds followed by silence, mask_start_s = N. `init_noise_level` 0 = pure inpaint; > 0 also seeds the whole clip from the same audio.
+- `/generate_inpaint` — `token, model_variant, inpaint_audio, prompt, negative_prompt, mask_start_s, mask_end_s, seconds, steps, cfg_scale, seed, init_noise_level` — keeps `inpaint_audio` outside `[mask_start_s, mask_end_s]` and regenerates inside (mask_end_s 0 = to the end). Continuation: pass the previous chunk's last N seconds followed by silence, mask_start_s = N. `init_noise_level` 0 = pure inpaint; > 0 also seeds the whole clip from the same audio. Optional 13th arg `mask_soft_s`: the kept context fades out of the conditioning over that many seconds before `mask_start_s` (0 = hard edge).
 
 `seed = -1` picks a random one; the seed actually used comes back in `meta`.
 Inputs are clamped server-side (seconds per-model cap, steps 1–100, cfg 0–15).

app.py

@@ -263,7 +263,8 @@ def _generate(variant_key: str,
               init_noise_level: Optional[float] = None,
               inpaint_audio_path: Optional[str] = None,
               mask_start_s: Optional[float] = None,
-              mask_end_s: Optional[float] = None) -> tuple[str, dict]:
+              mask_end_s: Optional[float] = None,
+              mask_soft_s: float = 0.0) -> tuple[str, dict]:
     """Returns (wav_path, meta). Inputs must already be clamped.
     inpaint_audio_path + mask_start_s/mask_end_s: the audio is kept verbatim
     outside [mask_start_s, mask_end_s] and regenerated inside it (that is how
@@ -305,8 +306,24 @@ def _generate(variant_key: str,
             model_dtype = next(lv.model.parameters()).dtype
             gen_kwargs["inpaint_audio"] = _load_init_audio(
                 inpaint_audio_path, lv.sample_rate, model_dtype)
-            gen_kwargs["inpaint_mask_start_seconds"] = float(mask_start_s)
-            gen_kwargs["inpaint_mask_end_seconds"] = float(mask_end_s)
+            if mask_soft_s and mask_soft_s > 0:
+                # Soft edge: the kept context fades out of the conditioning over
+                # mask_soft_s before mask_start_s instead of stopping at a wall.
+                # The library multiplies the encoded audio by this mask (fractional
+                # values propagate; nearest-neighbour resize to latent frames).
+                n = lv.sample_size
+                m = torch.ones(1, n, device="cuda")
+                a = int(float(mask_start_s) * lv.sample_rate)
+                b = int(float(mask_end_s) * lv.sample_rate)
+                m[:, a:b] = 0.0
+                r = int(float(mask_soft_s) * lv.sample_rate)
+                r0 = max(0, a - r)
+                if a > r0:
+                    m[:, r0:a] = torch.linspace(1.0, 0.0, a - r0, device="cuda")
+                gen_kwargs["inpaint_mask"] = m
+            else:
+                gen_kwargs["inpaint_mask_start_seconds"] = float(mask_start_s)
+                gen_kwargs["inpaint_mask_end_seconds"] = float(mask_end_s)
 
         output = generate_diffusion_cond_inpaint(lv.model, **gen_kwargs)
         output = rearrange(output, "b d n -> d (b n)")
@@ -334,6 +351,7 @@ def _generate(variant_key: str,
             init_noise_level if init_noise_level is not None else 0.4)
     if inpaint_audio_path:
         meta["inpaint_mask_s"] = [float(mask_start_s), float(mask_end_s)]
+        meta["mask_soft_s"] = float(mask_soft_s or 0.0)
     print(f"[gen] {meta}", flush=True)
     return out_path, meta
 
@@ -408,14 +426,14 @@ def api_generate_a2a(token, variant_key, init_audio, prompt, negative_prompt,
 
 def _api_duration_inpaint(token, variant_key, inpaint_audio, prompt, negative_prompt,
                           mask_start_s, mask_end_s, seconds, steps, cfg_scale, seed,
-                          init_noise_level):
+                          init_noise_level, mask_soft_s=0):
     return _gpu_seconds(seconds)
 
 
 @spaces.GPU(duration=_api_duration_inpaint)
 def api_generate_inpaint(token, variant_key, inpaint_audio, prompt, negative_prompt,
                          mask_start_s, mask_end_s, seconds, steps, cfg_scale, seed,
-                         init_noise_level):
+                         init_noise_level, mask_soft_s=0):
     """Keep inpaint_audio outside [mask_start_s, mask_end_s], regenerate inside.
     For continuation: inpaint_audio = the previous chunk's tail followed by
     anything (silence is fine) up to `seconds`; mask_start_s = tail length,
@@ -432,7 +450,8 @@ def api_generate_inpaint(token, variant_key, inpaint_audio, prompt, negative_pro
     if me <= ms:
         raise gr.Error("mask_end_s must be greater than mask_start_s.")
     noise = float(init_noise_level or 0.0)
-    kw = dict(inpaint_audio_path=inpaint_audio, mask_start_s=ms, mask_end_s=me)
+    soft = max(0.0, min(float(mask_soft_s or 0.0), ms))
+    kw = dict(inpaint_audio_path=inpaint_audio, mask_start_s=ms, mask_end_s=me, mask_soft_s=soft)
     if noise > 0:
         kw.update(init_audio_path=inpaint_audio, init_noise_level=max(0.0, min(noise, 1.0)))
     path, meta = _generate(key, prompt, negative_prompt, seconds, steps, cfg_scale, seed, **kw)
@@ -1042,13 +1061,14 @@ with gr.Blocks(theme=gr.themes.Citrus(), title="abv1 sa3 engine") as demo:
         _i_cfg = gr.Number(value=1.0, label="cfg_scale")
         _i_seed = gr.Number(value=-1, label="seed")
         _i_noise = gr.Number(value=0, label="init_noise_level (0 = pure inpaint)")
+        _i_soft = gr.Number(value=0, label="mask_soft_s (context fades out over this many s before mask_start_s; 0 = hard edge)")
         _i_file = gr.File(label="audio out")
         _i_json = gr.JSON(label="meta")
         _i_btn = gr.Button("generate_inpaint")
         _i_btn.click(
             fn=api_generate_inpaint,
             inputs=[_i_token, _i_variant, _i_audio, _i_prompt, _i_negative,
-                    _i_ms, _i_me, _i_seconds, _i_steps, _i_cfg, _i_seed, _i_noise],
+                    _i_ms, _i_me, _i_seconds, _i_steps, _i_cfg, _i_seed, _i_noise, _i_soft],
             outputs=[_i_file, _i_json],
             api_name="generate_inpaint",
             show_progress="hidden",