Update float_streamer.py

float_streamer.py

@@ -300,15 +300,12 @@ class FloatStreamer:
 
     def _generate_idle_chunk(self):
         """Generate one chunk of idle motion using proper silence features + dampening.
-        After speech ends, gradually increases dampening over several chunks for smooth transition."""
+        Uses fixed seed for consistent x0 noise — prevents flicker at chunk boundaries."""
         
         if self._transition_chunks > 0:
-            # Gradual transition: interpolate dampening from 1.0 (speech) to target (idle)
-            # 3→1.0, 2→0.78, 1→0.55 (or similar smooth curve)
-            progress = self._transition_chunks / 3.0  # 1.0 → 0.33
+            progress = self._transition_chunks / 3.0
             damp = 1.0 * progress + self._idle_dampening * (1.0 - progress)
             self._transition_chunks -= 1
-            logger.debug(f"[STREAMER] Transition chunk: dampening={damp:.2f}, remaining={self._transition_chunks}")
         else:
             damp = self._idle_dampening
 
@@ -319,6 +316,7 @@ class FloatStreamer:
             a_cfg_scale=1.0,
             e_cfg_scale=1.0,
             dampening=damp,
+            fixed_seed=42,
         )
 
     def _make_speech_start_callback(self, event):
@@ -342,14 +340,14 @@ class FloatStreamer:
         return SpeechStartCallback()
 
     @torch.no_grad()
-    def _generate_chunk(self, wa, we, actual_frames=None, a_cfg_scale=None, e_cfg_scale=None, dampening=None, pre_decode_callback=None):
+    def _generate_chunk(self, wa, we, actual_frames=None, a_cfg_scale=None, e_cfg_scale=None, dampening=None, pre_decode_callback=None, fixed_seed=None):
         """
         Generate one 50-frame chunk and push decoded frames to buffer.
         
         Args:
-            pre_decode_callback: if set, called after ODE solve but before frame decode.
-                                 Used to drain buffer and fire speech_start at the exact right moment.
-            dampening: multiply motion latent by this factor (idle: reduces motion amplitude)
+            pre_decode_callback: object with drain()/fire() for speech sync.
+            dampening: multiply motion latent by this factor (display-only, not saved to prev_x).
+            fixed_seed: if set, use deterministic x0 noise for chunk consistency.
         """
         if actual_frames is None:
             actual_frames = self.frames_per_chunk
@@ -367,8 +365,13 @@ class FloatStreamer:
             prev_x = self.prev_x
             prev_wa = self.prev_wa
 
-        # Random initial noise for ODE
-        x0 = torch.randn(1, self.frames_per_chunk, self.opt.dim_w, device=self.device)
+        # Initial noise for ODE — fixed seed for idle consistency
+        if fixed_seed is not None:
+            g = torch.Generator(device=self.device)
+            g.manual_seed(fixed_seed)
+            x0 = torch.randn(1, self.frames_per_chunk, self.opt.dim_w, device=self.device, generator=g)
+        else:
+            x0 = torch.randn(1, self.frames_per_chunk, self.opt.dim_w, device=self.device)
 
         # Time steps for ODE solver
         time_steps = torch.linspace(0, 1, self.opt.nfe, device=self.device)
@@ -396,27 +399,29 @@ class FloatStreamer:
                            method=self.opt.torchdiffeq_ode_method)
         sample = trajectory[-1]  # (1, frames_per_chunk, dim_w)
 
-        # Apply dampening to motion latent (idle: reduces all motion including mouth)
-        # This matches idle_generator.py's approach of scaling r_d
-        if dampening is not None:
-            sample = sample * dampening
-
         t_ode = time.time() - t0
 
-        # Update state for next chunk
+        # Update state for next chunk BEFORE dampening
+        # The model expects undampened prev_x context — dampening is display-only
         with self._lock:
             self.prev_x = sample[:, -self.num_prev_frames:].clone()
             self.prev_wa = wa[:, -self.num_prev_frames:].clone()
 
-        # Decode latent to pixel frames and push to buffer
+        # Apply dampening AFTER saving state (display-only, doesn't affect next chunk)
+        if dampening is not None:
+            sample = sample * dampening
+
         # Skip if this is an idle chunk and speech has arrived (discard stale idle)
         if dampening is not None and self._discard_idle_frames:
             logger.info("[STREAMER] Discarding idle chunk — speech arriving")
             return
 
-        # If this is the first speech chunk, drain idle frames BEFORE decoding
+        # For first speech chunk: drain idle frames then fire speech_start
+        # Both BEFORE decode — so client gets event before any speech frames
+        # WS loop checks events first, then frames, so audio starts with first frame
         if pre_decode_callback:
             pre_decode_callback.drain()
+            pre_decode_callback.fire()
 
         t_dec = time.time()
         for t in range(min(actual_frames, sample.shape[1])):
@@ -435,10 +440,6 @@ class FloatStreamer:
             except queue.Full:
                 logger.warning("[STREAMER] Frame buffer full, dropping frame")
 
-        # Fire speech_start AFTER frames are in buffer — audio and video start together
-        if pre_decode_callback:
-            pre_decode_callback.fire()
-
         t_dec_done = time.time()
         logger.debug(f"[STREAMER] Chunk: ODE={t_ode:.2f}s decode={t_dec_done-t_dec:.2f}s "
                      f"frames={actual_frames} total={t_dec_done-t0:.2f}s")