Fix merge

Dockerfile

 # Install dependencies
 RUN apt-get update --yes && apt-get upgrade --yes
 RUN apt-get install git nodejs npm \
-libcairo2-dev libjpeg8-dev libpango1.0-dev libgif-dev build-essential g++ \
+libcairo2-dev libjpeg8-dev libpango1.0-dev libgif-dev libpng-dev build-essential g++ \
 ffmpeg \
-libgroove-dev zlib1g-dev libpng-dev \
 redis-server --yes
 
 RUN ln -s `which nodejs` /usr/bin/node

INSTALL.md

 * [Node.js/NPM](https://nodejs.org/) v0.11.2 or greater
 * [node-canvas dependencies](https://github.com/Automattic/node-canvas#installation)
 * [FFmpeg](https://www.ffmpeg.org/)
-* [libgroove](https://github.com/andrewrk/libgroove)
 
 If you're using a particularly fancy distributed setup you'll also need to install [Redis](http://redis.io/).
 
 An example bootstrap script for installing Audiogram on Ubuntu looks like this:
 
 ```sh
-# 14.04 only: add PPAs for FFmpeg and Libgroove
+# 14.04 only: add PPA for FFmpeg
 # Not required for 15.04+
 sudo add-apt-repository ppa:mc3man/trusty-media --yes
-sudo apt-add-repository ppa:andrewrk/libgroove --yes
 
 # Update/upgrade
 sudo apt-get update --yes && sudo apt-get upgrade --yes
 # Git
 # node-canvas dependencies (Cairo, Pango, libgif, libjpeg)
 # FFmpeg
-# node-waveform dependencies (libgroove, zlib, libpng)
 sudo apt-get install git nodejs npm \
-libcairo2-dev libjpeg8-dev libpango1.0-dev libgif-dev build-essential g++ \
+libcairo2-dev libjpeg8-dev libpango1.0-dev libgif-dev libpng-dev build-essential g++ \
 ffmpeg \
-libgroove-dev zlib1g-dev libpng-dev \
 --yes
 
 # Install Redis if you plan to use it to share rendering among multiple processes/servers
 
 1. [Node.js/NPM](https://nodejs.org/)
 2. [node-canvas dependencies](https://github.com/Automattic/node-canvas#installation)
-4. [libgroove](https://github.com/andrewrk/libgroove)
-
-You probably don't need to install FFmpeg separately because libgroove depends on it.
+4. [FFmpeg](https://www.ffmpeg.org/)
 
 You can install Node.js by [downloading it from the website](https://nodejs.org/).
 
-Installation of node-canvas dependencies and libgroove might look like the following with [Homebrew](http://brew.sh/) (you'll want to make sure [XCode](https://developer.apple.com/xcode/) is installed and up-to-date too):
+Installation of node-canvas dependencies and FFmpeg might look like the following with [Homebrew](http://brew.sh/) (you'll want to make sure [XCode](https://developer.apple.com/xcode/) is installed and up-to-date too):
 
 ```sh
 # Install Git if you haven't already
 brew install git
 
-# Install Cairo, Pango, libgif, libjpeg, libgroove, and FFmpeg
+# Install Cairo, Pango, libgif, libjpeg, libpng, and FFmpeg
 # You may not need to install zlib
-brew install pkg-config cairo pango libpng jpeg giflib libgroove ffmpeg
+brew install pkg-config cairo pango libpng jpeg giflib ffmpeg
 
 # Go to the directory where you want the audiogram directory
 cd /where/to/put/this/
 
 Follow the [Homebrew troubleshooting guide](https://github.com/Homebrew/brew/blob/master/share/doc/homebrew/Troubleshooting.md#troubleshooting), particularly making sure that XCode is up to date.
 
-### Installing libgroove manually
-
-If you're on a Mac and installing [libgroove](https://github.com/andrewrk/libgroove) with Homebrew failed for some reason, you can try following the instructions in the repo to install it more manually.
-
-### Installing XCode command line tools
-
-Audiogram uses [waveform](https://github.com/andrewrk/waveform), which requires the development version of `zlib`. Your Mac might already have this, but if it doesn't, installing XCode command line tools might help:
-
-```sh
-xcode-select --install
-```
-
 ### Updating node-gyp
 
 Updating node-gyp to a current version with:

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"),
+    Profiler = require("../lib/profiler.js"),
+    probe = require("../lib/probe.js"),
     getWaveform = require("./waveform.js"),
     initializeCanvas = require("./initialize-canvas.js"),
     drawFrames = require("./draw-frames.js"),
   this.videoPath = path.join(this.dir, "video.mp4");
   this.frameDir = path.join(this.dir, "frames");
 
+  this.profiler = new Profiler();
+
   return this;
 
 }
 
-// Probe an audio file for its duration, compute the number of frames required
-Audiogram.prototype.getDuration = function(cb) {
+// Get the waveform data from the audio file, split into frames
+Audiogram.prototype.getWaveform = 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.theme.maxDuration && self.settings.theme.maxDuration < duration) {
-      cb("Exceeds max duration of " + self.settings.theme.maxDuration + "s");
+    if (self.settings.theme.maxDuration && self.settings.theme.maxDuration < data.duration) {
+      return cb("Exceeds max duration of " + self.settings.theme.maxDuration + "s");
     }
 
-    self.set("numFrames", self.numFrames = Math.floor(duration * self.settings.theme.framesPerSecond));
-
-    cb(null);
-
-  });
-
-};
+    self.profiler.size(data.duration);
+    self.set("numFrames", self.numFrames = Math.floor(data.duration * self.settings.theme.framesPerSecond));
+    self.status("waveform");
 
-// Get the waveform data from the audio file, split into frames
-Audiogram.prototype.getWaveform = function(cb) {
-
-  var self = this;
+    getWaveform(self.audioPath, {
+      numFrames: self.numFrames,
+      samplesPerFrame: self.settings.theme.samplesPerFrame,
+      channels: data.channels
+    }, function(waveformErr, waveform){
 
-  this.status("waveform");
+      return cb(waveformErr, self.waveform = waveform);
 
-  getWaveform(this.audioPath, {
-    numFrames: this.numFrames,
-    samplesPerFrame: this.settings.theme.samplesPerFrame
-  }, function(err, waveform){
+    });
 
-    return cb(err, self.waveform = waveform);
 
   });
 
     q.defer(this.trimAudio.bind(this), this.settings.start || 0, this.settings.end || null);
   }
 
-  // Get the audio's duration for computing number of frames
-  q.defer(this.getDuration.bind(this));
-
   // Get the audio waveform data
   q.defer(this.getWaveform.bind(this));
 
       self.set("url", transports.getURL(self.id));
     }
 
+    logger.debug(self.profiler.print());
+
     return cb(err);
 
   });
 
 // Convenience method for .set("status")
 Audiogram.prototype.status = function(value) {
+  this.profiler.start(value);
   return this.set("status", value);
 };
 

audiogram/trim.js

 var exec = require("child_process").exec,
-    getDuration = require("./duration.js");
+    probe = require("../lib/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);
 
     });

