使用AVAudioEngine实时检测音高是否可行？

Question

我正在尝试编写一个音乐应用程序，其中音调检测是所有程序的核心。 我已经看到了针对此问题的解决方案以及AppStore上的应用程序。 但是其中大多数都过时了，我想这样做的是Swift。 我一直在寻找AVAudioEngine作为实现此目的的一种方法，但是我发现缺少文档，或者可能我没有足够努力。

我发现我可以像这样轻敲inputNode总线：

self.audioEngine = AVAudioEngine()
self.audioInputNode = self.audioEngine.inputNode!
self.audioInputNode.installTapOnBus(0, bufferSize:256, format: audioInputNode.outputFormatForBus(0), block: {(buffer, time) in
      self.analyzeBuffer(buffer)
})

总线每秒被窃听2-3次，并且每个抽头的缓冲区包含超过16000个浮点。 这些幅度样本来自麦克风吗？

文档至少声称它是从节点输出的：“ buffer参数是从AVAudioNode的输出捕获的音频的缓冲区。 ”

是否可以使用AVAudioEngine实时检测音高，还是应该采用其他方式？

Answer 1

这里有一些不同的概念。 AVAudioEngine只是获取原始PCM数据的引擎，您可以直接使用Novocaine，Core-Audio或其他选项。

PCM数据是来自麦克风的浮点采样。

至于音高跟踪，有各种各样的技术。 要注意的一件事是频率检测与音高检测不同。

FFT很好，但无法检测到缺少基本信号的音调。 您可能需要通过低通滤波器运行信号，以减少高于奈奎斯特频率的频率可能出现的混叠，然后在将其传递给FFT之前对其进行窗口化 ，以减少频谱泄漏 。 FFT将在一系列仓中输出频谱内容，具有最高值的仓被认为是信号中最强的频率。

自相关可以提供更好的结果。 基本上是与自身相关的信号。

最后，取决于您要检测的内容，需要考虑一些注意事项。 诸如男性声音之类的东西和某些乐器可能会通过在未经预处理的缓冲区上运行常规FFT来给出错误的结果。

检查此间距检测方法评论

就Swift而言，它不太适合实时的，注重性能的系统。 您可以查看Swift与C ++的旧基准测试

C ++ FFT的执行速度提高了24倍以上

Answer 2

我意识到Hellium3确实在给我有关音高的信息，以及用Swift进行这些操作是否是个好主意。

我的问题最初是关于敲击PCM总线是否是从麦克风获取输入信号的方式。

自问这个问题以来，我已经做到了。 使用通过点击PCM总线获得的数据并分析缓冲区窗口。

它确实运行良好，而正是由于我对PCM总线，缓冲区和采样频率的理解不足，才使我首先提出了这个问题。

知道了这三个，就可以更容易地看出这是正确的。

编辑：根据需要，我将粘贴PitchDetector的（不建议使用的）实现。

class PitchDetector {
  var samplingFrequency: Float
  var harmonicConstant: Float

  init(harmonicConstant: Float, samplingFrequency: Float) {
    self.harmonicConstant = harmonicConstant
    self.samplingFrequency = samplingFrequency
  }

  //------------------------------------------------------------------------------
  // MARK: Signal processing
  //------------------------------------------------------------------------------

  func detectPitch(_ samples: [Float]) -> Pitch? {
    let snac = self.snac(samples)
    let (lags, peaks) = self.findKeyMaxima(snac)
    let (τBest, clarity) = self.findBestPeak(lags, peaks: peaks)
    if τBest > 0 {
      let frequency = self.samplingFrequency / τBest
      if PitchManager.sharedManager.inManageableRange(frequency) {
        return Pitch(measuredFrequency: frequency, clarity: clarity)
      }
    }

    return nil
  }

  // Returns a Special Normalision of the AutoCorrelation function array for various lags with values between -1 and 1
  private func snac(_ samples: [Float]) -> [Float] {
    let τMax = Int(self.samplingFrequency / PitchManager.sharedManager.noteFrequencies.first!) + 1
    var snac = [Float](repeating: 0.0, count: samples.count)
    let acf = self.acf(samples)
    let norm = self.m(samples)
    for τ in 1 ..< τMax {
      snac[τ] = 2 * acf[τ + acf.count / 2] / norm[τ]
    }

    return snac
  }

