duration.js -> probe.js

audiogram/duration.js

-var probe = require("node-ffprobe");
-
-module.exports = function(filename, cb){
-
-  probe(filename, function(err, probeData) {
-
-    if (err) {
-      return cb(err);
-    }
-
-    var duration = getDuration(probeData);
-
-    if (!duration || duration === "N/A" || !(duration > 0)) {
-      return cb("Couldn't probe audio duration.");
-    }
-
-    return cb(null, duration);
-
-  });
-
-};
-
-function getDuration(probeData) {
-
-  if (probeData.format && probeData.format.duration) {
-    return probeData.format.duration;
-  }
-
-  if (Array.isArray(probeData.streams) && probeData.streams.length && probeData.streams[0].duration) {
-    return probeData.streams[0].duration;
-  }
-
-  return null;
-
-}

audiogram/index.js

     serverSettings = require("../settings/"),
     transports = require("../lib/transports/"),
     logger = require("../lib/logger/"),
-    getDuration = require("./duration.js"),
+    probe = require("./probe.js"),
     getWaveform = require("./waveform.js"),
     initializeCanvas = require("./initialize-canvas.js"),
     drawFrames = require("./draw-frames.js"),
 
 }
 
-// Probe an audio file for its duration, compute the number of frames required
-Audiogram.prototype.getDuration = function(cb) {
+// 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("duration");
+  this.status("probing");
 
-  getDuration(this.audioPath, function(err, duration){
+  probe(this.audioPath, function(err, data){
 
     if (err) {
       return cb(err);
     }
 
-    if (self.settings.maxDuration && self.settings.maxDuration < duration) {
+    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(duration * self.settings.framesPerSecond));
+    self.set("numFrames", self.numFrames = Math.floor(data.duration * self.settings.framesPerSecond));
+    self.channels = data.channels;
 
     cb(null);
 
   }
 
   // Get the audio's duration for computing number of frames
-  q.defer(this.getDuration.bind(this));
+  q.defer(this.probe.bind(this));
 
   // Get the audio waveform data
   q.defer(this.getWaveform.bind(this));

audiogram/probe.js

+var probe = require("node-ffprobe");
+
+module.exports = function(filename, cb){
+
+  probe(filename, function(err, probeData) {
+
+    if (err) {
+      return cb(err);
+    }
+
+    var duration = getProperty(probeData, "duration"),
+        channels = getProperty(probeData, "channels");
+
+    if (!duration || duration === "N/A" || !(duration > 0)) {
+      return cb("Couldn't probe audio duration.");
+    }
+
+    if (typeof channels !== "number" || channels < 1 || channels > 2) {
+      return cb("Couldn't detect mono/stereo channels");
+    }
+
+    return cb(null, {
+      duration: duration,
+      channels: channels
+    });
+
+  });
+
+};
+
+function getProperty(probeData, property) {
+
+  if (probeData.format && probeData.format[property]) {
+    return probeData.format[property];
+  }
+
+  if (Array.isArray(probeData.streams) && probeData.streams.length && probeData.streams[0][property]) {
+    return probeData.streams[0][property];
+  }
+
+  return null;
+
+}

audiogram/trim.js

 var exec = require("child_process").exec,
-    getDuration = require("./duration.js");
+    probe = require("./probe.js");
 
 function trimAudio(options, cb) {
 
   if (!options.endTime) {
 
-    return getDuration(options.origin, function(err, duration){
+    return probe(options.origin, function(err, data){
       if (err) {
         return cb(err);
       }
 
-      options.endTime = duration;
+      options.endTime = data.duration;
       trimAudio(options, cb);
 
     });

client/index.js

       return "Downloading audio for processing";
     case "trim":
       return "Trimming audio";
-    case "duration":
-      return "Checking duration";
+    case "probing":
+      return "Probing audio file";
     case "waveform":
       return "Analyzing waveform";
     case "renderer":

client/waveform.js

   var fileReader = new FileReader();
 
   var close = function(err, data) {
+    console.warn(err);
     ctx.close();
     cb(err, data);
   };

package.json

   "dependencies": {
     "aws-sdk": "^2.2.39",
     "browserify": "^13.0.0",
+    "canvas": "git+https://github.com/chearon/node-canvas.git#b62dd3a9fa",
     "compression": "^1.6.1",
     "d3": "^4.1.1",
     "dotenv": "^2.0.0",
     "rimraf": "^2.5.0",
     "smartquotes": "^1.0.0",
     "underscore": "^1.8.3",
-    "canvas": "git+https://github.com/chearon/node-canvas.git#b62dd3a9fa",
     "waveform": "git+https://github.com/veltman/node-waveform.git#8b1a22f109",
     "webaudio-peaks": "0.0.5",
     "winston": "^2.2.0"

server/status.js

         hash = { status: "unknown" };
       }
 
-      ["duration","numFrames","framesComplete"].forEach(function(key) {
+      ["numFrames", "framesComplete"].forEach(function(key) {
         if (key in hash) {
           hash[key] = +hash[key];
         }

test/duration-test.js

 
 require("mkdirp").sync(path.join(__dirname, "tmp"));
 
-var getDuration = require("../audiogram/duration.js"),
+var probe = require("../audiogram/probe.js"),
     trimAudio = require("../audiogram/trim.js");
 
-tape("MP3 duration", function(test) {
+tape("MP3 probe", function(test) {
 
-  getDuration(path.join(__dirname, "data/glazed-donut.mp3"), function(err, duration){
+  probe(path.join(__dirname, "data/glazed-donut.mp3"), function(err, data){
 
     test.error(err);
-    test.equal(typeof duration, "number");
-    test.assert(Math.abs(duration - 26.67) < 0.1);
+    test.equal(typeof data.duration, "number");
+    test.equal(data.channels, 2);
+    test.assert(Math.abs(data.duration - 26.67) < 0.1);
     test.end();
 
   });
 
 });
 
-tape("WAV duration", function(test) {
+tape("WAV probe", function(test) {
 
-  getDuration(path.join(__dirname, "data/glazed-donut.wav"), function(err, duration){
+  probe(path.join(__dirname, "data/glazed-donut.wav"), function(err, data){
 
     test.error(err);
-    test.equal(typeof duration, "number");
-    test.assert(Math.abs(duration - 1.83) < 0.1);
+    test.equal(typeof data.duration, "number");
+    test.equal(data.channels, 2);
+    test.assert(Math.abs(data.duration - 1.83) < 0.1);
     test.end();
 
   });
 
 });
 
-tape("Duration error", function(test) {
+tape("Probe error", function(test) {
 
-  getDuration(path.join(__dirname, "..", "README.md"), function(err){
+  probe(path.join(__dirname, "..", "README.md"), function(err){
 
     test.ok(err);
     test.end();
 
   queue(1)
     .defer(trimAudio, options)
-    .defer(getDuration, options.destination)
-    .await(function(err, _, duration){
+    .defer(probe, options.destination)
+    .await(function(err, _, data){
 
       test.error(err);
-      test.equal(typeof duration, "number");
-      test.assert(Math.abs(duration - 20) < 0.1);
+      test.equal(typeof data.duration, "number");
+      test.assert(Math.abs(data.duration - 20) < 0.1);
       test.end();
 
     });
 
   queue(1)
     .defer(trimAudio, options)
-    .defer(getDuration, options.destination)
-    .await(function(err, _, duration){
+    .defer(probe, options.destination)
+    .await(function(err, _, data){
 
       test.error(err);
-      test.equal(typeof duration, "number");
-      test.assert(Math.abs(duration - 20) < 0.1);
+      test.equal(typeof data.duration, "number");
+      test.assert(Math.abs(data.duration - 20) < 0.1);
       test.end();
 
     });
 
   queue(1)
     .defer(trimAudio, options)
-    .defer(getDuration, options.destination)
-    .await(function(err, _, duration){
+    .defer(probe, options.destination)
+    .await(function(err, _, data){
 
       test.error(err);
-      test.equal(typeof duration, "number");
-      test.assert(Math.abs(duration - 5) < 0.1);
+      test.equal(typeof data.duration, "number");
+      test.assert(Math.abs(data.duration - 5) < 0.1);
       test.end();
 
     });
     endTime: 4
   };
 
-  queue(1)
-    .defer(trimAudio, options)
-    .defer(getDuration, options.destination)
-    .await(function(err, _, duration){
-
-      test.ok(err);
-      test.end();
-
-    });
-
-});
-
-// Cleanup
-tape.onFinish(function(){
-  require("rimraf")(path.join(__dirname, "tmp"), function(err){
-    if (err) {
-      throw err;
-    }
+  trimAudio(options, function(err){
+    test.ok(err);
+    test.end();
   });
+
 });
 
 // Cleanup