Maestría en AudioKit: Creación de Apps de Música y Procesamiento de Audio en iOS con Swift

🚀 Introducción a AudioKit: El Sonido en Tus Manos

El desarrollo de aplicaciones de audio en iOS puede ser un desafío debido a la complejidad de los frameworks de bajo nivel como Core Audio. Sin embargo, AudioKit emerge como una solución robusta y accesible, ofreciendo una capa de abstracción de alto nivel que simplifica enormemente la creación de sintetizadores, efectos, procesadores de audio y herramientas de visualización de sonido. Este tutorial está diseñado para desarrolladores iOS que desean integrar capacidades de audio avanzadas en sus aplicaciones, ya sea para instrumentos musicales, grabadoras, reproductores o simplemente para añadir un toque interactivo y sonoro a sus proyectos.

AudioKit es una poderosa biblioteca de código abierto escrita en Swift que se construye sobre las capacidades de Core Audio y AVFoundation de Apple. Su objetivo principal es hacer que el desarrollo de audio sea más fácil y divertido, permitiendo a los desarrolladores centrarse en la creatividad en lugar de en la gestión de buffers y threads de audio. Con AudioKit, puedes desde reproducir un simple tono hasta construir un complejo sintetizador polifónico con múltiples osciladores, filtros y efectos, todo con relativamente pocas líneas de código.

¿Por qué AudioKit? 🎶

AudioKit destaca por varias razones clave que lo hacen una elección preferente para muchos desarrolladores de audio en iOS:

• Simplicidad: Abstrae la complejidad de Core Audio, ofreciendo una API intuitiva.
• Potencia: Permite construir aplicaciones de audio profesionales, desde sintetizadores hasta DAWs.
• Flexibilidad: Ofrece una gran variedad de nodos de audio preconstruidos y la capacidad de crear los tuyos propios.
• Comunidad: Cuenta con una comunidad activa y una excelente documentación.
• Rendimiento: Optimizado para un rendimiento de audio de baja latencia.

🛠️ Configuración Inicial y Primeros Pasos con AudioKit

Antes de sumergirnos en la creación de sonido, necesitamos configurar nuestro proyecto iOS para usar AudioKit. La forma más sencilla y recomendada es a través de Swift Package Manager (SPM).

1. Creando un Nuevo Proyecto Xcode

Comienza creando un nuevo proyecto de iOS en Xcode. Selecciona la plantilla App (iOS -> App). Dale un nombre significativo, por ejemplo, MiAppDeAudioKit. Asegúrate de que la interfaz sea SwiftUI (o UIKit si lo prefieres, AudioKit es compatible con ambos).

2. Integrando AudioKit con Swift Package Manager

Sigue estos pasos para añadir AudioKit a tu proyecto:

1. En Xcode, ve a File > Add Packages....
2. En la barra de búsqueda superior derecha, pega la URL del repositorio de AudioKit: https://github.com/AudioKit/AudioKit.
3. Selecciona la versión más reciente (o una rama específica si lo necesitas) y haz clic en Add Package.
4. Xcode procesará las dependencias y te preguntará qué bibliotecas quieres añadir a tu objetivo. Asegúrate de seleccionar AudioKit y AudioKitEX (este último contiene algunas utilidades y extensiones útiles).

Una vez que los paquetes se han añadido, Xcode los compilará y estarán listos para usar en tu proyecto.

3. Solicitando Permisos de Micrófono (Si es Necesario)

Si tu aplicación va a grabar audio del micrófono o procesar entrada en tiempo real, necesitarás solicitar el permiso del usuario. Añade la siguiente clave a tu archivo Info.plist:

• Key: Privacy - Microphone Usage Description
• Value: Necesitamos acceso a tu micrófono para grabar audio. (Personaliza el mensaje)

Sin este permiso, tu aplicación fallará al intentar acceder al micrófono.

4. Inicializando el Motor de AudioKit

El corazón de cualquier aplicación de AudioKit es el AudioEngine. Debes inicializarlo y arrancarlo antes de poder reproducir o procesar cualquier sonido. Es buena práctica hacerlo al inicio de tu aplicación o cuando necesites comenzar las operaciones de audio.

import AudioKit

class AudioManager: ObservableObject {
    let engine = AudioEngine()

    init() {
        // Configuración inicial del motor de audio
        do {
            Settings.bufferLength = .short
            try Settings.set){AudioSessionCategory(.playAndRecord, options: [.defaultToSpeaker, .allowBluetooth])
        } catch {
            print("Error al configurar la sesión de audio: \(error)")
        }
    }

    func start() {
        do {
            try engine.start()
            print("AudioEngine iniciado.")
        } catch {
            print("Error al iniciar AudioEngine: \(error)")
        }
    }

    func stop() {
        engine.stop()
        print("AudioEngine detenido.")
    }
}

// Ejemplo de uso en SwiftUI
struct ContentView: View {
    @StateObject var audioManager = AudioManager()

    var body: some View {
        VStack {
            Text("Mi App de AudioKit")
            Button("Iniciar Audio") {
                audioManager.start()
            }
            Button("Detener Audio") {
                audioManager.stop()
            }
        }
        .onAppear {
            // Puedes iniciar el audio automáticamente al aparecer la vista si es necesario
        }
        .onDisappear {
            audioManager.stop()
        }
    }
}

En este ejemplo, creamos un AudioManager que envuelve nuestro AudioEngine. Lo inicializamos con algunas Settings para la sesión de audio, permitiendo reproducir y grabar (.playAndRecord) y forzando la salida por el altavoz (.defaultToSpeaker). Luego, proporcionamos métodos para iniciar y detener el motor.

🎼 Generando Sonido: Osciladores y Sintetizadores Básicos

