├── .gitignore
├── LICENSE
├── README.md
├── demo
    ├── Arpeggio.ogg
    └── demo.js
├── package.json
├── pitch.js
└── test
    ├── multi.js
    ├── noise.js
    └── test.js


/.gitignore:
--------------------------------------------------------------------------------
 1 | lib-cov
 2 | *.seed
 3 | *.log
 4 | *.csv
 5 | *.dat
 6 | *.out
 7 | *.pid
 8 | *.gz
 9 | 
10 | pids
11 | logs
12 | results
13 | 
14 | npm-debug.log
15 | node_modules/*


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | 
 2 | The MIT License (MIT)
 3 | 
 4 | Copyright (c) 2013 Mikola Lysenko
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in
14 | all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | detect-pitch
 2 | ============
 3 | Detects the pitch of a signal using the autocorrelation method.
 4 | 
 5 | ## Example
 6 | 
 7 | ```javascript
 8 | var detectPitch = require('detect-pitch')
 9 | 
10 | var n = 1024
11 | var ω = 2.0 * Math.PI / n
12 | 
13 | //Initialize signal
14 | var signal = new Float32Array(n)
15 | for(var i=0; i<n; ++i) {
16 |   signal[i] = Math.sin(100 * i * ω)
17 | }
18 | 
19 | console.log(Math.round(n / detectPitch(signal)))
20 | 
21 | //Prints out:
22 | //
23 | //    100
24 | //
25 | ```
26 | 
27 | ## Install
28 | 
29 |     npm install detect-pitch
30 | 
31 | ### `require('detect-pitch')(signal[, threshold])`
32 | Detects the pitch of `signal` by computing the period by autocorrelation.
33 | 
34 | * `signal` is a snippet of an audio signal.  Represented as either a typed array or an [ndarray](https://github.com/scijs/ndarray).
35 | * `threshold` is an optional parameter between `0` and `1` which determines the cutoff for reporting a successful detection.  Higher values indicate stricture cutoff.  Default is `0`
36 | 
37 | **Returns** The number of samples in the **period** of the signal.  If no pitch was detected, returns `0`.  To recover the pitch *frequency*, you need to divide the sample rate by this number (note that this will be `NaN` for signals with no pitch):
38 | 
39 | ```javascript
40 | var pitchInHz = sampleRateInHz / periodInSamples
41 | ```
42 | 
43 | ## Credits
44 | (c) 2013-2015 Mikola Lysenko. MIT License
45 | 


--------------------------------------------------------------------------------
/demo/Arpeggio.ogg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mikolalysenko/detect-pitch/0b78183fbb7d3a68987485363eb786ac16940843/demo/Arpeggio.ogg


--------------------------------------------------------------------------------
/demo/demo.js:
--------------------------------------------------------------------------------
 1 | var fit = require('canvas-fit')
 2 | var detectPitch = require('../pitch')
 3 | 
 4 | var NUM_SAMPLES = 4096
 5 | 
 6 | var signal = new Float32Array(NUM_SAMPLES)
 7 | 
 8 | var audio = new Audio
 9 | audio.src = 'Arpeggio.ogg'
10 | audio.loop = true
11 | 
12 | var pitchDiv = document.createElement('div')
13 | pitchDiv.style.position = 'absolute'
14 | pitchDiv.style.top = '60%'
15 | pitchDiv.style.left = '0px'
16 | pitchDiv.style.width = '100%'
17 | pitchDiv.style['text-align'] = 'center'
18 | pitchDiv.style['font-size'] = '400px'
19 | pitchDiv.style['z-index'] = 10
20 | document.body.appendChild(pitchDiv)
21 | 
22 | var pitchCanvas = document.createElement('canvas')
23 | pitchCanvas.style['z-index'] = '0'
24 | document.body.appendChild(pitchCanvas)
25 | window.addEventListener('resize', fit(pitchCanvas), false)
26 | 
27 | var drawContext = pitchCanvas.getContext('2d')
28 | drawContext.fillStyle = '#fff'
29 | drawContext.fillRect(0, 0, pitchCanvas.width, pitchCanvas.height)
30 | 
31 | var fillColumn = 0
32 | 
33 | audio.addEventListener('canplay', function() {
34 |   var context = new (window.AudioContext || window.webkitAudioContext)
35 |   var stream = context.createMediaElementSource(audio)
36 |   var analyser = context.createAnalyser(audio)
37 | 
38 |   stream.connect(analyser)
39 |   analyser.connect(context.destination)
40 | 
41 |   audio.play()
42 | 
43 |   function processSection() {
44 |     requestAnimationFrame(processSection)
45 | 
46 |     analyser.getFloatTimeDomainData(signal)
47 |     var period = detectPitch(signal, 0.2)
48 |     var pitch = -1
49 |     pitchDiv.style['font-size'] = ((0.25*(window.innerHeight))|0) + 'px'
50 |     if(period) {
51 |       pitch = Math.round(44100.0 / period)
52 |       pitchDiv.innerHTML = (pitch) + ' Hz'
53 |     } else {
54 |       pitchDiv.innerHTML = '-'
55 |     }
56 | 
57 |     drawContext.fillStyle = '#fff'
58 |     drawContext.fillRect(fillColumn % pitchCanvas.width, 0, 1, pitchCanvas.height)
59 |     drawContext.fillStyle = '#00f'
60 |     drawContext.fillRect(fillColumn % pitchCanvas.width, pitch, 1, 1)
61 |     fillColumn += 1
62 |   }
63 | 
64 |   processSection()
65 | })
66 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "detect-pitch",
 3 |   "version": "1.1.0",
 4 |   "description": "Detects the pitch of an audio snippet",
 5 |   "main": "pitch.js",
 6 |   "directories": {
 7 |     "test": "test"
 8 |   },
 9 |   "dependencies": {
10 |     "bit-twiddle": "^1.0.2",
11 |     "ndarray": "^1.0.18",
12 |     "ndarray-fft": "^1.0.0",
13 |     "ndarray-ops": "^1.2.2",
14 |     "scijs-window-functions": "^2.0.2",
15 |     "typedarray-pool": "^1.1.0"
16 |   },
17 |   "devDependencies": {
18 |     "canvas-fit": "^1.4.0",
19 |     "tape": "^4.0.0"
20 |   },
21 |   "scripts": {
22 |     "test": "tape test/*.js"
23 |   },
24 |   "repository": {
25 |     "type": "git",
26 |     "url": "git://github.com/mikolalysenko/detect-pitch.git"
27 |   },
28 |   "keywords": [
29 |     "pitch",
30 |     "frequency",
31 |     "detection",
32 |     "audio",
33 |     "processing"
34 |   ],
35 |   "author": "Mikola Lysenko",
36 |   "license": "MIT",
37 |   "readmeFilename": "README.md",
38 |   "gitHead": "bf7972a7935b4bdbcef8154891f2e9baa82d5d04",
39 |   "bugs": {
40 |     "url": "https://github.com/mikolalysenko/detect-pitch/issues"
41 |   }
42 | }
43 | 


--------------------------------------------------------------------------------
/pitch.js:
--------------------------------------------------------------------------------
  1 | "use strict"
  2 | 
  3 | var bits = require('bit-twiddle')
  4 | var pool = require('typedarray-pool')
  5 | var ndarray = require('ndarray')
  6 | var ops = require('ndarray-ops')
  7 | var fft = require('ndarray-fft')
  8 | var hann = require('scijs-window-functions/hann')
  9 | 
 10 | function square(x, y) {
 11 |   var n = x.length
 12 |   for(var i=0; i<n; ++i) {
 13 |     var a = x[i], b = y[i]
 14 |     x[i] = a*a + b*b
 15 |     y[i] = 0.0
 16 |   }
 17 | }
 18 | 
 19 | function prefilter(x, xf, n) {
 20 |   x[0] = 1
 21 |   var s = 0
 22 |   for(var i=1; i<n; ++i) {
 23 |     var d = Math.max(xf - x[i], 0.0)
 24 |     s += d
 25 |     x[i] = d * i / s
 26 |   }
 27 | }
 28 | 
 29 | function aperiodic(x, n) {
 30 |   if(n<=3) {
 31 |     return true
 32 |   }
 33 |   var d = ((x + 0.5 * n) % n) - 0.5 * n
 34 |   return Math.abs(d) > 1
 35 | }
 36 | 
 37 | function findPeriod(x, lo, hi, threshold) {
 38 |   var smallest = 1.0
 39 |   var period = 0
 40 |   for(var i=lo; i+2<hi; ++i) {
 41 |     var y0 = x[i], y1 = x[i+1], y2 = x[i+2]
 42 |     var denom = y2 - 2.0 * y1 + y0
 43 |     if(Math.abs(denom) < 1e-6) {
 44 |       if(y1 < smallest && aperiodic(i+1, period)) {
 45 |         smallest = y1
 46 |         period = i+1
 47 |       }
 48 |     } else {
 49 |       var s = 0.5 * (y0 - y2) / denom
 50 |       if(Math.abs(s) > 1.0) {
 51 |         continue
 52 |       }
 53 |       var ymin = y1 + 0.25 * Math.pow(y0 - y2, 2) / denom
 54 |       if(ymin < smallest) {
 55 |         var f0 = i + s + 1
 56 |         if(aperiodic(f0, period)) {
 57 |           smallest = ymin
 58 |           period = f0
 59 |         }
 60 |       }
 61 |     }
 62 |   }
 63 |   if(smallest < 1.0 - threshold) {
 64 |     return period
 65 |   }
 66 |   return 0.0
 67 | }
 68 | 
 69 | function detectPitch(signal, threshold) {
 70 |   threshold = threshold || 0.0
 71 | 
 72 |   var xs
 73 |   if(signal.shape) {
 74 |     xs = signal.shape[0]
 75 |   } else {
 76 |     xs = signal.length
 77 |   }
 78 | 
 79 |   var n = bits.nextPow2(2*xs)
 80 | 
 81 |   var i, j, k
 82 |   var re_arr = pool.mallocFloat(n)
 83 |   var im_arr = pool.mallocFloat(n)
 84 |   var X = ndarray(re_arr, [n], [1], 0)
 85 |   var Y = ndarray(im_arr, [n], [1], 0)
 86 | 
 87 |   //Initialize array depending on if it is a typed array
 88 |   if(signal.shape) {
 89 |     ops.assign(X.hi(xs), signal)
 90 |   } else {
 91 |     re_arr.set(signal)
 92 |   }
 93 | 
 94 |   //Compute magnitude
 95 |   var magnitude = 0.0
 96 |   for(var i=0; i<xs; ++i) {
 97 |     var z = re_arr[i] *= hann(i, xs)
 98 |     magnitude += Math.pow(z, 2)
 99 |   }
100 | 
101 |   //Zero out arrays
102 |   for(var i=xs; i<n; ++i) {
103 |     re_arr[i] = 0.0
104 |   }
105 |   for(var i=0; i<n; ++i) {
106 |     im_arr[i] = 0.0
107 |   }
108 | 
109 |   //Autocorrelate
110 |   fft(1, X, Y)
111 |   square(re_arr, im_arr)
112 |   fft(-1, X, Y)
113 | 
114 |   //Apply prefiltering
115 |   prefilter(re_arr, magnitude, xs)
116 | 
117 |   //Detect pitch
118 |   var period = findPeriod(re_arr, 0, xs>>>1, threshold)
119 | 
120 |   //Free temporary arrays
121 |   pool.freeFloat(re_arr)
122 |   pool.freeFloat(im_arr)
123 | 
124 |   return period
125 | }
126 | module.exports = detectPitch
127 | 


--------------------------------------------------------------------------------
/test/multi.js:
--------------------------------------------------------------------------------
 1 | "use strict"
 2 | 
 3 | var detectPitch = require("../pitch.js")
 4 | 
 5 | function runTest(t, n, freq_list, phase_list, amplitude_list) {
 6 |   var signal = new Float32Array(n)
 7 |   var omega = 2.0 * Math.PI / n
 8 | 
 9 |   for(var i=0; i<freq_list.length; ++i) {
10 |     var f = freq_list[i]
11 |     for(var j=0; j<n; ++j) {
12 |       signal[j] += Math.sin(f * j * omega + phase_list[i]) * amplitude_list[i]
13 |     }
14 |   }
15 |   var pitch = detectPitch(signal)
16 |   t.equals(Math.round(n/pitch), freq_list[0], 'detected period: ' + (pitch) + ', expected: ' + (n/freq_list[0]))
17 | }
18 | 
19 | require("tape")("detect-pitch: pure sine wave", function(t) {
20 | 
21 |   var freqs = [32, 117]
22 |   var phases = [0, 0]
23 |   var amplitudes = [1, 0.1]
24 | 
25 |   runTest(t, 4096, freqs, phases, amplitudes)
26 |   runTest(t, 2048, freqs, phases, amplitudes)
27 |   runTest(t, 1024, freqs, phases, amplitudes)
28 | 
29 |   for(var i=16; i<64; ++i) {
30 | 
31 |     var freqs = [i]
32 |     var phases = [Math.random()]
33 |     var amplitudes = [1]
34 | 
35 |     for(var j=0; j<2; ++ j) {
36 |       freqs.push(Math.random()*256)
37 |       phases.push(Math.random()*2.0*Math.PI)
38 |       amplitudes.push(0.1)
39 |     }
40 | 
41 |     runTest(t, 4096, freqs, phases, amplitudes)
42 |     runTest(t, 2048, freqs, phases, amplitudes)
43 |     runTest(t, 1024, freqs, phases, amplitudes)
44 | 
45 |   }
46 | 
47 |   t.end()
48 | })
49 | 


--------------------------------------------------------------------------------
/test/noise.js:
--------------------------------------------------------------------------------
 1 | "use strict"
 2 | 
 3 | var detectPitch = require("../pitch.js")
 4 | 
 5 | function runTest(t, n, freq_list, phase_list, amplitude_list) {
 6 |   var signal = new Float32Array(n)
 7 |   var omega = 2.0 * Math.PI / n
 8 | 
 9 |   for(var i=0; i<freq_list.length; ++i) {
10 |     var f = freq_list[i]
11 |     for(var j=0; j<n; ++j) {
12 |       signal[j] = Math.sin(f * j * omega + phase_list[i]) * amplitude_list[i] + 0.25*(0.5-Math.random())
13 |     }
14 |     var pitch = detectPitch(signal)
15 |     t.equals(Math.round(n/pitch), f, 'detected period: ' + (pitch) + ', expected: ' + (n/f))
16 |   }
17 | }
18 | 
19 | require("tape")("detect-pitch: pure sine wave + uniform noise", function(t) {
20 | 
21 |   var freqs = []
22 |   var phases = []
23 |   var amplitudes = []
24 |   for(var i=16; i<64; ++i) {
25 |     freqs.push(i)
26 |     phases.push(Math.random() * 2.0 * Math.PI)
27 |     amplitudes.push(1)
28 |   }
29 |   runTest(t, 4096, freqs, phases, amplitudes)
30 |   runTest(t, 2048, freqs, phases, amplitudes)
31 |   runTest(t, 1024, freqs, phases, amplitudes)
32 | 
33 |   t.end()
34 | })
35 | 


--------------------------------------------------------------------------------
/test/test.js:
--------------------------------------------------------------------------------
 1 | "use strict"
 2 | 
 3 | var detectPitch = require("../pitch.js")
 4 | 
 5 | function runTest(t, n, freq_list, phase_list, amplitude_list) {
 6 |   var signal = new Float32Array(n)
 7 |   var omega = 2.0 * Math.PI / n
 8 | 
 9 |   for(var i=0; i<freq_list.length; ++i) {
10 |     var f = freq_list[i]
11 |     for(var j=0; j<n; ++j) {
12 |       signal[j] = Math.sin(f * j * omega + phase_list[i]) * amplitude_list[i]
13 |     }
14 |     var pitch = detectPitch(signal)
15 |     t.equals(Math.round(n/pitch), f, 'detected period: ' + (pitch) + ', expected: ' + (n/f))
16 |   }
17 | }
18 | 
19 | require("tape")("detect-pitch: pure sine wave", function(t) {
20 | 
21 |   var freqs = []
22 |   var phases = []
23 |   var amplitudes = []
24 |   for(var i=16; i<64; ++i) {
25 |     freqs.push(i)
26 |     phases.push(Math.random() * 2.0 * Math.PI)
27 |     amplitudes.push(1)
28 |   }
29 |   runTest(t, 4096, freqs, phases, amplitudes)
30 |   runTest(t, 2048, freqs, phases, amplitudes)
31 |   runTest(t, 1024, freqs, phases, amplitudes)
32 | 
33 |   t.end()
34 | })
35 | 


--------------------------------------------------------------------------------