Update app.py

app.py

@@ -8,57 +8,54 @@ import matplotlib.pyplot as plt
 import librosa
 import librosa.display
 import os
-import moviepy.video.io.ImageSequenceClip
+import moviepy.editor as mp
 
 # Function to generate frequency visualization frames from audio
-def generate_frequency_visualization(audio_path):
+def generate_frequency_visualization(audio_path, fps, num_bars):
     try:
         # Load the audio file
         y, sr = librosa.load(audio_path, sr=None)
-        print(f"Loaded audio file with sampling rate: {sr}, and duration: {librosa.get_duration(y=y, sr=sr)} seconds.")
+        duration = librosa.get_duration(y=y, sr=sr)
+        print(f"Loaded audio file with sampling rate: {sr}, and duration: {duration} seconds.")
 
         if sr == 0 or len(y) == 0:
             raise ValueError("Invalid audio file: sampling rate or audio data is zero.")
 
         # Perform Short-Time Fourier Transform (STFT)
-        n_fft = 2048  # Ensure n_fft is set to a valid number
-        hop_length = 512  # Ensure hop_length is set to a valid number
-        D = librosa.amplitude_to_db(np.abs(librosa.stft(y, n_fft=n_fft, hop_length=hop_length)), ref=np.max)
+        hop_length = int(sr / fps)  # Hop length to match the desired fps
+        S = np.abs(librosa.stft(y, n_fft=2048, hop_length=hop_length))
+        frequencies = librosa.fft_frequencies(sr=sr)
+
+        # Create frequency bins for the bars
+        bins = np.linspace(0, len(frequencies), num_bars + 1, dtype=int)
+        bar_heights = []
+
+        # Aggregate power for each bar
+        for i in range(len(S[0])):
+            frame = S[:, i]
+            bar_frame = [np.mean(frame[bins[j]:bins[j+1]]) for j in range(num_bars)]
+            bar_heights.append(bar_frame)
 
         # Create a directory to save the frames
         os.makedirs('frames', exist_ok=True)
 
         # Generate and save each frame
-        for i in range(D.shape[1]):  # Iterate over columns of D (time frames)
+        for i, heights in enumerate(bar_heights):
             plt.figure(figsize=(10, 6))
-            librosa.display.specshow(D[:, i].reshape(-1, 1), sr=sr, x_axis='time', y_axis='log', hop_length=hop_length, cmap='viridis')
+            plt.bar(range(num_bars), heights, color=plt.cm.viridis(np.linspace(0, 1, num_bars)))
+            plt.ylim(0, np.max(S))
             plt.axis('off')
             plt.savefig(f'frames/frame_{i:04d}.png', bbox_inches='tight', pad_inches=0)
             plt.close()
 
-        print(f"Generated {D.shape[1]} frames for visualization.")
-        return 'frames'
+        print(f"Generated {len(bar_heights)} frames for visualization.")
+        return 'frames', duration
     except Exception as e:
         print(f"Error generating frequency visualization: {e}")
-        # Fallback: Generate a default visualization
-        generate_default_visualization()
-        return 'frames'
-
-# Function to generate a default visualization
-def generate_default_visualization():
-    # Create a directory to save the frames
-    os.makedirs('frames', exist_ok=True)
-
-    # Generate and save default frames
-    for i in range(10):  # Generate 10 default frames
-        plt.figure(figsize=(10, 6))
-        plt.plot(np.sin(np.linspace(0, 10, 100)) * (i + 1))
-        plt.axis('off')
-        plt.savefig(f'frames/frame_{i:04d}.png', bbox_inches='tight', pad_inches=0)
-        plt.close()
+        return None, None
 
 # Function to create a video from the generated frames
-def create_video_from_frames(frames_directory):
+def create_video_from_frames(frames_directory, audio_path, fps, duration):
     try:
         # Get the list of frame files
         frame_files = [os.path.join(frames_directory, f) for f in os.listdir(frames_directory) if f.endswith('.png')]
@@ -68,9 +65,13 @@ def create_video_from_frames(frames_directory):
             raise ValueError("No frames found to create the video.")
 
         # Create a video from the frames
-        clip = moviepy.video.io.ImageSequenceClip.ImageSequenceClip(frame_files, fps=10)  # Set fps to 10 for better visibility
+        clip = mp.ImageSequenceClip(frame_files, fps=fps)
         video_path = 'output_video.mp4'
-        clip.write_videofile(video_path, codec='libx264')
+
+        # Add the audio to the video
+        audio_clip = mp.AudioFileClip(audio_path)
+        final_clip = clip.set_audio(audio_clip.subclip(0, duration))
+        final_clip.write_videofile(video_path, codec='libx264', audio_codec='aac')
 
         print(f"Video created with {len(frame_files)} frames.")
         return video_path
@@ -81,9 +82,14 @@ def create_video_from_frames(frames_directory):
 # Gradio interface function
 def process_audio(audio):
     audio_path = audio
-    frames_directory = generate_frequency_visualization(audio_path)
-    video_path = create_video_from_frames(frames_directory)
-    return video_path
+    fps = 60
+    num_bars = 12
+    frames_directory, duration = generate_frequency_visualization(audio_path, fps, num_bars)
+    if frames_directory:
+        video_path = create_video_from_frames(frames_directory, audio_path, fps, duration)
+        return video_path
+    else:
+        return None
 
 # Create the Gradio interface with explanations and recommendations
 iface = gr.Interface(
@@ -94,7 +100,7 @@ iface = gr.Interface(
     description="Upload an audio file to generate a video with frequency visualization. "
                 "Supported file types: WAV, MP3, FLAC. "
                 "Recommended file duration: 10 seconds to 5 minutes. "
-                "If the file is invalid or cannot be processed, a default visualization will be generated.",
+                "The visualization will consist of 12 bars representing frequency ranges.",
 )
 
 # Launch the Gradio interface