Replacing waveform calc

audiogram/index.js

@@ -5,7 +5,6 @@ var path = require("path"),
     serverSettings = require("../settings/"),
     transports = require("../lib/transports/"),
     logger = require("../lib/logger/"),
-    probe = require("./probe.js"),
     getWaveform = require("./waveform.js"),
     initializeCanvas = require("./initialize-canvas.js"),
     drawFrames = require("./draw-frames.js"),
@@ -29,32 +28,6 @@ function Audiogram(settings) {
 
 }
 
-// Probe an audio file for its duration and # of channels, compute the number of frames required
-Audiogram.prototype.probe = function(cb) {
-
-  var self = this;
-
-  this.status("probing");
-
-  probe(this.audioPath, function(err, data){
-
-    if (err) {
-      return cb(err);
-    }
-
-    if (self.settings.maxDuration && self.settings.maxDuration < data.duration) {
-      cb("Exceeds max duration of " + self.settings.maxDuration + "s");
-    }
-
-    self.set("numFrames", self.numFrames = Math.floor(data.duration * self.settings.framesPerSecond));
-    self.channels = data.channels;
-
-    cb(null);
-
-  });
-
-};
-
 // Get the waveform data from the audio file, split into frames
 Audiogram.prototype.getWaveform = function(cb) {
 
@@ -63,11 +36,12 @@ Audiogram.prototype.getWaveform = function(cb) {
   this.status("waveform");
 
   getWaveform(this.audioPath, {
-    channels: this.channels,
-    numFrames: this.numFrames,
-    samplesPerFrame: this.settings.samplesPerFrame
+    samplesPerFrame: this.settings.samplesPerFrame,
+    maxDuration: this.settings.maxDuration
   }, function(err, waveform){
 
+    self.set("numFrames", self.numFrames = self.settings.waveform.length);
+
     return cb(err, self.settings.waveform = waveform);
 
   });

audiogram/waveform.js

@@ -1,62 +1,25 @@
-var d3 = require("d3"),
-    getPCM = require("../lib/pcm.js");
+var probe = require("../lib/probe.js"),
+    processWaveform = require("../lib/waveform.js");
 
 function getWaveform(filename, options, cb) {
 
-
-
-  options.numFrames
-  options.samplesPerFrame;
-
-  var waveformOptions = {
-    "scan": false,
-    "waveformjs": "-",
-    "wjs-width": numSamples,
-    "wjs-precision": 2,
-    "wjs-plain": true,
-    "encoding": "utf8"
-  };
-
-  waveform(filename, waveformOptions, function(err, buf) {
+  probe(filename, function(err, data) {
 
     if (err) {
       return cb(err);
     }
 
-    cb(null, processWaveform(JSON.parse(buf)));
-
-  });
-
-  // Slice one-dimensional waveform data into array of arrays, one array per frame
-  function processWaveform(waveformData) {
-
-    var max = -Infinity,
-        maxFrame;
-
-    waveformData.forEach(function(d, i){
-      if (d > max) {
-        max = d;
-        maxFrame = Math.floor(i / options.samplesPerFrame);
-      }
-    });
-
-    // Scale peaks to 1
-    var scaled = d3.scaleLinear()
-      .domain([0, max])
-      .range([0, 1]);
-
-    var waveformFrames = d3.range(options.numFrames).map(function getFrame(frameNumber) {
-
-      return waveformData.slice(options.samplesPerFrame * frameNumber, options.samplesPerFrame * (frameNumber + 1)).map(scaled);
-
-    });
-
-    // Set the first and last frame's waveforms to something peak-y for better thumbnails
-    waveformFrames[0] = waveformFrames[waveformFrames.length - 1] = waveformFrames[maxFrame];
+    if (options.maxDuration && options.maxDuration < data.duration) {
+      return cb("Exceeds max duration of " + options.maxDuration + "s");
+    }
 
-    return waveformFrames;
+    processWaveform(filename, {
+      numFrames: Math.floor(data.duration * options.samplesPerFrame),
+      samplesPerFrame: options.samplesPerFrame,
+      channels: data.channels
+    }, cb);
 
-  }
+  });
 
 }
 

lib/waveform.js

@@ -0,0 +1,70 @@
+var pcm = require("./pcm.js"),
+    d3 = require("d3");
+
+function processWaveform(filename, options, cb) {
+
+  var stream = pcm(filename, {
+        channels: options.channels
+      }),
+      samples = [];
+
+  stream.on("data",function(sample, channel){
+
+    // Average multiple channels
+    if (channel > 0) {
+      samples[samples.length - 1] = ((samples[samples.length - 1] * channel) + sample) / (channel + 1);
+    } else {
+      samples.push(sample);
+    }
+
+  });
+
+  stream.on("error", cb);
+
+  stream.on("end", function(output){
+    var processed = processSamples(samples, options.numFrames, options.samplesPerFrame);
+    return cb(null, processed);
+  });
+
+}
+
+function processSamples(samples, numFrames, samplesPerFrame) {
+
+  // TODO spread out slop across frames
+  var perFrame = Math.floor(samples.length / numFrames),
+      perPoint = Math.floor(perFrame / samplesPerFrame),
+      range = d3.range(samplesPerFrame),
+      min = max = 0;
+
+  var unadjusted = d3.range(numFrames).map(function(frame){
+
+    var frameSamples = samples.slice(frame * perFrame, (frame + 1) * perFrame);
+
+    return range.map(function(point){
+
+      var pointSamples = frameSamples.slice(point * perPoint, (point + 1) * perPoint),
+          localMin = localMax = 0;
+
+      for (var i = 0, l = pointSamples.length; i < l; i++) {
+        localMin = Math.min(localMin, pointSamples[i]);
+        localMax = Math.min(localMax, pointSamples[i]);
+      }
+
+      min = Math.min(min, localMin);
+      max = Math.min(max, localMax);
+
+      return [localMin, localMax];
+
+    });
+
+  });
+
+  return unadjusted.map(function(frame){
+    return frame.map(function(point){
+      return [point[0] / min, point[1] / max];
+    });
+  });
+
+}
+
+module.exports = processWaveform;