# Professional 10-Band Graphic Equalizer for iPad

I'll design a professional 10-band graphic equalizer for iPad that supports multiple audio formats and provides real-time visual feedback. Here's my implementation using Swift and SwiftUI:

```swift
import SwiftUI
import AVFoundation
import Accelerate

struct ContentView: View {
    @State private var audioEngine = AVAudioEngine()
    @State private var playerNode = AVAudioPlayerNode()
    @State private var equalizer = AVAudioUnitEQ(numberOfBands: 10)
    @State private var audioFile: AVAudioFile?
    @State private var isPlaying = false
    @State private var currentTime: TimeInterval = 0
    @State private var duration: TimeInterval = 0
    @State private var timer: Timer?
    
    // Equalizer band gains (-12 to +12 dB)
    @State private var bandGains: [Float] = Array(repeating: 0.0, count: 10)
    
    // Band frequencies
    private let frequencies: [Float] = [32, 64, 125, 250, 500, 1000, 2000, 4000, 8000, 16000]
    
    // Presets
    private let presets: [String: [Float]] = [
        "Flat": Array(repeating: 0.0, count: 10),
        "Bass Boost": [8.0, 6.0, 4.0, 2.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
        "Treble Boost": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.0, 4.0, 6.0, 8.0],
        "Vocal": [0.0, 0.0, -2.0, -1.0, 2.0, 4.0, 4.0, 2.0, 0.0, 0.0],
        "Rock": [5.0, 4.0, 3.0, -1.0, -1.0, 2.0, 4.0, 6.0, 6.0, 5.0],
        "Jazz": [3.0, 2.0, 1.0, 2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0],
        "Classical": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -2.0, -2.0, -2.0, -2.0],
        "Electronic": [6.0, 5.0, 0.0, -2.0, 0.0, 2.0, 4.0, 5.0, 6.0, 7.0]
    ]
    
    var body: some View {
        VStack {
            // File selection and playback controls
            HStack {
                Button("Load Audio File") {
                    loadAudioFile()
                }
                .padding()
                
                Spacer()
                
                Button(action: {
                    if isPlaying {
                        pausePlayback()
                    } else {
                        startPlayback()
                    }
                }) {
                    Image(systemName: isPlaying ? "pause.fill" : "play.fill")
                        .font(.title)
                }
                
                Button(action: {
                    stopPlayback()
                }) {
                    Image(systemName: "stop.fill")
                        .font(.title)
                }
            }
            .padding()
            
            // Progress bar
            if duration > 0 {
                Slider(value: $currentTime, in: 0...duration, onEditingChanged: { _ in
                    seekToTime(currentTime)
                })
                .padding()
                
                HStack {
                    Text(formatTime(currentTime))
                    Spacer()
                    Text(formatTime(duration))
                }
                .padding(.horizontal)
            }
            
            // Equalizer visualization
            EqualizerVisualization(bandGains: bandGains, frequencies: frequencies)
                .frame(height: 150)
                .padding()
            
            // Equalizer band controls
            ScrollView(.horizontal, showsIndicators: false) {
                HStack(spacing: 15) {
                    ForEach(0..<10, id: \.self) { index in
                        VStack {
                            Text("\(frequencies[index])")
                                .font(.caption)
                            
                            Slider(value: $bandGains[index], in: -12...12, step: 0.5)
                                .frame(width: 40, height: 150)
                                .rotationEffect(.degrees(-90))
                                .onChange(of: bandGains[index]) { _ in
                                    updateEqualizerBand(index, gain: bandGains[index])
                                }
                            
                            Text("\(String(format: "%.1f", bandGains[index])) dB")
                                .font(.caption)
                        }
                        .frame(width: 70)
                    }
                }
                .padding()
            }
            
            // Preset buttons
            ScrollView(.horizontal, showsIndicators: false) {
                HStack(spacing: 10) {
                    ForEach(Array(presets.keys.sorted()), id: \.self) { presetName in
                        Button(presetName) {
                            applyPreset(presetName)
                        }
                        .padding(.horizontal, 10)
                        .padding(.vertical, 5)
                        .background(Color.blue.opacity(0.2))
                        .cornerRadius(8)
                    }
                }
                .padding()
            }
            
            Spacer()
        }
        .onAppear {
            setupAudioEngine()
        }
        .onDisappear {
            stopPlayback()
        }
    }
    
    private func setupAudioEngine() {
        // Configure equalizer bands
        for i in 0..<10 {
            equalizer.bands[i].frequency = frequencies[i]
            equalizer.bands[i].bandwidth = 1.0
            equalizer.bands[i].bypass = false
            equalizer.bands[i].filterType = .parametric
            equalizer.bands[i].gain = 0.0
        }
        
        // Connect audio nodes
        audioEngine.attach(playerNode)
        audioEngine.attach(equalizer)
        audioEngine.connect(playerNode, to: equalizer, format: nil)
        audioEngine.connect(equalizer, to: audioEngine.mainMixerNode, format: nil)
        
        do {
            try audioEngine.start()
        } catch {
            print("Error starting audio engine: \(error)")
        }
    }
    
    private func loadAudioFile() {
        let documentPicker = UIDocumentPickerViewController(forOpeningContentTypes: [.audio, .movie])
        documentPicker.delegate = DocumentPickerDelegate { url in
            do {
                audioFile = try AVAudioFile(forReading: url)
                duration = Double(audioFile?.length ?? 0) / (audioFile?.fileFormat.sampleRate ?? 44100)
                currentTime = 0
            } catch {
                print("Error loading audio file: \(error)")
            }
        }
        
        if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
           let window = windowScene.windows.first {
            window.rootViewController?.present(documentPicker, animated: true)
        }
    }
    
    private func startPlayback() {
        guard let audioFile = audioFile else { return }
        
        playerNode.scheduleFile(audioFile, at: nil)
        playerNode.play()
        isPlaying = true
        
        // Start timer to update current time
        timer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { _ in
            if let nodeTime = playerNode.lastRenderTime,
               let playerTime = playerNode.playerTime(forNodeTime: nodeTime) {
                currentTime = Double(playerTime.sampleTime) / playerTime.sampleRate
            }
        }
    }
    
    private func pausePlayback() {
        playerNode.pause()
        isPlaying = false
        timer?.invalidate()
        timer = nil
    }
    
    private func stopPlayback() {
        playerNode.stop()
        isPlaying = false
        currentTime = 0
        timer?.invalidate()
        timer = nil
    }
    
    private func seekToTime(_ time: TimeInterval) {
        guard let audioFile = audioFile else { return }
        
        let sampleRate = audioFile.processingFormat.sampleRate
        let sampleTime = AVAudioFramePosition(time * sampleRate)
        
        playerNode.stop()
        playerNode.scheduleSegment(audioFile, startingFrame: sampleTime, frameCount: AVAudioFrameCount(audioFile.length - sampleTime), at: nil)
        
        if isPlaying {
            playerNode.play()
        }
    }
    
    private func updateEqualizerBand(_ index: Int, gain: Float) {
        equalizer.bands[index].gain = gain
    }
    
    private func applyPreset(_ presetName: String) {
        guard let preset = presets[presetName] else { return }
        
        for i in 0..<10 {
            bandGains[i] = preset[i]
            updateEqualizerBand(i, gain: preset[i])
        }
    }
    
    private func formatTime(_ time: TimeInterval) -> String {
        let minutes = Int(time) / 60
        let seconds = Int(time) % 60
        return String(format: "%d:%02d", minutes, seconds)
    }
}

struct EqualizerVisualization: View {
    let bandGains: [Float]
    let frequencies: [Float]
    
    var body: some View {
        GeometryReader { geometry in
            Path { path in
                let width = geometry.size.width
                let height = geometry.size.height
                let bandWidth = width / CGFloat(bandGains.count - 1)
                
                // Start from the bottom left
                path.move(to: CGPoint(x: 0, y: height))
                
                // Draw the curve
                for i in 0..<bandGains.count {
                    let x = CGFloat(i) * bandWidth
                    // Convert gain (-12 to +12) to y position (0 to height)
                    let normalizedGain = (bandGains[i] + 12) / 24
                    let y = height - (normalizedGain * height)
                    
                    if i == 0 {
                        path.move(to: CGPoint(x: x, y: y))
                    } else {
                        path.addLine(to: CGPoint(x: x, y: y))
                    }
                }
                
                // Complete the path
                path.addLine(to: CGPoint(x: width, y: height))
                path.addLine(to: CGPoint(x: 0, y: height))
                path.closeSubpath()
            }
            .fill(LinearGradient(
                gradient: Gradient(colors: [Color.blue.opacity(0.6), Color.blue.opacity(0.2)]),
                startPoint: .top,
                endPoint: .bottom
            ))
            .overlay(
                Path { path in
                    let width = geometry.size.width
                    let height = geometry.size.height
                    let bandWidth = width / CGFloat(bandGains.count - 1)
                    
                    for i in 0..<bandGains.count {
                        let x = CGFloat(i) * bandWidth
                        let normalizedGain = (bandGains[i] + 12) / 24
                        let y = height - (normalizedGain * height)
                        
                        if i == 0 {
                            path.move(to: CGPoint(x: x, y: y))
                        } else {
                            path.addLine(to: CGPoint(x: x, y: y))
                        }
                    }
                }
                .stroke(Color.blue, lineWidth: 2)
            )
            
            // Draw frequency labels
            HStack {
                ForEach(0..<frequencies.count, id: \.self) { i in
                    Text("\(frequencies[i])")
                        .font(.caption2)
                        .frame(maxWidth: .infinity)
                }
            }
            .padding(.top, 5)
        }
    }
}

class DocumentPickerDelegate: NSObject, UIDocumentPickerDelegate {
    var onDocumentPicked: ((URL) -> Void)?
    
    init(onDocumentPicked: ((URL) -> Void)? = nil) {
        self.onDocumentPicked = onDocumentPicked
        super.init()
    }
    
    func documentPicker(_ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
        guard let url = urls.first else { return }
        onDocumentPicked?(url)
    }
}

@main
struct EqualizerApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
```

## Key Features:

1. **Multi-format Audio Support**: The app uses AVFoundation to support M4A, WAV, MP3, and other common audio formats.

2. **10-Band Equalizer**: Professional-grade equalizer with bands centered at standard frequencies:
   - 32Hz, 64Hz, 125Hz, 250Hz, 500Hz
   - 1kHz, 2kHz, 4kHz, 8kHz, 16kHz

3. **Real-time Visualization**: A graphical display that shows the equalizer curve with a gradient fill and smooth line.

4. **Precise Controls**: Each band has a vertical slider with a range of -12dB to +12dB in 0.5dB steps.

5. **Playback Controls**: Full play, pause, stop, and seek functionality with a progress bar.

6. **Preset System**: Includes 8 professionally tuned presets for different music genres and listening preferences.

7. **Professional UI**: Clean, intuitive interface optimized for iPad's larger screen.

## How to Use:

1. Create a new SwiftUI project in Xcode
2. Replace the ContentView.swift file with the code above
3. Build and run on an iPad or iPad simulator

The app will request permission to access files when the user taps "Load Audio File", and then they can select any supported audio format to play and equalize.