Create app.py

app.py

@@ -0,0 +1,183 @@
+import os
+import sys
+import shutil
+import subprocess
+import glob
+import importlib.util
+import gradio as gr
+
+# --- Constants ---
+BASE_DIR = os.getcwd()
+RIFE_DIR = os.path.join(BASE_DIR, "Practical-RIFE")
+MODEL_URL = "https://huggingface.co/hzwer/RIFE/resolve/main/RIFEv4.26_0921.zip"
+
+def run_command(command):
+    """Helper to run shell commands"""
+    subprocess.run(command, shell=True, check=True)
+
+def setup_environment():
+    """
+    1. Clones the RIFE repo.
+    2. Downloads weights.
+    3. Re-organizes folders (User's Fix).
+    4. Patches scikit-video.
+    """
+    print("--- Starting Environment Setup ---")
+
+    # 1. Clone Repo if not exists
+    if not os.path.exists(RIFE_DIR):
+        print("Cloning Practical-RIFE...")
+        run_command(f"git clone https://github.com/hzwer/Practical-RIFE {RIFE_DIR}")
+    
+    # 2. Download and Organize Weights
+    # We check if 'HDv3' exists to avoid re-downloading on restart
+    if not os.path.exists(os.path.join(RIFE_DIR, "HDv3")):
+        print("Downloading RIFE v4.26 model weights...")
+        zip_path = os.path.join(RIFE_DIR, "RIFEv4.26_0921.zip")
+        
+        # Download
+        run_command(f"wget -O {zip_path} {MODEL_URL}")
+        
+        # Unzip
+        print("Unzipping...")
+        run_command(f"unzip -o {zip_path} -d {RIFE_DIR}")
+        
+        # --- APPLY USER'S DIRECTORY FIX ---
+        print("Applying directory structure fix...")
+        
+        # Create train_log
+        train_log_dir = os.path.join(RIFE_DIR, "train_log")
+        os.makedirs(train_log_dir, exist_ok=True)
+        
+        # Move Python files
+        extract_folder = os.path.join(RIFE_DIR, "RIFEv4.26_0921")
+        shutil.move(os.path.join(extract_folder, "RIFE_HDv3.py"), train_log_dir)
+        shutil.move(os.path.join(extract_folder, "IFNet_HDv3.py"), train_log_dir)
+        
+        # Create __init__.py
+        with open(os.path.join(train_log_dir, "__init__.py"), 'w') as f:
+            pass
+            
+        # Create HDv3 and move weights
+        hdv3_dir = os.path.join(RIFE_DIR, "HDv3")
+        os.makedirs(hdv3_dir, exist_ok=True)
+        shutil.move(os.path.join(extract_folder, "flownet.pkl"), hdv3_dir)
+        
+        # Cleanup
+        shutil.rmtree(extract_folder)
+        if os.path.exists(zip_path):
+            os.remove(zip_path)
+            
+        print("Files moved and directories created.")
+
+    # 3. Patch skvideo (The numpy fix)
+    print("Checking skvideo for necessary patches...")
+    try:
+        spec = importlib.util.find_spec('skvideo.io.abstract')
+        if spec and spec.origin:
+            abstract_path = spec.origin
+            
+            # Read file to see if patching is needed
+            with open(abstract_path, 'r') as f:
+                content = f.read()
+            
+            if 'np.float' in content or 'np.int' in content:
+                print(f"Patching {abstract_path}...")
+                run_command(f"sed -i 's/np.float/float/g' {abstract_path}")
+                run_command(f"sed -i 's/np.int/int/g' {abstract_path}")
+                print("skvideo patched.")
+            else:
+                print("skvideo already patched or compatible.")
+    except Exception as e:
+        print(f"Warning: Could not patch skvideo: {e}")
+
+    # 4. Patch inference_video.py for libx264
+    inference_script = os.path.join(RIFE_DIR, "inference_video.py")
+    if os.path.exists(inference_script):
+        # Read to check if already patched
+        with open(inference_script, 'r') as f:
+            script_content = f.read()
+        
+        if "libx264" not in script_content:
+            print("Patching inference_video.py for libx264...")
+            # Replicating the sed command using python replace for safety
+            new_content = script_content.replace(
+                "-c:v', 'mpeg4', '-qscale:v', '1'", 
+                "-c:v', 'libx264', '-preset', 'medium', '-crf', '23'"
+            )
+            with open(inference_script, 'w') as f:
+                f.write(new_content)
+
+    print("--- Setup Complete ---")
+
+# Run Setup immediately upon app launch
+setup_environment()
+
+def interpolate_video(input_video_path):
+    if input_video_path is None:
+        return None
+
+    print(f"Processing video: {input_video_path}")
+    
+    output_path = os.path.join(BASE_DIR, "output_rife.mp4")
+    final_output_path = os.path.join(BASE_DIR, "final_output.mp4")
+
+    # Clean up previous runs
+    if os.path.exists(output_path): os.remove(output_path)
+    if os.path.exists(final_output_path): os.remove(final_output_path)
+
+    # Change dir to RIFE for execution
+    os.chdir(RIFE_DIR)
+
+    try:
+        # Run RIFE inference
+        # Note: --multi 4 means 4x interpolation (e.g. 30fps -> 120fps)
+        cmd = [
+            'python3', 'inference_video.py',
+            '--video', input_video_path,
+            '--output', output_path,
+            '--multi', '4',
+            '--model', 'HDv3'
+        ]
+        subprocess.run(cmd, check=True)
+
+        # Post-process for Web Compatibility (Faststart + h264)
+        if os.path.exists(output_path):
+            print("Re-encoding for web compatibility...")
+            ffmpeg_cmd = [
+                'ffmpeg', '-i', output_path,
+                '-c:v', 'libx264',
+                '-pix_fmt', 'yuv420p',
+                '-preset', 'medium',
+                '-crf', '23',
+                '-movflags', '+faststart',
+                '-y', final_output_path
+            ]
+            subprocess.run(ffmpeg_cmd, check=True)
+            
+            return final_output_path
+        else:
+            return None
+            
+    except Exception as e:
+        print(f"Error during inference: {e}")
+        return None
+    finally:
+        # Reset directory
+        os.chdir(BASE_DIR)
+
+# --- Gradio Interface ---
+with gr.Blocks() as demo:
+    gr.Markdown("# 🎞️ RIFE Video Interpolation (v4.26)")
+    gr.Markdown("Upload a video to smoothen it (4X Frame Interpolation). **Note:** This process is slow on CPU. Using a GPU Space is recommended.")
+    
+    with gr.Row():
+        with gr.Column():
+            video_input = gr.Video(label="Input Video")
+            submit_btn = gr.Button("Interpolate Frames", variant="primary")
+        with gr.Column():
+            video_output = gr.Video(label="Smoothed Output")
+    
+    submit_btn.click(fn=interpolate_video, inputs=video_input, outputs=video_output)
+
+demo.launch()