Update app.py

app.py

@@ -1,103 +1,21 @@
 import gradio as gr
-from functools import partial
-from pathlib import Path
-import librosa
-import numpy as np
-import matplotlib.pyplot as plt
-import soundfile as sf
-import scipy.signal as sig
-import psola
+import subprocess
 
-SEMITONES_IN_OCTAVE = 12
+def autotune_audio(path_to_audio_file, scale):
+    command = f"python autotune_script.py {path_to_audio_file} --scale {scale}"
+    process = subprocess.run(command, shell=True, capture_output=True, text=True)
+    return process.stdout, process.stderr
 
-def degrees_from(scale: str):
-    degrees = librosa.key_to_degrees(scale)
-    degrees = np.concatenate((degrees, [degrees[0] + SEMITONES_IN_OCTAVE]))
-    return degrees
-
-def closest_pitch(f0):
-    midi_note = np.around(librosa.hz_to_midi(f0))
-    nan_indices = np.isnan(f0)
-    midi_note[nan_indices] = np.nan
-    return librosa.midi_to_hz(midi_note)
-
-def closest_pitch_from_scale(f0, scale):
-    if np.isnan(f0):
-        return np.nan
-    degrees = degrees_from(scale)
-    midi_note = librosa.hz_to_midi(f0)
-    degree = midi_note % SEMITONES_IN_OCTAVE
-    degree_id = np.argmin(np.abs(degrees - degree))
-    degree_difference = degree - degrees[degree_id]
-    midi_note -= degree_difference
-    return librosa.midi_to_hz(midi_note)
-
-def aclosest_pitch_from_scale(f0, scale):
-    sanitized_pitch = np.zeros_like(f0)
-    for i in np.arange(f0.shape[0]):
-        sanitized_pitch[i] = closest_pitch_from_scale(f0[i], scale)
-    smoothed_sanitized_pitch = sig.medfilt(sanitized_pitch, kernel_size=11)
-    smoothed_sanitized_pitch[np.isnan(smoothed_sanitized_pitch)] = sanitized_pitch[np.isnan(smoothed_sanitized_pitch)]
-    return smoothed_sanitized_pitch
-
-def autotune(audio, sr, correction_function, plot=False):
-    frame_length = 2048
-    hop_length = frame_length // 4
-    fmin = librosa.note_to_hz('C2')
-    fmax = librosa.note_to_hz('C7')
-
-    f0, voiced_flag, voiced_probabilities = librosa.pyin(audio, frame_length=frame_length, hop_length=hop_length, sr=sr, fmin=fmin, fmax=fmax)
-    corrected_f0 = correction_function(f0)
-
-    if plot:
-        stft = librosa.stft(audio, n_fft=frame_length, hop_length=hop_length)
-        time_points = librosa.times_like(stft, sr=sr, hop_length=hop_length)
-        log_stft = librosa.amplitude_to_db(np.abs(stft), ref=np.max)
-        fig, ax = plt.subplots()
-        img = librosa.display.specshow(log_stft, x_axis='time', y_axis='log', ax=ax, sr=sr, hop_length=hop_length, fmin=fmin, fmax=fmax)
-        fig.colorbar(img, ax=ax, format="%+2.f dB")
-        ax.plot(time_points, f0, label='original pitch', color='cyan', linewidth=2)
-        ax.plot(time_points, corrected_f0, label='corrected pitch', color='orange', linewidth=1)
-        ax.legend(loc='upper right')
-        plt.ylabel('Frequency [Hz]')
-        plt.xlabel('Time [M:SS]')
-        plt.savefig('pitch_correction.png', dpi=300, bbox_inches='tight')
-        plt.close()
-
-    return psola.vocode(audio, sample_rate=int(sr), target_pitch=corrected_f0, fmin=fmin, fmax=fmax)
-
-def process_audio(vocals_file, correction_method, scale, plot):
-    y, sr = librosa.load(vocals_file, sr=None, mono=False)
-    if y.ndim > 1:
-        y = y[0, :]
+with gr.Blocks() as demo:
+    gr.Markdown("## Autotune Audio File")
     
-    correction_function = closest_pitch if correction_method == 'closest' else partial(aclosest_pitch_from_scale, scale=scale)
-    pitch_corrected_y = autotune(y, sr, correction_function, plot)
-
-    output_file = "pitch_corrected_audio.wav"
-    sf.write(output_file, pitch_corrected_y, sr)
+    path_input = gr.Audio(label="Path to Audio File", placeholder="your audio file")
+    scale_input = gr.Textbox(label="Scale", placeholder="Enter the scale (e.g., C5)")
     
-    if plot:
-        return output_file, 'pitch_correction.png'
-    return output_file, None
-
-def main():
-    with gr.Blocks(title="Hex AutoTune") as demo:
-        gr.Markdown("# Hex Auto-Tune Audio with Pitch Correction")
-        with gr.Row():
-            with gr.Column():
-                vocals_file = gr.Audio(type="filepath", label="Upload Vocals File")
-                correction_method = gr.Radio(["closest", "scale"], label="Correction Method", value="closest")
-                scale = gr.Textbox(label="Scale (only for 'scale' method)", placeholder="e.g., C:maj")
-                plot = gr.Checkbox(label="Generate Pitch Correction Plot", value=False)
-                submit = gr.Button("Process")
-            with gr.Column():
-                output_audio = gr.Audio(label="Pitch Corrected Audio")
-                output_image = gr.Image(label="Pitch Correction Plot (if selected)")
-        
-        submit.click(fn=process_audio, inputs=[vocals_file, correction_method, scale, plot], outputs=[output_audio, output_image])
-
-    demo.launch()
+    output_text = gr.Textbox(label="Output", placeholder="Autotune script output will appear here")
+    error_text = gr.Textbox(label="Errors", placeholder="Any errors will appear here")
+    
+    run_button = gr.Button("Run Autotune Script")
+    run_button.click(fn=autotune_audio, inputs=[path_input, scale_input], outputs=[output_text, error_text])
 
-if __name__ == '__main__':
-    main()
+demo.launch()