Update app.py

app.py

@@ -1,179 +1,344 @@
-import gradio as gr, subprocess, os, tempfile, glob, time
+import gradio as gr
+import subprocess
+import os
+import tempfile
+import glob
+import time
+
 
 def p(x):
-    return x if isinstance(x,str) else (x.get("path") or x.get("name") if isinstance(x,dict) else None)
+    return x if isinstance(x, str) else (x.get("path") or x.get("name") if isinstance(x, dict) else None)
+
 
 def meta(v):
-    r=subprocess.run(["ffprobe","-v","error","-select_streams","v:0",
-        "-show_entries","stream=width,height,r_frame_rate,duration",
-        "-of","default=noprint_wrappers=1",v],capture_output=True,text=True,check=True)
-    d=dict(x.split("=",1) for x in r.stdout.strip().splitlines())
-    a=d["r_frame_rate"].split("/")
-    return int(d["width"]),int(d["height"]),float(a[0])/float(a[1]),float(d["duration"])
+    r = subprocess.run(
+        [
+            "ffprobe", "-v", "error", "-select_streams", "v:0",
+            "-show_entries", "stream=width,height,r_frame_rate,duration",
+            "-of", "default=noprint_wrappers=1", v,
+        ],
+        capture_output=True, text=True, check=True,
+    )
+    d = dict(x.split("=", 1) for x in r.stdout.strip().splitlines())
+    a = d["r_frame_rate"].split("/")
+    return int(d["width"]), int(d["height"]), float(a[0]) / float(a[1]), float(d["duration"])
+
 
 def audio_meta(a):
-    """Fetches the duration of the audio file in seconds."""
+    """Fetch the duration of an audio file in seconds."""
     try:
-        r = subprocess.run(["ffprobe","-v","error","-show_entries",
-            "format=duration","-of","default=noprint_wrappers=1:nokey=1",a],
-            capture_output=True,text=True,check=True)
+        r = subprocess.run(
+            [
+                "ffprobe", "-v", "error", "-show_entries", "format=duration",
+                "-of", "default=noprint_wrappers=1:nokey=1", a,
+            ],
+            capture_output=True, text=True, check=True,
+        )
         return float(r.stdout.strip())
     except Exception:
         return 0.0
 
-def save_frames(v,t,n):
-    v=p(v)
-    if not v:return [],None,"Upload a video."
+
+def save_frames(v, t, n):
+    v = p(v)
+    if not v:
+        return [], None, "Upload a video."
     try:
-        t=float(t); n=int(n); w,h,fps,dur=meta(v)
-        if n<1:return [],None,"Number of frames must be at least 1."
-        if t<0 or t>=dur:return [],None,f"Time must be between 0 and {dur:.3f}s."
-
-        d=tempfile.mkdtemp(); pat=os.path.join(d,"f_%06d.png")
-        r=subprocess.run(["ffmpeg","-y","-ss",str(t),"-i",v,
-            "-frames:v",str(n),"-vsync","0",pat],capture_output=True,text=True)
-        if r.returncode:return [],None,r.stderr
-
-        fs=sorted(glob.glob(os.path.join(d,"f_*.png")))
-        if not fs:return [],None,"No frames found."
-
-        return [(f,f"Frame {i+1}") for i,f in enumerate(fs)],\
-            {"v":v,"d":d,"fs":fs,"fps":fps,"w":w,"h":h, "dur":dur},\
-            f"✅ Extracted {len(fs)} frame(s) from {t:.3f}s"
-    except Exception as e:return [],None,str(e)
-
-def extract_last(v,n):
-    v=p(v)
-    if not v:return [],None,"Upload a video."
+        t = float(t)
+        n = int(n)
+        w, h, fps, dur = meta(v)
+        if n < 1:
+            return [], None, "Number of frames must be at least 1."
+        if t < 0 or t >= dur:
+            return [], None, f"Time must be between 0 and {dur:.3f}s."
+
+        d = tempfile.mkdtemp()
+        pat = os.path.join(d, "f_%06d.png")
+        r = subprocess.run(
+            ["ffmpeg", "-y", "-ss", str(t), "-i", v,
+             "-frames:v", str(n), "-vsync", "0", pat],
+            capture_output=True, text=True,
+        )
+        if r.returncode:
+            return [], None, r.stderr
+
+        fs = sorted(glob.glob(os.path.join(d, "f_*.png")))
+        if not fs:
+            return [], None, "No frames found."
+
+        return (
+            [(f, f"Frame {i + 1}") for i, f in enumerate(fs)],
+            {"v": v, "d": d, "fs": fs, "fps": fps, "w": w, "h": h, "dur": dur},
+            f"✅ Extracted {len(fs)} frame(s) from {t:.3f}s",
+        )
+    except Exception as e:
+        return [], None, str(e)
+
+
+def extract_last(v, n):
+    v = p(v)
+    if not v:
+        return [], None, "Upload a video."
     try:
-        n=int(n); w,h,fps,dur=meta(v)
-        if n<1:return [],None,"Number of frames must be at least 1."
+        n = int(n)
+        _, _, fps, dur = meta(v)
+        if n < 1:
+            return [], None, "Number of frames must be at least 1."
+        t = max(0, dur - (n / fps))
+        return save_frames(v, t, n)
+    except Exception as e:
+        return [], None, str(e)
+
+
+
+def apply_speed_to_video(input_path, speed_factor):
+    """Change the playback speed of the complete compiled video and its audio."""
+    speed_factor = float(speed_factor)
+    if not 0.5 <= speed_factor <= 1.5:
+        raise ValueError("Playback speed must be between 0.5x and 1.5x.")
+    if abs(speed_factor - 1.0) < 1e-9:
+        return input_path
+
+    # Detect whether the compiled video has an audio stream.
+    probe = subprocess.run(
+        [
+            "ffprobe", "-v", "error", "-select_streams", "a:0",
+            "-show_entries", "stream=index", "-of", "csv=p=0", input_path,
+        ],
+        capture_output=True, text=True,
+    )
+    has_audio = probe.returncode == 0 and bool(probe.stdout.strip())
+    sped_path = os.path.join(
+        tempfile.mkdtemp(), f"speed_{int(time.time() * 1000)}.mp4"
+    )
+
+    common = [
+        "ffmpeg", "-y", "-i", input_path,
+    ]
+    if has_audio:
+        # setpts makes the video faster/slower; atempo applies the same factor to audio.
+        cmd = common + [
+            "-filter_complex",
+            f"[0:v:0]setpts=PTS/{speed_factor}[v];[0:a:0]atempo={speed_factor}[a]",
+            "-map", "[v]", "-map", "[a]",
+            "-c:v", "libx264", "-crf", "18", "-preset", "medium",
+            "-c:a", "aac", "-b:a", "192k",
+            "-movflags", "+faststart", sped_path,
+        ]
+    else:
+        cmd = common + [
+            "-vf", f"setpts=PTS/{speed_factor}",
+            "-map", "0:v:0", "-an",
+            "-c:v", "libx264", "-crf", "18", "-preset", "medium",
+            "-movflags", "+faststart", sped_path,
+        ]
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode:
+        raise RuntimeError(result.stderr or "Could not change playback speed.")
+    return sped_path
+
+
+def finish_video(out, msg, speed_factor):
+    """Apply the selected speed to the full result and update the status message."""
+    speed_factor = float(speed_factor)
+    if abs(speed_factor - 1.0) < 1e-9:
+        msg += " Playback speed: normal (1.0x)."
+    else:
+        out = apply_speed_to_video(out, speed_factor)
+        if speed_factor < 1.0:
+            msg += f" Playback slowed to {speed_factor:.1f}x."
+        else:
+            msg += f" Playback sped up to {speed_factor:.1f}x."
+    return out, msg
 