audiogram/waveform.js

-var waveform = require("waveform"),
-    d3 = require("d3");
+var probe = require("../lib/probe.js"),
+    d3 = require("d3"),
+    pcmStream = require("../lib/pcm.js");
 
 function getWaveform(filename, options, cb) {
 
-  var numSamples = options.numFrames * options.samplesPerFrame;
+  var stream = pcmStream(filename, {
+        channels: options.channels
+      }),
+      samples = [];
 
-  var waveformOptions = {
-    "scan": false,
-    "waveformjs": "-",
-    "wjs-width": numSamples,
-    "wjs-precision": 2,
-    "wjs-plain": true,
-    "encoding": "utf8"
-  };
+  stream.on("data",function(sample, channel){
 
-  waveform(filename, waveformOptions, function(err, buf) {
-
-    if (err) {
-      return cb(err);
+    // Average multiple channels
+    if (channel > 0) {
+      samples[samples.length - 1] = ((samples[samples.length - 1] * channel) + sample) / (channel + 1);
+    } else {
+      samples.push(sample);
     }
 
-    cb(null, processWaveform(JSON.parse(buf)));
+  });
+
+  stream.on("error", cb);
 
+  stream.on("end", function(output){
+    var processed = processSamples(samples, options.numFrames, options.samplesPerFrame);
+    return cb(null, processed);
   });
 
-  // Slice one-dimensional waveform data into array of arrays, one array per frame
-  function processWaveform(waveformData) {
+}
 
-    var max = -Infinity,
-        maxFrame;
+function processSamples(samples, numFrames, samplesPerFrame) {
 
-    waveformData.forEach(function(d, i){
-      if (d > max) {
-        max = d;
-        maxFrame = Math.floor(i / options.samplesPerFrame);
-      }
-    });
+  // TODO spread out slop across frames
+  var perFrame = Math.floor(samples.length / numFrames),
+      perPoint = Math.floor(perFrame / samplesPerFrame),
+      range = d3.range(samplesPerFrame),
+      maxFrame,
+      maxMedian = min = max = 0;
 
-    // Scale peaks to 1
-    var scaled = d3.scaleLinear()
-      .domain([0, max])
-      .range([0, 1]);
+  var unadjusted = d3.range(numFrames).map(function(frame){
 
-    var waveformFrames = d3.range(options.numFrames).map(function getFrame(frameNumber) {
+    var frameSamples = samples.slice(frame * perFrame, (frame + 1) * perFrame),
+        points = range.map(function(point){
 
-      return waveformData.slice(options.samplesPerFrame * frameNumber, options.samplesPerFrame * (frameNumber + 1)).map(scaled);
+          var pointSamples = frameSamples.slice(point * perPoint, (point + 1) * perPoint),
+              localMin = localMax = 0;
 
-    });
+          for (var i = 0, l = pointSamples.length; i < l; i++) {
+            if (pointSamples[i] < localMin) localMin = pointSamples[i];
+            if (pointSamples[i] > localMax) localMax = pointSamples[i];
+          }
+
+          if (localMin < min) min = localMin;
+          if (localMax > max) max = localMax;
+
+          // Min value, max value, and midpoint value
+          return [localMin, localMax, pointSamples[Math.floor(pointSamples.length / 2)]];
+
+        }),
+        median = d3.median(points.map(function(point){
+          return point[1] - point[0];
+        }));
 
-    // Set the first and last frame's waveforms to something peak-y for better thumbnails
-    waveformFrames[0] = waveformFrames[waveformFrames.length - 1] = waveformFrames[maxFrame];
+    if (median > maxMedian) {
+      maxMedian = median;
+      maxFrame = frame;
+    }
+
+    return points;
+
+  });
+
+  // Scale up to -1 / 1
+  var adjustment = 1 / Math.max(Math.abs(min), Math.abs(max));
+
+  var adjusted = unadjusted.map(function(frame){
+    return frame.map(function(point){
+      return [adjustment * point[0], adjustment * point[1]];
+    });
+  });
 
-    return waveformFrames;
+  // Make first and last frame peaky
+  adjusted[0] = adjusted[numFrames - 1] = adjusted[maxFrame];
 
-  }
+  return adjusted;
 
 }
 

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);
   };

lib/pcm.js

+var spawn = require("child_process").spawn,
+    stream = require("stream");
+
+// Based on https://github.com/jhurliman/node-pcm
+// Modified to respect channels, use fewer vars, and return a stream
+module.exports = function(filename, options) {
+  var sampleStream = new stream.Stream(),
+      channels = 2,
+      output = "",
+      channel = 0,
+      oddByte;
+
+  sampleStream.readable = true;
+
+  if (options && options.channels) channels = options.channels;
+
+  var args = ["-i", filename, "-f", "s16le", "-ac", channels, "-acodec", "pcm_s16le"];
+
+  if (options && options.sampleRate) {
+    args.push("-ar", options.sampleRate);
+  }
+
+  args.push("-y", "pipe:1");
+
+  var spawned = spawn("ffmpeg", args);
+
+  spawned.stdout.on("data", function(data) {
+
+    var len = data.length;
+
+    if (oddByte != null) {
+      sampleStream.emit("data", ((data.readInt8(i++, true) << 8) | oddByte) / 32767.0, channel);
+      channel = ++channel % channels;
+    }
+
+    for (var i = 0; i < len; i += 2) {
+      sampleStream.emit("data", data.readInt16LE(i, true) / 32767.0, channel);
+      channel = ++channel % channels;
+    }
+
+    oddByte = (i < len) ? data.readUInt8(i, true) : null;
+
+  });
+
+  spawned.stderr.on("data", function(data) {
+    output += data.toString();
+  });
+
+  spawned.stderr.on("end", function() {
+    sampleStream.emit(oddByte !== undefined ? "end" : "error", output);
+  });
+
+  return sampleStream;
+
+};

lib/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;
+
+}

