寻求Swift/Objective-C非实时音频移调功能实现方案

我正在为应用KeyStage的音频播放器添加移调功能，发现AVAudioEngine的实时移调单元存在约0.1秒延迟无法使用。因不懂数字信号处理（DSP），且所有实时移调算法均有类似延迟，故需非实时处理方案。我需要一个函数，接收AVAudioFile或AVAudioPCMBuffer与音高偏移量（音分），输出移调后的对应音频对象，可通过完成回调或代理返回。我未找到相关项目或库，也无法自行编写，尝试用ChatGPT生成的代码存在大量错误，代码如下：

import Foundation
import Accelerate

func pitchShiftUsingFFT(audioFile: AVAudioFile, semitones: Float) -> AVAudioPCMBuffer? {
    
    // Load input audio file
    guard let inputFormat = AVAudioFormat(commonFormat: .pcmFormatFloat32, sampleRate: audioFile.fileFormat.sampleRate, channels: 1, interleaved: false),
          let inputFile = try? AVAudioFile(forReading: audioFile.url, commonFormat: .pcmFormatFloat32, interleaved: false) else {
        print("Failed to load input audio file")
        return nil
    }
    
    // Calculate pitch shift factor and ratio
    let pitchShiftFactor = pow(2.0, semitones/12.0)
    let pitchShiftRatio = Float(inputFormat.sampleRate) / (pitchShiftFactor * Float(inputFormat.sampleRate))
    
    // Allocate memory for input and output audio buffers
    let inputBufferSize = AVAudioFrameCount(inputFile.length)
    let outputBufferSize = AVAudioFrameCount(Float(inputBufferSize) * pitchShiftFactor)
    let inputBuffer = AVAudioPCMBuffer(pcmFormat: inputFormat, frameCapacity: inputBufferSize)
    let outputBuffer = AVAudioPCMBuffer(pcmFormat: inputFormat, frameCapacity: outputBufferSize)
    
    // Read input audio file into input buffer
    guard let inputAudioBuffer = inputBuffer?.floatChannelData else {
        print("Failed to allocate memory for input buffer")
        return nil
    }
    do {
        try inputFile.read(into: inputBuffer!)
    } catch {
        print("Failed to read input audio file")
        return nil
    }
    
    // Allocate memory for FFT buffers
    let fftSize = vDSP_Length(ceil(log2(Float(inputBufferSize))))
    let fftSetup = vDSP_create_fftsetup(fftSize, Int32(kFFTRadix2))
    let fftInputBuffer = UnsafeMutablePointer<Float>(calloc(inputBufferSize, MemoryLayout<Float>.size))
    let fftOutputBuffer = UnsafeMutablePointer<DSPComplex>(calloc(inputBufferSize/2, MemoryLayout<DSPComplex>.size))
    
    // Apply pitch shift using FFT
    for channel in 0..<inputFormat.channelCount {
        // Initialize variables
        var phase = DSPFloat()
        let phaseIncrement = 2.0 * Float.pi * pitchShiftRatio
        var fftOffset = vDSP_Length(0)
        
        // Copy input audio data into FFT input buffer
        vDSP_vflt32(inputAudioBuffer[channel], 1, fftInputBuffer, 1, inputBufferSize)
        
        // Perform FFT on input data
        vDSP_ctoz(UnsafePointer<DSPFloat>(fftInputBuffer), 2, fftOutputBuffer, 1, inputBufferSize/2)
        vDSP_fft_zrip(fftSetup, fftOutputBuffer, 1, fftSize, FFTDirection(FFT_FORWARD))
        vDSP_ztoc(fftOutputBuffer, 1, UnsafeMutablePointer<DSPFloat>(fftInputBuffer), 2, inputBufferSize/2)
        
        // Apply phase shift to FFT output
        let phaseShift = DSPFloat(phaseIncrement * Float(fftOffset))
        for i in 0..<inputBufferSize/2 {
            let fftReal = fftInputBuffer[i*2]
            let fftImag = fftInputBuffer[i*2+1]
            let complex = DSPComplex(real: fftReal * cos(phase) - fftImag * sin(phase),
                                      imaginary: fftReal * sin(phase) + fftImag * cos(phase))
            fftOutputBuffer[i] = complex
            phase += phaseShift
            if phase > Float.pi {
                phase -= 2.0 * Float.pi
            }
        }
        
        // Perform inverse FFT on phase shifted output
        vDSP_ctoz(fftOutputBuffer, 1, fftOutputBuffer, 1, inputBufferSize/2)
        vDSP_fft_zrip(fftSetup, fftOutputBuffer, 1, fftSize, FFTDirection(FFT_INVERSE))
        vDSP_ztoc(fftOutputBuffer, 1, UnsafeMutablePointer<DSPFloat>(fftInputBuffer), 2, inputBufferSize/2)
        
        // Overlap-add FFT output to output audio buffer
        var outputOffset = vDSP_Length(0)
        let hopSize = vDSP_Length(Float(grainSize) * pitchShiftRatio)
        let overlapSize = vDSP_Length(Float(overlap) * pitchShiftRatio)
        while outputOffset < outputBufferSize {
            let outputRemaining = outputBufferSize - outputOffset
            let inputRemaining = inputBufferSize - fftOffset
            let frameCount = min(inputRemaining, outputRemaining)
            let overlapCount = min(frameCount, overlapSize)
            
            // Add overlapped frames to output audio buffer
            vDSP_vadd(inputAudioBuffer[channel]+fftOffset, 1,
                      outputBuffer!.floatChannelData[channel]+outputOffset, 1,
                      outputBuffer!.floatChannelData[channel]+outputOffset, 1,
                      overlapCount)
            
            // Add remaining frames to output audio buffer
            vDSP_vadd(fftInputBuffer+fftOffset, 1,
                      outputBuffer!.floatChannelData[channel]+outputOffset+overlapCount, 1,
                      outputBuffer!.floatChannelData[channel]+outputOffset+overlapCount, 1,
                      frameCount-overlapCount)
            
            // Update buffer offsets
            outputOffset += frameCount
            fftOffset += hopSize
        }
    }
    
    // Clean up FFT buffers and setup
    vDSP_destroy_fftsetup(fftSetup)
    free(fftInputBuffer)
    free(fftOutputBuffer)
    
    return outputBuffer
}

