Update app.py

app.py

@@ -15,97 +15,66 @@ subprocess.run([
 # Unzip the downloaded file
 subprocess.run([
     "unzip",
+    "-o", 
     "RIFE_trained_model_v4.13.2.zip"
 ], check=True)
 
 # The name of your script
 SCRIPT_NAME = "inference_video.py"
 
-@spaces.GPU()
+@spaces.GPU(duration=120)
 def run_rife(
     input_video, 
-    model_dir, 
-    multi, 
-    exp, 
-    fps, 
-    scale, 
-    uhd, 
-    fp16, 
-    skip, 
-    montage, 
-    png_mode, 
-    ext
+    frame_multiplier, 
+    time_exponent, 
+    fixed_fps, 
+    video_scale, 
+    enable_uhd_mode, 
+    remove_duplicate_frames, 
+    create_montage
 ):
-    """
-    Constructs the command line arguments based on Gradio inputs 
-    and runs the inference_video.py script via subprocess.
-    """
-    
     if input_video is None:
         raise gr.Error("Please upload a video first.")
 
-    # 1. Define Output Filename
-    output_name = f"output_{multi}X.{ext}"
+    ext = "mp4"
+    model_dir = "train_log"
     
-    # 2. Build the Command
-    cmd = ["python3", SCRIPT_NAME]
+    video_path_wo_ext = os.path.splitext(os.path.basename(input_video))[0]
+    output_base_name = "{}_{}X_{}fps.{}".format(video_path_wo_ext, int(frame_multiplier), int(fixed_fps), ext)
     
-    # --video
+    cmd = ["python3", SCRIPT_NAME]
     cmd.extend(["--video", input_video])
+    cmd.extend(["--output", output_base_name])
+    cmd.extend(["--multi", str(int(frame_multiplier))])
     
-    # --output
-    cmd.extend(["--output", output_name])
-    
-    # --multi (Multiplier)
-    cmd.extend(["--multi", str(int(multi))])
-    
-    # --exp 
-    # Only add exp if it is not default, or if specific logic requires it. 
-    # Usually multi overrides exp in RIFE logic, but we pass it if set.
-    if exp != 1:
-        cmd.extend(["--exp", str(int(exp))])
-
-    # --fps (Target FPS)
-    if fps > 0:
-        cmd.extend(["--fps", str(int(fps))])
+    if time_exponent != 1:
+        cmd.extend(["--exp", str(int(time_exponent))])
+
+    if fixed_fps > 0:
+        cmd.extend(["--fps", str(int(fixed_fps))])
+        gr.Warning("Will not merge audio because using fps flag!")
         
-    # --scale (Resolution scale)
-    # Check against float 1.0
-    if scale != 1.0:
-        cmd.extend(["--scale", str(scale)])
+    if video_scale != 1.0:
+        cmd.extend(["--scale", str(video_scale)])
 
-    # --ext (Extension)
     cmd.extend(["--ext", ext])
+    cmd.extend(["--model", model_dir])
+    cmd.append("--fp16") 
 
-    # --model (Model directory)
-    if model_dir and model_dir.strip() != "":
-        cmd.extend(["--model", model_dir])
-
-    # --- Boolean Flags ---
-    
-    if uhd:
+    if enable_uhd_mode:
         cmd.append("--UHD")
         
-    if fp16:
-        cmd.append("--fp16")
-        
-    if skip:
+    if remove_duplicate_frames:
         cmd.append("--skip")
         
-    if montage:
+    if create_montage:
         cmd.append("--montage")
-        
-    if png_mode:
-        cmd.append("--png")
 
     print(f"Executing command: {' '.join(cmd)}")
 
-    # 3. Run the Subprocess
     try:
-        # We use a large timeout because video processing takes time
         process = subprocess.run(cmd, capture_output=True, text=True)
         
-        # Log stdout/stderr
         if process.stdout:
             print("STDOUT:", process.stdout)
         if process.stderr:
@@ -114,15 +83,14 @@ def run_rife(
         if process.returncode != 0:
             raise gr.Error(f"Inference failed. Error: {process.stderr}")
 
-        # 4. Return Result
-        if png_mode:
-            gr.Info("Processing complete. Output is a folder of PNGs (Video preview unavailable for PNG mode).")
-            return None 
+        final_output_file = f"{output_base_name}.{ext}"
         
-        if os.path.exists(output_name):
-            return output_name
+        if os.path.exists(final_output_file):
+            return final_output_file
         else:
-            raise gr.Error("Output file was not found. Check console for details.")
+            if os.path.exists(output_base_name):
+                return output_base_name
+            raise gr.Error(f"Output file not found. Expected: {final_output_file}")
 
     except Exception as e:
         raise gr.Error(f"An error occurred: {str(e)}")
@@ -130,111 +98,82 @@ def run_rife(
 
 # --- Gradio UI Layout ---
 
-with gr.Blocks(title="RIFE Video Interpolation") as app:
-    gr.Markdown("# 🚀 RIFE: Real-Time Intermediate Flow Estimation")
-    gr.Markdown("Upload a video to increase its frame rate (smoothness) using AI.")
+with gr.Blocks(title="Professional FPS Booster") as app:
+    gr.Markdown("# ⚡ RIFE: High-Performance FPS Booster")
+    gr.Markdown("Maximize video fluidity and frame rate using deep flow estimation.")
+    gr.Markdown("⚠️ **Tip:** Optimized for short videos. Avoid long videos to prevent 'GPU task aborted'.")
 
     with gr.Row():
         # --- Left Column: Inputs & Settings ---
         with gr.Column(scale=1):
-            input_vid = gr.Video(label="Input Video", sources=["upload"])
+            input_vid = gr.Video(label="🎬 Input Source Video", sources=["upload"])
             
             with gr.Group():
-                gr.Markdown("### 🎯 Core Parameters")
+                gr.Markdown("### 🚀 Performance Settings")
                 
-                with gr.Row():
-                    multi_param = gr.Dropdown(
-                        choices=["2", "4", "8", "16", "32"], 
-                        value="2", 
-                        label="Interpolation Multiplier (--multi)",
-                        info="How many times to multiply the frames. 2X doubles the FPS (e.g., 30fps -> 60fps). 4X quadruples it."
-                    )
-                    ext_param = gr.Dropdown(
-                        choices=["mp4", "avi", "mov", "mkv"], 
-                        value="mp4", 
-                        label="Output Format (--ext)",
-                        info="The file extension for the generated video."
-                    )
-                
-                model_param = gr.Textbox(
-                    value="train_log", 
-                    label="Model Directory (--model)", 
-                    placeholder="train_log",
-                    info="Path to the folder containing the trained model files (e.g., 'train_log' or 'rife-v4.6')."
+                multi_param = gr.Dropdown(
+                    choices=["2", "3", "4", "5", "6"], 
+                    value="2", 
+                    label="⚡ Frame Multiplier",
+                    info="2X = Double FPS (e.g. 30 -> 60). Higher multipliers create more intermediate frames."
                 )
 
-            with gr.Accordion("⚙️ Advanced Settings", open=False):
-                gr.Markdown("Fine-tune the inference process.")
+            with gr.Accordion("🛠️ Advanced Configuration", open=False):
+                gr.Markdown("Control rendering parameters.")
                 
                 with gr.Row():
                     scale_param = gr.Slider(
                         minimum=0.1, maximum=1.0, value=1.0, step=0.1, 
-                        label="Input Scale (--scale)", 
-                        info="1.0 = Original resolution. Set to 0.5 to reduce memory usage for 4K video inputs."
+                        label="📉 Render Scale", 
+                        info="1.0 = Original Resolution. Reduce to 0.5 for faster processing on 4K content."
                     )
                     fps_param = gr.Number(
                         value=0, 
-                        label="Force Target FPS (--fps)", 
-                        info="0 = Auto-calculate based on multiplier. Enter a number (e.g., 60) to force a specific output frame rate."
+                        label="🎯 Force Output FPS", 
+                        info="0 = Auto-calculate. Set to 30 or 60 to lock the framerate. Audio will be removed when forcing FPS"
                     )
                     exp_param = gr.Number(
                         value=1, 
-                        label="Exponent Power (--exp)", 
-                        info="Alternative to Multiplier. Sets multiplier to 2^exp. (Usually left at 1 if Multiplier is set)."
+                        label="🔢 Exponent Power", 
+                        info="Alternative multiplier calculation (2^exp)."
                     )
 
                 with gr.Row():
                     uhd_chk = gr.Checkbox(
-                        label="UHD Mode (--UHD)", 
+                        label="💎 UHD/4K Optimization", 
                         value=False,
-                        info="Optimized for 4K video. Equivalent to setting scale=0.5 manually."
-                    )
-                    fp16_chk = gr.Checkbox(
-                        label="FP16 Mode (--fp16)", 
-                        value=True, 
-                        info="Uses half-precision floating point. Faster and uses less VRAM with minimal quality loss."
+                        info="Enable for high-resolution sources."
                     )
-                
-                with gr.Row():
                     skip_chk = gr.Checkbox(
-                        label="Skip Static Frames (--skip)", 
+                        label="⏩ Skip Static Frames", 
                         value=False,
-                        info="If the video has frames that don't move, skip processing them to save time."
+                        info="Bypass processing for non-moving scenes to save time."
                     )
                     montage_chk = gr.Checkbox(
-                        label="Montage (--montage)", 
-                        value=False,
-                        info="Creates a video with the Original on the Left and Interpolated on the Right for comparison."
-                    )
-                    png_chk = gr.Checkbox(
-                        label="Output as PNGs (--png)", 
+                        label="🆚 Split-Screen Comparison", 
                         value=False,
-                        info="Outputs a sequence of images instead of a video file. (Video Preview will be disabled)."
+                        info="Output video showing Original vs. Processed."
                     )
 
-            btn_run = gr.Button("✨ Start Interpolation", variant="primary", size="lg")
+            btn_run = gr.Button("🚀 RENDER HIGH FPS VIDEO", variant="primary", size="lg")
 
         # --- Right Column: Output ---
         with gr.Column(scale=1):
-            output_vid = gr.Video(label="Interpolated Result")
-            gr.Markdown("**Note:** Processing time depends on video length, resolution, and your GPU speed.")
+            output_vid = gr.Video(label="⚡ High FPS Result")
+            gr.Markdown("**Status:** Rendering time depends on input resolution and duration.")
 
     # --- Bind Logic ---
     btn_run.click(
         fn=run_rife,
         inputs=[
             input_vid, 
-            model_param, 
             multi_param, 
             exp_param, 
             fps_param, 
             scale_param, 
             uhd_chk, 
-            fp16_chk, 
             skip_chk, 
-            montage_chk, 
-            png_chk, 
-            ext_param
+            montage_chk
         ],
         outputs=output_vid
     )