lib/profiler.js

+function Profiler() {
+  this._times = {};
+  return this;
+};
+
+Profiler.prototype.start = function(key) {
+  this.end(this._current);
+  this._current = key;
+  this._times[this._current] = { start: Date.now() };
+  return this;
+};
+
+Profiler.prototype.size = function(size) {
+  if (!arguments.length) return this._size;
+  this._size = size;
+  return this;
+};
+
+Profiler.prototype.end = function(key) {
+  if (key in this._times) this._times[key].end = Date.now();
+  return this;
+};
+
+Profiler.prototype.print = function(size) {
+  var rows = [],
+      row;
+
+  this.end(this._current);
+
+  for (var key in this._times) {
+    row = { key: key, time: this._times[key].end - this._times[key].start };
+    if (this._size) row.per = row.time / this._size;
+    rows.push(row);
+  }
+
+  return rows.map(function(row){
+    return row.key + ": " + Math.round(row.time) + "ms total" + (row.per ? ", " + Math.round(row.per) + "ms per" : "");
+  }).join("\n");
+
+};
+
+module.exports = Profiler;

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"
   },

renderer/patterns.js

 
     var top = data.map(function(d,i){
 
-      return [x(i), baseline - height(d)];
+      return [x(i), baseline - height(d[1])];
 
     });
 
     var bottom = data.map(function(d,i){
 
-      return [x(i), baseline + height(d)];
+      return [x(i), baseline + height(-d[0])];
 
     }).reverse();
 
 
     data.forEach(function(val, i){
 
-      var h = height(val),
-          x = barX(i);
+      var h = height(-val[0]) + height(val[1]),
+          x = barX(i),
+          y = baseline - height(val[1]);
 
-      context.fillRect(x, baseline - h, barWidth, h * 2);
+      context.fillRect(x, y, barWidth, h);
 
       if (round) {
         context.beginPath();
-        context.arc(x + barWidth / 2, baseline - h, barWidth / 2, 0, 2 * Math.PI);
-        context.moveTo(x + barWidth / 2, baseline + h);
-        context.arc(x + barWidth / 2, baseline + h, barWidth / 2, 0, 2 * Math.PI);
+        context.arc(x + barWidth / 2, y, barWidth / 2, 0, 2 * Math.PI);
+        context.moveTo(x + barWidth / 2, y + h);
+        context.arc(x + barWidth / 2, y + h, barWidth / 2, 0, 2 * Math.PI);
         context.fill();
       }
 
 
     data.forEach(function(val, i){
 
-      var bricks = Math.max(1, Math.floor(height(val) / (brickHeight + brickGap))),
+      var bricks = Math.max(1, Math.floor(height(val[1]) / (brickHeight + brickGap))),
           x = barX(i);
 
       d3.range(bricks).forEach(function(b){

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/frame-test.js

 
 var frameDir = path.join(__dirname, "tmp", "frames");
 
-var waveform = [[0, 1, 0], [1, 0.1, 1]];
+var waveform = [
+  [
+    [0, 0], [-1, 1], [0, 0]
+  ],
+  [
+    [-1, 1], [-0.1, 0.1], [-1, 1]
+  ]
+];
 
 function tester(options) {
 

test/duration-test.js → test/probe-test.js

 
 require("mkdirp").sync(path.join(__dirname, "tmp"));
 
-var getDuration = require("../audiogram/duration.js"),
+var probe = require("../lib/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("Mono probe", function(test) {
 
-  getDuration(path.join(__dirname, "..", "README.md"), function(err){
+  probe(path.join(__dirname, "data/short.wav"), function(err, data){
+
+    test.error(err);
+    test.equal(typeof data.duration, "number");
+    test.equal(data.channels, 1);
+    test.assert(Math.abs(data.duration - 0.01) < 0.01);
+    test.end();
+
+  });
+
+});
+
+tape("Probe error", function(test) {
+
+  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

test/waveform-test.js

 var tape = require("tape"),
     path = require("path");
 
-var getWaveform = require("../audiogram/waveform.js");
+var getWaveform = require("../audiogram/waveform.js"),
+    probe = require("../lib/probe.js");
 
 var sample = path.join(__dirname, "data/glazed-donut.mp3");
 
 tape("Waveform", function(test) {
 
   var options = {
-    numFrames: 500,
+    framesPerSecond: 20,
     samplesPerFrame: 10
   };
 
-  getWaveform(sample, options, function(err, waveform){
+  probe(sample, function(e1, data){
 
-    test.error(err);
-    test.assert(Array.isArray(waveform) && waveform.length === options.numFrames);
+    test.error(e1);
 
-    var firstMax = Math.max.apply(null, waveform[0]);
+    getWaveform(sample, options, function(e2, waveform){
 
-    test.assert(firstMax <= 1);
+      test.error(e2);
+      test.assert(Array.isArray(waveform) && waveform.length === Math.floor(data.duration * options.framesPerSecond));
 
-    test.assert(waveform.every(function(frame){
-      return frame.length === options.samplesPerFrame;
-    }));
+      var firstMax = Math.max.apply(null, waveform[0].map(function(d){ return d[1]; }));
 
-    test.assert(waveform.every(function(frame){
-      return frame.every(function(val){
-        return typeof val === "number" && val >= 0 && val <= firstMax;
-      });
-    }));
+      test.assert(firstMax <= 1);
 
-    test.end();
+      test.assert(waveform.every(function(frame){
+        return frame.length === options.samplesPerFrame && frame.every(function(f){
+          return f.length === 2 && typeof f[0] === "number" && typeof f[1] === "number" && f[0] <= 0 && f[0] >= -1 && f[1] >= 0 && f[1] <= firstMax;
+        });
+      }));
+
+      test.end();
+
+    });
 
   });
 
 });
 
-tape("Waveform missing numFrames", function(test) {
+tape("Max Duration Error", function(test) {
 
   var options = {
-    samplesPerFrame: 10
+    framesPerSecond: 20,
+    samplesPerFrame: 10,
+    maxDuration: 20
   };
 
   getWaveform(sample, options, function(err, waveform){
 
-    test.ok(err);
+    test.assert(err);
     test.end();
 
   });
 
 });
 
-tape("Waveform missing samplesPerFrame", function(test) {
+tape("Max Duration OK", function(test) {
 
   var options = {
-    numFrames: 500,
+    framesPerSecond: 20,
+    samplesPerFrame: 10,
+    maxDuration: 30
   };
 
   getWaveform(sample, options, function(err, waveform){
 
-    test.ok(err);
+    test.error(err);
     test.end();
 
   });