tone-stream 1.4.4 → 1.6.0

package/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+
+[Makefile]
+indent_style = tab
+
+[*]
+indent_style = space
+indent_size = 2

package/examples/detect_tones.js

@@ -1,51 +1,28 @@
 const { ToneStream } = require('../index.js')
-const goertzel = require('goertzel-stream')
-
-const {PassThrough} = require('stream')
-
-const sampleRate = 8000
+const DtmfDetectionStream = require('dtmf-detection-stream')
 
 const format = {
-	sampleRate: sampleRate,
-	bitDepth: 16,
-	channels: 1,
+        sampleRate: 8000,
+        bitDepth: 16,
+        channels: 1,
 }
 
 const ts = new ToneStream(format)
-
-var notes = [
-	//[2000, 'DTMF:#'],
-	[2000, 697],
-	[1000, 's'],
-	/*
-	[2000, 770],
-	[1000, 's'],
-	[2000, 852],
-	[1000, 's'],
-	*/
-]
-
-ts.concat(notes)
-
-var detector = goertzel([697, 770, 852, 941, 1209, 1336, 1477, 1633], {
-	sampleRate: sampleRate,
-})
-
-// adding PassThrough stream to check data in the pipe
-const pt = new PassThrough()
-
-pt.on('data', data => {
-	console.log(data.length, data)
-})
-
-ts.pipe(pt)
-pt.pipe(detector)
-
-detector.on('toneStart', function (tones) {
-  console.log('start', tones)
+ts.add([800, 's']) // silence
+ts.add([800, 'DTMF:1'])
+ts.add([800, 's']) // silence
+ts.add([800, 'DTMF:2'])
+ts.add([800, 's']) // silence
+ts.add([800, 'DTMF:3'])
+ts.add([800, 's']) // silence
+
+const dds = new DtmfDetectionStream(format)
+
+dds.on('dtmf', data => {
+        console.log('Got', data)
 })
 
-detector.on('toneEnd', function (tones) {
-  console.log('end', tones)
+ts.on('data', data => {
+        dds.write(data)
 })
 

package/examples/{silence_filler.js → stay_alive.js}

@@ -10,9 +10,11 @@ const format = {
 	channels: 1
 }
 
-const filler = 0 // silence
+const opts = {
+  stay_alive: true,
+}
 
-const ts = new ToneStream(format, filler)
+const ts = new ToneStream(format, opts)
 
 const s = new Speaker(format)
 
@@ -44,7 +46,7 @@ assert(b.length == 140)
 s.write(b)
 
 b = ts.read(12000)
-assert(b.length == 12000) // this will be filled with zeros after all items are consumed.
+assert(b.length == 12000) // this will be filled with silence (zero) after all items are consumed.
 s.write(b)
 
 setTimeout(() => {}, 2000)

package/index.js

@@ -1,159 +1,169 @@
-const { Readable } = require('stream')
+const { Readable } = require("stream");
 
-const SpecReadStream = require('spec-read-stream')
+const SpecReadStream = require("spec-read-stream");
 
-const DTMF = require('./lib/dtmf')
+const DTMF = require("./lib/dtmf");
 
 class ToneStream extends Readable {
-	constructor(format, filler) {
-		super()
-
-		if(format) {
-			this.sampleRate = format.sampleRate
-			this.bitDepth = format.bitDepth
-			this.channels = format.channels
-		} else {
-			// default
-			this.sampleRate = 8000
-			this.bitDepth = 16
-			this.channels = 1
-		}
-
-		this.filler = filler
-
-		this.amplitude = (2**this.bitDepth)/2 - 1
-	
-		this.specReadStream = new SpecReadStream()
-
-		this.currentSample = 0
-	}
-
-	add(spec) {
-		this.specReadStream.add(spec)
-	}
-
-	concat(specs) {
-		specs.forEach(spec => {
-			this.specReadStream.add(spec)
-		})
-	}
-
-	on(evt, cb) {
-		super.on(evt, cb)
-
-		if(evt == 'empty') {
-			this.specReadStream.on(evt, cb)
-		}
-	}
-
-	_read(n) {
-		//console.log(`_read(${n})`)
-
-		let sampleSize = this.bitDepth / 8
-		let blockAlign = sampleSize * this.channels
-
-		let numSamples = Math.floor(n / blockAlign)
-
-		let end = this.currentSample + numSamples
-
-		let buf = Buffer.alloc(numSamples * blockAlign)
-
-		let setter = (buf['writeInt' + this.bitDepth + 'LE']).bind(buf)
-
-		var specs = this.specReadStream.read(numSamples)
-		//console.log(`specs=${specs}`)
-
-		var buf_idx = 0;
-
-		if(!specs) {
-			//console.log(`no specs filler=${this.filler}`)
-			if(typeof this.filler == 'number') {
-				for(var j=0 ; j<numSamples * this.channels; j++) {
-					let offset = (j * sampleSize * this.channels)
-					setter(this.filler, offset)
-				}
-				return buf
-			} else {
-				return null
-			}
-		}
-
-		let actualSamples = specs.reduce((total, spec) => { return total + spec[0] }, 0)
-		//console.log(`actualSamples=${actualSamples}`)
-
-		for(var i=0 ; i<specs.length ; i++) {
-			var spec = specs[i]
-			//console.log(`spec=${spec}`)
-
-			var nSamples = spec[0]
-			var spec_val = spec[1]
-
-			var val_calculator = (() => {
-				if(spec_val == 's') {
-					// silence
-					return () => { return 0 }
-				} else if(typeof spec_val == 'number') {
-					var freq = spec_val
-					let t = (Math.PI * 2 * freq) / this.sampleRate
-
-					return (amplitude, currentSample) => {
-						return Math.round(amplitude * Math.sin(t * currentSample)) // sine wave
-					}
-				} else if(typeof spec_val == 'string' && spec_val.startsWith("DTMF:")) {
-					var tone = DTMF[spec_val.split(":")[1]]
-					var lo = tone[0]
-					var hi = tone[1]
-
-					let t_lo = (Math.PI * 2 * lo) / this.sampleRate
-					let t_hi = (Math.PI * 2 * hi) / this.sampleRate
-
-					return (amplitude, currentSample) => {
-						return (
-							Math.round(amplitude * Math.sin(t_lo * currentSample)) +
-							Math.round(amplitude * Math.sin(t_hi * currentSample))
-						) / 2
-					}
-				} else {
-					throw `invalid spec ${spec}`
-				}
-			})()
-
-			for(var j=0 ; j<nSamples ; j++) {
-				for (let channel = 0; channel < this.channels; channel++) {
-					let val = val_calculator(this.amplitude, this.currentSample) / 2 // halve amplitude
-					let offset = (buf_idx * sampleSize * this.channels) + (channel * sampleSize)
-					setter(val, offset)
-					buf_idx++
-					this.currentSample++
-				}
-			}
-		}
-
-		if(typeof this.filler == 'number') {
-			while(numSamples > actualSamples) {
-				//console.log("adding filler")
-				for (let channel = 0; channel < this.channels; channel++) {
-					let offset = (actualSamples-1) * sampleSize * this.channels
-					setter(this.filler, offset)
-					this.currentSample++
-					actualSamples++
-				}
-			}
-		}
-
-		if(numSamples > actualSamples) {
-			//console.log(`slicing buf from ${numSamples} to ${actualSamples}`)
-			//console.log(`${actualSamples * sampleSize * this.channels}`)
-			buf = buf.slice(0, actualSamples * sampleSize * this.channels)
-		}
-
-		//console.log("pushing")
-		//console.log(buf.length)
-		this.push(buf)
-	}
+  constructor(format, opts) {
+    super();
+
+    if (format) {
+      this.sampleRate = format.sampleRate;
+      this.bitDepth = format.bitDepth;
+      this.channels = format.channels;
+    } else {
+      // default
+      this.sampleRate = 8000;
+      this.bitDepth = 16;
+      this.channels = 1;
+    }
+
+    this.opts = opts;
+
+    this.amplitude = 2 ** this.bitDepth / 2 - 1;
+
+    this.specReadStream = new SpecReadStream();
+
+    this.currentSample = 0;
+  }
+
+  add(spec) {
+    this.specReadStream.add(spec);
+  }
+
+  concat(specs) {
+    specs.forEach((spec) => {
+      this.specReadStream.add(spec);
+    });
+  }
+
+  on(evt, cb) {
+    super.on(evt, cb);
+
+    if (evt == "empty") {
+      this.specReadStream.on(evt, cb);
+    }
+  }
+
+  _read(n) {
+    //console.log(`_read(${n})`)
+
+    let sampleSize = this.bitDepth / 8;
+    let blockAlign = sampleSize * this.channels;
+
+    let numSamples = Math.floor(n / blockAlign);
+
+    let end = this.currentSample + numSamples;
+
+    let buf = Buffer.alloc(numSamples * blockAlign);
+
+    let setter = buf["writeInt" + this.bitDepth + "LE"].bind(buf);
+
+    var specs = this.specReadStream.read(numSamples);
+    //console.log(`specs=${specs}`)
+
+    var buf_idx = 0;
+
+    if (!specs) {
+      if (this.opts && this.opts.stay_alive) {
+        for (var j = 0; j < numSamples * this.channels; j++) {
+          let offset = j * sampleSize * this.channels;
+          setter(0, offset);
+        }
+
+        this.push(buf);
+        return;
+      } else {
+        return null;
+      }
+    }
+
+    let actualSamples = specs.reduce((total, spec) => {
+      return total + spec[0];
+    }, 0);
+    //console.log(`actualSamples=${actualSamples}`)
+
+    for (var i = 0; i < specs.length; i++) {
+      var spec = specs[i];
+      //console.log(`spec=${spec}`)
+
+      var nSamples = spec[0];
+      var spec_val = spec[1];
+
+      var val_calculator = (() => {
+        if (spec_val == "s") {
+          // silence
+          return () => {
+            return 0;
+          };
+        } else if (typeof spec_val == "number") {
+          var freq = spec_val;
+          let t = (Math.PI * 2 * freq) / this.sampleRate;
+
+          return (amplitude, currentSample) => {
+            return Math.round(amplitude * Math.sin(t * currentSample)); // sine wave
+          };
+        } else if (
+          typeof spec_val == "string" &&
+          spec_val.startsWith("DTMF:")
+        ) {
+          var tone = DTMF[spec_val.split(":")[1]];
+          var lo = tone[0];
+          var hi = tone[1];
+
+          let t_lo = (Math.PI * 2 * lo) / this.sampleRate;
+          let t_hi = (Math.PI * 2 * hi) / this.sampleRate;
+
+          return (amplitude, currentSample) => {
+            return (
+              (Math.round(amplitude * Math.sin(t_lo * currentSample)) +
+                Math.round(amplitude * Math.sin(t_hi * currentSample))) /
+              2
+            );
+          };
+        } else {
+          throw `invalid spec ${spec}`;
+        }
+      })();
+
+      for (var j = 0; j < nSamples; j++) {
+        for (let channel = 0; channel < this.channels; channel++) {
+          let val = val_calculator(this.amplitude, this.currentSample) / 2; // halve amplitude
+          let offset =
+            buf_idx * sampleSize * this.channels + channel * sampleSize;
+          setter(val, offset);
+          buf_idx++;
+          this.currentSample++;
+        }
+      }
+    }
+
+    if (typeof this.filler == "number") {
+      while (numSamples > actualSamples) {
+        //console.log("adding filler")
+        for (let channel = 0; channel < this.channels; channel++) {
+          let offset = (actualSamples - 1) * sampleSize * this.channels;
+          setter(this.filler, offset);
+          this.currentSample++;
+          actualSamples++;
+        }
+      }
+    }
+
+    if (numSamples > actualSamples) {
+      //console.log(`slicing buf from ${numSamples} to ${actualSamples}`)
+      //console.log(`${actualSamples * sampleSize * this.channels}`)
+      buf = buf.slice(0, actualSamples * sampleSize * this.channels);
+    }
+
+    //console.log("pushing")
+    //console.log(buf.length)
+    this.push(buf);
+  }
 }
 
 module.exports = {
-    ToneStream,
-    utils: require('./lib/utils.js'),
-}
+  ToneStream,
+  utils: require("./lib/utils.js"),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tone-stream",
-  "version": "1.4.4",
+  "version": "1.6.0",
   "description": "A simple audio tone stream library",
   "main": "index.js",
   "repository": {
@@ -21,11 +21,11 @@
   "author": "MayamaTakeshi",
   "license": "MIT",
   "devDependencies": {
-    "goertzel-stream": "git+https://github.com/MayamaTakeshi/goertzel-stream.git",
     "lodash": "^4.17.21",
     "speaker": "^0.5.1"
   },
   "dependencies": {
+    "dtmf-detection-stream": "^1.10.0",
     "morse-node": "^0.1.1",
     "note-to-frequency": "^1.4.1",
     "spec-read-stream": "^1.2.0",