Update app.py

app.py

@@ -1,276 +1,110 @@
 import gradio as gr
-import os
-import shutil
-import subprocess
-from datetime import datetime
-from pydub import AudioSegment, silence
-from pydub.effects import normalize
+from pydub import AudioSegment
+import librosa
 import noisereduce as nr
 import numpy as np
-import random
-from scipy.io import wavfile
-import librosa
-import yt_dlp
-
-
-# Part 1: Audio Processor
-# Global variable to store processed audio path from Step 1
-processed_audio_path_step1 = None
-
-SILENCE_THRESHOLD_MS = 500  # Example: 500ms
-
-def generate_unique_filename(base_path, duration, suffix=""):
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    duration_str = f"{duration:.2f}"
-    base_name = os.path.basename(base_path)
-    name, ext = os.path.splitext(base_name)
-    unique_filename = f"Mirchi_{duration_str}_{timestamp}{suffix}{ext}"
-    return unique_filename
-
-sarcastic_messages = [
-    "Oh wow, that went well... Not.",
-    "You really outdid yourself this time.",
-    "Congratulations, you've hit an error. Again.",
-    "Well, that didn't work. Shocker.",
-    "Surprise, surprise, another error.",
-    "Great job! Another error for your collection."
-]
+from io import BytesIO
+import tempfile
+import os
 
-def remove_unwanted_sounds(audio_path, silence_threshold_ms):
-    y, sr = librosa.load(audio_path, sr=None)
+# Function to load audio
+def load_audio(audio_file_path):
+    # Open the file and read its bytes
+    with open(audio_file_path, "rb") as f:
+        audio_bytes = f.read()
     
-    non_silent_intervals = librosa.effects.split(y, top_db=35)  # Fine-tuned silence detection
+    # Load the audio using pydub from the file bytes
+    audio_segment = AudioSegment.from_file(BytesIO(audio_bytes))
+    audio_array = np.array(audio_segment.get_array_of_samples(), dtype=np.float32)
+    sample_rate = audio_segment.frame_rate
+    return audio_array, sample_rate
+
+# Function for noise reduction
+def reduce_noise(audio, sample_rate):
+    reduced_noise_audio = nr.reduce_noise(y=audio, sr=sample_rate)
+    return reduced_noise_audio
+
+# Function for pitch shifting
+def pitch_shift(audio, sample_rate, n_steps):
+    shifted_audio = librosa.effects.pitch_shift(audio, sr=sample_rate, n_steps=n_steps)
+    return shifted_audio
+
+# Function for time-stretching
+def time_stretch(audio, rate):
+    stretched_audio = librosa.effects.time_stretch(audio, rate)
+    return stretched_audio
+
+# Function to save audio to a temporary file and return the path
+def save_audio(audio, sample_rate):
+    # Create a temporary file to save the audio
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
+    temp_file_name = temp_file.name
     
-    if not non_silent_intervals.any():
-        raise ValueError("No non-silent segments detected.")
+    # Use pydub to save the audio to the temp file
+    audio_segment = AudioSegment(
+        np.int16(audio).tobytes(), frame_rate=sample_rate, sample_width=2, channels=1
+    )
+    audio_segment.export(temp_file_name, format="wav")
     
-    processed_audio = []
-    last_end = 0
+    temp_file.close()
+    return temp_file_name
+
+# Main function to apply audio effects
+def apply_effects(audio_file, noise_reduction, pitch_shift_steps, time_stretch_rate):
+    audio, sr = load_audio(audio_file)
     
-    for start, end in non_silent_intervals:
-        silence_duration = start - last_end
-        
-        if silence_duration <= silence_threshold_ms * sr / 1000:
-            processed_audio.append(y[last_end:start])
-        
-        processed_audio.append(y[start:end])
-        last_end = end
+    if noise_reduction:
+        audio = reduce_noise(audio, sr)
     
-    remaining_silence_duration = len(y) - last_end
-    if remaining_silence_duration <= silence_threshold_ms * sr / 1000:
-        processed_audio.append(y[last_end:])
+    if pitch_shift_steps != 0:
+        audio = pitch_shift(audio, sr, pitch_shift_steps)
     
-    processed_audio = np.concatenate(processed_audio)
+    if time_stretch_rate != 1.0:
+        audio = time_stretch(audio, time_stretch_rate)
     
-    return processed_audio, sr
-
-def apply_noise_removal(y, sr):
-    reduced_noise = nr.reduce_noise(y=y, sr=sr, prop_decrease=0.6, n_fft=1024, win_length=512, hop_length=256)
-    return reduced_noise
+    return save_audio(audio, sr)
 
-def numpy_to_audiosegment(y, sr):
-    y = (y * np.iinfo(np.int16).max).astype(np.int16)
-    audio_segment = AudioSegment(
-        y.tobytes(), 
-        frame_rate=sr,
-        sample_width=2,
-        channels=1
-    )
-    return audio_segment
-
-def process_audio_step1(audio_path, crossfade, normalize_audio, noise_removal):
-    global processed_audio_path_step1
-    try:
-        if not audio_path:
-            return None, random.choice(sarcastic_messages), None
-        
-        y, sr = remove_unwanted_sounds(audio_path, SILENCE_THRESHOLD_MS)
+# Gradio UI
+def build_ui():
+    with gr.Blocks() as demo:
+        # Custom Title
+        gr.Markdown("# Shyam's AI Audio Studio")
         
