Spaces:
Running
Running
| import gradio as gr | |
| import librosa | |
| import numpy as np | |
| from pydub import AudioSegment | |
| import io | |
| import os | |
| import soundfile as sf # Required for sf.write | |
| # Function to convert any audio to WAV using pydub | |
| def convert_to_wav(audio_file_path): | |
| try: | |
| audio = AudioSegment.from_file(audio_file_path) | |
| # Create a temporary file path for WAV | |
| wav_file_path = audio_file_path + ".wav" | |
| audio.export(wav_file_path, format="wav") | |
| return wav_file_path | |
| except Exception as e: | |
| raise gr.Error(f"Error converting audio to WAV: {e}") | |
| # Main voice changer function (simplified) | |
| def voice_changer(source_audio_path, target_audio_path): | |
| if source_audio_path is None or target_audio_path is None: | |
| raise gr.Error("Please upload both source and target audio files.") | |
| # Ensure audio files are in WAV format | |
| source_wav_path = None | |
| target_wav_path = None | |
| try: | |
| source_wav_path = convert_to_wav(source_audio_path) | |
| target_wav_path = convert_to_wav(target_audio_path) | |
| # Load audio files | |
| y_source, sr_source = librosa.load(source_wav_path, sr=None) | |
| y_target, sr_target = librosa.load(target_wav_path, sr=None) | |
| # Resample target audio to source sample rate if different | |
| if sr_source != sr_target: | |
| y_target = librosa.resample(y_target, orig_sr=sr_target, target_sr=sr_source) | |
| print(f"Resampled target audio from {sr_target} to {sr_source} Hz.") | |
| # --- Simplified Voice Transfer Logic (Melody/Rhythm Transfer) --- | |
| # This is a very basic approach and not a full timbre transfer. | |
| # It tries to align the dominant pitch of the target with the source. | |
| # 1. Pitch Estimation for Source | |
| # librosa.pyin returns (f0, voiced_flag, voiced_probabilities) | |
| try: | |
| f0_source, voiced_flag_source, voiced_probs_source = librosa.pyin( | |
| y_source, fmin=librosa.note_to_hz('C2'), fmax=librosa.note_to_hz('C7'), sr=sr_source | |
| # frame_length argument is not directly for pyin in newer librosa versions | |
| # It's usually inferred from hop_length for features, or not needed for pyin directly | |
| ) | |
| except Exception as e: | |
| print(f"Pyin failed for source with general range, trying broader range: {e}") | |
| f0_source, voiced_flag_source, voiced_probs_source = librosa.pyin( | |
| y_source, fmin=60, fmax=500, sr=sr_source # More robust range for typical speech | |
| ) | |
| # 2. Estimate F0 for Target | |
| try: | |
| f0_target, voiced_flag_target, voiced_probs_target = librosa.pyin( | |
| y_target, fmin=librosa.note_to_hz('C2'), fmax=librosa.note_to_hz('C7'), sr=sr_target | |
| ) | |
| except Exception as e: | |
| print(f"Pyin failed for target with general range, trying broader range: {e}") | |
| f0_target, voiced_flag_target, voiced_probs_target = librosa.pyin( | |
| y_target, fmin=60, fmax=500, sr=sr_target # More robust range for typical speech | |
| ) | |
| # Handle NaN values in f0 (unvoiced segments) | |
| # Replace NaN with 0, so they don't affect mean calculation, but also limit to voiced segments | |
| f0_source_valid = f0_source[~np.isnan(f0_source)] | |
| f0_target_valid = f0_target[~np.isnan(f0_target)] | |
| # Calculate a simple pitch shift ratio based on mean F0 | |
| # This is very simplistic and doesn't account for variations over time. | |
| # A more advanced approach would involve temporal alignment and mapping. | |
| mean_f0_source = np.mean(f0_source_valid) if len(f0_source_valid) > 0 else 0 | |
| mean_f0_target = np.mean(f0_target_valid) if len(f0_target_valid) > 0 else 0 | |
| if mean_f0_target > 0.1 and mean_f0_source > 0.1: # Check for very small positive values | |
| pitch_shift_factor = mean_f0_source / mean_f0_target | |
| else: | |
| pitch_shift_factor = 1.0 # No pitch shift if no valid pitch detected or both are silent | |
| # Apply a pitch shift to the target audio | |
| # Using a simple `librosa.effects.pitch_shift` which is based on phase vocoder. | |
| # This is not PSOLA and can introduce artifacts. | |
| # The `n_steps` argument is in semitones. | |
| # log2(pitch_shift_factor) * 12 gives us semitones | |
| n_steps = 12 * np.log2(pitch_shift_factor) if pitch_shift_factor > 0 else 0 | |
| print(f"Calculated pitch shift: {n_steps:.2f} semitones.") | |
| # Adjust the duration of the target audio to roughly match the source | |
| # This is a crude time stretching/compressing | |
| # Using librosa.get_duration to handle potential discrepancies in array lengths | |
| duration_source = librosa.get_duration(y=y_source, sr=sr_source) | |
| duration_target = librosa.get_duration(y=y_target, sr=sr_target) | |
| # Avoid division by zero | |
| if duration_target > 0: | |
| duration_ratio = duration_source / duration_target | |
| else: | |
| duration_ratio = 1.0 # No time change if target has no duration | |
| print(f"Duration Source: {duration_source:.2f}s, Target: {duration_target:.2f}s, Ratio: {duration_ratio:.2f}") | |
| if duration_ratio != 1.0: | |
| # We need to compute an appropriate hop_length for time_stretch if rate is not int. | |
| # Using rate directly for time_stretch | |
| y_target_adjusted_tempo = librosa.effects.time_stretch(y_target, rate=duration_ratio) | |
| else: | |
| y_target_adjusted_tempo = y_target # No stretching needed | |
| # Apply pitch shift to the tempo-adjusted target audio | |
| y_output = librosa.effects.pitch_shift(y_target_adjusted_tempo, sr=sr_source, n_steps=n_steps) | |
| # Normalize the output audio to prevent clipping | |
| y_output = librosa.util.normalize(y_output) | |
| # Create a temporary file to save the output audio | |
| output_file_path = "output_voice_changed.wav" | |
| sf.write(output_file_path, y_output, sr_source) | |
| return output_file_path | |
| except Exception as e: | |
| raise gr.Error(f"An error occurred during voice processing: {e}") | |
| finally: | |
| # Clean up temporary WAV files irrespective of success/failure | |
| if source_wav_path and os.path.exists(source_wav_path): | |
| os.remove(source_wav_path) | |
| if target_wav_path and os.path.exists(target_wav_path): | |
| os.remove(target_wav_path) | |
| # Gradio Interface | |
| with gr.Blocks() as demo: | |
| gr.Markdown( | |
| """ | |
| # Simple Audio Style Transfer (Voice Changer - Experimental) | |
| Upload two audio files. The goal is to make the "Target Audio" mimic the pitch/melody of the "Source Audio". | |
| **Note:** This is a very basic implementation and **not a full voice cloning/timbre transfer**. | |
| It performs a simplified pitch and tempo adjustment based on the source's characteristics. | |
| Expect artifacts and limited "voice changing" effect. For true voice cloning, more advanced models are needed. | |
| """ | |
| ) | |
| with gr.Row(): | |
| source_audio_input = gr.Audio(type="filepath", label="Source Audio (Reference Voice/Style)", sources=["upload"]) | |
| target_audio_input = gr.Audio(type="filepath", label="Target Audio (Voice to be Changed)", sources=["upload"]) | |
| output_audio = gr.Audio(label="Transformed Audio") | |
| voice_changer_button = gr.Button("Transform Voice") | |
| voice_changer_button.click( | |
| fn=voice_changer, | |
| inputs=[source_audio_input, target_audio_input], | |
| outputs=output_audio | |
| ) | |
| if __name__ == "__main__": | |
| demo.launch() | |