AudioKit proporciona una variedad de nodos de audio que puedes conectar para generar y procesar sonido. Uno de los más fundamentales es el oscilador, que produce formas de onda básicas (seno, cuadrada, sierra, triangular).

El Nudo Oscillator

Un Oscillator es el punto de partida para muchos sonidos. Vamos a crear un simple sintetizador que reproduce un tono de onda sinusoidal.

import AudioKit
import AudioKitEX
import SoundpipeAudioKit
import SwiftUI

class SynthesizerManager: ObservableObject {
    let engine = AudioEngine()
    var oscillator: Oscillator // Usaremos un AudioKit.Oscillator

    init() {
        // Inicializamos el oscilador con una frecuencia y amplitud por defecto
        oscillator = Oscillator(waveform: Table(.sine))
        oscillator.amplitude = 0.5 // Volumen a la mitad
        oscillator.frequency = 440.0 // Tono La (A4)

        // Conectamos el oscilador directamente a la salida del motor
        engine.output = oscillator

        do {
            Settings.bufferLength = .short
            try Settings.setAudioSessionCategory(.playback, options: [.defaultToSpeaker])
        } catch {
            print("Error al configurar la sesión de audio: \(error)")
        }
    }

    func startOscillator() {
        do {
            try engine.start()
            oscillator.start()
            print("Oscilador iniciado.")
        } catch {
            print("Error al iniciar AudioEngine o oscilador: \(error)")
        }
    }

    func stopOscillator() {
        oscillator.stop()
        engine.stop()
        print("Oscilador detenido.")
    }

    func setFrequency(_ freq: Double) {
        oscillator.frequency = freq
    }

    func setAmplitude(_ amp: Double) {
        oscillator.amplitude = amp
    }
}

struct SynthesizerView: View {
    @StateObject var synthManager = SynthesizerManager()
    @State private var frequency: Double = 440.0
    @State private var amplitude: Double = 0.5

    var body: some View {
        VStack(spacing: 20) {
            Text("Sintetizador Básico")
                .font(.largeTitle)
                .fontWeight(.bold)

            HStack {
                Text("Frecuencia: \(frequency, specifier: "%.1f") Hz")
                Slider(value: $frequency, in: 20.0...2000.0) {
                    Text("Frecuencia")
                } onEditingChanged: { _ in
                    synthManager.setFrequency(frequency)
                }
            }
            .padding(.horizontal)

            HStack {
                Text("Amplitud: \(amplitude, specifier: "%.2f")")
                Slider(value: $amplitude, in: 0.0...1.0) {
                    Text("Amplitud")
                } onEditingChanged: { _ in
                    synthManager.setAmplitude(amplitude)
                }
            }
            .padding(.horizontal)

            HStack {
                Button("Iniciar Tono") {
                    synthManager.startOscillator()
                }
                .padding()
                .background(Color.green)
                .foregroundColor(.white)
                .cornerRadius(10)

                Button("Detener Tono") {
                    synthManager.stopOscillator()
                }
                .padding()
                .background(Color.red)
                .foregroundColor(.white)
                .cornerRadius(10)
            }

            Spacer()
        }
        .onDisappear {
            synthManager.stopOscillator()
        }
        .padding()
    }
}

En este código:

1. Creamos una instancia de Oscillator usando Table(.sine) para generar una onda sinusoidal. AudioKit proporciona diferentes tipos de formas de onda (.square, .sawtooth, .triangle).
2. Ajustamos su amplitude (volumen, de 0 a 1) y frequency (tono en Hz).
3. Conectamos el oscilador a la salida del engine (engine.output = oscillator).
4. Los métodos startOscillator() y stopOscillator() controlan la reproducción.
5. La interfaz de SwiftUI permite ajustar la frecuencia y la amplitud con sliders.

Múltiples Osciladores y Mezcladores 🎚️

Para crear sonidos más ricos, puedes usar múltiples osciladores y mezclarlos. AudioKit facilita esto con el nodo Mixer.

import AudioKit
import AudioKitEX
import SoundpipeAudioKit
import SwiftUI

class MultiSynthManager: ObservableObject {
    let engine = AudioEngine()
    var oscillator1: Oscillator
    var oscillator2: Oscillator
    var mixer: Mixer

    init() {
        oscillator1 = Oscillator(waveform: Table(.sine))
        oscillator1.amplitude = 0.3
        oscillator1.frequency = 440.0

        oscillator2 = Oscillator(waveform: Table(.sawtooth))
        oscillator2.amplitude = 0.2
        oscillator2.frequency = 880.0 // Una octava más alta

        // Creamos un mezclador y le añadimos los dos osciladores como entradas
        mixer = Mixer(oscillator1, oscillator2)

        // Conectamos el mezclador a la salida del motor
        engine.output = mixer

        do {
            Settings.bufferLength = .short
            try Settings.setAudioSessionCategory(.playback, options: [.defaultToSpeaker])
        } catch {
            print("Error al configurar la sesión de audio: \(error)")
        }
    }

    func startSynths() {
        do {
            try engine.start()
            oscillator1.start()
            oscillator2.start()
            print("Sintetizadores iniciados.")
        } catch {
            print("Error al iniciar AudioEngine o sintetizadores: \(error)")
        }
    }

    func stopSynths() {
        oscillator1.stop()
        oscillator2.stop()
        engine.stop()
        print("Sintetizadores detenidos.")
    }

    func setOsc1Frequency(_ freq: Double) { oscillator1.frequency = freq }
    func setOsc2Frequency(_ freq: Double) { oscillator2.frequency = freq }
    // Añade más setters para amplitud si es necesario
}

// La vista SwiftUI sería similar, con sliders para ambos osciladores.

🎤 Grabación y Reproducción de Audio

La capacidad de grabar y reproducir audio es fundamental para muchas aplicaciones. AudioKit simplifica estas tareas, ya sea que quieras grabar del micrófono, reproducir un archivo de audio o una combinación de ambos.