恳请协助：是否有第三方库可在Objective-C或Swift中实现该功能？若算法简单，能否提供实现指导？

一、第三方库推荐 #

• AudioKit：Swift生态中成熟的音频处理库，提供非实时音高偏移工具。可使用AKPitchShifter配合离线渲染，将AVAudioFile或AVAudioPCMBuffer传入，设置音分偏移量后导出处理后的音频，无需手动实现FFT逻辑。
• libsoxr：跨平台采样率转换库，可通过"改变采样率实现音高变化+重新转换回原采样率"的方式实现移调，适合对音质要求不极致的场景，实现成本低。
• ffmpeg：可通过Objective-C/Swift调用其swresample模块实现音高偏移，支持多种音频格式，适合处理不同类型音频文件的场景。

二、基础实现指导（基于非实时相位声码器） #

核心步骤 #

1. 格式统一：将输入音频转换为单声道32位浮点PCM格式，多声道需分轨处理。
2. 计算偏移因子：音分转音高因子公式为 pitchFactor = pow(2.0, cents / 1200.0)（音分是半音的1/100，若输入是半音则用semitones / 12.0）。
3. 分帧与加窗：将音频分割为2的幂次大小的帧（如1024、2048帧），帧间保留50%重叠，对每帧加汉明窗减少频谱泄漏。
4. FFT与相位调整：对每一帧执行FFT得到频域数据，根据偏移因子调整各频率分量的相位，保证相邻帧相位连续。
5. 逆FFT与重叠相加：对调整后的频域数据执行逆FFT得到时域帧，将帧重叠相加合成完整输出音频。
6. 输出转换：将处理后的PCM数据转为AVAudioPCMBuffer或写入AVAudioFile返回。

关键注意事项 #

• 帧大小取2的幂次可优化FFT计算效率。
• 必须使用窗函数处理帧，否则会导致严重频谱泄漏，音质劣化。
• 相位连续性是核心，需跟踪每个频率分量的相位变化，避免出现失真的"机器人声"。

内容的提问来源于stack exchange，提问作者Ali Gokturk