AVAudioEngine详解

import AVFoundation

let audioEngine = AVAudioEngine()
let timePitchUnit = AVAudioUnitTimePitch()

// 设置音调变化和播放速度
timePitchUnit.pitch = 1.5 // 提升一个半音
timePitchUnit.rate = 1.0 // 正常速度播放

// 将时间音调单元添加到音频引擎
audioEngine.attach(timePitchUnit)

// 连接输入和输出节点
let inputNode = audioEngine.inputNode
let outputNode = audioEngine.outputNode
audioEngine.connect(inputNode, to: timePitchUnit, format: nil)
audioEngine.connect(timePitchUnit, to: outputNode, format: nil)

// 准备并启动音频引擎
do {
    try audioEngine.start()
} catch {
    print("Error starting audio engine: \(error)")
}

public enum AVAudioUnitEQFilterType :Int{
  case Parametric 参量均衡器 可以通过设置一些参量，来调节咱们均衡器的频点
  case LowPass 低通滤波器 衰弱高频
  case HighPass 高通滤波器 衰弱低频
  case ResonantLowPass  可以引发共鸣的 低通滤波器
  case ResonantHighPass 可以引发共鸣的  高通滤波器
  case BandPass 带通滤波器  提升某一频率附近的信号 忽略过高 或 过低的 部分
  case BandStop 与上面的相反  忽略某一频率附近的信号
  case LowShelf 低架 降低整体
  case HighShelf 高架 提升整体
  case ResonantLowShelf  可以引发共鸣的 低架
  case ResonantHighShelf可以引发共鸣的 高架
}

import AVFoundation

// 创建音频引擎
let audioEngine = AVAudioEngine()

// 创建均衡器，设置为10个频段
let eq = AVAudioUnitEQ(numberOfBands: 10)

// 配置每个频段
for i in 0..<eq.bands.count {
    let band = eq.bands[i]
    band.filterType = .parametric
    band.frequency = Float(32 * pow(2.0, Double(i))) // 设置频率
    band.bandwidth = 0.5 // 设置带宽
    band.gain = 0.0 // 设置增益
    band.bypass = false // 启用频段
}

// 设置全局增益
eq.globalGain = 1.0

// 将均衡器添加到音频引擎
audioEngine.attach(eq)

// 连接均衡器到主混音器节点
audioEngine.connect(eq, to: audioEngine.mainMixerNode, format: nil)

// 启动音频引擎
do {
    try audioEngine.start()
} catch {
    print("音频引擎启动失败: \(error)")
}

// 调整某个频段的增益
eq.bands[0].gain = 5.0 // 增加第一个频段的增益

let audioEngine = AVAudioEngine()
let eq = AVAudioUnitEQ(numberOfBands: 3)
let reverb = AVAudioUnitReverb()

// 添加单元
audioEngine.attach(eq)
audioEngine.attach(reverb)

// 连接单元
let inputNode = audioEngine.inputNode
let outputNode = audioEngine.outputNode
audioEngine.connect(inputNode, to: eq, format: nil)
audioEngine.connect(eq, to: reverb, format: nil)
audioEngine.connect(reverb, to: outputNode, format: nil)

import AVFoundation
import Accelerate

class SpectrumAnalyzer {
    private var fftSetup: FFTSetup?
    private var log2n: vDSP_Length
    var bufferSize: Int // 将访问级别更改为 internal
    private var window: [Float]
    private var outputBuffer: [Float]
    private var frequencyData: [Float]
    private var downsampleFactor: Int

    init(bufferSize: Int, downsampleFactor: Int = 10) { // 默认降采样因子为10
        self.bufferSize = bufferSize
        self.downsampleFactor = downsampleFactor
        self.log2n = vDSP_Length(log2(Float(bufferSize)))
        self.fftSetup = vDSP_create_fftsetup(log2n, Int32(kFFTRadix2))
        self.window = [Float](repeating: 0, count: bufferSize)
        vDSP_hann_window(&window, vDSP_Length(bufferSize), Int32(vDSP_HANN_NORM))
        self.outputBuffer = [Float](repeating: 0, count: bufferSize / 2)
        self.frequencyData = [Float](repeating: 0, count: bufferSize / 2)
    }

    deinit {
        if let fftSetup = fftSetup {
            vDSP_destroy_fftsetup(fftSetup)
        }
    }

