Latest 4.0.2
License MIT
Platforms ios 8.0, requires ARC
Dependencies Pitchy
Frameworks Foundation, AVFoundation, Accelerate


CI Status
Carthage Compatible

Beethoven is an audio processing Swift library that provides an
easy-to-use interface to solve an age-old problem of pitch detection of musical
signals. You can read more about this subject on

The basic workflow is to get the audio buffer from the input/output source,
transform it to a format applicable for processing and apply one of the pitch
estimation algorithms to find the fundamental frequency. For the end user it
comes down to choosing estimation algorithm and implementation of delegate

Beethoven is designed to be flexible, customizable and highly extensible.

The main purpose of the library is to collect Swift implementations of various
time and frequency domain algorithms for monophonic pitch extraction, with
different rate of accuracy and speed, to cover as many as possible pitch
detection scenarios, musical instruments and human voice. Current
implementations could also be not perfect and obviously there is a place for
improvements. It means that contribution is very important
and more than welcome!

Table of Contents

Beethoven Icon

Key features

  • [x] Audio signal tracking with AVAudioEngine and audio nodes.
  • [x] Pre-processing of audio buffer by one of the available "transformers".
  • [x] Pitch estimation.



Configure buffer size and estimation strategy with the Config struct, which
is used in the initialization of PitchEngine. For the case when a signal
needs to be tracked from the device output, there is the audioUrl parameter,
which is meant to be a URL of your audio file.

// Creates a configuration for the input signal tracking (by default).
let config = Config(
  bufferSize: 4096,
  estimationStrategy: .yin

// Creates a configuration for the output signal tracking.
let config = Config(
  bufferSize: 4096,
  estimationStrategy: .yin,
  audioUrl: URL

Config could also be instantiated without any parameters:

// Input signal tracking with YIN algorithm.
let config = Config()

Pitch engine

PitchEngine is the main class you are going to work with to find the pitch.
It can be instantiated with a configuration and delegate:

let pitchEngine = PitchEngine(config: config, delegate: pitchEngineDelegate)

Both parameters are optional, standard config is used by default, and delegate
could always be set later:

let pitchEngine = PitchEngine()
pitchEngine.delegate = pitchEngineDelegate

PitchEngine uses PitchEngineDelegate to inform about results or errors when
the pitch detection has been started:

func pitchEngine(_ pitchEngine: PitchEngine, didReceivePitch pitch: Pitch)
func pitchEngine(_ pitchEngine: PitchEngine, didReceiveError error: Error)
func pitchEngineWentBelowLevelThreshold(_ pitchEngine: PitchEngine)

To start or stop the pitch tracking process just use the corresponding
PitchEngine methods:


Signal tracking

There are 2 signal tracking classes:

  • InputSignalTracker uses AVAudioInputNode to get an audio buffer from the
    recording input (microphone) in real-time.
  • OutputSignalTracker uses AVAudioOutputNode and AVAudioFile to play an
    audio file and get the audio buffer from the playback output.


Transform is the first step of audio processing where AVAudioPCMBuffer object
is converted to an array of floating numbers. Also it’s a place for different
kind of optimizations. Then array is kept in the elements property of the
internal Buffer struct, which also has optional realElements and
imagElements properties that could be useful in the further calculations.

There are 3 types of transformations at the moment:

A new transform strategy could be easily added by implementing of Transformer

public protocol Transformer {
  func transform(buffer: AVAudioPCMBuffer) -> Buffer


A pitch detection algorithm (PDA) is an algorithm designed to estimate the pitch
or fundamental frequency. Pitch is a psycho-acoustic phenomena, and it’s
important to choose the most suitable algorithm for your kind of input source,
considering allowable error rate and needed performance.

The list of available implemented algorithms:

A new estimation algorithm could be easily added by implementing of Estimator
or LocationEstimator protocol:

protocol Estimator {
  var transformer: Transformer { get }

  func estimateFrequency(sampleRate: Float, buffer: Buffer) throws -> Float
  func estimateFrequency(sampleRate: Float, location: Int, bufferCount: Int) -> Float

protocol LocationEstimator: Estimator {
  func estimateLocation(buffer: Buffer) throws -> Int

Then it should be added to EstimationStrategy enum and in the create method
of EstimationFactory struct. Normally, a buffer transformation should be
performed in a separate struct or class to keep the code base more clean and

Error handling

Pitch detection is not a trivial task due to some difficulties, such as attack
transients, low and high frequencies. Also it’s a real-time processing, so we
are not protected against different kinds of errors. For this purpose there is a
range of error types that should be handled properly.

Signal tracking errors

public enum InputSignalTrackerError: Error {
  case inputNodeMissing

Record permission errors

PitchEngine asks for AVAudioSessionRecordPermission on start, but if
permission is denied it produces the corresponding error:

public enum PitchEngineError: Error {
  case recordPermissionDenied

Pitch estimation errors

Some errors could occur during the process of pitch estimation:

public enum EstimationError: Error {
  case emptyBuffer
  case unknownMaxIndex
  case unknownLocation
  case unknownFrequency

Pitch detection specifics

At the moment Beethoven performs only a pitch detection of a monophonic

Based on Stackoverflow answer:

Pitch detection depends greatly on the musical content you want to work with.
Extracting the pitch of a monophonic recording (i.e. single instrument or voice)
is not the same as extracting the pitch of a single instrument from a polyphonic
mixture (e.g. extracting the pitch of the melody from a polyphonic recording).

For monophonic pitch extraction there are various algorithm that could be
implemented both in the time domain and frequency domain

However, neither will work well if you want to extract the melody from
polyphonic material. Melody extraction from polyphonic music is still a
research problem.


Beethoven Tuner Example

Check out Guitar Tuner
example to see how you can use Beethoven in the real-world scenario to tune
your instrument. It uses YIN
estimation algorithm, adopted by @glaurent, and it appears to be quite accurate
in the pitch detection of electric and acoustic guitar strings.


Beethoven is available through CocoaPods. To install
it, simply add the following line to your Podfile:

pod 'Beethoven'

Beethoven is also available through Carthage.
To install just write into your Cartfile:

github "vadymmarkov/Beethoven"

Beethoven can also be installed manually. Just download and drop Sources
folders in your project.


Beethoven uses Pitchy library to
get a music pitch with note, octave and offsets from a specified frequency.


Vadym Markov, [email protected]


file for more info.


Beethoven is available under the MIT license. See the LICENSE file
for more info.

Latest podspec

    "name": "Beethoven",
    "summary": "A maestro of pitch detection",
    "version": "4.0.2",
    "homepage": "",
    "license": "MIT",
    "authors": {
        "Vadym Markov": "[email protected]"
    "source": {
        "git": "",
        "tag": "4.0.2"
    "social_media_url": "",
    "platforms": {
        "ios": "8.0"
    "requires_arc": true,
    "ios": {
        "source_files": "Source/**/*"
    "frameworks": [
    "dependencies": {
        "Pitchy": [
            "~> 3.0"
    "pod_target_xcconfig": {
        "SWIFT_VERSION": "3.0"
    "pushed_with_swift_version": "4.0"

Pin It on Pinterest

Share This