Update app.py

app.py

@@ -409,11 +409,11 @@ def create_subtitle_clip_pil(text, start_time, end_time, video_width, video_heig
         logger.error(f"\u274c Failed to create subtitle clip: {e}")
         return None
 
-
 def solve_optimal_alignment(original_segments, generated_durations, total_duration):
     """
     Aligns speech segments using quadratic programming. If optimization fails,
     applies greedy fallback: center shorter segments, stretch longer ones.
+    Logs alignment results for traceability.
     """
     N = len(original_segments)
     d = np.array(generated_durations)
@@ -437,9 +437,13 @@ def solve_optimal_alignment(original_segments, generated_durations, total_durati
         for i in range(N):
             original_segments[i]['start'] = round(s.value[i], 3)
             original_segments[i]['end'] = round(s.value[i] + d[i], 3)
+            logger.info(
+                f"[OPT] Segment {i}: duration={d[i]:.2f}s | start={original_segments[i]['start']:.2f}s | "
+                f"end={original_segments[i]['end']:.2f}s | mid={m[i]:.2f}s"
+            )
 
     except Exception as e:
-        print(f"⚠️ Optimization failed: {e}, falling back to greedy alignment.")
+        logger.warning(f"⚠️ Optimization failed: {e}, falling back to greedy alignment.")
 
         for i in range(N):
             orig_start = original_segments[i]['start']
@@ -456,12 +460,10 @@ def solve_optimal_alignment(original_segments, generated_durations, total_durati
                 new_start = orig_start - extra
                 new_end = orig_end + extra
 
-                # Prevent overlap with previous
                 if i > 0:
                     prev_end = original_segments[i - 1]['end']
                     new_start = max(new_start, prev_end + 0.01)
 
-                # Prevent overlap with next
                 if i < N - 1:
                     next_start = original_segments[i + 1]['start']
                     new_end = min(new_end, next_start - 0.01)
@@ -473,6 +475,11 @@ def solve_optimal_alignment(original_segments, generated_durations, total_durati
             original_segments[i]['start'] = round(new_start, 3)
             original_segments[i]['end'] = round(new_end, 3)
 
+            logger.info(
+                f"[FALLBACK] Segment {i}: duration={gen_duration:.2f}s | start={new_start:.2f}s | "
+                f"end={new_end:.2f}s | original_mid={orig_mid:.2f}s"
+            )
+
     return original_segments
 
 def get_frame_image_bytes(video, t):
@@ -706,7 +713,10 @@ def generate_voiceover_clone(full_text, tts_model, desired_speed, target_languag
             speed=desired_speed,
             split_sentences=True
         )
-        msg = "✅ Voice cloning completed successfully."
+        msg = (
+            f"✅ Voice cloning completed successfully. "
+            f"[Speaker Wav: {speaker_wav_path}] [Speed: {desired_speed}]"
+        )
         logger.info(msg)
         return output_audio_path, msg, None
 
@@ -718,9 +728,9 @@ def generate_voiceover_clone(full_text, tts_model, desired_speed, target_languag
 
 def apply_adaptive_speed(translated_json_raw, source_language, target_language, k=3.0, default_prior_speed=5.0):
     """
-    Adds a `speed` (chars/sec) and `target_duration` (sec) field to each segment
-    using shrinkage-based estimation and language stretch ratios.
-    Optionally modulates based on tone or style tags (e.g., "dramatic", "urgent").
+    Adds `speed` (relative, 1.0 = normal speed) and `target_duration` (sec) to each segment
+    using shrinkage-based estimation, language stretch ratios, and optional style modifiers.
+    Speeds are clamped to [0.85, 1.7] to avoid unnatural TTS behavior.
     """
     translated_json = copy.deepcopy(translated_json_raw)
 
@@ -744,8 +754,8 @@ def apply_adaptive_speed(translated_json_raw, source_language, target_language,
 
     # Optional style modulation factor
     style_modifiers = {
-        "dramatic": 0.9,   # slower
-        "urgent": 1.1,     # faster
+        "dramatic": 0.9,
+        "urgent": 1.1,
         "neutral": 1.0
     }
 
@@ -758,38 +768,45 @@ def apply_adaptive_speed(translated_json_raw, source_language, target_language,
         category = entry.get("category", "drama")
         source_lang = source_language
         target_lang = target_language
-        style = entry.get("style", "neutral")  # Optional field like "dramatic"
+        style = entry.get("style", "neutral").lower()
 
         # Observed speed from original
         base_text = original_text or translated_text
         obs_speed = len(base_text) / duration
 
-        # Prior speed from category + language
+        # Prior speed
         prior_speed = priors.get((category, target_lang), default_prior_speed)
 
-        # Shrinkage estimate
+        # Shrinkage
         shrink_speed = (duration * obs_speed + k * prior_speed) / (duration + k)
 
-        # Adjust for language-specific pacing
+        # Language pacing adjustment
         ratio = lang_ratio.get((source_lang, target_lang), 1.0)
         adjusted_speed = shrink_speed * ratio
 
-        # Optional tone/style modulation (if available)
-        mod = style_modifiers.get(style.lower(), 1.0)
+        # Style modulation
+        mod = style_modifiers.get(style, 1.0)
         adjusted_speed *= mod
 
-        # Final estimated duration for synthesized segment
+        # Final relative speed (normalized to prior)
+        relative_speed = adjusted_speed / prior_speed
+
+        # Clamp relative speed to [0.85, 1.7]
+        relative_speed = max(0.85, min(1.7, relative_speed))
+
+        # Compute target duration for synthesis
         target_chars = len(translated_text)
-        target_duration = round(target_chars / adjusted_speed, 2)
+        target_duration = round(target_chars / (prior_speed * relative_speed), 2)
 
-        # Logging for debugging
+        # Logging
         logger.info(
-            f"Segment {idx}: dur={duration:.2f}s, obs={obs_speed:.2f}, "
-            f"prior={prior_speed:.2f}, shrink={shrink_speed:.2f}, "
-            f"final_speed={adjusted_speed:.2f}, target_dur={target_duration:.2f}s"
+            f"[Segment {idx}] dur={duration:.2f}s | obs_speed={obs_speed:.2f} | prior={prior_speed:.2f} | "
+            f"shrinked={shrink_speed:.2f} | lang_ratio={ratio} | style_mod={mod} | "
+            f"adj_speed={adjusted_speed:.2f} | rel_speed={relative_speed:.2f} | "
+            f"target_dur={target_duration:.2f}s"
         )
 
-        entry["speed"] = round(adjusted_speed, 3)
+        entry["speed"] = round(relative_speed, 3)
         entry["target_duration"] = target_duration
 
     return translated_json