Update app.py

app.py

@@ -1,117 +1,53 @@
 import os
-import subprocess
-import sys
-
-# Diagnostic: Print Python version and executable path
-print("Python version:", sys.version)
-print("Python executable:", sys.executable)
-
-# Diagnostic: List installed packages to confirm if moviepy is installed
-installed_packages = subprocess.check_output([sys.executable, "-m", "pip", "freeze"]).decode("utf-8")
-print("Installed packages:")
-print(installed_packages)
-
-# Try importing moviepy, force install if not found
-try:
-    from moviepy.editor import VideoFileClip, AudioFileClip
-except ImportError:
-    print("MoviePy not found, attempting to install...")
-    subprocess.check_call([sys.executable, "-m", "pip", "install", "moviepy"])
-    from moviepy.editor import VideoFileClip, AudioFileClip
-
-# Hugging Face repo path (update with your repo details)
-MUSIC_DIR = "/mnt/data/chunks"  # Modify this if necessary
-
-DEFAULT_MUSIC = "/mnt/data/default_music.mp3"  # Path to default music if needed
-
-def load_music_files():
-    """
-    Load all music files from the directory.
-    """
-    try:
-        # Ensure directory exists and is readable
-        if not os.path.exists(MUSIC_DIR):
-            raise FileNotFoundError(f"Music directory not found: {MUSIC_DIR}")
-
-        music_files = [os.path.join(MUSIC_DIR, f) for f in os.listdir(MUSIC_DIR) if f.endswith(".mp3")]
-        if not music_files:
-            print("No music files found! Using default music.")
-            if not os.path.exists(DEFAULT_MUSIC):
-                raise FileNotFoundError("Default music file is missing!")
-            music_files.append(DEFAULT_MUSIC)
-        print(f"Loaded {len(music_files)} music files.")
-        return music_files
-    except Exception as e:
-        raise FileNotFoundError(f"Error loading music files: {e}")
-
-def generate_music(scene_analysis):
-    """
-    Select a random music file from the available files.
-    """
-    music_files = load_music_files()
-    selected_music = choice(music_files)  # Pick a random music file
-    print(f"Selected music: {selected_music}")
-    return selected_music
-
-def analyze_video(video_path):
-    """
-    Dummy scene analysis function. Replace with an actual analysis implementation.
-    """
-    print(f"Analyzing video: {video_path}")
-    return {"scene_type": "Generic", "detected_objects": []}
-
-def process_video(video_path, music_path):
-    """
-    Combines the video with background music.
-    """
-    try:
-        print(f"Processing video: {video_path} with music: {music_path}")
-
-        video_clip = VideoFileClip(video_path)
-        music_clip = AudioFileClip(music_path)
-
-        # Trim music to match video duration
-        music_clip = music_clip.subclip(0, min(video_clip.duration, music_clip.duration))
-
-        # Add music to video
-        final_video = video_clip.set_audio(music_clip)
-
-        # Save the processed video
-        output_path = tempfile.mktemp(suffix=".mp4")
-        final_video.write_videofile(output_path, codec="libx264", audio_codec="aac")
-        return output_path
-
-    except Exception as e:
-        print(f"Error in process_video: {e}")
-        raise e
-
-def main(video_path):
-    try:
-        analysis = analyze_video(video_path)
-        music_path = generate_music(analysis)  # Get a fresh music track every time
-        output_path = process_video(video_path, music_path)
-        return output_path, f"Music file used: {os.path.basename(music_path)}"
-    except Exception as e:
-        print(f"Error in main: {e}")
-        return None, f"Error: {e}"
+import random
+import ffmpeg
+import gradio as gr
+
+# Function to add music to video
+def add_music_to_video(video_path, chunks_folder="chunks", output_path="output_with_music.mp4"):
+    # List all MP3 files in the chunks folder
+    music_files = [os.path.join(chunks_folder, f) for f in os.listdir(chunks_folder) if f.endswith('.mp3')]
+    
+    if not music_files:
+        return "Error: No audio files found in the chunks folder."
+    
+    # Randomly select one MP3 file
+    music_file_path = random.choice(music_files)
+    print(f"Selected music file: {music_file_path}")
+    
+    # Get the duration of the video
+    video_info = ffmpeg.probe(video_path)
+    video_duration = float(video_info['streams'][0]['duration'])
+    
+    # Trim the music file to match the video duration
+    trimmed_music_path = "trimmed_music.mp3"
+    ffmpeg.input(music_file_path).output(
+        trimmed_music_path, ss=0, t=video_duration
+    ).run(overwrite_output=True)
+    
+    # Combine video and audio
+    video_input = ffmpeg.input(video_path)
+    audio_input = ffmpeg.input(trimmed_music_path)
+    ffmpeg.concat(video_input, audio_input, v=1, a=1).output(
+        output_path, vcodec="libx264", acodec="aac", strict="experimental"
+    ).run(overwrite_output=True)
+    
+    return output_path
+
+# Define Gradio interface
+def process_video(uploaded_video):
+    video_path = uploaded_video.name
+    output_video = add_music_to_video(video_path, chunks_folder="/content/chunks")
+    return output_video
 
 # Gradio Interface
-def gradio_interface(video_file):
-    output_path, message = main(video_file)
-    if output_path:
-        return output_path, message
-    else:
-        return None, message
-
-iface = gr.Interface(
-    fn=gradio_interface,
+interface = gr.Interface(
+    fn=process_video,
     inputs=gr.Video(label="Upload Video"),
-    outputs=[
-        gr.Video(label="Processed Video"),
-        gr.Textbox(label="Result Info"),
-    ],
-    title="Music Video Processor",
-    description="Upload a video, and it will randomly select one of the uploaded or default music files to combine with the video."
+    outputs=gr.Video(label="Video with Background Music"),
+    title="Add Background Music to Video",
+    description="Upload a video, and this app will add a 10-second background music track that matches the video duration."
 )
 
-iface.launch(debug=True)
+# Launch Gradio app
+interface.launch(share=True)