    func analyze(buffer: AVAudioPCMBuffer) -> [Float] {
        guard let fftSetup = fftSetup else { return [] }

        let frameCount = buffer.frameLength
        var realp = [Float](repeating: 0, count: Int(frameCount / 2))
        var imagp = [Float](repeating: 0, count: Int(frameCount / 2))
        var magnitudes = [Float](repeating: 0.0, count: Int(frameCount / 2))

        realp.withUnsafeMutableBufferPointer { realpPtr in
            imagp.withUnsafeMutableBufferPointer { imagpPtr in
                var output = DSPSplitComplex(realp: realpPtr.baseAddress!, imagp: imagpPtr.baseAddress!)

                buffer.floatChannelData?.pointee.withMemoryRebound(to: DSPComplex.self, capacity: Int(frameCount)) { (inputData) in
                    vDSP_ctoz(inputData, 2, &output, 1, vDSP_Length(frameCount / 2))
                }

                vDSP_fft_zrip(fftSetup, &output, 1, log2n, FFTDirection(FFT_FORWARD))

                vDSP_zvmags(&output, 1, &magnitudes, 1, vDSP_Length(frameCount / 2))
            }
        }

        return downsample(magnitudes, factor: downsampleFactor)
    }

    private func downsample(_ data: [Float], factor: Int) -> [Float] {
        guard factor > 0 else { return data }
        let downsampledCount = data.count / factor
        var downsampledData = [Float](repeating: 0.0, count: downsampledCount)
        for i in 0..<downsampledCount {
            let start = i * factor
            let end = start + factor
            let sum = data[start..<end].reduce(0, +)
            downsampledData[i] = sum / Float(factor)
        }
        return downsampledData
    }
}

import AVFoundation
import MediaPlayer

class AudioEnginePlayer {
   //...
   var onSpectrumDataAvailable: (([Float]) -> Void)?
   //...
   private var playerNode: AVAudioPlayerNode
   private var spectrumAnalyzer: SpectrumAnalyzer
   //...
  
   /// 播放状态
    var isPlaying: Bool = false {
        didSet {
            if !isPlaying {
                // 如果没有播放，则所有频谱柱显示为 0 值
                onSpectrumDataAvailable?([Float](repeating: 0.0, count: 24))
            }
        }
    }
   
   init() {
       //...
        playerNode = AVAudioPlayerNode()
      //...
        spectrumAnalyzer = SpectrumAnalyzer(bufferSize: 1024, downsampleFactor: 10)
        //...
        setupAudioEngineTap()
    }
  
   //...
   private func setupAudioEngineTap() {
        audioEngine.mainMixerNode.installTap(onBus: 0, bufferSize: AVAudioFrameCount(spectrumAnalyzer.bufferSize), format: audioEngine.mainMixerNode.outputFormat(forBus: 0)) { [weak self] (buffer, time) in
            guard let self = self else { return }
            let magnitudes = self.spectrumAnalyzer.analyze(buffer: buffer)
            DispatchQueue.main.async {
                if self.isPlaying {
                    //print("\(magnitudes)\n\n\n")
                    self.onSpectrumDataAvailable?(magnitudes)
                }
            }
        }
    }
   //...
}

import UIKit

class VisualizerView: UIView {
    private var magnitudes: [Float] = []

    override init(frame: CGRect) {
        super.init(frame: frame)
        self.backgroundColor = .black // 设置背景颜色
    }

    required init?(coder: NSCoder) {
        super.init(coder: coder)
        self.backgroundColor = .black // 设置背景颜色
    }

    func update(with magnitudes: [Float]) {
        self.magnitudes = magnitudes
        setNeedsDisplay()
    }

    override func draw(_ rect: CGRect) {
        guard !magnitudes.isEmpty else { return }

        let context = UIGraphicsGetCurrentContext()
        context?.clear(rect)

        let barWidth = rect.width / CGFloat(magnitudes.count)
        for (index, magnitude) in magnitudes.enumerated() {
            let barHeight = CGFloat(magnitude) * rect.height
            let barRect = CGRect(x: CGFloat(index) * barWidth, y: rect.height - barHeight, width: barWidth, height: barHeight)
            context?.setFillColor(UIColor.green.cgColor) // 设置填充颜色
            context?.fill(barRect)
        }

        // 添加调试日志
        //print("Drawing \(magnitudes.count) bars")
    }
}

import UIKit

class ViewController: UIViewController {
    private var visualizerView: VisualizerView!
    lazy var audioEnginePlayer = AudioEnginePlayer()

    override func viewDidLoad() {
        super.viewDidLoad()

        visualizerView = VisualizerView(frame: CGRectMake(0, 0, view.bounds.width, 300))
        view.addSubview(visualizerView)
        view.sendSubviewToBack(visualizerView)
        
        audioEnginePlayer.onSpectrumDataAvailable = { [weak self] magnitudes in
            //print(magnitudes)
            self?.visualizerView.update(with: magnitudes)
        }
    }
}