-        if noise_removal:
-            y = apply_noise_removal(y, sr)
+        # Description for the tool
+        gr.Markdown(
+            """
+            Welcome to **Shyam's AI Audio Studio**! 
+            This tool allows you to upload audio files and apply various effects like:
+            - Noise Reduction
+            - Pitch Shifting (up or down by semitones)
+            - Time Stretching (speed up or slow down)
+
+            Experiment with the sliders to fine-tune the effects and get your desired sound!
+            """
+        )
         
-        final_audio = numpy_to_audiosegment(y, sr)
+        # Input components
+        audio_input = gr.Audio(type="filepath", label="Upload Audio File")
+        noise_reduction = gr.Checkbox(label="Apply Noise Reduction", value=True)
+        pitch_shift_steps = gr.Slider(label="Pitch Shift (in semitones)", minimum=-12, maximum=12, value=0, step=1)
+        time_stretch_rate = gr.Slider(label="Time Stretch Rate", minimum=0.5, maximum=2.0, value=1.0, step=0.1)
         
-        if normalize_audio:
-            final_audio = normalize(final_audio)
+        # Output component
+        audio_output = gr.File(label="Download Edited Audio")
         
-        if crossfade:
-            crossfade_duration = 1000  # 1 second crossfade
-            processed_audio = final_audio[:crossfade_duration]
-            for i in range(crossfade_duration, len(final_audio), crossfade_duration):
-                chunk = final_audio[i:i + crossfade_duration]
-                processed_audio = processed_audio.append(chunk, crossfade=crossfade_duration)
-        else:
-            processed_audio = final_audio
+        # Button to trigger the process
+        edit_button = gr.Button("Apply Effects")
         
-        unique_filename = generate_unique_filename(audio_path, len(processed_audio) / 1000, "_step1")
-        output_path = os.path.join("audios_output_step1", unique_filename)
-        os.makedirs("audios_output_step1", exist_ok=True)
-        processed_audio.export(output_path, format="wav")
-        processed_audio_path_step1 = output_path
-        return output_path, "Success! Your audio is now processed.", output_path
-    except Exception as e:
-        return None, f"{random.choice(sarcastic_messages)} Error: {str(e)}", None
-
-def process_audio_step2(audio_path, target_duration):
-    try:
-        if not audio_path:
-            return None, random.choice(sarcastic_messages), None
-        
-        audio = AudioSegment.from_file(audio_path)
-        original_duration = len(audio) / 1000
-        stretch_ratio = original_duration / target_duration
-        unique_filename = generate_unique_filename(audio_path, original_duration, "_step2")
-        output_path = os.path.join("audios_output_step2", unique_filename)
-        os.makedirs("audios_output_step2", exist_ok=True)
-        command = [
-            'ffmpeg',
-            '-i', audio_path,
-            '-filter:a', f'atempo={stretch_ratio}',
-            output_path
-        ]
-        subprocess.run(command, check=True)
-        return output_path, "Done! Your audio is stretched.", None
-    except subprocess.CalledProcessError:
-        return None, f"{random.choice(sarcastic_messages)} FFmpeg error occurred.", None
-    except Exception as e:
-        return None, f"{random.choice(sarcastic_messages)} Error: {str(e)}", None
-
-def clear_output_folders():
-    folders = ["audios_output_step1", "audios_output_step2"]
-    for folder in folders:
-        if os.path.exists(folder):
-            shutil.rmtree(folder)
-    return "All output folders are cleared."
-
-def open_output_folder(folder_name):
-    try:
-        if os.name == 'nt':  # Windows
-            os.startfile(folder_name)
-        elif os.name == 'posix':  # macOS or Linux
-            if os.uname().sysname == 'Darwin':  # macOS
-                subprocess.run(['open', folder_name])
-            else:  # Linux
-                subprocess.run(['xdg-open', folder_name])
-        return "Opening folder."
-    except Exception as e:
-        return f"{random.choice(sarcastic_messages)} Failed to open folder: {str(e)}"
-
-# Part 2: YouTube Downloader
-def download_youtube_video(url, save_path='.', file_format='mp4'):
-    try:
-        if file_format == 'mp4':
-            ydl_opts = {
-                'format': 'bestvideo+bestaudio/best',
-                'outtmpl': os.path.join(save_path, '%(title)s.%(ext)s'),
-                'merge_output_format': 'mp4',
-                'postprocessors': [{
-                    'key': 'FFmpegVideoConvertor',
-                    'preferedformat': 'mp4',
-                }],
-            }
-        elif file_format == 'mp3':
-            ydl_opts = {
-                'format': 'bestaudio/best',
-                'outtmpl': os.path.join(save_path, '%(title)s.%(ext)s'),
-                'postprocessors': [{
-                    'key': 'FFmpegExtractAudio',
-                    'preferredcodec': 'mp3',
-                    'preferredquality': '192',
-                }],
-            }
-
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            info = ydl.extract_info(url, download=True)
-            filename = ydl.prepare_filename(info)
-            file_ext = '.mp4' if file_format == 'mp4' else '.mp3'
-            final_filename = filename.rsplit('.', 1)[0] + file_ext
-
-            if os.path.exists(final_filename):
-                return final_filename, f"Downloaded successfully as {file_format.upper()}!"
-            else:
-                return None, f"Download failed, file not found."
-
-    except Exception as e:
-        return None, f"An error occurred: {str(e)}"
-
-def download_video_from_ui(url, save_location, file_format):
-    if not url.strip():
-        return None, "Please enter a valid URL."
+        # Link the button to the effect function
+        edit_button.click(
+            apply_effects, 
+            inputs=[audio_input, noise_reduction, pitch_shift_steps, time_stretch_rate],
+            outputs=audio_output
+        )
     