1. Reproducción de Archivos de Audio 🎧

Para reproducir un archivo de audio (por ejemplo, un .wav o .mp3) que tengas en tu bundle de aplicación, usa el nodo AudioPlayer.

import AudioKit
import AudioKitEX
import AVFoundation
import SwiftUI

class AudioPlayerManager: ObservableObject {
    let engine = AudioEngine()
    var player: AudioPlayer
    @Published var isPlaying: Bool = false

    init() {
        guard let url = Bundle.main.url(forResource: "drumloop", withExtension: "wav") else {
            fatalError("No se encontró el archivo de audio 'drumloop.wav'")
        }

        do {
            // Carga el archivo de audio en el reproductor
            player = try AudioPlayer(url: url)
            player.isLooping = true // Opcional: para que se repita continuamente
            player.volume = 0.8

            // Conecta el reproductor a la salida del motor
            engine.output = player

            try Settings.setAudioSessionCategory(.playback, options: [.defaultToSpeaker])
        } catch {
            fatalError("Error al inicializar AudioPlayer: \(error)")
        }
    }

    func togglePlayback() {
        if engine.isRunning && player.isPlaying {
            player.stop()
            engine.stop()
            isPlaying = false
            print("Reproducción detenida.")
        } else {
            do {
                try engine.start()
                player.play()
                isPlaying = true
                print("Reproducción iniciada.")
            } catch {
                print("Error al iniciar reproducción: \(error)")
            }
        }
    }

    func stopPlayback() {
        player.stop()
        engine.stop()
        isPlaying = false
        print("Reproducción detenida.")
    }
}

struct AudioPlayerView: View {
    @StateObject var playerManager = AudioPlayerManager()

    var body: some View {
        VStack(spacing: 20) {
            Text("Reproductor de Audio")
                .font(.largeTitle)
                .fontWeight(.bold)

            Button(action: playerManager.togglePlayback) {
                Text(playerManager.isPlaying ? "Detener" : "Reproducir")
                    .font(.title2)
                    .padding()
                    .background(playerManager.isPlaying ? Color.red : Color.blue)
                    .foregroundColor(.white)
                    .cornerRadius(15)
            }
            .padding(.top, 40)

            Spacer()
        }
        .onDisappear {
            playerManager.stopPlayback()
        }
        .padding()
    }
}

Asegúrate de arrastrar un archivo de audio (drumloop.wav en este caso) a tu proyecto de Xcode para que esté disponible en el bundle de la aplicación.

2. Grabación de Audio 🎙️

Para grabar audio del micrófono, necesitarás un AudioRecorder. Recuerda que ya debes haber configurado los permisos del micrófono en Info.plist.

import AudioKit
import AudioKitEX
import AVFoundation
import SwiftUI

class AudioRecorderManager: ObservableObject {
    let engine = AudioEngine()
    var mic: AudioEngine.InputNode
    var recorder: AudioRecorder?
    var mixer: Mixer

    @Published var isRecording: Bool = false
    @Published var showRecordedFile: Bool = false
    @Published var recordedFileURL: URL? = nil

    init() {
        // El micrófono es el input principal del AudioEngine
        mic = engine.input!

        // Creamos un mezclador para el caso de que queramos añadir más nodos
        mixer = Mixer(mic)

        // Conectamos el mezclador a la salida del motor
        engine.output = mixer

        do {
            try Settings.setAudioSessionCategory(.record, options: [.defaultToSpeaker])
            // También podríamos usar .playAndRecord si queremos escuchar mientras grabamos
        } catch {
            print("Error al configurar la sesión de audio para grabación: \(error)")
        }
    }

    func startRecording() {
        do {
            let documentsPath = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
            let url = documentsPath.appendingPathComponent("recording_\(UUID().uuidString).wav")

            // Inicializamos el grabador con el nodo de entrada (mic) y la URL de destino
            recorder = try AudioRecorder(node: mic, file: url)

            try engine.start()
            try recorder?.record()
            isRecording = true
            showRecordedFile = false // Resetear para una nueva grabación
            print("Grabación iniciada en: \(url.lastPathComponent)")
        } catch {
            print("Error al iniciar grabación: \(error)")
        }
    }

    func stopRecording() {
        recorder?.stop()
        engine.stop()
        isRecording = false
        recordedFileURL = recorder?.audioFile?.url // Guardamos la URL del archivo grabado
        showRecordedFile = true
        print("Grabación detenida. Archivo: \(recordedFileURL?.lastPathComponent ?? "")")
    }

    func playLastRecording() {
        guard let url = recordedFileURL else { return }
        do {
            let player = try AudioPlayer(url: url)
            engine.output = player // Cambiamos el output para reproducir el archivo
            try engine.start()
            player.play()
            print("Reproduciendo última grabación.")
            // Añadir un observador para detener el motor cuando el archivo termine
            player.completionHandler = { [weak self] in
                self?.engine.stop()
                print("Reproducción de grabación finalizada.")
            }
        } catch {
            print("Error al reproducir grabación: \(error)")
        }
    }
}

struct AudioRecorderView: View {
    @StateObject var recorderManager = AudioRecorderManager()

    var body: some View {
        VStack(spacing: 20) {
            Text("Grabadora de Audio")
                .font(.largeTitle)
                .fontWeight(.bold)

            Button(action: recorderManager.isRecording ? recorderManager.stopRecording : recorderManager.startRecording) {
                Text(recorderManager.isRecording ? "Detener Grabación" : "Iniciar Grabación")
                    .font(.title2)
                    .padding()
                    .background(recorderManager.isRecording ? Color.red : Color.orange)
                    .foregroundColor(.white)
                    .cornerRadius(15)
            }
            .padding(.top, 40)

            if recorderManager.showRecordedFile && recorderManager.recordedFileURL != nil {
                VStack {
                    Text("Grabación guardada: \(recorderManager.recordedFileURL!.lastPathComponent)")
                        .font(.headline)
                        .padding(.top)
                    Button("Reproducir Grabación") {
                        recorderManager.playLastRecording()
                    }
                    .padding()
                    .background(Color.purple)
                    .foregroundColor(.white)
                    .cornerRadius(10)
                }
                .transition(.opacity)
            }

            Spacer()
        }
        .onDisappear {
            recorderManager.stopRecording()
        }
        .padding()
    }
}

