Update app.py

app.py

@@ -48,66 +48,17 @@ def get_duration(path):
         return -1.0
 
 
-def _concat_audios(audio_paths, per_clip_trim_seconds=0):
+def clean_audio(audio_path, trim_seconds):
     """
-    Normalize each uploaded audio to the same format (mono, 16kHz, pcm_s16le),
-    OPTIONALLY trim each one to a fixed length (per_clip_trim_seconds, e.g.
-    10/15/20s — 0 means "no trim, use full clip"), then concatenate them in
-    the order the user uploaded them, using ffmpeg's concat demuxer.
-    Normalizing first is required — concat demuxer with `-c copy` only works
-    reliably when every input already shares the same codec/sample-rate/
-    channel-layout.
-    """
-    os.makedirs("temp", exist_ok=True)
-    norm_paths = []
-    for i, p in enumerate(audio_paths):
-        norm_path = f"temp/norm_{i}.wav"
-        cmd = ["ffmpeg", "-y", "-i", p]
-        if per_clip_trim_seconds and per_clip_trim_seconds > 0:
-            cmd += ["-t", str(per_clip_trim_seconds)]
-        cmd += ["-ac", "1", "-ar", "16000", "-c:a", "pcm_s16le", norm_path]
-        subprocess.check_call(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-        norm_paths.append(norm_path)
-
-    if len(norm_paths) == 1:
-        return norm_paths[0]
-
-    list_file = "temp/concat_list.txt"
-    with open(list_file, "w") as f:
-        for p in norm_paths:
-            f.write(f"file '{os.path.abspath(p)}'\n")
-
-    combined_path = "temp/combined_audio.wav"
-    subprocess.check_call(
-        ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", list_file, "-c", "copy", combined_path],
-        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
-    )
-    return combined_path
-
-
-def clean_audio(audio_paths, per_clip_trim_seconds, max_total_seconds):
-    """
-    Cleaning pipeline (supports one OR multiple uploaded audio files):
-    - if multiple files given, concatenates them in upload order first
-    - if per_clip_trim_seconds > 0, each individual clip is trimmed to that
-      length BEFORE joining (e.g. 3 clips capped at 15s each -> ~45s total)
+    Cleaning pipeline for a single uploaded audio clip:
     - trims ONLY leading/trailing silence (mid-audio pauses/breaths are kept)
     - loudness-normalizes
     - reduces background noise
-    - THEN hard-caps the final combined result to max_total_seconds as a
-      safety limit (protects the free daily ZeroGPU quota from an
-      accidental huge upload — longer combined audio = proportionally more
-      GPU time).
+    - if trim_seconds > 0, hard-trims the final result to that length
+      (e.g. 10/15/20s). trim_seconds = 0 means "no trim, keep full clip".
     """
-    if not audio_paths:
-        raise gr.Error("Pehle kam az kam ek audio file upload karein.")
-    if isinstance(audio_paths, str):
-        audio_paths = [audio_paths]
-
-    try:
-        combined = _concat_audios(audio_paths, per_clip_trim_seconds)
-    except subprocess.CalledProcessError as e:
-        raise gr.Error(f"Audio files jodte waqt error aayi: {e}")
+    if not audio_path:
+        raise gr.Error("Pehle audio upload karein.")
 
     os.makedirs("temp", exist_ok=True)
     ffmpeg_out = "temp/ffmpeg_stage.wav"
@@ -117,7 +68,7 @@ def clean_audio(audio_paths, per_clip_trim_seconds, max_total_seconds):
     try:
         subprocess.check_call(
             [
-                "ffmpeg", "-y", "-i", combined,
+                "ffmpeg", "-y", "-i", audio_path,
                 "-af",
                 "silenceremove=start_periods=1:start_threshold=-45dB:start_silence=0.1,"
                 "areverse,"
@@ -132,15 +83,16 @@ def clean_audio(audio_paths, per_clip_trim_seconds, max_total_seconds):
     except subprocess.CalledProcessError as e:
         raise gr.Error(f"Audio clean karte waqt error aayi: {e}")
 
-    # Safety cap — combined length can't exceed the selected max
-    try:
-        subprocess.check_call(
-            ["ffmpeg", "-y", "-i", ffmpeg_out, "-t", str(max_total_seconds), trimmed_out],
-            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
-        )
-        trim_source = trimmed_out
-    except subprocess.CalledProcessError:
-        trim_source = ffmpeg_out
+    trim_source = ffmpeg_out
+    if trim_seconds and trim_seconds > 0:
+        try:
+            subprocess.check_call(
+                ["ffmpeg", "-y", "-i", ffmpeg_out, "-t", str(trim_seconds), trimmed_out],
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+            )
+            trim_source = trimmed_out
+        except subprocess.CalledProcessError:
+            trim_source = ffmpeg_out  # if trim fails, fall back to un-trimmed cleaned audio
 
     try:
         data, sr = sf.read(trim_source)
@@ -150,26 +102,24 @@ def clean_audio(audio_paths, per_clip_trim_seconds, max_total_seconds):
         out_path = trim_source
 
     final_dur = get_duration(out_path)
-    print(f"[INFO] combined+cleaned audio duration: {final_dur:.2f}s (cap={max_total_seconds}s, files={len(audio_paths)})")
+    print(f"[INFO] cleaned audio duration: {final_dur:.2f}s (trim={trim_seconds or 'none'}s)")
 
     return out_path, gr.update(interactive=True)
 
 
-def estimate_gpu_duration(avatar_image, cleaned_audio, enhance_face, still_mode, max_total_seconds, framing, progress=None):
+def estimate_gpu_duration(avatar_image, cleaned_audio, enhance_face, still_mode, trim_seconds, framing, progress=None):
     """
-    Uses the ACTUAL final cleaned/combined audio duration (via ffprobe),
-    since with multi-audio concatenation the real length can vary up to
-    the safety cap rather than always being a fixed 10/15/20s value.
+    Uses the ACTUAL final cleaned audio duration (via ffprobe) to size the
+    GPU time request accurately.
     """
     base_overhead = 40  # model load / warmup, roughly fixed
     audio_len = get_duration(cleaned_audio) if cleaned_audio else 10
     if audio_len <= 0:
-        audio_len = float(max_total_seconds) if max_total_seconds else 10
+        audio_len = float(trim_seconds) if trim_seconds else 10
 
     per_second_cost = 9 if enhance_face else 4.5
     estimated = (base_overhead + audio_len * per_second_cost) * 1.25
 
-    # Hard cap raised to comfortably cover longer multi-audio combos.
     return int(min(max(estimated, 50), 280))
 
 
@@ -293,7 +243,7 @@ def _build_attempt_plan(enhance_face, still_mode):
 
 
 @spaces.GPU(duration=estimate_gpu_duration)
-def run(avatar_image, cleaned_audio, enhance_face, still_mode, max_total_seconds, framing, progress=gr.Progress()):
+def run(avatar_image, cleaned_audio, enhance_face, still_mode, trim_seconds, framing, progress=gr.Progress()):
     if avatar_image is None:
         raise gr.Error("Pehle avatar photo upload karein.")
     if cleaned_audio is None:
@@ -334,38 +284,26 @@ def run(avatar_image, cleaned_audio, enhance_face, still_mode, max_total_seconds
 
 with gr.Blocks(title="NextGen Analytics — Avatar Talking Video (SadTalker)") as demo:
     gr.Markdown(
-        "# NextGen Analytics — Avatar Talking Video Generator (v4, SadTalker)\n"
+        "# NextGen Analytics — Avatar Talking Video Generator (v5, SadTalker)\n"
         "Head movement, eye blink, aur natural expression shamil hain.\n\n"
         "1) Avatar photo upload karein (clear, front-facing, shoulders tak visible ho to behtar)\n"
-        "2) Voice audio upload karein — **ek ya zyada files** (multiple select karein to woh order mein jud kar ek lambi video banegi)\n"
-        "3) Chahain to **har audio ko ek fix length tak trim** karein (10/15/20 sec — 'No Trim' se poori clip use hogi)\n"
-        "4) Final combined length ka safety cap choose karein (30/45/60 sec)\n"
-        "5) **Clean Audio** dabayein\n"
-        "6) **Generate Video** dabayein\n\n"
+        "2) Voice audio upload karein\n"
+        "3) Chahain to audio ko ek fix length tak **trim** karein (10/15/20 sec — 'No Trim' se poori audio use hogi)\n"
+        "4) **Clean Audio** dabayein\n"
+        "5) **Generate Video** dabayein\n\n"
         "✅ **Reliability upgrade**: Video ka duration/metadata ffprobe se verify hota hai (NaN:NaN wala issue "
         "fix), aur agar generation fail ho ya corrupt nikle to system khud-ba-khud safer settings ke saath "
-        "dobara try karta hai.\n\n"
-        "⚠️ **Note**: Lambi video (jaise 45-60 sec, kai audios jod ke) zyada ZeroGPU time leti hai — free daily "
-        "quota jaldi khatam ho sakta hai."
+        "dobara try karta hai."
     )
     with gr.Row():
         with gr.Column():
             avatar_input = gr.Image(label="Avatar Photo", type="filepath", sources=["upload"])
-            audio_input = gr.File(
-                label="Voice Audio(s) — ek ya zyada files select karein (order wahi rahega jis order mein select karenge)",
-                file_count="multiple",
-                file_types=["audio"],
-            )
-            per_clip_trim = gr.Radio(
-                label="Trim Har Audio Ko (join karne se pehle)",
-                choices=[("No Trim (poori clip use karein)", 0), ("10 sec", 10), ("15 sec", 15), ("20 sec", 20)],
+            audio_input = gr.Audio(label="Voice Audio", type="filepath", sources=["upload"])
+            trim_seconds = gr.Radio(
+                label="Trim Audio To",
+                choices=[("No Trim (poori audio use karein)", 0), ("10 sec", 10), ("15 sec", 15), ("20 sec", 20)],
                 value=0,
             )
-            max_total_seconds = gr.Radio(
-                label="Max Total Length (final safety cap — sab clips jud ne ke baad)",
-                choices=[("30 sec", 30), ("45 sec", 45), ("60 sec", 60)],
-                value=30,
-            )
             framing = gr.Radio(
                 label="Framing",
                 choices=[("Full Body / Shoulders (jaisa original photo mein hai)", "full"), ("Face Close-up (crop)", "crop")],
@@ -384,12 +322,12 @@ with gr.Blocks(title="NextGen Analytics — Avatar Talking Video (SadTalker)") a
 
     clean_btn.click(
         fn=clean_audio,
-        inputs=[audio_input, per_clip_trim, max_total_seconds],
+        inputs=[audio_input, trim_seconds],
         outputs=[cleaned_audio_preview, generate_btn],
     )
     generate_btn.click(
         fn=run,
-        inputs=[avatar_input, cleaned_audio_preview, enhance_face, still_mode, max_total_seconds, framing],
+        inputs=[avatar_input, cleaned_audio_preview, enhance_face, still_mode, trim_seconds, framing],
         outputs=[video_output],
         api_name="run",
     )