  // Auto correlation function
  private func acf(_ x: [Float]) -> [Float] {
    let resultSize = 2 * x.count - 1
    var result = [Float](repeating: 0, count: resultSize)
    let xPad = repeatElement(Float(0.0), count: x.count - 1)
    let xPadded = xPad + x + xPad
    vDSP_conv(xPadded, 1, x, 1, &result, 1, vDSP_Length(resultSize), vDSP_Length(x.count))

    return result
  }

  private func m(_ samples: [Float]) -> [Float] {
    var sum: Float = 0.0
    for i in 0 ..< samples.count {
      sum += 2.0 * samples[i] * samples[i]
    }
    var m = [Float](repeating: 0.0, count: samples.count)
    m[0] = sum
    for i in 1 ..< samples.count {
      m[i] = m[i - 1] - samples[i - 1] * samples[i - 1] - samples[samples.count - i - 1] * samples[samples.count - i - 1]
    }
    return m
  }

  /**
   * Finds the indices of all key maximum points in data
   */
  private func findKeyMaxima(_ data: [Float]) -> (lags: [Float], peaks: [Float]) {
    var keyMaximaLags: [Float] = []
    var keyMaximaPeaks: [Float] = []
    var newPeakIncoming = false
    var currentBestPeak: Float = 0.0
    var currentBestτ = -1
    for τ in 0 ..< data.count {
      newPeakIncoming = newPeakIncoming || ((data[τ] < 0) && (data[τ + 1] > 0))
      if newPeakIncoming {
        if data[τ] > currentBestPeak {
          currentBestPeak = data[τ]
          currentBestτ = τ
        }
        let zeroCrossing = (data[τ] > 0) && (data[τ + 1] < 0)
        if zeroCrossing {
          let (τEst, peakEst) = self.approximateTruePeak(currentBestτ, data: data)
          keyMaximaLags.append(τEst)
          keyMaximaPeaks.append(peakEst)
          newPeakIncoming = false
          currentBestPeak = 0.0
          currentBestτ = -1
        }
      }
    }

    if keyMaximaLags.count <= 1 {
      let unwantedPeakOfLowPitchTone = (keyMaximaLags.count == 1 && data[Int(keyMaximaLags[0])] < data.max()!)
      if unwantedPeakOfLowPitchTone {
        keyMaximaLags.removeAll()
        keyMaximaPeaks.removeAll()
      }
      let (τEst, peakEst) = self.approximateTruePeak(data.index(of: data.max()!)!, data: data)
      keyMaximaLags.append(τEst)
      keyMaximaPeaks.append(peakEst)
    }

    return (lags: keyMaximaLags, peaks: keyMaximaPeaks)
  }

  /**
   * Approximates the true peak according to https://www.dsprelated.com/freebooks/sasp/Quadratic_Interpolation_Spectral_Peaks.html
   */
  private func approximateTruePeak(_ τ: Int, data: [Float]) -> (τEst: Float, peakEst: Float) {
    let α = data[τ - 1]
    let β = data[τ]
    let γ = data[τ + 1]
    let p = 0.5 * ((α - γ) / (α - 2.0 * β + γ))
    let peakEst = min(1.0, β - 0.25 * (α - γ) * p)
    let τEst = Float(τ) + p

    return (τEst, peakEst)
  }

  private func findBestPeak(_ lags: [Float], peaks: [Float]) -> (τBest: Float, clarity: Float) {
    let threshold: Float = self.harmonicConstant * peaks.max()!
    for i in 0 ..< peaks.count {
      if peaks[i] > threshold {
        return (τBest: lags[i], clarity: peaks[i])
      }
    }

    return (τBest: lags[0], clarity: peaks[0])
  }
}

所有归功于Philip McLeod，他的研究成果已在我的上述实现中使用。 http://www.cs.otago.ac.nz/research/publications/oucs-2008-03.pdf