En este ejemplo de grabación:

1. Accedemos al micrófono a través de engine.input!. Necesitarás un guard o manejo de errores si el input puede ser nil (por ejemplo, si no hay micrófono o permisos).
2. Creamos un AudioRecorder, pasándole el nodo del micrófono y una URL de destino para el archivo de audio. El archivo se guardará en el directorio de documentos de la aplicación.
3. startRecording() y stopRecording() controlan la grabación.
4. playLastRecording() demuestra cómo reproducir el archivo grabado, notando que necesitas reconfigurar engine.output al nuevo reproductor temporalmente.

🎛️ Aplicando Efectos de Audio y Procesamiento

Una de las características más potentes de AudioKit es su amplia gama de efectos de audio y procesadores. Puedes encadenar estos nodos para crear paisajes sonoros complejos. Algunos ejemplos comunes incluyen reverberación, delay, filtros, distorsión y ecualización.

Encadenando Nodos de Efecto

Vamos a tomar nuestro oscilador básico y añadirle un reverb y un delay.

import AudioKit
import AudioKitEX
import SoundpipeAudioKit
import SwiftUI

class EffectsManager: ObservableObject {
    let engine = AudioEngine()
    var oscillator: Oscillator
    var reverb: Reverb
    var delay: Delay
    var booster: Booster // Para controlar el volumen general

    init() {
        oscillator = Oscillator(waveform: Table(.sine))
        oscillator.amplitude = 0.4
        oscillator.frequency = 440.0

        // Creamos un nodo de reverberación
        reverb = Reverb(oscillator)
        reverb.loadFactoryPreset(.largeHall)
        reverb.dryWetMix = 0.5 // Mezcla de señal seca (original) y húmeda (con efecto)

        // Creamos un nodo de delay
        delay = Delay(reverb)
        delay.time = 0.3 // Tiempo del delay en segundos
        delay.feedback = 0.7 // Cantidad de repetición
        delay.dryWetMix = 0.4 // Mezcla de señal seca y húmeda

        // Añadimos un Booster para controlar el volumen final después de los efectos
        booster = Booster(delay)
        booster.gain = 1.0

        // El orden de los nodos es importante: oscilador -> reverb -> delay -> booster -> output
        engine.output = booster

        do {
            try Settings.setAudioSessionCategory(.playback, options: [.defaultToSpeaker])
        } catch {
            print("Error al configurar la sesión de audio: \(error)")
        }
    }

    func startSound() {
        do {
            try engine.start()
            oscillator.start()
            print("Sonido con efectos iniciado.")
        } catch {
            print("Error al iniciar AudioEngine o sonido: \(error)")
        }
    }

    func stopSound() {
        oscillator.stop()
        engine.stop()
        print("Sonido con efectos detenido.")
    }

    func setReverbMix(_ mix: Double) { reverb.dryWetMix = mix }
    func setDelayTime(_ time: Double) { delay.time = time }
    func setDelayFeedback(_ feedback: Double) { delay.feedback = feedback }
    func setBoosterGain(_ gain: Double) { booster.gain = gain }
    func setFrequency(_ freq: Double) { oscillator.frequency = freq }
}

struct EffectsView: View {
    @StateObject var effectsManager = EffectsManager()
    @State private var reverbMix: Double = 0.5
    @State private var delayTime: Double = 0.3
    @State private var delayFeedback: Double = 0.7
    @State private var boosterGain: Double = 1.0
    @State private var frequency: Double = 440.0

    var body: some View {
        VStack(spacing: 20) {
            Text("Sintetizador con Efectos")
                .font(.largeTitle)
                .fontWeight(.bold)

            Group {
                HStack {
                    Text("Frecuencia: \(frequency, specifier: "%.1f") Hz")
                    Slider(value: $frequency, in: 20.0...2000.0) {
                        Text("Frecuencia")
                    } onEditingChanged: { _ in
                        effectsManager.setFrequency(frequency)
                    }
                }

                HStack {
                    Text("Reverb Mix: \(reverbMix, specifier: "%.2f")")
                    Slider(value: $reverbMix, in: 0.0...1.0) {
                        Text("Reverb Mix")
                    } onEditingChanged: { _ in
                        effectsManager.setReverbMix(reverbMix)
                    }
                }

                HStack {
                    Text("Delay Time: \(delayTime, specifier: "%.2f") s")
                    Slider(value: $delayTime, in: 0.0...1.0) {
                        Text("Delay Time")
                    } onEditingChanged: { _ in
                        effectsManager.setDelayTime(delayTime)
                    }
                }

                HStack {
                    Text("Delay Feedback: \(delayFeedback, specifier: "%.2f")")
                    Slider(value: $delayFeedback, in: 0.0...1.0) {
                        Text("Delay Feedback")
                    } onEditingChanged: { _ in
                        effectsManager.setDelayFeedback(delayFeedback)
                    }
                }

                HStack {
                    Text("Volumen: \(boosterGain, specifier: "%.2f")")
                    Slider(value: $boosterGain, in: 0.0...2.0) {
                        Text("Volumen")
                    } onEditingChanged: { _ in
                        effectsManager.setBoosterGain(boosterGain)
                    }
                }
            }
            .padding(.horizontal)

            HStack {
                Button("Iniciar Sonido") {
                    effectsManager.startSound()
                }
                .padding()
                .background(Color.green)
                .foregroundColor(.white)
                .cornerRadius(10)

                Button("Detener Sonido") {
                    effectsManager.stopSound()
                }
                .padding()
                .background(Color.red)
                .foregroundColor(.white)
                .cornerRadius(10)
            }

            Spacer()
        }
        .onDisappear {
            effectsManager.stopSound()
        }
        .padding()
    }
}

