How to detect the BPM of a song in php [closed]

Question

How can the tempo/BPM of a song be determined programmatically? What algorithms are commonly used, and what considerations must be made?

Laminous

Answer 1

This is challenging to explain in a single StackOverflow post. In general, the simplest beat-detection algorithms work by locating peaks in sound energy, which is easy to detect. More sophisticated methods use comb filters and other statistical/waveform methods. For a detailed explication including code samples, check this GameDev article out.

Levee

5 years later the GameDev article does not 404 ツ (Besides you can often use webarchive.org, as per web.archive.org/web/20120525085210/http://archive.gamedev.net/… ) – Person

Can you pls explain to me one moment from GameDev article? Author says let 1024 samples be about 5 hundred(th?)s of second. And some later he says that 44032 samples is about 1 second. But how did we get it if 1024 samples per 0.05 seconds are equals 20480 samples per 1 second? Are there different frequencies? This fragment of text can be easily found by first entry of number 1024. – Width

gamedev.net/tutorials/_/technical/math-and-physics/… contains the same information – Pronounced

Answer 2

The keywords to search for are "Beat Detection", "Beat Tracking" and "Music Information Retrieval". There is lots of information here: http://www.music-ir.org/

There is a (maybe) annual contest called MIREX where different algorithms are tested on their beat detection performance.

http://nema.lis.illinois.edu/nema_out/mirex2010/results/abt/mck/

That should give you a list of algorithms to test.

A classic algorithm is Beatroot (google it), which is nice and easy to understand. It works like this:

1. Short-time FFT the music to get a sonogram.
2. Sum the increases in magnitude over all frequencies for each time step (ignore the decreases). This gives you a 1D time-varying function called the "spectral flux".
3. Find the peaks using any old peak detection algorithm. These are called "onsets" and correspond to the start of sounds in the music (starts of notes, drum hits, etc).
4. Construct a histogram of inter-onset-intervals (IOIs). This can be used to find likely tempos.
5. Initialise a set of "agents" or "hypotheses" for the beat-tracking result. Feed these agents the onsets one at a time in order. Each agent tracks the list of onsets that are also beats, and the current tempo estimate. The agents can either accept the onsets, if they fit closely with their last tracked beat and tempo, ignore them if they are wildly different, or spawn a new agent if they are in-between. Not every beat requires an onset - agents can interpolate.
6. Each agent is given a score according to how neat its hypothesis is - if all its beat onsets are loud it gets a higher score. If they are all regular it gets a higher score.
7. The highest scoring agent is the answer.

Downsides to this algorithm in my experience:

• The peak-detection is rather ad-hoc and sensitive to threshold parameters and whatnot.
• Some music doesn't have obvious onsets on the beats. Obviously it won't work with those.
• Difficult to know how to resolve the 60bpm-vs-120bpm issue, especially with live tracking!
• Throws away a lot of information by only using a 1D spectral flux. I reckon you can do much better by having a few band-limited spectral fluxes (and maybe one broadband one for drums).

Here is a demo of a live version of this algorithm, showing the spectral flux (black line at the bottom) and onsets (green circles). It's worth considering the fact that the beat is extracted from only the green circles. I've played back the onsets just as clicks, and to be honest I don't think I could hear the beat from them, so in some ways this algorithm is better than people at beat detection. I think the reduction to such a low-dimensional signal is its weak step though.

Annoyingly I did find a very good site with many algorithms and code for beat detection a few years ago. I've totally failed to refind it though.

Edit: Found it!

Here are some great links that should get you started:

http://marsyasweb.appspot.com/

http://www.vamp-plugins.org/download.html

Jaquez

Hard to build Vamp Plugin for OSX target. No probem with dependencies, but with the os typedefs for darwin. Try make -f build/Makefile.osx after switching the sdk to .../Developer/SDKs/iPhoneOS7.0.sdk to see what I mean. – Celeriac

Answer 3

Beat extraction involves the identification of cognitive metric structures in music. Very often these do not correspond to physical sound energy - for example, in most music there is a level of syncopation, which means that the "foot-tapping" beat that we perceive does not correspond to the presence of a physical sound. This means that this is a quite different field to onset detection, which is the detection of the physical sounds, and is performed in a different way.

You could try the Aubio library, which is a plain C library offering both onset and beat extraction tools.

There is also the online Echonest API, although this involves uploading an MP3 to a website and retrieving XML, so might not be so suitable..

EDIT: I came across this last night - a very promising looking C/C++ library, although I haven't used it myself. Vamp Plugins

Junejuneau

Answer 4

The general area of research you are interested in is called MUSIC INFORMATION RETRIEVAL

There are many different algorithms that do this but they all are fundamentally centered around ONSET DETECTION.

Onset detection measures the start of an event, the event in this case is a note being played. You can look for changes in the weighted fourier transform (High Frequency Content) you can look for large changes in spectrial content. (Spectrial Difference). (there are a couple of papers that I recommend you look into further down) Once you apply an onset detection algorithm you pick off where the beats are via thresholding.

There are various algorithms that you can use once you've gotten that time localization of the beat. You can turn it into a pulse train (create a signal that is zero for all time and 1 only when your beat happens) then apply a FFT to that and BAM now you have a Frequency of Onsets at the largest peak.

Here are some papers to lead you in the right direction:

https://web.archive.org/web/20120310151026/http://www.elec.qmul.ac.uk/people/juan/Documents/Bello-TSAP-2005.pdf

https://adamhess.github.io/Onset_Detection_Nov302011.pdf

Here is an extension to what some people are discussing:

Someone mentioned looking into applying a machine learning algorithm: Basically collect a bunch of features from the onset detection functions (mentioned above) and combine them with the raw signal in a neural network/logistic regression and learn what makes a beat a beat.

look into Dr Andrew Ng, he has free machine learning lectures from Stanford University online (not the long winded video lectures, there is actually an online distance course)

Jeffereyjefferies

2nd URL is dead. Permission or not found and checked the archives but no luck. web.archive.org/web/20220000000000*/bingweb.binghamton.edu/~ahess2/Onset_Detection_Nov302011.pdf – Proustite

You can now find it at my github page. adamhess.github.io/Onset_Detection_Nov302011.pdf – Panter

Answer 5

If you can manage to interface with python code in your project, Echo Nest Remix API is a pretty slick API for python:

There's a method analysis.tempo which will give you the BPM. It can do a whole lot more than simple BPM, as you can see from the API docs or this tutorial

Balkhash

Answer 6

Perform a Fourier transform, and find peaks in the power spectrum. You're looking for peaks below the 20 Hz cutoff for human hearing. I'd guess typically in the 0.1-5ish Hz range to be generous.

SO question that might help: Bpm audio detection Library

Also, here is one of several "peak finding" questions on SO: Peak detection of measured signal

---

Edit: Not that I do audio processing. It's just a guess based on the fact that you're looking for a frequency domain property of the file...

---

another edit: It is worth noting that lossy compression formats like mp3, store Fourier domain data rather than time domain data in the first place. With a little cleverness, you can save yourself some heavy computation...but see the thoughtful comment by cobbal.

Doug

however, mp3 achieves it's compression by chopping off the frequencies outside of human hearing. Fourier may not be the right tool here. – Vendible

MP3 doesn't 'chop off' frequencies outside of human hearing and it performs cosine transformations (related to Fourier's) individually to enveloped windows about 1 ms wide each. I'd try dmckee's first suggestion on 10 s long windows and see what comes out. – Wetzell

This is too simplistic to really work well. – Jaquez

Answer 7

To repost my answer: The easy way to do it is to have the user tap a button in rhythm with the beat, and count the number of taps divided by the time.

Pieria

Answer 8

There are several methods to get the BPM but the one I find the most effective is the "beat spectrum" (described here). This algorithm computes a similarity matrix by comparing each short sample of the music with every others. Once the similarity matrix is computed it is possible to get average similarity between every samples pairs {S(T);S(T+1)} for each time interval T: this is the beat spectrum. The first high peak in the beat spectrum is most of the time the beat duration. The best part is you can also do things like music structure or rythm analyses.

Construct

Answer 9

Others have already described some beat-detection methods. I want to add that there are some libraries available that provide techniques and algorithms for this sort of task.

Aubio is one of them, it has a good reputation and it's written in C with a C++ wrapper so you can integrate it easily with a cocoa application (all the audio stuff in Apple's frameworks is also written in C/C++).

Chantel

Answer 10

I'd imagine this will be easiest in 4-4 dance music, as there should be a single low frequency thud about twice a second.

Myrna