-        t=max(0,dur-(n/fps))
-        return save_frames(v,t,n)
-    except Exception as e:return [],None,str(e)
 
-def make_video(s, video_in, audio_in):
+def make_video(s, video_in, audio_in, trim_frames=0, speed_factor=1.0):
+    """Compile extracted frames before the source video, optionally skipping its first N frames."""
     v_path = p(video_in)
     audio_path = p(audio_in)
 
     if not v_path:
         return None, "Upload a video first."
-    
-    # If no frames extracted AND no audio uploaded
-    if not s and not audio_path:
-        return None, "Extract frames first OR upload an audio file to replace."
 
+    has_frames = bool(s and s.get("fs"))
     try:
+        trim_frames = int(trim_frames or 0)
+        speed_factor = float(speed_factor if speed_factor is not None else 1.0)
+        if trim_frames < 0:
+            return None, "Initial frames to remove must be 0 or greater."
+        if not 0.5 <= speed_factor <= 1.5:
+            return None, "Playback speed must be between 0.5x and 1.5x."
+        if trim_frames > 0 and not has_frames:
+            return None, "Extract frames first to use the initial-frame trimming feature."
+
+        if not has_frames and not audio_path:
+            return None, "Extract frames first OR upload an audio file to replace."
+
         out = os.path.join(tempfile.mkdtemp(), f"final_{int(time.time())}.mp4")
-        
-        # Check if we have extracted frames
-        has_frames = bool(s and s.get("fs"))
-        
+
         if has_frames:
             d_s, v, fs, fps, dur = s["d"], s["v"], s["fs"], s["fps"], s["dur"]
-            total_vid_dur = dur + (len(fs) / fps)
+            trim_seconds = trim_frames / fps
+            if trim_seconds >= dur:
+                return None, f"Cannot remove {trim_frames} frame(s): the video is only {dur:.3f}s long."
+
+            intro_duration = len(fs) / fps
+            total_vid_dur = (dur - trim_seconds) + intro_duration
             intro = os.path.join(d_s, "intro.mp4")
-            
-            # 1. Create intro block
-            r = subprocess.run(["ffmpeg","-y","-framerate",str(fps),
-                "-i",os.path.join(d_s,"f_%06d.png"),
-                "-c:v","libx264","-crf","18","-preset","medium",
-                "-pix_fmt","yuv420p",intro], capture_output=True, text=True)
-            if r.returncode: return None, r.stderr
+
+            # Turn the extracted PNG sequence into a short video.
+            r = subprocess.run(
+                [
+                    "ffmpeg", "-y", "-framerate", str(fps),
+                    "-i", os.path.join(d_s, "f_%06d.png"),
+                    "-c:v", "libx264", "-crf", "18", "-preset", "medium",
+                    "-pix_fmt", "yuv420p", intro,
+                ],
+                capture_output=True, text=True,
+            )
+            if r.returncode:
+                return None, r.stderr
+
+            # Drop the specified number of initial source-video frames, reset timestamps,
+            # and place the extracted frame sequence before the remaining source video.
+            concat_filter = (
+                f"[1:v]trim=start_frame={trim_frames},setpts=PTS-STARTPTS[vtrim];"
+                "[0:v][vtrim]concat=n=2:v=1:a=0[v]"
+            )
         else:
-            # Fallback if no frames were extracted
+            # Audio replacement without extracted frames retains the original video.
             _, _, _, dur = meta(v_path)
             total_vid_dur = dur
-            v = v_path # Just use the original video
+            v = v_path
             fs = []
+            trim_seconds = 0.0
+            intro = None
+            concat_filter = None
 
-        # 2. Combine Logic
         if audio_path:
             a_dur = audio_meta(audio_path)
             loop_args = ["-stream_loop", "-1"] if (total_vid_dur - a_dur) > 1.0 else []