Aquí, hemos creado una cadena de audio: oscillator -> reverb -> delay -> booster -> engine.output. Cada nodo procesa la señal del nodo anterior. La propiedad dryWetMix es común en muchos efectos y permite controlar la proporción entre la señal original (seca) y la señal procesada (húmeda).

📊 Visualización de Audio

Una parte crucial de muchas aplicaciones de audio es la visualización del sonido. AudioKit ofrece herramientas para mostrar ondas, espectros de frecuencia y medidores de nivel. Esto no solo mejora la experiencia del usuario, sino que también puede ser útil para depurar.

Medidores de Nivel y Espectro

AudioKitEX incluye vistas de SwiftUI listas para usar, como NodeOutputView que puede mostrar un espectrograma o un medidor de forma de onda. Para usar estas vistas, necesitas un nodo AmplitudeTap o FFTTap.

import AudioKit
import AudioKitEX
import SoundpipeAudioKit
import SwiftUI

class VisualizerManager: ObservableObject {
    let engine = AudioEngine()
    var oscillator: Oscillator
    var mixer: Mixer
    var fftTap: FFTTap // Para el espectro de frecuencia

    init() {
        oscillator = Oscillator(waveform: Table(.sine))
        oscillator.amplitude = 0.3
        oscillator.frequency = 440.0

        mixer = Mixer(oscillator)
        engine.output = mixer

        // Creamos un FFTTap para analizar el espectro de frecuencia del mezclador
        fftTap = FFTTap(mixer)

        do {
            try Settings.setAudioSessionCategory(.playback, options: [.defaultToSpeaker])
        } catch {
            print("Error al configurar la sesión de audio: \(error)")
        }
    }

    func startSound() {
        do {
            try engine.start()
            oscillator.start()
            print("Oscilador con visualización iniciado.")
        } catch {
            print("Error al iniciar AudioEngine o oscilador: \(error)")
        }
    }

    func stopSound() {
        oscillator.stop()
        engine.stop() // Detiene también el FFTTap
        print("Oscilador con visualización detenido.")
    }

    func setFrequency(_ freq: Double) {
        oscillator.frequency = freq
    }
}

struct VisualizerView: View {
    @StateObject var visualizerManager = VisualizerManager()
    @State private var frequency: Double = 440.0

    var body: some View {
        VStack(spacing: 20) {
            Text("Visualización de Audio")
                .font(.largeTitle)
                .fontWeight(.bold)

            HStack {
                Text("Frecuencia: \(frequency, specifier: "%.1f") Hz")
                Slider(value: $frequency, in: 20.0...2000.0) {
                    Text("Frecuencia")
                } onEditingChanged: { _ in
                    visualizerManager.setFrequency(frequency)
                }
            }
            .padding(.horizontal)

            // Visualizador de espectro de frecuencia
            // NodeOutputView toma un FFTTap o un AmplitudeTap como argumento
            NodeOutputView(visualizerManager.fftTap)
                .frame(height: 200)
                .border(Color.gray, width: 1)
                .padding()

            HStack {
                Button("Iniciar Sonido") {
                    visualizerManager.startSound()
                }
                .padding()
                .background(Color.green)
                .foregroundColor(.white)
                .cornerRadius(10)

                Button("Detener Sonido") {
                    visualizerManager.stopSound()
                }
                .padding()
                .background(Color.red)
                .foregroundColor(.white)
                .cornerRadius(10)
            }

            Spacer()
        }
        .onDisappear {
            visualizerManager.stopSound()
        }
        .padding()
    }
}

En este código, usamos FFTTap(mixer) para analizar la señal de audio que pasa por el mezclador. NodeOutputView luego utiliza estos datos para dibujar un espectrograma en tiempo real. Para visualizaciones de forma de onda, usarías AmplitudeTap en su lugar.

🎹 MIDI y Control de Instrumentos Virtuales

MIDI (Musical Instrument Digital Interface) es un estándar que permite la comunicación entre instrumentos musicales electrónicos y ordenadores. AudioKit tiene un excelente soporte para MIDI, lo que te permite crear teclados virtuales, recibir entrada de controladores MIDI externos y controlar tus sintetizadores virtuales.

1. Recibiendo Eventos MIDI

Para recibir eventos MIDI, AudioKit utiliza un MIDIIO object. Puedes registrarte como oyente para recibir mensajes MIDI.

import AudioKit
import AudioKitEX
import SoundpipeAudioKit
import SwiftUI

class MIDIControllerManager: ObservableObject {
    let engine = AudioEngine()
    var midi = MIDIIO()
    var sampler: Sampler
    
    // Para mostrar los mensajes MIDI recibidos
    @Published var midiMessage: String = "Esperando MIDI..."

