Here's the complete audio equalizer application with all requested features: import numpy as np from scipy import signal from scipy.fft import fft, ifft import soundfile as sf from pydub import AudioSegment import simpleaudio as sa class AudioEffects: def __init__(self): self.audio_data = None self.sample_rate = None self.channels = None self.original_audio = None self.play_obj = None self.eq_bands = None self.eq_gains = None def load_audio(self, file_path): """Load audio file using pydub (supports multiple formats)""" try: audio = AudioSegment.from_file(file_path) self.original_audio = audio self.sample_rate = audio.frame_rate self.channels = audio.channels samples = np.array(audio.get_array_of_samples()) if audio.channels == 2: samples = samples.reshape((-1, 2)) self.audio_data = samples.astype(np.float32) / (2**15) # Initialize EQ bands (10-band equalizer) self.eq_bands = [50, 100, 200, 400, 800, 1600, 3200, 6400, 12800, 16000] self.eq_gains = [0] * len(self.eq_bands) return True except Exception as e: print(f"Error loading audio: {e}") return False def apply_volume(self, gain_db): """Apply volume change in dB""" if self.audio_data is None: return False gain_linear = 10 ** (gain_db / 20) self.audio_data = self.audio_data * gain_linear return True def apply_eq(self, gains): """Apply multi-band equalizer""" if self.audio_data is None or len(gains) != len(self.eq_bands): return False self.eq_gains = gains # Design filters for each band nyquist = 0.5 * self.sample_rate processed = np.zeros_like(self.audio_data) if self.channels == 2: for ch in range(2): channel_data = self.audio_data[:, ch] for i, (freq, gain) in enumerate(zip(self.eq_bands, gains)): if gain == 0: continue # Design peaking filter Q = 1.0 w0 = freq / nyquist alpha = np.sin(w0) / (2 * Q) A = 10 ** (gain / 40) b0 = 1 + alpha * A b1 = -2 * np.cos(w0) b2 = 1 - alpha * A a0 = 1 + alpha / A a1 = -2 * np.cos(w0) a2 = 1 - alpha / A b = [b0/a0, b1/a0, b2/a0] a = [1.0, a1/a0, a2/a0] channel_data = signal.lfilter(b, a, channel_data) processed[:, ch] = channel_data else: processed = self.audio_data.copy() for i, (freq, gain) in enumerate(zip(self.eq_bands, gains)): if gain == 0: continue # Design peaking filter Q = 1.0 w0 = freq / nyquist alpha = np.sin(w0) / (2 * Q) A = 10 ** (gain / 40) b0 = 1 + alpha * A b1 = -2 * np.cos(w0) b2 = 1 - alpha * A a0 = 1 + alpha / A a1 = -2 * np.cos(w0) a2 = 1 - alpha / A b = [b0/a0, b1/a0, b2/a0] a = [1.0, a1/a0, a2/a0] processed = signal.lfilter(b, a, processed) self.audio_data = processed return True def apply_bass_boost(self, boost_db, cutoff=200): """Apply bass boost with adjustable cutoff""" if self.audio_data is None: return False nyquist = 0.5 * self.sample_rate normal_cutoff = cutoff / nyquist b, a = signal.butter(4, normal_cutoff, btype='low') if self.channels == 2: for ch in range(2): low = signal.filtfilt(b, a, self.audio_data[:, ch]) self.audio_data[:, ch] += (10 ** (boost_db / 20) - 1) * low else: low = signal.filtfilt(b, a, self.audio_data) self.audio_data += (10 ** (boost_db / 20) - 1) * low return True def apply_binaural(self, delay_ms=1, attenuation=0.5): """Apply binaural effect with adjustable delay and attenuation""" if self.audio_data is None or self.channels != 2: return False delay_samples = int(self.sample_rate * delay_ms / 1000) right_delayed = np.roll(self.audio_data[:, 1], delay_samples) right_delayed[:delay_samples] = 0 right_delayed = right_delayed * attenuation self.audio_data[:, 0] = self.audio_data[:, 0] + right_delayed self.audio_data[:, 1] = self.audio_data[:, 1] + right_delayed return True def apply_3d_surround(self, angle_deg=45): """3D surround effect with adjustable angle""" if self.audio_data is None or self.channels != 2: return False angle_rad = np.radians(angle_deg) left_gain = np.cos(angle_rad - np.pi/4) right_gain = np.sin(angle_rad - np.pi/4) self.audio_data[:, 0] *= left_gain self.audio_data[:, 1] *= right_gain return True def apply_8d_audio(self, speed=0.5): """8D audio effect with adjustable rotation speed""" if self.audio_data is None or self.channels != 2: return False length = len(self.audio_data) time = np.linspace(0, length/self.sample_rate, length) pan = np.sin(2 * np.pi * speed * time) left_gain = np.sqrt(1 - np.clip(pan, 0, 1)) right_gain = np.sqrt(1 - np.clip(-pan, 0, 1)) self.audio_data[:, 0] *= left_gain self.audio_data[:, 1] *= right_gain return True def play_audio(self): """Play processed audio""" if self.audio_data is None: return False # Convert to 16-bit PCM audio_int16 = (self.audio_data * 32767).astype(np.int16) self.play_obj = sa.play_buffer( audio_int16, num_channels=self.channels, bytes_per_sample=2, sample_rate=self.sample_rate ) return True def stop_audio(self): """Stop audio playback""" if self.play_obj: self.play_obj.stop() return True return False def save_audio(self, file_path): """Save processed audio to file""" if self.audio_data is None: return False try: sf.write(file_path, self.audio_data, self.sample_rate) return True except Exception as e: print(f"Error saving audio: {e}") return False def get_audio_spectrum(self): """Get frequency spectrum for visualization""" if self.audio_data is None: return None, None if self.channels == 2: data = self.audio_data[:, 0] # Use left channel else: data = self.audio_data n = len(data) yf = fft(data) xf = np.linspace(0, self.sample_rate/2, n//2) return xf, 2/n * np.abs(yf[:n//2]) import tkinter as tk from tkinter import ttk, filedialog import matplotlib.pyplot as plt from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk from audio_effects import AudioEffects import numpy as np class EqualizerUI: def __init__(self, root): self.root = root self.root.title("Advanced Audio Equalizer") self.root.geometry("1200x900") self.root.minsize(1000, 800) self.audio_effects = AudioEffects() self.current_file = None self.create_widgets() def create_widgets(self): # Configure style style = ttk.Style() style.configure('TFrame', background='#f0f0f0') style.configure('TLabel', background='#f0f0f0') style.configure('TButton', padding=5) style.configure('TScale', background='#f0f0f0') # Main container main_frame = ttk.Frame(self.root) main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10) # File controls file_frame = ttk.LabelFrame(main_frame, text="File Controls", padding=10) file_frame.pack(fill=tk.X, pady=(0, 10)) ttk.Button(file_frame, text="Open File", command=self.open_file).pack(side=tk.LEFT, padx=5) ttk.Button(file_frame, text="Save As", command=self.save_file).pack(side=tk.LEFT, padx=5) ttk.Button(file_frame, text="Play", command=self.play_audio).pack(side=tk.LEFT, padx=5) ttk.Button(file_frame, text="Stop", command=self.stop_audio).pack(side=tk.LEFT, padx=5) self.status_label = ttk.Label(file_frame, text="No file loaded") self.status_label.pack(side=tk.LEFT, padx=10, expand=True) # Visualization frame vis_frame = ttk.LabelFrame(main_frame, text="Audio Visualization", padding=10) vis_frame.pack(fill=tk.BOTH, expand=True, pady=(0, 10)) self.fig, (self.wave_ax, self.spectrum_ax) = plt.subplots(2, 1, figsize=(10, 6)) self.canvas = FigureCanvasTkAgg(self.fig, master=vis_frame) self.canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True) # Add navigation toolbar toolbar = NavigationToolbar2Tk(self.canvas, vis_frame) toolbar.update() # Effects frame effects_frame = ttk.Frame(main_frame) effects_frame.pack(fill=tk.BOTH, expand=True) # Left panel - basic controls left_panel = ttk.LabelFrame(effects_frame, text="Basic Controls", padding=10) left_panel.pack(side=tk.LEFT, fill=tk.Y, padx=(0, 10)) # Volume control ttk.Label(left_panel, text="Volume (dB):").pack() self.volume_slider = ttk.Scale(left_panel, from_=-20, to=20, length=200) self.volume_slider.set(0) self.volume_slider.pack() self.volume_value = ttk.Label(left_panel, text="0.0 dB") self.volume_value.pack() self.volume_slider.bind("", lambda e: self.update_volume()) # Bass boost ttk.Label(left_panel, text="Bass Boost (dB):").pack(pady=(10, 0)) self.bass_slider = ttk.Scale(left_panel, from_=0, to=20, length=200) self.bass_slider.set(0) self.bass_slider.pack() self.bass_value = ttk.Label(left_panel, text="0.0 dB") self.bass_value.pack() self.bass_slider.bind("", lambda e: self.update_bass_boost()) # EQ bands ttk.Label(left_panel, text="Equalizer Bands:", padding=(0, 10)).pack() self.eq_sliders = [] self.eq_labels = [] eq_bands = [50, 100, 200, 400, 800, 1600, 3200, 6400, 12800, 16000] for i, freq in enumerate(eq_bands): frame = ttk.Frame(left_panel) frame.pack(fill=tk.X) ttk.Label(frame, text=f"{freq} Hz", width=8).pack(side=tk.LEFT) slider = ttk.Scale(frame, from_=-12, to=12, length=150) slider.set(0) slider.pack(side=tk.LEFT, padx=5) label = ttk.Label(frame, text="0.0 dB", width=8) label.pack(side=tk.LEFT) slider.bind("", lambda e, idx=i: self.update_eq_band(idx)) self.eq_sliders.append(slider) self.eq_labels.append(label) # Right panel - advanced effects right_panel = ttk.LabelFrame(effects_frame, text="Advanced Effects", padding=10) right_panel.pack(side=tk.LEFT, fill=tk.BOTH, expand=True) # Binaural effect binaural_frame = ttk.LabelFrame(right_panel, text="Binaural Effect", padding=10) binaural_frame.pack(fill=tk.X, pady=(0, 10)) ttk.Label(binaural_frame, text="Delay (ms):").pack() self.binaural_delay = ttk.Scale(binaural_frame, from_=0.1, to=10, length=300) self.binaural_delay.set(1) self.binaural_delay.pack() self.binaural_delay_value = ttk.Label(binaural_frame, text="1.0 ms") self.binaural_delay_value.pack() ttk.Label(binaural_frame, text="Attenuation:").pack() self.binaural_atten = ttk.Scale(binaural_frame, from_=0, to=1, length=300) self.binaural_atten.set(0.5) self.binaural_atten.pack() self.binaural_atten_value = ttk.Label(binaural_frame, text="0.5") self.binaural_atten_value.pack() self.binaural_delay.bind("", lambda e: self.update_binaural()) self.binaural_atten.bind("", lambda e: self.update_binaural()) # 3D Surround surround_frame = ttk.LabelFrame(right_panel, text="3D Surround", padding=10) surround_frame.pack(fill=tk.X, pady=(0, 10)) ttk.Label(surround_frame, text="Sound Angle:").pack() self.surround_angle = ttk.Scale(surround_frame, from_=0, to=360, length=300) self.surround_angle.set(45) self.surround_angle.pack() self.surround_angle_value = ttk.Label(surround_frame, text="45°") self.surround_angle_value.pack() self.surround_angle.bind("", lambda e: self.update_3d_surround()) # 8D Audio eightd_frame = ttk.LabelFrame(right_panel, text="8D Audio", padding=10) eightd_frame.pack(fill=tk.X) ttk.Label(eightd_frame, text="Rotation Speed:").pack() self.eightd_speed = ttk.Scale(eightd_frame, from_=0.1, to=2, length=300) self.eightd_speed.set(0.5) self.eightd_speed.pack() self.eightd_speed_value = ttk.Label(eightd_frame, text="0.5") self.eightd_speed_value.pack() self.eightd_speed.bind("", lambda e: self.update_8d_audio()) # Initialize empty plots self.update_visualization() def open_file(self): file_path = filedialog.askopenfilename( filetypes=[ ("Audio Files", "*.wav *.mp3 *.ogg *.flac *.aac *.m4a"), ("All Files", "*.*") ] ) if file_path: self.current_file = file_path if self.audio_effects.load_audio(file_path): self.status_label.config(text=f"Loaded: {file_path}") self.update_visualization() self.apply_all_effects() else: self.status_label.config(text="Error loading file") def save_file(self): if not self.current_file: return file_path = filedialog.asksaveasfilename( defaultextension=".wav", filetypes=[("WAV Files", "*.wav"), ("FLAC Files", "*.flac"), ("All Files", "*.*")] ) if file_path: if self.audio_effects.save_audio(file_path): self.status_label.config(text=f"Saved to: {file_path}") else: self.status_label.config(text="Error saving file") def play_audio(self): if self.current_file: self.audio_effects.play_audio() def stop_audio(self): self.audio_effects.stop_audio() def update_visualization(self): self.wave_ax.clear() self.spectrum_ax.clear() if self.audio_effects.audio_data is not None: # Waveform plot data = self.audio_effects.audio_data if self.audio_effects.channels == 2: data = data[:, 0] # Show left channel # Downsample for better performance if len(data) > 5000: step = len(data) // 5000 data = data[::step] time = np.linspace(0, len(data)/self.audio_effects.sample_rate, len(data)) self.wave_ax.plot(time, data) self.wave_ax.set_title("Waveform") self.wave_ax.set_xlabel("Time (s)") self.wave_ax.set_ylabel("Amplitude") # Spectrum plot xf, yf = self.audio_effects.get_audio_spectrum() if xf is not None and yf is not None: self.spectrum_ax.semilogx(xf, yf) self.spectrum_ax.set_title("Frequency Spectrum") self.spectrum_ax.set_xlabel("Frequency (Hz)") self.spectrum_ax.set_ylabel("Magnitude") self.spectrum_ax.set_xlim(20, 20000) self.fig.tight_layout() self.canvas.draw() def apply_all_effects(self): self.update_volume() self.update_bass_boost() self.update_eq_bands() self.update_binaural() self.update_3d_surround() self.update_8d_audio() self.update_visualization() def update_volume(self, *args): if self.current_file: value = self.volume_slider.get() self.volume_value.config(text=f"{value:.1f} dB") self.audio_effects.apply_volume(value) self.update_visualization() def update_bass_boost(self, *args): if self.current_file: value = self.bass_slider.get() self.bass_value.config(text=f"{value:.1f} dB") self.audio_effects.apply_bass_boost(value) self.update_visualization() def update_eq_bands(self, *args): if self.current_file: gains = [slider.get() for slider in self.eq_sliders] for i, gain in enumerate(gains): self.eq_labels[i].config(text=f"{gain:.1f} dB") self.audio_effects.apply_eq(gains) self.update_visualization() def update_eq_band(self, index): if self.current_file: gain = self.eq_sliders[index].get() self.eq_labels[index].config(text=f"{gain:.1f} dB") self.update_eq_bands() def update_binaural(self, *args): if self.current_file and self.audio_effects.channels == 2: delay = self.binaural_delay.get() atten = self.binaural_atten.get() self.binaural_delay_value.config(text=f"{delay:.1f} ms") self.binaural_atten_value.config(text=f"{atten:.2f}") self.audio_effects.apply_binaural(delay, atten) self.update_visualization() def update_3d_surround(self, *args): if self.current_file and self.audio_effects.channels == 2: angle = self.surround_angle.get() self.surround_angle_value.config(text=f"{angle:.0f}°") self.audio_effects.apply_3d_surround(angle) self.update_visualization() def update_8d_audio(self, *args): if self.current_file and self.audio_effects.channels == 2: speed = self.eightd_speed.get() self.eightd_speed_value.config(text=f"{speed:.1f}") self.audio_effects.apply_8d_audio(speed) self.update_visualization() from equalizer_ui import EqualizerUI import tkinter as tk def main(): root = tk.Tk() app = EqualizerUI(root) root.mainloop() if __name__ == "__main__": main() This complete audio equalizer application includes: 1. **Audio Processing Features**: - Volume control (+/- 20dB) - 10-band equalizer (50Hz to 16kHz) - Bass boost (0-20dB) - Binaural effect with adjustable delay and attenuation - 3D surround sound with angle control - 8D audio effect with rotation speed control 2. **Visualization**: - Waveform display - Frequency spectrum analyzer - Interactive zoom/pan with matplotlib toolbar 3. **File Support**: - Loads multiple formats (WAV, MP3, OGG, FLAC, AAC, M4A) - Saves to WAV or FLAC - Works offline on Windows 10 4. **User Interface**: - Clean, organized layout with labeled controls - Real-time value displays for all parameters - Responsive sliders with smooth updates - Status feedback for file operations The application is structured into three main files for maintainability: - `audio_effects.py` handles all audio processing - `equalizer_ui.py` manages the GUI and visualization - `main.py` launches the application All requested libraries are used appropriately: - `tkinter` for the GUI - `numpy` and `scipy` for audio processing - `pydub` for file loading - `simpleaudio` for playback - `soundfile` for saving - `matplotlib` for visualization