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 Wikipedia.
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 methods.
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
- Key features
- Usage
- Pitch detection specifics
- Examples
- Installation
- Components
- Author
- Contributing
- License
Key features
- Audio signal tracking with
AVAudioEngineand audio nodes. - Pre-processing of audio buffer by one of the available "transformers".
- Pitch estimation.
Usage
Configuration
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:
pitchEngine.start()
pitchEngine.stop()
Signal tracking
There are 2 signal tracking classes:
InputSignalTrackerusesAVAudioInputNodeto get an audio buffer from the recording input (microphone) in real-time.OutputSignalTrackerusesAVAudioOutputNodeandAVAudioFileto play an audio file and get the audio buffer from the playback output.
Transform
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:
- Fast Fourier transform
- YIN
Simpleconversion to use raw float channel data
A new transform strategy could be easily added by implementing of Transformer protocol:
public protocol Transformer {
func transform(buffer: AVAudioPCMBuffer) -> Buffer
}
Estimation
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:
maxValue- the index of the maximum value in the audio buffer used as a peakquadradic- Quadratic interpolation of spectral peaksbarycentric- Barycentric correctionquinnsFirst- Quinn's First EstimatorquinnsSecond- Quinn's Second Estimatorjains- Jain's Methodhps- Harmonic Product Spectrumyin- YIN
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 readable.
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 recording.
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 (Wikipedia).
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.
Examples
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.
Installation
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.
Components
Beethoven uses Pitchy library to get a music pitch with note, octave and offsets from a specified frequency.
Author
Vadym Markov, [email protected]
Contributing
Check the CONTRIBUTING file for more info.
License
Beethoven is available under the MIT license. See the LICENSE file for more info.
8.7k Sep 30, 2021
523 Nov 12, 2022
3 Dec 22, 2022
11 Nov 5, 2022
419 Dec 23, 2022
97 Dec 14, 2022
637 Nov 17, 2022
218 Dec 16, 2022
0 Mar 11, 2022
417 Jan 7, 2023
322 Aug 4, 2022
1 Apr 14, 2022
16 Nov 5, 2022
3 Apr 28, 2022
676 Dec 25, 2022
260 Nov 27, 2022
1.1k Dec 21, 2022
0 Nov 7, 2021