-    if not save_location.strip():
-        save_location = '.'  # Use current directory if save path is empty
-
-    file_path, message = download_youtube_video(url, save_location, file_format)
-    return file_path, message
-
-
-# Gradio interface with tabs
-with gr.Blocks(theme="soft") as demo:
-    with gr.Tabs():
-        with gr.Tab("Audio Processor"):
-            with gr.Column():
-                gr.Markdown("### Step 1: Cleanup")
-                audio_input_step1 = gr.Audio(label="Upload Audio for Cleanup", type="filepath")
-                with gr.Row():
-                    crossfade_option = gr.Checkbox(label="Apply Crossfade")
-                    normalize_option = gr.Checkbox(label="Normalize Audio")
-                    noise_removal_option = gr.Checkbox(label="Noise Removal")
-                step1_error = gr.Textbox(lines=2, interactive=False)
-                step1_output = gr.Audio(label="Processed Audio", interactive=False)
-                step1_button = gr.Button("Process Step 1")
-
-                gr.Markdown("### Step 2: Time Stretch")
-                step2_audio_input = gr.Audio(label="Upload Audio for Time Stretch", type="filepath")
-                with gr.Row():
-                    target_duration_input = gr.Number(label="Target Duration (seconds)", value=60.0)
-                    process_step2_button = gr.Button("Process Step 2")
-                step2_error = gr.Textbox(lines=2, interactive=False)
-                step2_output = gr.Audio(label="Processed Audio", interactive=False)
-
-                gr.Markdown("### Manage Outputs")
-                with gr.Row():
-                    open_output_button_step1 = gr.Button("Open Cleanup Output Folder")
-                    open_output_button_step2 = gr.Button("Open Stretch Output Folder")
-                with gr.Row():
-                    clear_button = gr.Button("Clear Output Folders")
-                step1_button.click(fn=process_audio_step1,
-                    inputs=[audio_input_step1, crossfade_option, normalize_option, noise_removal_option],
-                    outputs=[step1_output, step1_error, step1_output])
-                process_step2_button.click(fn=process_audio_step2,
-                    inputs=[step2_audio_input, target_duration_input],
-                    outputs=[step2_output, step2_error, step2_output])
-                clear_button.click(fn=clear_output_folders, inputs=None, outputs=None)
-                open_output_button_step1.click(fn=lambda: open_output_folder("audios_output_step1"), inputs=None, outputs=None)
-                open_output_button_step2.click(fn=lambda: open_output_folder("audios_output_step2"), inputs=None, outputs=None)
-
-        with gr.Tab("YouTube Downloader"):
-            gr.Markdown("""
-                <div style="text-align: center;">
-                    <h1>YouTube Video Downloader</h1>
-                    <p>This application allows you to download YouTube videos or audio tracks. 
-                    You can choose the format (MP4 for video or MP3 for audio) and specify a save location for the downloaded file.</p>
-                </div>
-            """)
-            with gr.Row():
-                url_input = gr.Textbox(label="YouTube Video URL", placeholder="Enter YouTube video URL here...")
-                format_input = gr.Radio(label="Select Format", choices=['mp4', 'mp3'], value='mp4')
-                save_path_input = gr.Textbox(label="Save Path", placeholder="Enter path to save the video (or leave blank for current directory)")
-
-            download_button = gr.Button("Download Video/Audio")
-            output_text = gr.Textbox(label="Status", interactive=False)
-            file_output = gr.File(label="Download Link")
-            def enable_button(url):
-                if url.strip():
-                    return gr.update(interactive=True)
-                else:
-                    return gr.update(interactive=False)
-
-            def execute_download(url, save_path, file_format):
-                file_path, result = download_video_from_ui(url, save_path, file_format)
-                return result, file_path
-
-            url_input.change(enable_button, inputs=url_input, outputs=download_button)
-            download_button.click(execute_download, inputs=[url_input, save_path_input, format_input], outputs=[output_text, file_output])
+    return demo
 
-demo.launch()
+# Launch the Gradio app
+if __name__ == "__main__":
+    ui = build_ui()
+    ui.launch()