-            
+
             if has_frames:
-                # Scenario A: Frames + Audio Replacement
-                cmd = ["ffmpeg", "-y", "-i", intro, "-i", v] + loop_args + ["-i", audio_path,
-                    "-filter_complex", "[0:v][1:v]concat=n=2:v=1:a=0[v]",
-                    "-map", "[v]", "-map", "2:a",
-                    "-t", str(total_vid_dur),
-                    "-c:v", "libx264", "-crf", "18", "-preset", "medium",
-                    "-c:a", "aac", "-b:a", "192k", "-movflags", "+faststart", out]
+                cmd = (
+                    ["ffmpeg", "-y", "-i", intro, "-i", v]
+                    + loop_args
+                    + [
+                        "-i", audio_path,
+                        "-filter_complex", concat_filter,
+                        "-map", "[v]", "-map", "2:a",
+                        "-t", str(total_vid_dur),
+                        "-c:v", "libx264", "-crf", "18", "-preset", "medium",
+                        "-c:a", "aac", "-b:a", "192k", "-movflags", "+faststart", out,
+                    ]
+                )
             else:
-                # Scenario B: NO Frames + Audio Replacement ONLY
-                # We use "-c:v copy" here which is instantaneous since we aren't merging videos
-                cmd = ["ffmpeg", "-y", "-i", v] + loop_args + ["-i", audio_path,
-                    "-map", "0:v", "-map", "1:a",
-                    "-t", str(total_vid_dur),
-                    "-c:v", "copy",
-                    "-c:a", "aac", "-b:a", "192k", "-movflags", "+faststart", out]
-                    
-            r = subprocess.run(cmd, capture_output=True, text=True)
-            if r.returncode: return None, r.stderr
-            
-            msg = f"✅ Final video created."
-            if has_frames: msg += f" Added {len(fs)} frame(s)."
-            if loop_args: msg += f" Audio looped (was {total_vid_dur - a_dur:.1f}s short)."
-            else: msg += " Audio matched to video length."
-            return out, msg
-            
-        else:
-            # Scenario C: Frames added + Keep Original Audio
-            cmd = ["ffmpeg","-y","-i",intro,"-i",v,
-                "-filter_complex","[0:v][1:v]concat=n=2:v=1:a=0[v]",
-                "-map","[v]","-map","1:a?",
-                "-c:v","libx264","-crf","18","-preset","medium",
-                "-c:a","copy","-movflags","+faststart",out]
-                
+                cmd = (
+                    ["ffmpeg", "-y", "-i", v]
+                    + loop_args
+                    + [
+                        "-i", audio_path,
+                        "-map", "0:v", "-map", "1:a",
+                        "-t", str(total_vid_dur),
+                        "-c:v", "copy", "-c:a", "aac", "-b:a", "192k",
+                        "-movflags", "+faststart", out,
+                    ]
+                )
+
             r = subprocess.run(cmd, capture_output=True, text=True)
-            if r.returncode: return None, r.stderr
-            return out, f"✅ Added {len(fs)} frame(s) to beginning (original audio kept)."
+            if r.returncode:
+                return None, r.stderr
+
+            msg = "✅ Final video created."
+            if has_frames:
+                msg += f" Added {len(fs)} frame(s)."
+            if trim_frames:
+                msg += f" Removed the first {trim_frames} source frame(s) ({trim_seconds:.3f}s)."
+            if loop_args:
+                msg += f" Audio looped (was {total_vid_dur - a_dur:.1f}s short)."
+            else:
+                msg += " Audio matched to video length."
+            return finish_video(out, msg, speed_factor)
+
+        # Keep the source video's audio if no replacement audio was uploaded.
+        cmd = [
+            "ffmpeg", "-y", "-i", intro, "-i", v,
+            "-filter_complex", concat_filter,
+            "-map", "[v]", "-map", "1:a?",
+            "-t", str(total_vid_dur),
+            "-c:v", "libx264", "-crf", "18", "-preset", "medium",
+            "-c:a", "copy", "-movflags", "+faststart", out,
+        ]
+        r = subprocess.run(cmd, capture_output=True, text=True)
+        if r.returncode:
+            return None, r.stderr
+
+        msg = f"✅ Added {len(fs)} frame(s) to the beginning (original audio kept)."
+        if trim_frames:
+            msg += f" Removed the first {trim_frames} source frame(s) ({trim_seconds:.3f}s)."
+        return finish_video(out, msg, speed_factor)
 
     except Exception as e:
         return None, str(e)
 
