Merge pull request #2 from nypublicradio/master

.travis.yml

+language: node_js
+node_js:
+  - '6'
+  - '4'
+  - '0.12'
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+      - sourceline: 'ppa:mc3man/trusty-media'
+    packages:
+      - libcairo2-dev
+      - libjpeg8-dev
+      - libpango1.0-dev
+      - libgif-dev
+      - g++-4.9
+      - ffmpeg
+env:
+  - CXX=g++-4.9
+before_install:
+  - npm explore npm -g -- npm install node-gyp@latest
+sudo: required
+dist: trusty

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:

README.md

 # Audiogram
 
+[![Build Status](https://travis-ci.org/nypublicradio/audiogram.svg?branch=alpha)](https://travis-ci.org/nypublicradio/audiogram)
+
 🔊 -> 🎥
 
 Audiogram is a library for generating shareable videos from audio clips.

THEMES.md

 
 ### Wave options
 
-* `pattern` - What waveform shape to draw. Current options are `wave`, `bars`, `roundBars`, `pixel`, `bricks`, and `equalizer` (default: `wave`)
+* `pattern` - What waveform shape to draw. Current options are `wave`, `bars`, `line`, `curve`, `roundBars`, `pixel`, `bricks`, and `equalizer` (default: `wave`)
 * `waveTop` - How many pixels from the top edge to start the waveform (default: `0`)
 * `waveBottom` - How many pixels from the top edge to end the waveform (default: same as `height`)
 * `waveLeft` - How many pixels from the left edge to start the waveform (default: `0`)

audiogram/draw-frames.js

 var fs = require("fs"),
     path = require("path"),
+    Canvas = require("canvas"),
     queue = require("d3").queue;
 
 function drawFrames(renderer, options, cb) {
 
-  var frameQueue = queue(10);
+  var frameQueue = queue(10),
+      canvases = [];
 
-  for (var i = 0; i < options.numFrames; i++) {
+  for (var i = 0; i < 10; i++) {
+    canvases.push(new Canvas(options.width, options.height));
+  }
 
+  for (var i = 0; i < options.numFrames; i++) {
     frameQueue.defer(drawFrame, i);
-
   }
 
   frameQueue.awaitAll(cb);
 
   function drawFrame(frameNumber, frameCallback) {
 
-    renderer.drawFrame(frameNumber);
-    fs.writeFile(path.join(options.frameDir, zeropad(frameNumber + 1, 6) + ".png"), renderer.context.canvas.toBuffer(), function(err) {
+    var canvas = canvases.pop(),
+        context = canvas.getContext("2d");
+
+    renderer.drawFrame(context, {
+      caption: options.caption,
+      waveform: options.waveform[frameNumber],
+      frame: frameNumber
+    });
+
+    canvas.toBuffer(function(err, buf){
+
       if (err) {
-        return frameCallback(err);
+        return cb(err);
       }
 
-      if (options.tick) {
-        options.tick();
-      }
+      fs.writeFile(path.join(options.frameDir, zeropad(frameNumber + 1, 6) + ".png"), buf, function(writeErr) {
+
+        if (writeErr) {
+          return frameCallback(writeErr);
+        }
+
+        if (options.tick) {
+          options.tick();
+        }
+
+        canvases.push(canvas);
+
+        return frameCallback(null);
 
-      return frameCallback(null);
+      });
 
     });
 

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

     queue = require("d3").queue,
     mkdirp = require("mkdirp"),
     rimraf = require("rimraf"),
-    serverSettings = require("../settings/"),
+    serverSettings = require("../lib/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"),
     combineFrames = require("./combine-frames.js"),
     trimAudio = require("./trim.js");
 
-function Audiogram(settings) {
+function Audiogram(id) {
 
   // Unique audiogram ID
-  this.id = settings.id;
-
-  this.settings = settings;
+  this.id = id;
 
   // File locations to use
   this.dir = path.join(serverSettings.workingDirectory, this.id);
+
   this.audioPath = path.join(this.dir, "audio");
   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.maxDuration && self.settings.maxDuration < duration) {
-      cb("Exceeds max duration of " + self.settings.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.framesPerSecond));
+    self.profiler.size(data.duration);
+    self.set("numFrames", self.numFrames = Math.floor(data.duration * self.settings.theme.framesPerSecond));
+    self.status("waveform");
 
-    cb(null);
-
-  });
-
-};
-
-// 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.samplesPerFrame
-  }, function(err, waveform){
+    });
 
-    return cb(err, self.settings.waveform = waveform);
 
   });
 
 
   this.status("renderer");
 
-  initializeCanvas(this.settings, function(err, renderer){
+  initializeCanvas(this.settings.theme, function(err, renderer){
 
     if (err) {
       return cb(err);
     self.status("frames");
 
     drawFrames(renderer, {
+      width: self.settings.theme.width,
+      height: self.settings.theme.height,
       numFrames: self.numFrames,
       frameDir: self.frameDir,
+      caption: self.settings.caption,
+      waveform: self.waveform,
       tick: function() {
         transports.incrementField(self.id, "framesComplete");
       }
     framePath: path.join(this.frameDir, "%06d.png"),
     audioPath: this.audioPath,
     videoPath: this.videoPath,
-    framesPerSecond: this.settings.framesPerSecond
+    framesPerSecond: this.settings.theme.framesPerSecond
   }, cb);
 
 };
 
   // If the audio needs to be clipped, clip it first and update the path
   if (this.settings.start || this.settings.end) {
-    q.defer(this.trimAudio.bind(this), this.settings.start || 0, this.settings.end);
+    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/initialize-canvas.js

 var fs = require("fs"),
     path = require("path"),
     Canvas = require("canvas"),
-    getRenderer = require("../renderer/"),
-    serverSettings = require("../settings/");
+    getRenderer = require("../renderer/");
 
-function initializeCanvas(options, cb) {
+function initializeCanvas(theme, cb) {
 
   // Fonts pre-registered in bin/worker
+  var renderer = getRenderer(theme);
 
-  var canvas = new Canvas(options.width, options.height),
-      context = canvas.getContext("2d"),
-      renderer = getRenderer(context).update(options);
-
-  renderer.caption = options.caption;
-
-  if (!options.backgroundImage) {
+  if (!theme.backgroundImage) {
     return cb(null, renderer);
   }
 
   // Load background image from file (done separately so renderer code can work in browser too)
-  fs.readFile(path.join(__dirname, "..", "settings", "backgrounds", options.backgroundImage), function(err, raw){
+  fs.readFile(path.join(__dirname, "..", "settings", "backgrounds", theme.backgroundImage), function(err, raw){
 
     if (err) {
       return cb(err);
 
     var bg = new Canvas.Image;
     bg.src = raw;
-    renderer.backgroundImage = bg;
+    renderer.backgroundImage(bg);
 
     return cb(null, renderer);
 

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) {
+}
+
+function processSamples(samples, numFrames, samplesPerFrame) {
 
-    var max = -Infinity,
-        maxFrame;
+  // TODO spread out slop across frames
+  var perFrame = Math.floor(samples.length / numFrames),
+      perPoint = Math.floor(perFrame / samplesPerFrame),
+      range = d3.range(samplesPerFrame),
+      maxFrame,
+      maxRms = maxMid = 0;
 
-    waveformData.forEach(function(d, i){
-      if (d > max) {
-        max = d;
-        maxFrame = Math.floor(i / options.samplesPerFrame);
-      }
-    });
+  var unadjusted = d3.range(numFrames).map(function(frame){
 
-    // Scale peaks to 1
-    var scaled = d3.scaleLinear()
-      .domain([0, max])
-      .range([0, 1]);
+    var frameSamples = samples.slice(frame * perFrame, (frame + 1) * perFrame),
+        points = range.map(function(point){
 
-    var waveformFrames = d3.range(options.numFrames).map(function getFrame(frameNumber) {
+          var pointSamples = frameSamples.slice(point * perPoint, (point + 1) * perPoint),
+              midpoint = pointSamples[Math.floor(pointSamples.length / 2)];
 
-      return waveformData.slice(options.samplesPerFrame * frameNumber, options.samplesPerFrame * (frameNumber + 1)).map(scaled);
+          var rms = Math.sqrt(d3.sum(pointSamples.map(function(d){
+            return d * d;
+          })) / perPoint);
 
-    });
+          if (rms > maxRms) {
+            maxRms = rms;
+            maxFrame = frame;
+          }
+
+          if (Math.abs(midpoint) > maxMid) {
+            maxMid = Math.abs(midpoint);
+          }
 
-    // Set the first and last frame's waveforms to something peak-y for better thumbnails
-    waveformFrames[0] = waveformFrames[waveformFrames.length - 1] = waveformFrames[maxFrame];
+          // Min value, max value, and midpoint value
+          return [rms, midpoint];
+
+        });
+
+    return points;
+
+  });
+
+  var adjusted = unadjusted.map(function(frame){
+    return frame.map(function(point){
+      return [
+        point[0] / maxRms,
+        point[1] / maxMid
+      ];
+    });
+  });
 
-    return waveformFrames;
+  // Make first and last frame peaky
+  adjusted[0] = adjusted[numFrames - 1] = adjusted[maxFrame];
 
-  }
+  return adjusted;
 
 }
 

bin/server

 #!/usr/bin/env node
 
+// Require settings first, for validation
+require("../lib/settings/");
+
 var dotenv = require("dotenv").config({silent: true}),
     logger = require("../lib/logger/"),
     server = require("../server/");

bin/worker

 #!/usr/bin/env node
+
+// Require settings first, for validation
+require("../lib/settings/");
+
 var dotenv = require("dotenv").config({silent: true}),
     Audiogram = require("../audiogram/"),
     transports = require("../lib/transports/");
 
 function pluckJob(){
 
-  transports.getJob(function(err, settings){
+  transports.getJob(function(err, job){
 
     if (err) {
       throw err;
     }
 
-    if (settings) {
+    if (job) {
 
-      return render(settings);
+      return render(job);
 
     }
 
 
 }
 
-function render(settings) {
+function render(job) {
+
+  var audiogram = new Audiogram(job.id);
 
-  var audiogram = new Audiogram(settings);
+  audiogram.settings = job;
 
   audiogram.render(function(err){
 

client/index.js

 
 d3.json("/settings/themes.json", function(err, themes){
 
-  if (err) {
-    throw err;
+  var errorMessage;
+
+  // Themes are missing or invalid
+  if (err || !d3.keys(themes).filter(function(d){ return d !== "default"; }).length) {
+    if (err instanceof SyntaxError) {
+      errorMessage = "Error in settings/themes.json:<br/><code>" + err.toString() + "</code>";
+    } else if (err instanceof ProgressEvent) {
+      errorMessage = "Error: no settings/themes.json.";
+    } else if (err) {
+      errorMessage = "Error: couldn't load settings/themes.json.";
+    } else {
+      errorMessage = "No themes found in settings/themes.json.";
+    }
+    d3.select("#loading-bars").remove();
+    d3.select("#loading-message").html(errorMessage);
+    if (err) {
+      throw err;
+    }
+    return;
   }
 
   for (var key in themes) {
 
   var formData = new FormData();
 
-  var settings = $.extend({}, theme, {
-    caption: caption,
-    start: selection.start,
-    end: selection.end
-  });
-
-  delete settings.backgroundImageFile;
-
   formData.append("audio", file);
-  formData.append("settings", JSON.stringify(settings));
+  if (selection.start || selection.end) {
+    formData.append("start", selection.start);
+    formData.append("end", selection.end);
+  }
+  formData.append("theme", JSON.stringify($.extend({}, theme, { backgroundImageFile: null })));
+  formData.append("caption", caption);
 
   setClass("loading");
   d3.select("#loading-message").text("Uploading audio...");
       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/preview.js

     audio = require("./audio.js"),
     video = require("./video.js"),
     minimap = require("./minimap.js"),
+    sampleWave = require("./sample-wave.js"),
+    getRenderer = require("../renderer/"),
     getWaveform = require("./waveform.js");
 
 var context = d3.select("canvas").node().getContext("2d");
 
-var renderer = require("../renderer/")(context);
-
 var theme,
     caption,
     file,
 
   video.kill();
 
-  renderer.update(theme);
-  renderer.caption = caption;
-  renderer.backgroundImage = theme.backgroundImageFile || null;
-  renderer.drawFrame(0);
+  var renderer = getRenderer(theme);
+
+  renderer.backgroundImage(theme.backgroundImageFile || null);
+
+  renderer.drawFrame(context, {
+    caption: caption,
+    waveform: sampleWave,
+    frame: 0
+  });
 
 }
 

client/waveform.js

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

editor/index.html

     <title>Audiogram</title>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1">
-    <link href="https://fonts.googleapis.com/css?family=Source+Sans+Pro:400,300,600" rel="stylesheet" type="text/css">
     <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.5.0/css/font-awesome.min.css">
-    <link href="css/base.css" rel="stylesheet" type="text/css">
-    <link href="css/editor.css" rel="stylesheet" type="text/css">
+    <link href="https://fonts.googleapis.com/css?family=Source+Sans+Pro:400,300,600" rel="stylesheet" type="text/css">
+    <link href="/css/base.css" rel="stylesheet" type="text/css">
+    <link href="/css/editor.css" rel="stylesheet" type="text/css">
+    <link href="/fonts/fonts.css" rel="stylesheet" type="text/css">
   </head>
   <body class="loading">
     <div class="container">
         </div>
       </div><!-- #loaded -->
     </div><!-- .container -->
-    <script src="js/bundle.js"></script>
+    <script src="/js/bundle.js"></script>
+    <!-- Force load custom fonts -->
+    <script src="/fonts/fonts.js"></script>
   </body>
 </html>

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;

lib/register-fonts.js

-var fonts = require("../settings/").fonts,
+var fonts = require("./settings/").fonts,
     _ = require("underscore"),
     Canvas = require("canvas");
 

lib/settings/index.js

+var _ = require("underscore"),
+    path = require("path"),
+    fs = require("fs"),
+    load = require("./load.js");
+
+var settings = load("settings/index.js"),
+    themes = load("settings/themes.json");
+
+// Validate settings
+settings = require("./validate-settings.js")(settings);
+
+// Validate themes
+themes = require("./validate-themes.js")(themes);
+
+module.exports = settings;

lib/settings/load.js

+var path = require("path");
+
+// Try to load module
+module.exports = function(filename) {
+
+  var loaded;
+
+  try {
+    loaded = require(path.join(__dirname, "..", "..", filename));
+    if (!loaded) {
+      throw new Error("Couldn't load contents of " + filename + ".");
+    }
+  } catch(e) {
+    if (e.code === "MODULE_NOT_FOUND") {
+      throw new Error("No " + filename + " file found.");
+    } else if (e instanceof SyntaxError) {
+      console.warn("Error parsing " + filename + ".");
+      throw e;
+    } else {
+      throw e;
+    }
+  }
+
+  return loaded;
+
+}

lib/settings/validate-settings.js

+var fs = require("fs"),
+    path = require("path"),
+    mkdirp = require("mkdirp"),
+    _ = require("underscore");
+
+module.exports = function(settings) {
+
+  // Check paths
+  if (typeof settings.workingDirectory !== "string") {
+    throw new Error("settings.workingDirectory is required. See https://github.com/nypublicradio/audiogram/blob/master/SERVER.md#all-settings for details.");
+  }
+
+  if (typeof settings.storagePath !== "string" && typeof settings.s3Bucket !== "string") {
+    throw new Error("settings.storagePath or settings.s3Bucket is required. See https://github.com/nypublicradio/audiogram/blob/master/SERVER.md#all-settings for details.");
+  }
+
+  // TODO normalize workingDirectory, s3Bucket, and storagePath
+  settings.workingDirectory = normalize(settings.workingDirectory);
+  tryToCreate(settings.workingDirectory, "workingDirectory");
+
+  if (typeof settings.s3Bucket === "string") {
+
+    // Remove s3:// and trailing slash, bucket name only
+    settings.s3Bucket = settings.s3Bucket.replace(/^(s3[:]\/\/)|\/$/g, "");
+
+    if (typeof settings.storagePath === "string") {
+
+      // No leading slash, one trailing slash
+      settings.storagePath = settings.storagePath.replace(/^\/|\/$/g, "");
+
+      if (settings.storagePath) {
+        settings.storagePath += "/";
+      }
+
+    } else {
+      settings.storagePath = "";
+    }
+
+  } else {
+    settings.storagePath = normalize(settings.storagePath);
+    tryToCreate(settings.storagePath, "storagePath");
+  }
+
+  // Check maxUploadSize
+  if ("maxUploadSize" in settings && typeof settings.maxUploadSize !== "number") {
+    throw new TypeError("settings.maxUploadSize must be an integer. See https://github.com/nypublicradio/audiogram/blob/master/SERVER.md#all-settings for details.");
+  }
+
+  // Check fonts
+  if ("fonts" in settings) {
+    if (!Array.isArray(settings.fonts)) {
+      throw new TypeError("settings.fonts must be an array of fonts. See https://github.com/nypublicradio/audiogram/blob/master/THEMES.md#a-note-about-fonts for details.")
+    }
+
+    settings.fonts.forEach(function(font){
+
+      if (!font || typeof font.family !== "string" || typeof font.file !== "string") {
+        return console.warn("Custom font in settings.fonts missing a 'family' or 'file'. See https://github.com/nypublicradio/audiogram/blob/master/THEMES.md#a-note-about-fonts for details.");
+      }
+
+      font.file = normalize(font.file);
+
+      try {
+        fs.accessSync(font.file);
+      } catch(e) {
+        return console.warn("Font file " + font.file + " does not exist or is not readable.");
+      }
+
+    });
+  }
+
+  return settings;
+
+};
+
+function tryToCreate(dir, key) {
+  try {
+    mkdirp.sync(dir);
+    fs.accessSync(dir);
+  } catch(e) {
+    throw new Error("Could not create/access settings." + key + " at " + dir + "");
+  }
+}
+
+function normalize(p) {
+  if (path.isAbsolute(p)) {
+    return p;
+  }
+  return path.join(__dirname, "..", "..", p);
+}

lib/settings/validate-themes.js

+var path = require("path"),
+    _ = require("underscore"),
+    fs = require("fs");
+
+module.exports = function(themes) {
+
+  if (!themes || !_.keys(_.omit(themes, "default")).length) {
+    return console.warn("No themes found in settings/themes.json. See https://github.com/nypublicradio/audiogram/blob/master/THEMES.md for details.");
+  }
+
+  for (var key in themes) {
+    if (key !== "default") {
+      validateTheme(key, _.extend({}, themes.default || {}, themes[key]));
+    }
+  }
+
+  return themes;
+
+};
+
+function validateTheme(name, options) {
+
+  var fullBackgroundImagePath;
+
+  if (!options || !_.keys(options).length) {
+    return console.warn("Theme '" + name + "' is not defined.");
+  }
+
+  ["width", "height", "framesPerSecond", "samplesPerFrame"].forEach(function(key){
+    if (typeof options[key] !== "number") {
+      console.warn("The required property '" + key +"' is missing from theme '" + name + "' or invalid.");
+    }
+  });
+
+  if (typeof options.backgroundImage === "string") {
+
+    fullBackgroundImagePath = options.backgroundImage;
+
+    if (!path.isAbsolute(options.backgroundImage)) {
+      fullBackgroundImagePath = path.join(__dirname, "..", "..", "settings/backgrounds/", options.backgroundImage);
+    }
+
+    try {
+      fs.accessSync(fullBackgroundImagePath);
+    } catch(e) {
+      console.warn("Background image for theme '" + name + "' (" + fullBackgroundImagePath + ") does not exist or is not readable.");
+    }
+  }
+}

lib/transports/index.js

 var extend = require("underscore").extend,
-    serverSettings = require("../../settings/"),
+    serverSettings = require("../settings/"),
     s3 = require("./s3")(serverSettings),
     redis = require("./redis")(serverSettings);
 

lib/transports/s3/fake.js

 
 module.exports = function(storagePath) {
 
-  storagePath = storagePath || "";
-
-  if (!path.isAbsolute(storagePath)) {
-    storagePath = path.join(__dirname, "..", "..", "..", storagePath);
-  }
-
   function copy(source, destination, cb) {
 
     if (!path.isAbsolute(source)) {

lib/transports/s3/remote.js

 
 module.exports = function(bucket, storagePath) {
 
-  storagePath = storagePath || "";
-
-  // Normalize slashes in path
-  if (storagePath.length) {
-    storagePath = storagePath.replace(/^\/|\/$/g, "") + "/";
-  }
-
-  // Catch single slash path
-  if (storagePath === "/") {
-    storagePath = "";
-  }
-
-  // Remove s3:// just in case
-  bucket = bucket.replace(/^(s3[:]\/\/)|\/$/g, "");
-
   var s3 = new AWS.S3({ params: { Bucket: bucket } });
 
   // Test credentials

package.json

 {
   "name": "audiogram",
-  "version": "0.9.4",
+  "version": "0.9.5",
   "description": "Turn audio into a shareable video.",
   "main": "index.js",
   "scripts": {
     "rebuild": "npm run postinstall",
     "watch": "mkdir -p editor/js && watchify client/index.js -o editor/js/bundle.js",
     "debug": "npm run postinstall && DEBUG=1 bin/server",
-    "test": "tape 'test/**/*-test.js'"
+    "test": "rm -rf test/tmp && tape 'test/**/*-test.js'"
   },
   "repository": {
     "type": "git",
   "dependencies": {
     "aws-sdk": "^2.2.39",
     "browserify": "^13.0.0",
+    "canvas": "git+https://github.com/chearon/node-canvas.git#12971f64a66b",
     "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/index.js

 var d3 = require("d3"),
     patterns = require("./patterns.js"),
-    sample = require("./sample-wave.js"),
     textWrapper = require("./text-wrapper.js");
 
-module.exports = function(context) {
+module.exports = function(t) {
 
-  context.patternQuality = "best";
+  var renderer = {},
+      backgroundImage,
+      wrapText,
+      theme;
 
-  var renderer = {};
+  renderer.backgroundImage = function(_) {
+    if (!arguments.length) return backgroundImage;
+    backgroundImage = _;
+    return this;
+  };
 
-  renderer.context = context;
+  renderer.theme = function(_) {
+    if (!arguments.length) return theme;
 
-  renderer.update = function(options) {
+    theme = _;
 
-    // TODO cleaner defaults
-    options.backgroundColor = options.backgroundColor || "#fff";
-    options.waveColor = options.waveColor || options.foregroundColor || "#000";
-    options.captionColor = options.captionColor || options.foregroundColor || "#000";
+    // Default colors
+    theme.backgroundColor = theme.backgroundColor || "#fff";
+    theme.waveColor = theme.waveColor || theme.foregroundColor || "#000";
+    theme.captionColor = theme.captionColor || theme.foregroundColor || "#000";
 
-    if (typeof options.waveTop !== "number") options.waveTop = 0;
-    if (typeof options.waveBottom !== "number") options.waveBottom = options.height;
-    if (typeof options.waveLeft !== "number") options.waveLeft = 0;
-    if (typeof options.waveRight !== "number") options.waveRight = options.width;
+    // Default wave dimensions
+    if (typeof theme.waveTop !== "number") theme.waveTop = 0;
+    if (typeof theme.waveBottom !== "number") theme.waveBottom = theme.height;
+    if (typeof theme.waveLeft !== "number") theme.waveLeft = 0;
+    if (typeof theme.waveRight !== "number") theme.waveRight = theme.width;
 
-    this.wrapText = textWrapper(context, options);
-    this.options = options;
-    this.waveform = options.waveform || [sample.slice(0, options.samplesPerFrame)];
-    return this;
-  };
+    wrapText = textWrapper(theme);
 
-  // Get the waveform data for this frame
-  renderer.getWaveform = function(frameNumber) {
-    return this.waveform[Math.min(this.waveform.length - 1, frameNumber)];
+    return this;
   };
 
   // Draw the frame
-  renderer.drawFrame = function(frameNumber) {
+  renderer.drawFrame = function(context, options){
+
+    context.patternQuality = "best";
 
     // Draw the background image and/or background color
-    context.clearRect(0, 0, this.options.width, this.options.height);
+    context.clearRect(0, 0, theme.width, theme.height);
 
-    context.fillStyle = this.options.backgroundColor;
-    context.fillRect(0, 0, this.options.width, this.options.height);
+    context.fillStyle = theme.backgroundColor;
+    context.fillRect(0, 0, theme.width, theme.height);
 
-    if (this.backgroundImage) {
-      context.drawImage(this.backgroundImage, 0, 0, this.options.width, this.options.height);
+    if (backgroundImage) {
+      context.drawImage(backgroundImage, 0, 0, theme.width, theme.height);
     }
 
-    patterns[this.options.pattern || "wave"](context, this.getWaveform(frameNumber), this.options);
+    patterns[theme.pattern || "wave"](context, options.waveform, theme);
 
     // Write the caption
-    if (this.caption) {
-      this.wrapText(this.caption);
+    if (options.caption) {
+      wrapText(context, options.caption);
     }
 
     return this;
 
   };
 
+  if (t) {
+    renderer.theme(t);
+  }
+
   return renderer;
 
 }

renderer/patterns.js

 var d3 = require("d3");
 
 module.exports = {
-  wave: curve(d3.curveCardinal.tension(0.1)),
-  pixel: curve(d3.curveStep),
+  wave: filledPath(d3.curveCardinal.tension(0.1)),
+  pixel: filledPath(d3.curveStep),
   roundBars: bars(true),
   bars: bars(),
   bricks: bricks(),
-  equalizer: bricks(true)
+  equalizer: bricks(true),
+  line: strokedPath(),
+  curve: strokedPath(d3.curveCardinal.tension(0.1))
 };
 
-function curve(interpolator) {
+function filledPath(interpolator) {
 
   return function drawCurve(context, data, options) {
 
     context.lineWidth = 3;
 
     var line = d3.line()
-      .curve(interpolator)
       .context(context);
 
+    if (interpolator) {
+      line.curve(interpolator);
+    }
+
     var waveHeight = options.waveBottom - options.waveTop;
 
     var baseline = options.waveTop + waveHeight / 2;
 
     var top = data.map(function(d,i){
 
-      return [x(i), baseline - height(d)];
+      return [x(i), baseline - height(d[0])];
 
     });
 
     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]) * 2,
+          x = barX(i),
+          y = baseline - height(val[0]);
 
-      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();
       }
 
 }
 
 function bricks(rainbow) {
-  return function (context, data, options) {
+  return function(context, data, options) {
 
     context.fillStyle = options.waveColor;
 
 
     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[0]) / (brickHeight + brickGap))),
           x = barX(i);
 
       d3.range(bricks).forEach(function(b){
 
   };
 }
+
+function strokedPath(interpolator) {
+  return function(context, data, options) {
+
+    context.fillStyle = options.waveColor;
+    context.strokeStyle = options.waveColor;
+    context.lineWidth = 5;
+
+    var line = d3.line()
+      .context(context);
+
+    if (interpolator) {
+      line.curve(interpolator);
+    }
+
+    var x = d3.scalePoint()
+      .padding(0.1)
+      .domain(d3.range(data.length))
+      .range([options.waveLeft, options.waveRight]);
+
+    var y = d3.scaleLinear()
+      .domain([-1, 1])
+      .range([options.waveBottom, options.waveTop]);
+
+    var points = data.map(function(d, i){
+      return [x(i), y(d[1])];
+    });
+
+    // Fill waveform
+    context.beginPath();
+    line(points);
+    context.stroke();
+
+  }
+}

renderer/text-wrapper.js

 var smartquotes = require("smartquotes").string;
 
-module.exports = function(context, options) {
-
-  context.font = options.captionFont;
-  context.textBaseline = "top";
-  context.textAlign = options.captionAlign || "center";
+module.exports = function(theme) {
 
   // Do some typechecking
-  var left = ifNumeric(options.captionLeft, 0),
-      right = ifNumeric(options.captionRight, options.width),
-      bottom = ifNumeric(options.captionBottom, null),
-      top = ifNumeric(options.captionTop, null);
+  var left = ifNumeric(theme.captionLeft, 0),
+      right = ifNumeric(theme.captionRight, theme.width),
+      bottom = ifNumeric(theme.captionBottom, null),
+      top = ifNumeric(theme.captionTop, null);
 
   if (bottom === null && top === null) {
     top = 0;
 
   var captionWidth = right - left;
 
-  return function(caption) {
+  return function(context, caption) {
 
     if (!caption) {
       return;
         maxWidth = 0,
         words = smartquotes(caption + "").trim().replace(/\s\s+/g, " \n").split(/ /g);
 
+    context.font = theme.captionFont;
+    context.textBaseline = "top";
+    context.textAlign = theme.captionAlign || "center";
+
     // Check whether each word exceeds the width limit
     // Wrap onto next line as needed
     words.forEach(function(word,i){
 
     });
 
-    var totalHeight = lines.length * options.captionLineHeight + (lines.length - 1) * options.captionLineSpacing;
+    var totalHeight = lines.length * theme.captionLineHeight + (lines.length - 1) * theme.captionLineSpacing;
 
     // horizontal alignment
-    var x = options.captionAlign === "left" ? left : options.captionAlign === "right" ? right : (left + right) / 2;
+    var x = theme.captionAlign === "left" ? left : theme.captionAlign === "right" ? right : (left + right) / 2;
 
     // Vertical alignment
     var y;
       y = top;
     }
 
-    context.fillStyle = options.captionColor;
+    context.fillStyle = theme.captionColor;
     lines.forEach(function(line, i){
-      context.fillText(line.join(" "), x, y + i * (options.captionLineHeight + options.captionLineSpacing));
+      context.fillText(line.join(" "), x, y + i * (theme.captionLineHeight + theme.captionLineSpacing));
     });
 
  };

server/error.js

-var serverSettings = require("../settings/");
+var serverSettings = require("../lib/settings/");
 
 module.exports = function(err, req, res, next) {
 

server/fonts.js

+var fonts = require("../lib/settings/").fonts || [];
+
+var bySlug = {};
+
+fonts.forEach(function(font, i){
+
+  var extension = "",
+      split = font.file.split(".");
+
+  // Use existing file extension if there is one
+  if (split.length > 1){
+    extension = "." + split.pop();
+  }
+
+  bySlug[font.slug = "custom-" + i + extension] = font;
+
+});
+
+// Send a stylesheet with custom fonts
+function sendCSS(req, res) {
+  res.set("Content-Type", "text/css")
+    .send(fonts.map(declaration).join("\n\n"));
+}
+
+// Send JS that forces all custom fonts to download upfront
+function sendJS(req, res) {
+  res.set("Content-Type", "application/javascript")
+    .send("(function(){\n\n" + fonts.map(shim).join("\n\n") + "\n\n})();");
+}
+
+// Send custom file by its slug
+function sendFont(req, res) {
+
+  var font = bySlug[req.params.font];
+
+  if (font && font.file) {
+    return res.sendFile(font.file);
+  }
+
+  res.status(404).send("Cannot GET " + req.baseUrl);
+
+}
+
+function declaration(font, i) {
+  return [
+    "@font-face {",
+    "  font-family: '" + font.family + "';",
+    "  src: url('/fonts/" + font.slug + "');",
+    font.weight ? "  font-weight: " + font.weight + ";" : "",
+    font.style ? "  font-style: " + font.style + ";" : "",
+    "}"
+  ].filter(function(d){ return d; }).join("\n");
+}
+
+function shim(font, i) {
+  return [
+    "  var font" + i + " = document.createElement(\"div\");",
+    "  font" + i + ".innerHTML = '.';",
+    "  font" + i + ".style.fontFamily = \"" + font.family + "\";",
+    font.weight ? "  font" + i + ".style.fontWeight = \"" + font.weight + "\";" : "",
+    font.style ? "  font" + i + ".style.fontStyle = \"" + font.style + "\";" : "",
+    "  document.body.appendChild(font" + i + ");",
+    "  setTimeout(function(){ font" + i + ".remove(); }, 0);"
+  ].filter(function(d){ return d; }).join("\n");
+}
+
+module.exports = {
+  css: sendCSS,
+  js: sendJS,
+  font: sendFont
+};

server/index.js

 var logger = require("../lib/logger/"),
     render = require("./render.js"),
     status = require("./status.js"),
+    fonts = require("./fonts.js"),
     errorHandlers = require("./error.js");
 
 // Settings
-var serverSettings = require("../settings/");
+var serverSettings = require("../lib/settings/");
 
 var app = express();
 
   };
 }
 
-if (typeof serverSettings.workingDirectory !== "string") {
-  throw new TypeError("No workingDirectory set in settings/index.js");
-}
-
 // On submission, check upload, validate input, and start generating a video
 app.post("/submit/", [multer(fileOptions).single("audio"), render.validate, render.route]);
 
 // If not using S3, serve videos locally
 if (!serverSettings.s3Bucket) {
-  if (typeof serverSettings.storagePath !== "string") {
-    throw new TypeError("No storagePath set in settings/index.js");
-  }
-  var storagePath =  path.isAbsolute(serverSettings.storagePath) ? serverSettings.storagePath : path.join(__dirname, "..", serverSettings.storagePath);
-  app.use("/video/", express.static(path.join(storagePath, "video")));
+  app.use("/video/", express.static(path.join(serverSettings.storagePath, "video")));
+}
+
+// Serve custom fonts
+app.get("/fonts/fonts.css", fonts.css);
+app.get("/fonts/fonts.js", fonts.js);
+
+if (serverSettings.fonts) {
+  app.get("/fonts/:font", fonts.font);
 }
 
 // Check the status of a current video

server/render.js

-var serverSettings = require("../settings/"),
+var serverSettings = require("../lib/settings/"),
     spawn = require("child_process").spawn,
     path = require("path"),
     _ = require("underscore"),
-    Audiogram = require("../audiogram/"),
     logger = require("../lib/logger"),
     transports = require("../lib/transports");
 
 
   try {
 
-    req.body.settings = JSON.parse(req.body.settings);
+    req.body.theme = JSON.parse(req.body.theme);
 
   } catch(e) {
 
     return res.status(500).send("No valid audio received.");
   }
 
-  req.body.settings.id = req.file.destination.split(path.sep).pop();
-
   // Start at the beginning, or specified time
-  if (req.body.settings.start) {
-    req.body.settings.start = +req.body.settings.start;
+  if (req.body.start) {
+    req.body.start = +req.body.start;
   }
 
-  if (req.body.settings.end) {
-    req.body.settings.end = +req.body.settings.end;
+  if (req.body.end) {
+    req.body.end = +req.body.end;
   }
 
   return next();
 
 function route(req, res) {
 
-  var audiogram = new Audiogram(req.body.settings);
+  var id = req.file.destination.split(path.sep).pop();
 
-  transports.uploadAudio(audiogram.audioPath, "audio/" + audiogram.id,function(err) {
+  transports.uploadAudio(path.join(req.file.destination, "audio"), "audio/" + id,function(err) {
 
     if (err) {
       throw err;
     }
 
     // Queue up the job with a timestamp
-    transports.addJob(_.extend({ created: (new Date()).getTime() }, req.body.settings));
+    transports.addJob(_.extend({ id: id, created: (new Date()).getTime() }, req.body));
 
-    res.json({ id: req.body.settings.id });
+    res.json({ id: id });
 
     // If there's no separate worker, spawn one right away
     if (!serverSettings.worker) {

server/status.js

     .await(function(err, jobs, hash) {
 
       if (err) {
-        res.status(500).json("Unknown error.");
         throw err;
       }
 
         hash = { status: "unknown" };
       }
 
-      ["duration","numFrames","framesComplete"].forEach(function(key) {
+      ["numFrames", "framesComplete"].forEach(function(key) {
         if (key in hash) {
           hash[key] = +hash[key];
         }

settings/themes.json

     "captionBottom": 660,
     "captionTop": null
   },
+  "Line": {
+    "backgroundColor": "#edc951",
+    "foregroundColor": "#00a0b0",
+    "pattern": "line"
+  },
+  "Curve": {
+    "backgroundColor": "#00a0b0",
+    "foregroundColor": "#edc951",
+    "pattern": "curve"
+  },
   "Bricks": {
     "backgroundColor": "#8771aa",
     "foregroundColor": "#fff",

test/duration-test.js

-var tape = require("tape"),
-    path = require("path"),
-    fs = require("fs"),
-    queue = require("d3").queue;
-
-require("mkdirp").sync(path.join(__dirname, "tmp"));
-
-var getDuration = require("../audiogram/duration.js"),
-    trimAudio = require("../audiogram/trim.js");
-
-tape("MP3 duration", function(test) {
-
-  getDuration(path.join(__dirname, "data/glazed-donut.mp3"), function(err, duration){
-
-    test.error(err);
-    test.equal(typeof duration, "number");
-    test.assert(Math.abs(duration - 26.67) < 0.1);
-    test.end();
-
-  });
-
-});
-
-tape("WAV duration", function(test) {
-
-  getDuration(path.join(__dirname, "data/glazed-donut.wav"), function(err, duration){
-
-    test.error(err);
-    test.equal(typeof duration, "number");
-    test.assert(Math.abs(duration - 1.83) < 0.1);
-    test.end();
-
-  });
-
-});
-
-tape("Duration error", function(test) {
-
-  getDuration(path.join(__dirname, "..", "README.md"), function(err){
-
-    test.ok(err);
-    test.end();
-
-  });
-
-});
-
-tape("Trim start", function(test) {
-
-  var options = {
-    origin: path.join(__dirname, "data/glazed-donut.mp3"),
-    destination: path.join(__dirname, "tmp/trim-start.mp3"),
-    startTime: 6.67
-  };
-
-  queue(1)
-    .defer(trimAudio, options)
-    .defer(getDuration, options.destination)
-    .await(function(err, _, duration){
-
-      test.error(err);
-      test.equal(typeof duration, "number");
-      test.assert(Math.abs(duration - 20) < 0.1);
-      test.end();
-
-    });
-
-});
-
-tape("Trim end", function(test) {
-
-  var options = {
-    origin: path.join(__dirname, "data/glazed-donut.mp3"),
-    destination: path.join(__dirname, "tmp/trim-end.mp3"),
-    startTime: 6.67
-  };
-
-  queue(1)
-    .defer(trimAudio, options)
-    .defer(getDuration, options.destination)
-    .await(function(err, _, duration){
-
-      test.error(err);
-      test.equal(typeof duration, "number");
-      test.assert(Math.abs(duration - 20) < 0.1);
-      test.end();
-
-    });
-
-});
-
-tape("Trim start & end", function(test) {
-
-  var options = {
-    origin: path.join(__dirname, "data/glazed-donut.mp3"),
-    destination: path.join(__dirname, "tmp/trim-start-end.mp3"),
-    startTime: 5,
-    endTime: 10
-  };
-
-  queue(1)
-    .defer(trimAudio, options)
-    .defer(getDuration, options.destination)
-    .await(function(err, _, duration){
-
-      test.error(err);
-      test.equal(typeof duration, "number");
-      test.assert(Math.abs(duration - 5) < 0.1);
-      test.end();
-
-    });
-
-});
-
-
-tape("Trim invalid", function(test) {
-
-  var options = {
-    origin: path.join(__dirname, "data/glazed-donut.mp3"),
-    destination: path.join(__dirname, "tmp/trim-invalid.mp3"),
-    startTime: 5,
-    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;
-    }
-  });
-});
-
-// Cleanup
-tape.onFinish(function(){
-  require("rimraf")(path.join(__dirname, "tmp"), function(err){
-    if (err) {
-      throw err;
-    }
-  });
-});

test/font/OFL.txt

+Copyright (c) 2010-2016, Sorkin Type Co (www.sorkintype.com) with Reserved Font Name 'Merriweather'. Merriweather is a trademark of Sorkin Type Co.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

test/frame-test.js

 
 var frameDir = path.join(__dirname, "tmp", "frames");
 
-tape.test("Draw frame", function(test){
-
-  var options = {
-    width: 1280,
-    height: 720,
-    backgroundColor: "#f00",
-    foregroundColor: "#fff",
-    waveTop: 340,
-    waveBottom: 380,
-    waveform: [[0, 1, 0], [1, 0.1, 1]]
-  };
-
-  initializeCanvas(options, function(err, renderer){
+var waveform = [
+  [
+    [0, 0], [1, 1], [0, 0]
+  ],
+  [
+    [1, 1], [0.1, 0.1], [1, 1]
+  ]
+];
 
-    test.error(err);
-    test.assert(renderer.context.canvas instanceof Canvas);
-    test.assert(renderer.context.canvas.width === options.width);
-    test.assert(renderer.context.canvas.height === options.height);
+function tester(options) {
 
-    drawFrames(renderer, {
-      numFrames: 2,
-      frameDir: frameDir
-    }, function(err){
-      test.error(err);
-      checkFrame(test, options);
-    });
+  return function(test) {
 
-  });
-
-});
+    initializeCanvas(options, function(err, renderer){
 
-tape.test("Default colors", function(test){
-
-  var options = {
-    width: 1280,
-    height: 720,
-    waveTop: 340,
-    waveBottom: 380,
-    waveform: [[0, 1, 0], [1, 0.1, 1]]
-  };
-
-  initializeCanvas(options, function(err, renderer){
-
-    test.error(err);
-    test.assert(renderer.context.canvas instanceof Canvas);
-    test.assert(renderer.context.canvas.width === options.width);
-    test.assert(renderer.context.canvas.height === options.height);
-
-    drawFrames(renderer, {
-      numFrames: 2,
-      frameDir: frameDir
-    }, function(err){
       test.error(err);
-      checkFrame(test, options);
-    });
 
-  });
-
-});
+      drawFrames(renderer, {
+        numFrames: waveform.length,
+        frameDir: frameDir,
+        width: options.width,
+        height: options.height,
+        waveform: waveform
+      }, function(err){
+        test.error(err);
+        checkFrame(test, options);
+      });
 
-tape.test("Square frame", function(test){
+    });
 
-  var options = {
-    width: 720,
-    height: 720,
-    backgroundColor: "#fc0",
-    foregroundColor: "#fff",
-    waveTop: 340,
-    waveBottom: 380,
-    waveform: [[0, 1, 0], [1, 0.1, 1]]
   };
 
-  initializeCanvas(options, function(err, renderer){
-
-    test.error(err);
-    test.assert(renderer.context.canvas instanceof Canvas);
-    test.assert(renderer.context.canvas.width === options.width);
-    test.assert(renderer.context.canvas.height === options.height);
-
-    drawFrames(renderer, {
-      numFrames: 2,
-      frameDir: frameDir
-    }, function(err){
-      test.error(err);
-      checkFrame(test, options);
-    });
-
-  });
+}
 
-});
+tape.test("Draw frame", tester({
+  width: 1280,
+  height: 720,
+  backgroundColor: "#f00",
+  foregroundColor: "#fff",
+  waveTop: 340,
+  waveBottom: 380
+}));
+
+tape.test("Default colors", tester({
+  width: 1280,
+  height: 720,
+  waveTop: 340,
+  waveBottom: 380
+}));
+
+tape.test("Square frame", tester({
+  width: 720,
+  height: 720,
+  backgroundColor: "#f00",
+  foregroundColor: "#fff",
+  waveTop: 340,
+  waveBottom: 380
+}));
 
 function checkFrame(test, options) {
 

test/patch-settings.js

-var serverSettings = require("../settings/");
-
-module.exports = function(newSettings) {
-  for (var key in serverSettings) {
-    if (!(key in newSettings)) {
-      delete serverSettings[key];
-    }
-  }
-
-  for (var key in newSettings) {
-    serverSettings[key] = newSettings[key];
-  }
-
-  return serverSettings;
-
-};

test/probe-test.js

+var tape = require("tape"),
+    path = require("path"),
+    fs = require("fs"),
+    queue = require("d3").queue;
+
+require("mkdirp").sync(path.join(__dirname, "tmp"));
+
+var probe = require("../lib/probe.js"),
+    trimAudio = require("../audiogram/trim.js");
+
+tape("MP3 probe", function(test) {
+
+  probe(path.join(__dirname, "data/glazed-donut.mp3"), function(err, data){
+
+    test.error(err);
+    test.equal(typeof data.duration, "number");
+    test.equal(data.channels, 2);
+    test.assert(Math.abs(data.duration - 26.67) < 0.1);
+    test.end();
+
+  });
+
+});
+
+tape("Mono probe", function(test) {
+
+  probe(path.join(__dirname, "data/glazed-donut-mono.mp3"), function(err, data){
+
+    test.error(err);
+    test.equal(typeof data.duration, "number");
+    test.equal(data.channels, 1);
+    test.assert(Math.abs(data.duration - 26.67) < 0.1);
+    test.end();
+
+  });
+
+});
+
+tape("WAV probe", function(test) {
+
+  probe(path.join(__dirname, "data/glazed-donut.wav"), function(err, data){
+
+    test.error(err);
+    test.equal(typeof data.duration, "number");
+    test.equal(data.channels, 2);
+    test.assert(Math.abs(data.duration - 1.83) < 0.1);
+    test.end();
+
+  });
+
+});
+
+tape("Mono probe", function(test) {
+
+  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();
+
+  });
+
+});
+
+tape("Trim start", function(test) {
+
+  var options = {
+    origin: path.join(__dirname, "data/glazed-donut.mp3"),
+    destination: path.join(__dirname, "tmp/trim-start.mp3"),
+    startTime: 6.67
+  };
+
+  queue(1)
+    .defer(trimAudio, options)
+    .defer(probe, options.destination)
+    .await(function(err, _, data){
+
+      test.error(err);
+      test.equal(typeof data.duration, "number");
+      test.assert(Math.abs(data.duration - 20) < 0.1);
+      test.end();
+
+    });
+
+});
+
+tape("Trim end", function(test) {
+
+  var options = {
+    origin: path.join(__dirname, "data/glazed-donut.mp3"),
+    destination: path.join(__dirname, "tmp/trim-end.mp3"),
+    startTime: 6.67
+  };
+
+  queue(1)
+    .defer(trimAudio, options)
+    .defer(probe, options.destination)
+    .await(function(err, _, data){
+
+      test.error(err);
+      test.equal(typeof data.duration, "number");
+      test.assert(Math.abs(data.duration - 20) < 0.1);
+      test.end();
+
+    });
+
+});
+
+tape("Trim start & end", function(test) {
+
+  var options = {
+    origin: path.join(__dirname, "data/glazed-donut.mp3"),
+    destination: path.join(__dirname, "tmp/trim-start-end.mp3"),
+    startTime: 5,
+    endTime: 10
+  };
+
+  queue(1)
+    .defer(trimAudio, options)
+    .defer(probe, options.destination)
+    .await(function(err, _, data){
+
+      test.error(err);
+      test.equal(typeof data.duration, "number");
+      test.assert(Math.abs(data.duration - 5) < 0.1);
+      test.end();
+
+    });
+
+});
+
+
+tape("Trim invalid", function(test) {
+
+  var options = {
+    origin: path.join(__dirname, "data/glazed-donut.mp3"),
+    destination: path.join(__dirname, "tmp/trim-invalid.mp3"),
+    startTime: 5,
+    endTime: 4
+  };
+
+  trimAudio(options, function(err){
+    test.ok(err);
+    test.end();
+  });
+
+});
+
+// Cleanup
+tape.onFinish(function(){
+  require("rimraf")(path.join(__dirname, "tmp"), function(err){
+    if (err) {
+      throw err;
+    }
+  });
+});

test/server-test.js

     queue = require("d3").queue,
     request = require("supertest");
 
-var serverSettings = require("./patch-settings")({
-  workingDirectory: path.join(__dirname, "tmp", "working"),
-  maxUploadSize: 100000,
-  storagePath: path.join(__dirname, "tmp", "storage"),
-  worker: true
-});
+var serverSettings = require("../lib/settings/");
+
+serverSettings.workingDirectory = path.join(__dirname, "tmp", "working");
+serverSettings.storagePath = path.join(__dirname, "tmp", "storage");
+serverSettings.maxUploadSize = 100000;
+serverSettings.worker = true;
 
 var server = require("../server");
 
 
 });
 
+tape("404 3", function(test) {
+
+  request(server)
+    .get("/fonts/something")
+    .expect(404)
+    .end(function(err, res){
+      test.error(err);
+      test.end();
+    });
+
+});
+
+tape("Font stylesheet", function(test) {
+
+  request(server)
+    .get("/fonts/fonts.css")
+    .expect(200)
+    .expect(/font-face/)
+    .expect("Content-Type", /css/)
+    .end(function(err, res){
+      test.error(err);
+      test.end();
+    });
+
+});
+
+tape("Font file", function(test) {
+
+  request(server)
+    .get("/fonts/custom-0.ttf")
+    .expect(200)
+    .expect("Content-Type", /ttf/)
+    .end(function(err, res){
+      test.error(err);
+      test.end();
+    });
+
+});
+
 tape("Server static background", function(test) {
 
   request(server)
   request(server)
     .post("/submit/")
     .attach("audio", longSample)
-    .field("settings", "{}")
+    .field("theme", "{}")
     .expect(500)
     .end(function(err, res){
       test.assert(res.text.match(/uploads are limited/i));
   request(server)
     .post("/submit/")
     .type("json")
-    .field("settings", "{}")
+    .field("theme", "{}")
     .expect(500)
     .end(function(err, res){
       test.assert(res.text.match(/audio/i));
   request(server)
     .post("/submit/")
     .type("multipart/form-data")
-    .field("settings", "a")
+    .field("theme", "a")
     .expect(500)
     .end(function(err, res){
       test.assert(res.text.match(/settings/i));
   request(server)
     .post("/submit/")
     .attach("audio", shortSample)
-    .field("settings", JSON.stringify({ test: true }))
+    .field("theme", JSON.stringify({ test: true }))
     .expect(200)
     .end(function(err, res){
 

test/settings-test.js

+var tape = require("tape"),
+    path = require("path"),
+    validateSettings = require("../lib/settings/validate-settings.js"),
+    validateThemes = require("../lib/settings/validate-themes.js"),
+    load = require("../lib/settings/load.js");
+
+tape("Load test", function(test) {
+
+  test.throws(function(){
+    load("settings/blah.js");
+  }, /No .+ file found/);
+
+  test.throws(function(){
+    load("README.md");
+  }, /SyntaxError/);
+
+  test.doesNotThrow(function(){
+    load("settings/themes.json");
+  });
+
+  test.doesNotThrow(function(){
+    load("settings/index.js");
+  });
+
+  test.end();
+
+});
+
+tape("Required fields", function(test) {
+
+  test.throws(function(){
+    validateSettings({});
+  }, /settings.workingDirectory is required/);
+
+  test.throws(function(){
+    validateSettings({ workingDirectory: 1 });
+  }, /settings.workingDirectory is required/);
+
+  test.throws(function(){
+    validateSettings({ workingDirectory: "" });
+  }, /settings.storagePath/);
+
+  test.throws(function(){
+    validateSettings({ workingDirectory: "", storagePath: 1 });
+  }, /settings.storagePath/);
+
+  test.doesNotThrow(function(){
+    validateSettings({ workingDirectory: path.join(__dirname), storagePath: path.join(__dirname) });
+  }, /settings.storagePath/);
+
+  test.doesNotThrow(function(){
+    validateSettings({ workingDirectory: path.join(__dirname), s3Bucket: "bucket" });
+  }, /settings.storagePath/);
+
+  test.end();
+
+});
+
+tape("Max upload size", function(test) {
+
+  test.throws(function(){
+    validateSettings({ workingDirectory: path.join(__dirname), storagePath: path.join(__dirname), maxUploadSize: "a lot" });
+  }, /settings.maxUploadSize/);
+
+  test.end();
+
+});
+
+tape("Normalizing paths", function(test) {
+
+  var relative = validateSettings({
+    storagePath: "test/",
+    workingDirectory: "test/"
+  });
+
+  var absolute = validateSettings({
+    storagePath: path.join(__dirname),
+    workingDirectory: path.join(__dirname)
+  });
+
+  var relative2 = validateSettings({
+    storagePath: "test",
+    workingDirectory: "test"
+  });
+
+  test.equal(path.relative(relative.storagePath, absolute.storagePath), "");
+  test.equal(path.relative(relative.workingDirectory, absolute.workingDirectory), "");
+  test.equal(path.relative(relative2.storagePath, absolute.storagePath), "");
+  test.equal(path.relative(relative2.workingDirectory, absolute.workingDirectory), "");
+
+  test.end();
+
+});
+
+tape("Normalize S3 bucket", function(test) {
+
+  var settings = validateSettings({
+    s3Bucket: "bucket",
+    workingDirectory: "test/"
+  });
+
+  test.equal(settings.s3Bucket, "bucket");
+  test.equal(settings.storagePath, "");
+
+  var settings = validateSettings({
+    s3Bucket: "s3://bucket",
+    workingDirectory: "test/"
+  });
+
+  test.equal(settings.s3Bucket, "bucket");
+  test.equal(settings.storagePath, "");
+
+  settings = validateSettings({
+    s3Bucket: "s3://bucket/",
+    workingDirectory: "test/"
+  });
+
+  test.equal(settings.s3Bucket, "bucket");
+  test.equal(settings.storagePath, "");
+
+  settings = validateSettings({
+    s3Bucket: "s3://bucket/",
+    storagePath: "/",
+    workingDirectory: "test/"
+  });
+
+  test.equal(settings.s3Bucket, "bucket");
+  test.equal(settings.storagePath, "");
+
+  settings = validateSettings({
+    s3Bucket: "s3://bucket/",
+    storagePath: "dir",
+    workingDirectory: "test/"
+  });
+
+  test.equal(settings.s3Bucket, "bucket");
+  test.equal(settings.storagePath, "dir/");
+
+  settings = validateSettings({
+    s3Bucket: "s3://bucket/",
+    storagePath: "dir/",
+    workingDirectory: "test/"
+  });
+
+  test.equal(settings.s3Bucket, "bucket");
+  test.equal(settings.storagePath, "dir/");
+
+  settings = validateSettings({
+    s3Bucket: "s3://bucket/",
+    storagePath: "/dir/",
+    workingDirectory: "test/"
+  });
+
+  test.equal(settings.s3Bucket, "bucket");
+  test.equal(settings.storagePath, "dir/");
+
+  test.end();
+
+});
+
+tape("Fonts", function(test) {
+
+  test.throws(function(){
+    validateSettings({
+      s3Bucket: "bucket",
+      workingDirectory: "test/",
+      fonts: 1
+    });
+  }, /settings.fonts/);
+
+  test.throws(function(){
+    validateSettings({
+      s3Bucket: "bucket",
+      workingDirectory: "test/",
+      fonts: {}
+    });
+  }, /settings.fonts/);
+
+  doesWarn(test, function(){
+    validateSettings({
+      s3Bucket: "bucket",
+      workingDirectory: "test/",
+      fonts: [
+        {}
+      ]
+    });
+  }, /settings.fonts.+missing/);
+
+  doesWarn(test, function(){
+    validateSettings({
+      s3Bucket: "bucket",
+      workingDirectory: "test/",
+      fonts: [
+        { family: "" }
+      ]
+    });
+  }, /settings.fonts.+missing/);
+
+  doesWarn(test, function(){
+    validateSettings({
+      s3Bucket: "bucket",
+      workingDirectory: "test/",
+      fonts: [
+        { file: "" }
+      ]
+    });
+  }, /settings.fonts.+missing/);
+
+  doesWarn(test, function(){
+    validateSettings({
+      s3Bucket: "bucket",
+      workingDirectory: "test/",
+      fonts: [
+        { file: "notarealfont.ttf", family: "fake" }
+      ]
+    });
+  }, /Font file.+does not exist/);
+
+  doesNotWarn(test, function(){
+    validateSettings({
+      s3Bucket: "bucket",
+      workingDirectory: "test/",
+      fonts: [
+        { file: "settings/fonts/SourceSansPro-Light.ttf", family: "Source Sans Pro" },
+        { file: path.join(__dirname, "..", "settings/fonts/SourceSansPro-Bold.ttf"), family: "Source Sans Pro", weight: "bold" }
+      ]
+    });
+  });
+
+  test.end();
+
+});
+
+tape("Themes", function(test) {
+
+  doesWarn(test, function(){
+    validateThemes({});
+  }, /No themes/);
+
+  doesWarn(test, function(){
+    validateThemes([]);
+  }, /No themes/);
+
+  doesWarn(test, function(){
+    validateThemes({ "default": {} });
+  }, /No themes/);
+
+  doesNotWarn(test, function(){
+    validateThemes({ "default": { width: 0, height: 0, framesPerSecond: 0, samplesPerFrame: 0 }, "theme": {} });
+  });
+
+  doesNotWarn(test, function(){
+    validateThemes({ "default": { framesPerSecond: 0, samplesPerFrame: 0 }, "theme": { width: 0, height: 0 } });
+  });
+
+  doesWarn(test, function(){
+    validateThemes({ "default": { height: 0, framesPerSecond: 0, samplesPerFrame: 0 }, "theme": {} });
+  }, /required property 'width'/);
+
+  doesWarn(test, function(){
+    validateThemes({ "default": { width: 0, framesPerSecond: 0, samplesPerFrame: 0 }, "theme": {} });
+  }, /required property 'height'/);
+
+  doesWarn(test, function(){
+    validateThemes({ "default": { width: 0, height: 0, samplesPerFrame: 0 }, "theme": {} });
+  }, /required property 'framesPerSecond'/);
+
+  doesWarn(test, function(){
+    validateThemes({ "default": { width: 0, height: 0, framesPerSecond: 0 }, "theme": {} });
+  }, /required property 'samplesPerFrame'/);
+
+  doesWarn(test, function(){
+    validateThemes({ "default": { width: 0, height: 0, framesPerSecond: 0, samplesPerFrame: 0 }, "theme": { backgroundImage: "doesnotexist.jpg" } });
+  }, /Background image.+does not exist/);
+
+  doesNotWarn(test, function(){
+    validateThemes({ "default": { width: 0, height: 0, framesPerSecond: 0, samplesPerFrame: 0 }, "theme": { backgroundImage: "subway.jpg" } });
+  });
+
+  doesNotWarn(test, function(){
+    validateThemes({ "default": { width: 0, height: 0, framesPerSecond: 0, samplesPerFrame: 0 }, "theme": { backgroundImage: path.join(__dirname, "..", "settings/backgrounds/subway.jpg") } });
+  });
+
+  test.end();
+
+});
+
+function doesNotWarn(test, fn) {
+  doesWarn(test, fn, "");
+}
+
+function doesWarn(test, fn, regexp) {
+
+  var output = capture();
+
+  fn();
+
+  if (arguments.length > 2) {
+    if (typeof regexp === "string") {
+      test.equal(output(), regexp);
+    } else {
+      test.assert(regexp.test(output()));
+    }
+  } else {
+    test.assert(output().length);
+  }
+
+}
+
+function capture(){
+
+  var write = process.stderr.write,
+      out = "";
+
+  process.stderr.write = function(str) {
+    out += str;
+  };
+
+  return function(){
+    process.stderr.write = write;
+    return out;
+  }
+
+}

test/waveform-test.js

 var tape = require("tape"),
     path = require("path");
 
-var getWaveform = require("../audiogram/waveform.js");
+var Audiogram = require("../audiogram/"),
+    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]);
+    options.channels = data.channels;
+    options.numFrames = Math.floor(data.duration * options.framesPerSecond);
 
-    test.assert(firstMax <= 1);
+    getWaveform(sample, options, function(e2, waveform){
 
-    test.assert(waveform.every(function(frame){
-      return frame.length === options.samplesPerFrame;
-    }));
+      test.error(e2);
+      test.assert(Array.isArray(waveform) && waveform.length === options.numFrames);
 
-    test.assert(waveform.every(function(frame){
-      return frame.every(function(val){
-        return typeof val === "number" && val >= 0 && val <= firstMax;
-      });
-    }));
+      test.assert(waveform.every(function(frame){
+        return frame.length === options.samplesPerFrame && frame.every(function(f){
+          return f.length === 2 && f.every(function(d){ return typeof d === "number"; }) && f[0] >= 0 && f[0] <= 1 && f[1] >= -1 && f[1] <= 1;
+        });
+      }));
 
-    test.end();
+      test.end();
+
+    });
 
   });
 
 });
 
-tape("Waveform missing numFrames", function(test) {
+tape("Max Duration Error", function(test) {
 
-  var options = {
-    samplesPerFrame: 10
+  var audiogram = new Audiogram("xyz");
+  audiogram.audioPath = sample;
+  audiogram.settings = {
+    theme: {
+      maxDuration: 20
+    }
   };
 
-  getWaveform(sample, options, function(err, waveform){
-
-    test.ok(err);
+  audiogram.getWaveform(function(err, waveform){
+    test.assert(err);
+    test.assert(err.toString().match(/Exceeds max duration/));
     test.end();
-
   });
 
 });
 
-tape("Waveform missing samplesPerFrame", function(test) {
+tape("Max Duration OK", function(test) {
 
-  var options = {
-    numFrames: 500,
+  var audiogram = new Audiogram("xyz");
+  audiogram.audioPath = sample;
+  audiogram.settings = {
+    theme: {
+      samplesPerFrame: 10,
+      framesPerSecond: 20
+    }
   };
 
-  getWaveform(sample, options, function(err, waveform){
+  probe(sample, function(err, data){
+    test.deepEqual(Math.round(data.duration), 27);
+    test.deepEqual(data.channels, 2);
 
-    test.ok(err);
-    test.end();
+    audiogram.getWaveform(function(waveformErr, waveform){
+      test.error(waveformErr);
+      test.assert(Array.isArray(waveform));
+      test.deepEqual(waveform.length, Math.floor(data.duration * audiogram.settings.theme.framesPerSecond));
+      test.end();
+    });
 
   });