    init() {
        // Inicializamos un Sampler para reproducir sonidos cuando se reciban notas MIDI
        // Un Sampler puede cargar archivos de sonido (por ejemplo, un SoundFont o un WAV)
        // Para simplificar, aquí usaremos un oscilador para simular el sonido.
        // En una app real, cargarías samples de piano, batería, etc.
        sampler = Sampler()
        do {
            try sampler.loadMelodicSoundFont("UprightPianoKW-SFZ") // Necesitarías este archivo en tu bundle
            // Alternativa simple si no tienes un SoundFont: conectar un oscilador al sampler
        } catch {
            print("Error al cargar SoundFont: \(error). Usando un oscilador de respaldo.")
            // Si falla la carga, podríamos configurar un oscilador como respaldo.
            // Sin embargo, para MIDI, el Sampler es más apropiado.
            // Para este ejemplo, asegúrate de tener 'UprightPianoKW-SFZ.sf2' en tu bundle
            // o usa un instrumento MIDI predefinido de AudioKit.
            // Para un ejemplo rápido sin SoundFont, usaremos un AKMIDISampler
            // let a = AKMIDISampler() - esto es de AudioKit 4, en AudioKit 5+ usamos Sampler
            // Necesitas un archivo sf2 o sfz para el Sampler o usar un generador de tono básico
            // Para este ejemplo, asumiremos un archivo sf2 está presente.
        }

        engine.output = sampler

        do {
            try Settings.setAudioSessionCategory(.playAndRecord, options: [.defaultToSpeaker, .allowBluetooth])
            try engine.start()
        } catch {
            print("Error al configurar o iniciar audio para MIDI: \(error)")
        }

        // Iniciar la configuración MIDI
        setupMIDI()
    }

    func setupMIDI() {
        midi.openInput() // Abrir todos los puertos de entrada MIDI disponibles
        midi.addListener(self) // Registrarse como oyente de MIDI
        print("MIDI Input abierto. Escuchando mensajes...")
    }

    func stopMIDI() {
        midi.closeInput()
        engine.stop()
        print("MIDI Input cerrado. AudioEngine detenido.")
    }
}

extension MIDIControllerManager: MIDIListener {
    func receivedMIDINoteOn(noteNumber: MIDINoteNumber, velocity: MIDIVelocity, channel: MIDIChannel, portID: MIDIInputID?, offset: MIDITimeStamp) {
        print("MIDI Note On: note=\(noteNumber), velocity=\(velocity)")
        DispatchQueue.main.async {
            self.midiMessage = "Note On: \(noteNumber) (Vel: \(velocity))"
        }
        sampler.play(noteNumber: noteNumber, velocity: velocity, channel: channel)
    }

    func receivedMIDINoteOff(noteNumber: MIDINoteNumber, velocity: MIDIVelocity, channel: MIDIChannel, portID: MIDIInputID?, offset: MIDITimeStamp) {
        print("MIDI Note Off: note=\(noteNumber), velocity=\(velocity)")
        DispatchQueue.main.async {
            self.midiMessage = "Note Off: \(noteNumber)"
        }
        sampler.stop(noteNumber: noteNumber, channel: channel)
    }

    func receivedMIDIController(_ controller: MIDIController, value: MIDINonRPNValue, channel: MIDIChannel, portID: MIDIInputID?, offset: MIDITimeStamp) {
        print("MIDI Controller: \(controller) value=\(value)")
        DispatchQueue.main.async {
            self.midiMessage = "Controlador: \(controller) (Valor: \(value))"
        }
    }

    // Implementar otros métodos de MIDIListener si es necesario
    func receivedMIDIAftertouch(_ pressure: MIDIChannelPressure, channel: MIDIChannel, portID: MIDIInputID?, offset: MIDITimeStamp) {}
    func receivedMIDIAftertouch(_ pressure: MIDIAftertouch, noteNumber: MIDINoteNumber, channel: MIDIChannel, portID: MIDIInputID?, offset: MIDITimeStamp) {}
    func receivedMIDIPitchWheel(_ pitchWheelValue: MIDIPitchWheelValue, channel: MIDIChannel, portID: MIDIInputID?, offset: MIDITimeStamp) {}
    func receivedMIDIProgramChange(_ program: MIDIProgramChange, channel: MIDIChannel, portID: MIDIInputID?, offset: MIDITimeStamp) {}
    func receivedMIDIProtonMessage(data: [UInt8], portID: MIDIInputID?, offset: MIDITimeStamp) {}
    func receivedMIDISystemCommand(_ data: [UInt8], portID: MIDIInputID?, offset: MIDITimeStamp) {}
    func receivedMIDISetupChange() {
        print("MIDI Setup Changed.")
        // Vuelve a abrir la entrada si la configuración MIDI ha cambiado
        midi.closeInput()
        midi.openInput()
    }
    func receivedMIDIRawData(_ data: [UInt8], portID: MIDIInputID?, offset: MIDITimeStamp) {}
}

struct MIDIControlView: View {
    @StateObject var midiManager = MIDIControllerManager()

    var body: some View {
        VStack(spacing: 20) {
            Text("Control MIDI y Sampler")
                .font(.largeTitle)
                .fontWeight(.bold)

            Text(midiManager.midiMessage)
                .font(.title3)
                .padding()
                .background(Color.gray.opacity(0.2))
                .cornerRadius(10)

            Button("Reiniciar MIDI") {
                midiManager.stopMIDI()
                midiManager.setupMIDI()
            }
            .padding()
            .background(Color.blue)
            .foregroundColor(.white)
            .cornerRadius(10)

            Spacer()
        }
        .onAppear {
            midiManager.setupMIDI()
        }
        .onDisappear {
            midiManager.stopMIDI()
        }
        .padding()
    }
}

En este ejemplo, la clase MIDIControllerManager implementa el protocolo MIDIListener. Cuando se recibe un mensaje Note On (tecla presionada), el sampler.play se activa. Cuando se recibe un Note Off (tecla liberada), el sonido se detiene.

2. Creando un Teclado MIDI Virtual 🎹

AudioKitEX también proporciona una vista NodeTapView que permite crear un teclado MIDI en pantalla para probar tus instrumentos.

// Añade esta vista en tu ContentView o en la vista que controle el Sampler
struct KeyboardView: View {
    @StateObject var midiManager = MIDIControllerManager() // Reutilizamos el manager