+
 with gr.Blocks(title="Video Frame Editor") as demo:
     gr.Markdown("# 🎬 Video Frame Editor")
 
     with gr.Row():
-        video=gr.Video(label="Input Video")
-        audio_in=gr.Audio(type="filepath", label="Upload New Final Audio (Optional)")
+        video = gr.Video(label="Input Video")
+        audio_in = gr.Audio(type="filepath", label="Upload New Final Audio (Optional)")
 
     with gr.Row():
-        start=gr.Number(value=0,label="Start Time (seconds)")
-        count=gr.Number(value=1,minimum=1,precision=0,label="Number of Frames")
+        start = gr.Number(value=0, label="Start Time (seconds)")
+        count = gr.Number(value=1, minimum=1, precision=0, label="Number of Frames to Extract")
+        trim_count = gr.Number(
+            value=0,
+            minimum=0,
+            precision=0,
+            label="Initial Frames to Remove from Original Video",
+            info="Set to 0 to keep the original beginning. This applies when extracted frames are added first.",
+        )
+
+    speed_factor = gr.Slider(
+        minimum=0.5,
+        maximum=1.5,
+        value=1.0,
+        step=0.1,
+        label="Whole Video Playback Speed",
+        info="0.5x = half speed, 1.0x = normal speed, 1.5x = 50% faster. Audio speed changes too.",
+    )
 
     with gr.Row():
-        extract_btn=gr.Button("🎞️ Extract From Time",variant="primary")
-        last_btn=gr.Button("⏮️ Extract From Last")
+        extract_btn = gr.Button("🎞️ Extract From Time", variant="primary")
+        last_btn = gr.Button("⏮️ Extract From Last")
 
-    gallery=gr.Gallery(label="Extracted Frames",columns=5,object_fit="contain")
-    state=gr.State()
-    status=gr.Textbox(label="Status")
+    gallery = gr.Gallery(label="Extracted Frames", columns=5, object_fit="contain")
+    state = gr.State()
+    status = gr.Textbox(label="Status")
 
-    copy_btn=gr.Button("📋 Compile Final Video",variant="primary")
-    output=gr.Video(label="Final Video")
-    output_status=gr.Textbox(label="Output Status")
+    copy_btn = gr.Button("📋 Compile Final Video", variant="primary")
+    output = gr.Video(label="Final Video")
+    output_status = gr.Textbox(label="Output Status")
 
     extract_btn.click(
         fn=save_frames,
-        inputs=[video,start,count],
-        outputs=[gallery,state,status]
+        inputs=[video, start, count],
+        outputs=[gallery, state, status],
     )
 
     last_btn.click(
         fn=extract_last,
-        inputs=[video,count],
-        outputs=[gallery,state,status]
+        inputs=[video, count],
+        outputs=[gallery, state, status],
     )
 
-    # We now pass the original 'video' variable directly alongside state and audio
     copy_btn.click(
         fn=make_video,
-        inputs=[state, video, audio_in],
-        outputs=[output,output_status]
+        inputs=[state, video, audio_in, trim_count, speed_factor],
+        outputs=[output, output_status],
     )
 
-demo.launch(server_name="0.0.0.0",server_port=7860)
+
+demo.launch(server_name="0.0.0.0", server_port=7860)