    var body: some View {
        VStack {
            Text("Teclado Virtual")
                .font(.headline)

            // NodeTapView es un poco más genérica para visualizaciones.
            // Para un teclado MIDI específico, en AudioKit 4+ se usaba AKKeyboardView
            // En AudioKit 5+, a menudo se construye un teclado custom o se usa AudioKitUI/PianoView
            // Para este ejemplo, crearemos un teclado simple usando botones para simular MIDI

            VStack {
                Text("Toca una nota")
                HStack {
                    ForEach(60..<72) { noteNumber in // De C4 a B4 (MIDI 60-71)
                        Button(action: {
                            midiManager.sampler.play(noteNumber: MIDINoteNumber(noteNumber), velocity: 90, channel: 0)
                        }) {
                            Text("\(noteNumber)")
                                .frame(width: 40, height: 80)
                                .background(Color.black)
                                .foregroundColor(.white)
                                .cornerRadius(5)
                        }
                        .simultaneousGesture(DragGesture(minimumDistance: 0)
                            .onEnded({ _ in
                                midiManager.sampler.stop(noteNumber: MIDINoteNumber(noteNumber), channel: 0)
                            }))
                    }
                }
                .padding()
            }
            .onAppear {
                midiManager.setupMIDI() // Asegurarse de que el motor de audio esté listo
            }
            .onDisappear {
                midiManager.stopMIDI()
            }
        }
    }
}

Este KeyboardView simple usa botones para simular las notas MIDI y llamar directamente al método play y stop del sampler. Para un teclado visualmente más completo, podrías usar bibliotecas como AudioKitUI o crear un control personalizado.

🔄 Integración con SwiftUI y Gestión del Estado

Integrar AudioKit en una aplicación SwiftUI requiere una cuidadosa gestión del estado del motor de audio y los nodos. La mejor práctica es encapsular la lógica de AudioKit en una clase que conforme a ObservableObject y usar @StateObject o @ObservedObject en tus vistas SwiftUI.

Patrón ObservableObject para AudioKit

Todos los ejemplos anteriores ya siguen este patrón. Resumamos los puntos clave:

• Clase para la Lógica de Audio: Crea una clase (AudioManager, SynthesizerManager, etc.) que contenga la instancia de AudioEngine y todos los nodos de audio relevantes.
• ObservableObject: Conforma tu clase a ObservableObject para que SwiftUI pueda reaccionar a los cambios de estado publicados.
• @Published: Usa @Published para cualquier propiedad de tu clase de audio que necesite actualizar la interfaz de usuario (ej. isPlaying, recordedFileURL).
• @StateObject / @ObservedObject: En tu vista SwiftUI, usa @StateObject para crear y poseer la instancia de tu clase de audio (para el ciclo de vida de la vista) o @ObservedObject si la instancia es pasada desde una vista padre.
• onAppear / onDisappear: Utiliza estos modificadores para iniciar (engine.start()) y detener (engine.stop()) el motor de audio de manera apropiada según el ciclo de vida de la vista. Esto es crucial para liberar recursos de audio cuando la vista no está activa.

// Un ejemplo combinado que demuestra la estructura
import AudioKit
import AudioKitEX
import SoundpipeAudioKit
import SwiftUI

class MasterAudioManager: ObservableObject {
    let engine = AudioEngine()
    var oscillator: Oscillator
    var reverb: Reverb
    var mixer: Mixer

    @Published var isPlaying: Bool = false
    @Published var currentFrequency: Double = 440.0
    @Published var reverbDryWetMix: Double = 0.5

    init() {
        oscillator = Oscillator(waveform: Table(.sine))
        oscillator.amplitude = 0.5
        oscillator.frequency = currentFrequency

        reverb = Reverb(oscillator)
        reverb.loadFactoryPreset(.largeHall)
        reverb.dryWetMix = reverbDryWetMix

        mixer = Mixer(reverb) // El mezclador recibe la salida de la reverberación
        engine.output = mixer

        do {
            try Settings.setAudioSessionCategory(.playback, options: [.defaultToSpeaker])
        } catch {
            print("Error al configurar la sesión de audio: \(error)")
        }
    }

    func togglePlayback() {
        if isPlaying {
            oscillator.stop()
            engine.stop()
        } else {
            do {
                try engine.start()
                oscillator.start()
            } catch {
                print("Error al iniciar audio: \(error)")
            }
        }
        isPlaying.toggle()
    }

    func setFrequency(freq: Double) {
        oscillator.frequency = freq
        currentFrequency = freq
    }

    func setReverbMix(mix: Double) {
        reverb.dryWetMix = mix
        reverbDryWetMix = mix
    }

    func stopAllAudio() {
        if isPlaying {
            oscillator.stop()
            engine.stop()
            isPlaying = false
        }
    }
}

struct MasterAudioView: View {
    @StateObject var audioManager = MasterAudioManager()

    var body: some View {
        VStack(spacing: 30) {
            Text("Mi Synth con Reverb")
                .font(.largeTitle)
                .fontWeight(.heavy)
                .foregroundColor(.accentColor)

            VStack(alignment: .leading, spacing: 15) {
                Text("Frecuencia: \(audioManager.currentFrequency, specifier: "%.1f") Hz")
                    .font(.headline)
                Slider(value: $audioManager.currentFrequency, in: 100.0...1000.0) {
                    Text("Frecuencia")
                } onEditingChanged: { _ in
                    audioManager.setFrequency(freq: audioManager.currentFrequency)
                }
                .accentColor(.purple)
            }
            .padding(.horizontal)

            VStack(alignment: .leading, spacing: 15) {
                Text("Mezcla Reverb: \(audioManager.reverbDryWetMix, specifier: "%.2f")")
                    .font(.headline)
                Slider(value: $audioManager.reverbDryWetMix, in: 0.0...1.0) {
                    Text("Reverb Mix")
                } onEditingChanged: { _ in
                    audioManager.setReverbMix(mix: audioManager.reverbDryWetMix)
                }
                .accentColor(.teal)
            }
            .padding(.horizontal)

            Button(action: audioManager.togglePlayback) {
                Label(audioManager.isPlaying ? "Detener Sonido" : "Iniciar Sonido", systemImage: audioManager.isPlaying ? "stop.fill" : "play.fill")
                    .font(.title2)
                    .padding()
                    .frame(maxWidth: .infinity)
                    .background(audioManager.isPlaying ? Color.red.opacity(0.8) : Color.green.opacity(0.8))
                    .foregroundColor(.white)
                    .cornerRadius(20)
            }
            .padding(.horizontal)

            Spacer()
        }
        .onDisappear {
            audioManager.stopAllAudio()
        }
        .padding()
        .navigationTitle("AudioKit SwiftUI")
    }
}

Este patrón asegura que el motor de audio se inicie y detenga de forma segura, y que la interfaz de usuario se actualice reactivamente a los cambios en el estado del audio. Es fundamental recordar que las operaciones de audio deben ejecutarse en un hilo de audio de baja latencia (que AudioKit maneja internamente), mientras que las actualizaciones de la UI deben hacerse en el hilo principal (DispatchQueue.main.async).

🌐 Consideraciones Avanzadas y Optimización

Una vez que dominas los fundamentos, hay varias áreas avanzadas y de optimización a considerar para aplicaciones de audio profesionales.

Latencia y Rendimiento

El audio en tiempo real es sensible a la latencia. AudioKit está diseñado para ser eficiente, pero tus decisiones de diseño afectan el rendimiento.

• Settings.bufferLength: Ajustar la longitud del buffer de audio puede afectar la latencia. .short es ideal para instrumentos en tiempo real, pero puede aumentar el uso de CPU y el riesgo de underruns si el procesado es muy intenso. .long es más estable para reproducción, pero añade latencia.
• Evita Crear Nodos Dinámicamente: Crear y destruir nodos de audio en tiempo real puede introducir clicks o pops y es ineficiente. Es mejor crear todos los nodos necesarios al inicio y simplemente iniciar/detener o ajustar sus parámetros.
• Monitoreo del Rendimiento: Utiliza las herramientas de rendimiento de Xcode (Instruments) para monitorizar el uso de CPU y memoria de tu aplicación de audio.

AudioBus y Inter-App Audio

AudioKit soporta AudioBus e Inter-App Audio (IAA), lo que permite que tu aplicación de audio se conecte con otras aplicaciones de audio en iOS. Esto es crucial para crear instrumentos o efectos que puedan ser usados en un Digital Audio Workstation (DAW) móvil como GarageBand o Cubasis.

• Para IAA, necesitarás configurar tu proyecto como un Audio Unit Extension (AUv3), lo cual es un tema complejo en sí mismo pero AudioKit proporciona un excelente punto de partida.

Audio Units (AUv3)

Crear un Audio Unit (AUv3) es la forma más profesional de integrar tus instrumentos y efectos con el ecosistema de audio de iOS. Un AUv3 es un plugin de audio que puede ser cargado por cualquier aplicación host de audio compatible. AudioKit simplifica la creación de AUv3, proporcionando plantillas y herramientas para que tu sintetizador o efecto pueda funcionar como un plugin.

• Esto requiere una plantilla de proyecto diferente en Xcode (Audio Unit Extension) y un conocimiento más profundo de cómo se comunican las extensiones con la aplicación principal.

Uso de Múltiples Motores de Audio

En la mayoría de los casos, usar un solo AudioEngine es suficiente. Sin embargo, en escenarios muy específicos (por ejemplo, tener una sección de reproducción de archivos y una sección de sintetizador totalmente independiente, cada una con su propia cadena de efectos y que quieres controlar de forma aislada), podrías considerar múltiples motores. Esto añade complejidad y debe hacerse con precaución, ya que puede aumentar el uso de recursos.

Manejo de Interrupciones de Audio

Tu aplicación debe ser capaz de manejar interrupciones de audio, como llamadas telefónicas entrantes o el uso de Siri. Configurar correctamente la AVAudioSession con Settings.setAudioSessionCategory y escuchar las notificaciones AVAudioSession.interruptionNotification es esencial para una experiencia de usuario fluida.

✅ Conclusión: El Universo Sonoro de AudioKit

AudioKit es una herramienta increíblemente potente y flexible para cualquier desarrollador de iOS que desee explorar el mundo del audio. Desde la creación de sintetizadores y efectos hasta la grabación y visualización, proporciona una abstracción elegante sobre las complejidades de Core Audio, permitiéndote centrarte en la creatividad.

Hemos cubierto los fundamentos:

• Configuración de un proyecto con AudioKit.
• Generación de sonido con osciladores y mezcladores.
• Grabación y reproducción de archivos de audio.
• Aplicación de efectos de audio como reverb y delay.
• Visualización básica de audio.
• Integración de MIDI para control de instrumentos.
• Mejores prácticas para la integración con SwiftUI y consideraciones de rendimiento.

Este tutorial es solo el comienzo. AudioKit ofrece muchos más nodos y funcionalidades: filtros avanzados (LowPass, HighPass), distorsiones, ecualizadores gráficos y paramétricos, envolventes ADSR, sequencers y mucho más. La mejor manera de dominarlo es experimentando, leyendo la documentación oficial de AudioKit y explorando los ejemplos de su repositorio de GitHub.

¡Anímate a construir tu propia caja de ritmos, sintetizador polifónico, efecto de voz en tiempo real o cualquier otra aplicación de audio que puedas imaginar! El poder del sonido está ahora al alcance de tus dedos con AudioKit.