11 files changed, 926 insertions, 431 deletions

@@ -0,0 +1,5 @@
+.DS_Store
+CMakeFiles
+CMakeCache.txt
+cmake_install.cmake
+Makefile
@@ -1,22 +1,34 @@
 cmake_minimum_required (VERSION 3.1)
 project (sap)
 
-set(CMAKE_BUILD_TYPE Debug)
-
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/")
 
 find_package(FFMPEG REQUIRED)
-include_directories(${FFMPEG_INCLUDE_DIRS})
 
 find_package(PkgConfig)
+pkg_check_modules(yaml-cpp yaml-cpp REQUIRED)
 pkg_check_modules(GraphicsMagick GraphicsMagick++ REQUIRED)
-include_directories(${GraphicsMagick_INCLUDE_DIRS})
-link_directories(${GraphicsMagick_LIBRARY_DIRS})
 
 add_subdirectory(vendor/rawr-ebooks EXCLUDE_FROM_ALL)
-include_directories(vendor/rawr-ebooks vendor/rawr-ebooks/vendor/libtwittercpp/src vendor/rawr-ebooks/vendor/yaml-cpp/include)
 
-add_executable(sap sap.cpp)
+include_directories(
+  ${FFMPEG_INCLUDE_DIRS}
+  vendor/rawr-ebooks
+  vendor/rawr-ebooks/vendor/libtwittercpp/src
+  ${yaml-cpp_INCLUDE_DIRS}
+  ${GraphicsMagick_INCLUDE_DIRS})
+
+link_directories(
+  ${yaml-cpp_LIBRARY_DIRS}
+  ${GraphicsMagick_LIBRARY_DIRS})
+
+add_executable(sap sap.cpp director.cpp designer.cpp main.cpp)
 set_property(TARGET sap PROPERTY CXX_STANDARD 11)
 set_property(TARGET sap PROPERTY CXX_STANDARD_REQUIRED ON)
-target_link_libraries(sap rawr twitter++ ${FFMPEG_LIBRARIES} ${GraphicsMagick_LIBRARIES} yaml-cpp)
+
+target_link_libraries(sap
+  rawr
+  twitter++
+  ${FFMPEG_LIBRARIES}
+  ${GraphicsMagick_LIBRARIES}
+  ${yaml-cpp_LIBRARIES})
@@ -0,0 +1,244 @@
+#include "designer.h"
+#include <dirent.h>
+#include <stdexcept>
+#include <iostream>
+#include "util.h"
+
+designer::designer(std::string fontsDir)
+{
+  DIR* fontdir;
+  struct dirent* ent;
+  if ((fontdir = opendir(fontsDir.c_str())) == nullptr)
+  {
+    throw std::invalid_argument("Couldn't find fonts");
+  }
+
+  while ((ent = readdir(fontdir)) != nullptr)
+  {
+    std::string dname(ent->d_name);
+    if ((dname.find(".otf") != std::string::npos)
+      || (dname.find(".ttf") != std::string::npos))
+    {
+      fonts.push_back(fontsDir + "/" + dname);
+    }
+  }
+
+  closedir(fontdir);
+}
+
+Magick::Image designer::generate(
+  size_t width,
+  size_t height,
+  const std::string& text,
+  std::mt19937& rng) const
+{
+  // Initialize two layers: the text, and a shadow to increase contrast.
+  Magick::Image textimage(Magick::Geometry(width, height), "transparent");
+  Magick::Image shadowimage(Magick::Geometry(width, height), "transparent");
+
+  textimage.fillColor(Magick::Color(MaxRGB, MaxRGB, MaxRGB, MaxRGB * 0.0));
+  shadowimage.fillColor(Magick::Color(0, 0, 0, 0));
+  shadowimage.strokeColor("black");
+
+  bool hasFont = false;
+  std::uniform_int_distribution<size_t> fontDist(0, fonts.size() - 1);
+
+  std::vector<std::string> words = split<std::vector<std::string>>(text, " ");
+  std::vector<std::string>::const_iterator curWord = std::begin(words);
+
+  size_t top = V_PADDING;
+  size_t minWords = 1;
+  while (curWord != std::end(words))
+  {
+    // There is a 1 in 10 chance of randomly changing the font. We also have to
+    // set the font if this is the beginning of generation.
+    if (!hasFont || (std::bernoulli_distribution(0.1)(rng)))
+    {
+      std::string font = fonts[fontDist(rng)];
+
+      textimage.font(font);
+      shadowimage.font(font);
+
+      hasFont = true;
+    }
+
+    // Choose a font size for the current line.
+    std::uniform_int_distribution<size_t> sizeDist(
+      MIN_FONT_SIZE, MAX_FONT_SIZE);
+
+    size_t size = sizeDist(rng);
+    textimage.fontPointsize(size);
+
+    // Decide what words to put on this line.
+    size_t maxWords = maxWordsInLine(curWord, std::end(words), textimage);
+
+    size_t lineLen;
+    if (minWords > maxWords)
+    {
+      lineLen = maxWords;
+    } else {
+      std::uniform_int_distribution<size_t> lenDist(minWords, maxWords);
+      lineLen = lenDist(rng);
+    }
+
+    std::string prefixText = implode(curWord, curWord + lineLen, " ");
+
+    // Determine if the choice of font, font size, and number of words, would
+    // prevent the algorithm from being about to layout the entire string even
+    // if the rest of it were rendered in the smallest font size.
+    Magick::TypeMetric metric;
+    textimage.fontTypeMetrics(prefixText, &metric);
+
+    textimage.fontPointsize(MIN_FONT_SIZE);
+
+    // This is how much vertical space would be required to render the rest of
+    // the string at the minimum font size.
+    int lowpadding = minHeightRequired(
+      curWord + lineLen,
+      std::end(words),
+      textimage);
+
+    // This is the amount of space that would be left over if the rest of the
+    // string were rendered at the minimum font size.
+    int freespace =
+      static_cast<int>(height) - static_cast<int>(V_PADDING)
+        - static_cast<int>(top) - lowpadding - metric.textHeight();
+
+    // Some debug text.
+    std::cout << "top of " << top << " with lowpad of " << lowpadding
+      << " and textheight of " << metric.textHeight() << " with freespace="
+      << freespace << std::endl;
+
+    // If there wouldn't be enough room to render the rest of the string at the
+    // minimum font size, go back to the top of the loop and choose a different
+    // font, font size, and number of words.
+    if (freespace < 0)
+    {
+      minWords = lineLen;
+
+      continue;
+    }
+
+    minWords = 1;
+
+    // Determine how much space to leave between this line and the previous one.
+    size_t toppadding;
+    if (std::bernoulli_distribution(0.5)(rng))
+    {
+      // Exponential distribution, biased toward top
+      std::uniform_int_distribution<size_t> expDist(
+        1, static_cast<size_t>(exp(freespace + 1)));
+
+      toppadding = log(expDist(rng));
+    } else {
+      // Linear distribution, biased toward bottom
+      std::uniform_int_distribution<size_t> linDist(0, freespace);
+
+      toppadding = linDist(rng);
+    }
+
+    // Determine the x-coordinate of this line.
+    std::uniform_int_distribution<size_t> leftDist(
+      H_PADDING,
+      width - H_PADDING - static_cast<size_t>(metric.textWidth()) - 1);
+
+    size_t leftx = leftDist(rng);
+
+    // Render this line.
+    size_t ycor = top + toppadding + metric.ascent();
+
+    std::cout << "printing at " << leftx << "," << ycor << std::endl;
+
+    textimage.fontPointsize(size);
+    textimage.annotate(prefixText, Magick::Geometry(0, 0, leftx, ycor));
+
+    shadowimage.fontPointsize(size);
+    shadowimage.strokeWidth(size / 10);
+    shadowimage.annotate(prefixText, Magick::Geometry(0, 0, leftx, ycor));
+
+    top += toppadding + metric.textHeight();
+
+    std::advance(curWord, lineLen);
+  }
+
+  // Make the shadow layer semi-transparent.
+  Magick::PixelPacket* shadpixels = shadowimage.getPixels(0, 0, width, height);
+  Magick::PixelPacket* textpixels = textimage.getPixels(0, 0, width, height);
+  for (size_t j = 0; j < height; j++)
+  {
+    for (size_t i = 0; i < width; i++)
+    {
+      size_t ind = j * width + i;
+
+      if (shadpixels[ind].opacity != MaxRGB)
+      {
+        shadpixels[ind].opacity = MaxRGB * 0.25;
+      }
+    }
+  }
+
+  shadowimage.syncPixels();
+  textimage.syncPixels();
+
+  // Add some blur to the text and shadow.
+  shadowimage.blur(10.0, 20.0);
+  textimage.blur(0.0, 0.5);
+
+  // Put the text layer on top of the shadow.
+  shadowimage.composite(textimage, 0, 0, Magick::OverCompositeOp);
+
+  return shadowimage;
+}
+
+size_t designer::maxWordsInLine(
+  std::vector<std::string>::const_iterator first,
+  std::vector<std::string>::const_iterator last,
+  Magick::Image& textimage) const
+{
+  size_t result = 0;
+
+  std::string curline = "";
+  for (; first != last; first++)
+  {
+    curline += " " + *first;
+
+    Magick::TypeMetric metric;
+    textimage.fontTypeMetrics(curline, &metric);
+
+    if (metric.textWidth() > ((textimage.columns() / 10) * 9))
+    {
+      break;
+    } else {
+      result++;
+    }
+  }
+
+  return result;
+}
+
+size_t designer::minHeightRequired(
+  std::vector<std::string>::const_iterator first,
+  std::vector<std::string>::const_iterator last,
+  Magick::Image& textimage) const
+{
+  if (first == last)
+  {
+    return 0;
+  } else {
+    size_t result = 0;
+
+    while (first != last)
+    {
+      size_t prefixlen = maxWordsInLine(first, last, textimage);
+      std::string prefixText = implode(first, first + prefixlen, " ");
+
+      Magick::TypeMetric metric;
+      textimage.fontTypeMetrics(prefixText, &metric);
+      result += metric.textHeight() + V_PADDING;
+
+      std::advance(first, prefixlen);
+    }
+
+    return result - V_PADDING;
+  }
+}
@@ -0,0 +1,40 @@
+#ifndef DESIGNER_H_CCE34BEB
+#define DESIGNER_H_CCE34BEB
+
+#include <random>
+#include <string>
+#include <Magick++.h>
+#include <vector>
+
+class designer {
+public:
+
+  designer(std::string fontsPath);
+
+  Magick::Image generate(
+    size_t width,
+    size_t height,
+    const std::string& text,
+    std::mt19937& rng) const;
+
+private:
+
+  const size_t MIN_FONT_SIZE = 48;
+  const size_t MAX_FONT_SIZE = 96;
+  const size_t V_PADDING = 5;
+  const size_t H_PADDING = 5;
+
+  size_t maxWordsInLine(
+    std::vector<std::string>::const_iterator first,
+    std::vector<std::string>::const_iterator last,
+    Magick::Image& textimage) const;
+
+  size_t minHeightRequired(
+    std::vector<std::string>::const_iterator first,
+    std::vector<std::string>::const_iterator last,
+    Magick::Image& textimage) const;
+
+  std::vector<std::string> fonts;
+};
+
+#endif /* end of include guard: DESIGNER_H_CCE34BEB */
@@ -0,0 +1,378 @@
+#include "director.h"
+#include <dirent.h>
+#include <iostream>
+
+extern "C" {
+#include <libavformat/avformat.h>
+#include <libavcodec/avcodec.h>
+#include <libavutil/imgutils.h>
+#include <libswscale/swscale.h>
+}
+
+namespace ffmpeg {
+
+  class format {
+  public:
+
+    format(std::string videoPath)
+    {
+      if (avformat_open_input(&ptr_, videoPath.c_str(), nullptr, nullptr))
+      {
+        throw ffmpeg_error("Could not open video " + videoPath);
+      }
+
+      if (avformat_find_stream_info(ptr_, nullptr))
+      {
+        throw ffmpeg_error("Could not read stream");
+      }
+    }
+
+    ~format()
+    {
+      avformat_close_input(&ptr_);
+    }
+
+    format(const format& other) = delete;
+
+    AVFormatContext* ptr()
+    {
+      return ptr_;
+    }
+
+  private:
+
+    AVFormatContext* ptr_ = nullptr;
+  };
+
+  class codec {
+  public:
+
+    codec(
+      format& fmt,
+      AVStream* st)
+    {
+      AVCodec* dec = avcodec_find_decoder(st->codecpar->codec_id);
+      if (!dec)
+      {
+        throw ffmpeg_error("Failed to find codec");
+      }
+
+      ptr_ = avcodec_alloc_context3(dec);
+      if (!ptr_)
+      {
+        throw ffmpeg_error("Failed to allocate codec context");
+      }
+
+      if (avcodec_parameters_to_context(ptr_, st->codecpar) < 0)
+      {
+        throw ffmpeg_error("Failed to copy codec parameters to decoder");
+      }
+
+      // Init the decoders, with or without reference counting
+      AVDictionary* opts = nullptr;
+      av_dict_set(&opts, "refcounted_frames", "0", 0);
+
+      if (avcodec_open2(ptr_, dec, &opts) < 0)
+      {
+        throw ffmpeg_error("Failed to open codec");
+      }
+    }
+
+    codec(const codec& other) = delete;
+
+    ~codec()
+    {
+      avcodec_free_context(&ptr_);
+    }
+
+    int getWidth() const
+    {
+      return ptr_->width;
+    }
+
+    int getHeight() const
+    {
+      return ptr_->height;
+    }
+
+    enum AVPixelFormat getPixelFormat() const
+    {
+      return ptr_->pix_fmt;
+    }
+
+    AVCodecContext* ptr()
+    {
+      return ptr_;
+    }
+
+  private:
+
+    AVCodecContext* ptr_ = nullptr;
+  };
+
+  class packet {
+  public:
+
+    packet()
+    {
+      ptr_ = av_packet_alloc();
+    }
+
+    ~packet()
+    {
+      av_packet_free(&ptr_);
+    }
+
+    packet(const packet& other) = delete;
+
+    int getStreamIndex() const
+    {
+      return ptr_->stream_index;
+    }
+
+    AVPacket* ptr()
+    {
+      return ptr_;
+    }
+
+    int getFlags() const
+    {
+      return ptr_->flags;
+    }
+
+  private:
+
+    AVPacket* ptr_ = nullptr;
+  };
+
+  class frame {
+  public:
+
+    frame()
+    {
+      ptr_ = av_frame_alloc();
+    }
+
+    ~frame()
+    {
+      av_frame_free(&ptr_);
+    }
+
+    frame(const frame& other) = delete;
+
+    uint8_t** getData()
+    {
+      return ptr_->data;
+    }
+
+    int* getLinesize()
+    {
+      return ptr_->linesize;
+    }
+
+    AVFrame* ptr()
+    {
+      return ptr_;
+    }
+
+  private:
+
+    AVFrame* ptr_ = nullptr;
+  };
+
+  class sws {
+  public:
+
+    sws(
+      int srcW,
+      int srcH,
+      enum AVPixelFormat srcFormat,
+      int dstW,
+      int dstH,
+      enum AVPixelFormat dstFormat,
+      int flags,
+      SwsFilter* srcFilter,
+      SwsFilter* dstFilter,
+      const double* param)
+    {
+      ptr_ = sws_getContext(
+        srcW,
+        srcH,
+        srcFormat,
+        dstW,
+        dstH,
+        dstFormat,
+        flags,
+        srcFilter,
+        dstFilter,
+        param);
+
+      if (ptr_ == NULL)
+      {
+        throw ffmpeg_error("Could not allocate sws context");
+      }
+    }
+
+    ~sws()
+    {
+      sws_freeContext(ptr_);
+    }
+
+    sws(const sws& other) = delete;
+
+    void scale(
+      const uint8_t* const srcSlice[],
+      const int srcStride[],
+      int srcSliceY,
+      int srcSliceH,
+      uint8_t* const dst[],
+      const int dstStride[])
+    {
+      sws_scale(
+        ptr_,
+        srcSlice,
+        srcStride,
+        srcSliceY,
+        srcSliceH,
+        dst,
+        dstStride);
+    }
+
+  private:
+
+    SwsContext* ptr_;
+  };
+
+}
+
+director::director(std::string videosPath) : videosPath_(videosPath)
+{
+  DIR* videodir;
+  struct dirent* ent;
+  if ((videodir = opendir(videosPath.c_str())) == nullptr)
+  {
+    throw std::invalid_argument("Couldn't find videos");
+  }
+
+  while ((ent = readdir(videodir)) != nullptr)
+  {
+    std::string dname(ent->d_name);
+    if (dname.find(".mp4") != std::string::npos)
+    {
+      videos_.push_back(dname);
+    }
+  }
+
+  closedir(videodir);
+}
+
+Magick::Image director::generate(std::mt19937& rng) const
+{
+  std::uniform_int_distribution<size_t> videoDist(0, videos_.size() - 1);
+  std::string video = videosPath_ + "/" + videos_[videoDist(rng)];
+
+  ffmpeg::format fmt(video);
+
+  int streamIdx =
+    av_find_best_stream(fmt.ptr(), AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
+
+  if (streamIdx < 0)
+  {
+    throw ffmpeg_error("Could not find stream");
+  }
+
+  AVStream* stream = fmt.ptr()->streams[streamIdx];
+
+  ffmpeg::codec cdc(fmt, stream);
+
+  size_t codecw = cdc.getWidth();
+  size_t codech = cdc.getHeight();
+
+  std::uniform_int_distribution<int64_t> frameDist(0, stream->duration - 1);
+  int64_t seek = frameDist(rng);
+
+  std::cout << seek << std::endl;
+
+  if (av_seek_frame(fmt.ptr(), streamIdx, seek, 0))
+  {
+    throw ffmpeg_error("Could not seek");
+  }
+
+  ffmpeg::frame frame;
+  ffmpeg::frame converted;
+
+  av_image_alloc(
+    converted.getData(),
+    converted.getLinesize(),
+    codecw,
+    codech,
+    AV_PIX_FMT_RGB24,
+    1);
+
+  ffmpeg::packet pkt;
+
+  do
+  {
+    if (av_read_frame(fmt.ptr(), pkt.ptr()) < 0)
+    {
+      throw ffmpeg_error("Could not read frame");
+    }
+  } while ((pkt.getStreamIndex() != streamIdx)
+      || !(pkt.getFlags() & AV_PKT_FLAG_KEY));
+
+  int ret;
+  do {
+    if (avcodec_send_packet(cdc.ptr(), pkt.ptr()) < 0)
+    {
+      throw ffmpeg_error("Could not send packet");
+    }
+
+    ret = avcodec_receive_frame(cdc.ptr(), frame.ptr());
+  } while (ret == AVERROR(EAGAIN));
+
+  if (ret < 0)
+  {
+    throw ffmpeg_error("Could not decode frame");
+  }
+
+  ffmpeg::sws scaler(
+    cdc.getWidth(),
+    cdc.getHeight(),
+    cdc.getPixelFormat(),
+    cdc.getWidth(),
+    cdc.getHeight(),
+    AV_PIX_FMT_RGB24,
+    0, nullptr, nullptr, 0);
+
+  scaler.scale(
+    frame.getData(),
+    frame.getLinesize(),
+    0,
+    codech,
+    converted.getData(),
+    converted.getLinesize());
+
+  size_t buffer_size = av_image_get_buffer_size(
+    AV_PIX_FMT_RGB24, cdc.getWidth(), cdc.getHeight(), 1);
+
+  std::vector<uint8_t> buffer(buffer_size);
+
+  av_image_copy_to_buffer(
+    buffer.data(),
+    buffer_size,
+    converted.getData(),
+    converted.getLinesize(),
+    AV_PIX_FMT_RGB24,
+    cdc.getWidth(),
+    cdc.getHeight(),
+    1);
+
+  size_t width = 1024;
+  size_t height = codech * width / codecw;
+
+  Magick::Image image;
+  image.read(codecw, codech, "RGB", Magick::CharPixel, buffer.data());
+  image.zoom(Magick::Geometry(width, height));
+
+  return image;
+}
@@ -0,0 +1,31 @@
+#ifndef DIRECTOR_H_9DFD929C
+#define DIRECTOR_H_9DFD929C
+
+#include <stdexcept>
+#include <string>
+#include <vector>
+#include <Magick++.h>
+#include <random>
+
+class ffmpeg_error : public std::runtime_error {
+public:
+
+  ffmpeg_error(std::string msg) : std::runtime_error(msg)
+  {
+  }
+};
+
+class director {
+public:
+
+  director(std::string videosPath);
+
+  Magick::Image generate(std::mt19937& rng) const;
+
+private:
+
+  std::string videosPath_;
+  std::vector<std::string> videos_;
+};
+
+#endif /* end of include guard: DIRECTOR_H_9DFD929C */
@@ -0,0 +1,45 @@
+#include "sap.h"
+#include <iostream>
+#include <ctime>
+#include <cstdlib>
+
+extern "C" {
+#include <libavformat/avformat.h>
+}
+
+int main(int argc, char** argv)
+{
+  Magick::InitializeMagick(nullptr);
+  av_register_all();
+
+  std::random_device randomDevice;
+  std::mt19937 rng(randomDevice());
+
+  // We also have to seed the C-style RNG because librawr uses it.
+  srand(time(NULL));
+  rand(); rand(); rand(); rand();
+
+  if (argc != 2)
+  {
+    std::cout << "usage: sap [configfile]" << std::endl;
+    return -1;
+  }
+
+  std::string configfile(argv[1]);
+
+  try
+  {
+    sap bot(configfile, rng);
+
+    try
+    {
+      bot.run();
+    } catch (const std::exception& ex)
+    {
+      std::cout << "Error running bot: " << ex.what() << std::endl;
+    }
+  } catch (const std::exception& ex)
+  {
+    std::cout << "Error initializing bot: " << ex.what() << std::endl;
+  }
+}
@@ -1,22 +1,9 @@
-extern "C" {
-#include <libavformat/avformat.h>
-#include <libavcodec/avcodec.h>
-#include <libavutil/imgutils.h>
-#include <libswscale/swscale.h>
-}
-
-#include <Magick++.h>
-#include <iostream>
-#include <rawr.h>
-#include <vector>
-#include <list>
-#include <fstream>
-#include <dirent.h>
-#include <sstream>
-#include <twitter.h>
+#include "sap.h"
 #include <yaml-cpp/yaml.h>
 #include <thread>
 #include <chrono>
+#include <fstream>
+#include <iostream>
 
 /* - random frames from Spongebob (using ffmpeg)
  * with strange text overlaid, possibly rawr'd from
@@ -25,277 +12,24 @@ extern "C" {
  * frames
  */
 
-template <class Container>
-Container split(std::string input, std::string delimiter)
-{
-  Container result;
-  
-  while (!input.empty())
-  {
-    int divider = input.find(delimiter);
-    if (divider == std::string::npos)
-    {
-      result.push_back(input);
-      
-      input = "";
-    } else {
-      result.push_back(input.substr(0, divider));
-      
-      input = input.substr(divider+delimiter.length());
-    }
-  }
-  
-  return result;
-}
-
-template <class InputIterator>
-std::string implode(InputIterator first, InputIterator last, std::string delimiter)
-{
-  std::stringstream result;
-  
-  for (InputIterator it = first; it != last; it++)
-  {
-    if (it != first)
-    {
-      result << delimiter;
-    }
-    
-    result << *it;
-  }
-  
-  return result.str();
-}
-
-int maxWordsInLine(std::vector<std::string> words, Magick::Image& textimage)
-{
-  int result = 0;
-  
-  std::string curline = "";
-  Magick::TypeMetric metric;
-  for (auto word : words)
-  {
-    curline += " " + word;
-    
-    textimage.fontTypeMetrics(curline, &metric);
-    if (metric.textWidth() > ((textimage.columns()/10)*9))
-    {
-      break;
-    } else {
-      result++;
-    }
-  }
-  
-  return result;
-}
-
-int minHeightRequired(std::vector<std::string> words, Magick::Image& textimage)
-{
-  int result = 0;
-  while (!words.empty())
-  {
-    int prefixlen = maxWordsInLine(words, textimage);
-    std::string prefixText = implode(std::begin(words), std::begin(words) + prefixlen, " ");
-    std::vector<std::string> suffix(std::begin(words) + prefixlen, std::end(words));
-    Magick::TypeMetric metric;
-    textimage.fontTypeMetrics(prefixText, &metric);
-    result += metric.textHeight() + 5;
-    
-    words = suffix;
-  }
-  
-  return result - 5;
-}
-
-void layoutText(Magick::Image& textimage, Magick::Image& shadowimage, int width, int height, std::string text, const std::vector<std::string>& fonts)
-{
-  textimage.fillColor(Magick::Color(MaxRGB, MaxRGB, MaxRGB, MaxRGB * 0.0));
-  shadowimage.fillColor(Magick::Color(0, 0, 0, 0));
-  shadowimage.strokeColor("black");
-  
-  int minSize = 48;
-  int realMaxSize = 96;
-  int maxSize = realMaxSize;
-  Magick::TypeMetric metric;
-  std::string font;
-  auto words = split<std::vector<std::string>>(text, " ");
-  int top = 5;
-  int minWords = 1;
-  while (!words.empty())
-  {
-    if (font.empty() || (rand() % 10 == 0))
-    {
-      font = fonts[rand() % fonts.size()];
-      textimage.font(font);
-      shadowimage.font(font);
-    }
-    
-    int size = rand() % (maxSize - minSize + 1) + minSize;
-    textimage.fontPointsize(size);
-    int maxWords = maxWordsInLine(words, textimage);
-    int touse;
-    if (minWords > maxWords)
-    {
-      touse = maxWords;
-    } else {
-      touse = rand() % (maxWords - minWords + 1) + minWords;
-    }
-    std::string prefixText = implode(std::begin(words), std::begin(words) + touse, " ");
-    std::vector<std::string> suffix(std::begin(words) + touse, std::end(words));
-    textimage.fontTypeMetrics(prefixText, &metric);
-    
-    textimage.fontPointsize(minSize);
-    int lowpadding = minHeightRequired(suffix, textimage);
-    int freespace = height - 5 - top - lowpadding - metric.textHeight();
-    std::cout << "top of " << top << " with lowpad of " << lowpadding << " and textheight of " << metric.textHeight() << " with freespace=" << freespace << std::endl;
-    if (freespace < 0)
-    {
-      minWords = touse;
-
-      continue;
-    }
-    
-    maxSize = realMaxSize;
-    minWords = 1;
-    
-    int toppadding;
-    if (rand() % 2 == 0)
-    {
-      // Exponential distribution, biased toward top
-      toppadding = log(rand() % (int)exp(freespace + 1) + 1);
-    } else {
-      // Linear distribution, biased toward bottom
-      toppadding = rand() % (freespace + 1);
-    }
-    
-    int leftx = rand() % (width - 10 - (int)metric.textWidth()) + 5;
-    std::cout << "printing at " << leftx << "," << (top + toppadding + metric.ascent()) << std::endl;
-    textimage.fontPointsize(size);
-    textimage.annotate(prefixText, Magick::Geometry(0, 0, leftx, top + toppadding + metric.ascent()));
-    
-    shadowimage.fontPointsize(size);
-    shadowimage.strokeWidth(size / 10);
-    shadowimage.annotate(prefixText, Magick::Geometry(0, 0, leftx, top + toppadding + metric.ascent()));
-    //shadowimage.draw(Magick::DrawableRectangle(leftx - 5, top + toppadding, leftx + metric.textWidth() + 5, top + toppadding + metric.textHeight() + 10 + metric.descent()));
-    
-    words = suffix;
-    top += toppadding + metric.textHeight();
-  }
-  
-  Magick::PixelPacket* shadowpixels = shadowimage.getPixels(0, 0, width, height);
-  Magick::PixelPacket* textpixels = textimage.getPixels(0, 0, width, height);
-  for (int j=0; j<height; j++)
-  {
-    for (int i=0; i<width; i++)
-    {
-      int ind = j*width+i;
-      if (shadowpixels[ind].opacity != MaxRGB)
-      {
-        shadowpixels[ind].opacity = MaxRGB * 0.25;
-      }
-      
-      if (textpixels[ind].opacity != MaxRGB)
-      {
-        //textpixels[ind].opacity = MaxRGB * 0.05;
-      }
-    }
-  }
-  
-  shadowimage.syncPixels();
-  textimage.syncPixels();
-  
-  shadowimage.blur(10.0, 20.0);
-  textimage.blur(0.0, 0.5);
-}
-
-static int open_codec_context(int *stream_idx, AVFormatContext *fmt_ctx, enum AVMediaType type)
-{
-  int ret, stream_index;
-  AVStream *st;
-  AVCodecContext *dec_ctx = NULL;
-  AVCodec *dec = NULL;
-  AVDictionary *opts = NULL;
-  ret = av_find_best_stream(fmt_ctx, type, -1, -1, NULL, 0);
-  if (ret < 0)
-  {
-    //fprintf(stderr, "Could not find %s stream in input file '%s'\n", av_get_media_type_string(type), src_filename);
-    return ret;
-  } else {
-    stream_index = ret;
-    st = fmt_ctx->streams[stream_index];
-    
-    // find decoder for the stream
-    dec_ctx = st->codec;
-    dec = avcodec_find_decoder(dec_ctx->codec_id);
-    if (!dec)
-    {
-      fprintf(stderr, "Failed to find %s codec\n", av_get_media_type_string(type));
-      return AVERROR(EINVAL);
-    }
-    
-    // Init the decoders, with or without reference counting
-    av_dict_set(&opts, "refcounted_frames", "0", 0);
-    if ((ret = avcodec_open2(dec_ctx, dec, &opts)) < 0)
-    {
-      fprintf(stderr, "Failed to open %s codec\n", av_get_media_type_string(type));
-      return ret;
-    }
-    
-    *stream_idx = stream_index;
-  }
-  
-  return 0;
-}
-
-int main(int argc, char** argv)
+sap::sap(
+  std::string configFile,
+  std::mt19937& rng) :
+    rng_(rng)
 {
-  srand(time(NULL));
-  rand(); rand(); rand(); rand();
-  
-  Magick::InitializeMagick(nullptr);
-  av_register_all();
+  // Load the config file.
+  YAML::Node config = YAML::LoadFile(configFile);
 
-  if (argc != 2)
-  {
-    std::cout << "usage: sap [configfile]" << std::endl;
-    return -1;
-  }
-  
-  std::string configfile(argv[1]);
-  YAML::Node config = YAML::LoadFile(configfile);
-  
+  // Set up the Twitter client.
   twitter::auth auth;
   auth.setConsumerKey(config["consumer_key"].as<std::string>());
   auth.setConsumerSecret(config["consumer_secret"].as<std::string>());
   auth.setAccessKey(config["access_key"].as<std::string>());
   auth.setAccessSecret(config["access_secret"].as<std::string>());
-  
-  twitter::client client(auth);
-  
-  // Fonts
-  std::vector<std::string> fonts;
-  {
-    std::string fontdirname = config["fonts"].as<std::string>();
-    DIR* fontdir;
-    struct dirent* ent;
-    if ((fontdir = opendir(fontdirname.c_str())) == nullptr)
-    {
-      std::cout << "Couldn't find fonts." << std::endl;
-      return -2;
-    }
 
-    while ((ent = readdir(fontdir)) != nullptr)
-    {
-      std::string dname(ent->d_name);
-      if ((dname.find(".otf") != std::string::npos) || (dname.find(".ttf") != std::string::npos))
-      {
-        fonts.push_back(fontdirname + "/" + dname);
-      }
-    }
+  client_ = std::unique_ptr<twitter::client>(new twitter::client(auth));
 
-    closedir(fontdir);
-  }
-
-  rawr kgramstats;
+  // Set up the text generator.
   for (const YAML::Node& corpusname : config["corpuses"])
   {
     std::ifstream infile(corpusname.as<std::string>());
@@ -307,164 +41,76 @@ int main(int argc, char** argv)
       {
         line.pop_back();
       }
-      
+
       corpus += line + " ";
     }
-    
-    kgramstats.addCorpus(corpus);
-  }
 
-  kgramstats.compile(5);
-  kgramstats.setMinCorpora(config["corpuses"].size());
-  
-  std::string videodirname = config["videos"].as<std::string>();
-  DIR* videodir;
-  struct dirent* ent;
-  if ((videodir = opendir(videodirname.c_str())) == nullptr)
-  {
-    std::cout << "Couldn't find videos." << std::endl;
-    return -1;
+    kgramstats_.addCorpus(corpus);
   }
 
-  std::vector<std::string> videos;
-  while ((ent = readdir(videodir)) != nullptr)
-  {
-    std::string dname(ent->d_name);
-    if (dname.find(".mp4") != std::string::npos)
-    {
-      videos.push_back(dname);
-    }
-  }
+  kgramstats_.compile(5);
+  kgramstats_.setMinCorpora(config["corpuses"].size());
 
-  closedir(videodir);
-  
+  // Set up the layout designer.
+  layout_ = std::unique_ptr<designer>(
+    new designer(config["fonts"].as<std::string>()));
+
+  // Set up the frame picker.
+  director_ = std::unique_ptr<director>(
+    new director(config["videos"].as<std::string>()));
+}
+
+void sap::run() const
+{
   for (;;)
   {
-    std::string video = videodirname + "/" + videos[rand() % videos.size()];
-    std::cout << "Opening " << video << std::endl;
-  
-    AVFormatContext* format = nullptr;
-    if (avformat_open_input(&format, video.c_str(), nullptr, nullptr))
-    {
-      std::cout << "could not open file" << std::endl;
-      return 1;
-    }
-  
-    if (avformat_find_stream_info(format, nullptr))
-    {
-      std::cout << "could not read stream" << std::endl;
-      return 5;
-    }
-  
-    int video_stream_idx = -1;
-    if (open_codec_context(&video_stream_idx, format, AVMEDIA_TYPE_VIDEO))
-    {
-      std::cout << "could not open codec" << std::endl;
-      return 6;
-    }
-  
-    AVStream* stream = format->streams[video_stream_idx];
-    AVCodecContext* codec = stream->codec;
-    int codecw = codec->width;
-    int codech = codec->height;
+    std::cout << "Generating tweet..." << std::endl;
 
-    int64_t seek = (rand() % format->duration) * codec->time_base.num / codec->time_base.den;
-    std::cout << seek << std::endl;
-    if (av_seek_frame(format, video_stream_idx, seek, 0))
+    try
     {
-      std::cout << "could not seek" << std::endl;
-      return 4;
-    }
-  
-    AVPacket packet;
-    av_init_packet(&packet);
-  
-    AVFrame* frame = av_frame_alloc();
-    AVFrame* converted = av_frame_alloc();
-  
-    int buffer_size = av_image_get_buffer_size(AV_PIX_FMT_RGB24, codecw, codech, 1);
-    uint8_t* buffer = new uint8_t[buffer_size];
+      // Pick the video frame.
+      Magick::Image image = director_->generate(rng_);
+
+      // Generate the text.
+      std::uniform_int_distribution<size_t> lenDist(5, 19);
+      std::string action = kgramstats_.randomSentence(lenDist(rng_));
 
-    av_image_alloc(converted->data, converted->linesize, codecw, codech, AV_PIX_FMT_RGB24, 1);
+      // Lay the text on the video frame.
+      Magick::Image textimage =
+        layout_->generate(image.columns(), image.rows(), action, rng_);
+      image.composite(textimage, 0, 0, Magick::OverCompositeOp);
 
-    for (;;)
+      // Send the tweet.
+      std::cout << "Sending tweet..." << std::endl;
+
+      sendTweet(std::move(image));
+
+      std::cout << "Tweeted!" << std::endl;
+
+      // Wait.
+      std::this_thread::sleep_for(std::chrono::hours(1));
+    } catch (const Magick::ErrorImage& ex)
     {
-      if (av_read_frame(format, &packet))
-      {
-        std::cout << "could not read frame" << std::endl;
-        return 2;
-      }
-    
-      if (packet.stream_index != video_stream_idx)
-      {
-        continue;
-      }
-    
-      int got_pic;
-      if (avcodec_decode_video2(codec, frame, &got_pic, &packet) < 0)
-      {
-        std::cout << "could not decode frame" << std::endl;
-        return 7;
-      }
-  
-      if (!got_pic)
-      {
-        continue;
-      }
-    
-      if (packet.flags && AV_PKT_FLAG_KEY)
-      {
-        SwsContext* sws = sws_getContext(codecw, codech, codec->pix_fmt, codecw, codech, AV_PIX_FMT_RGB24, 0, nullptr, nullptr, 0);
-        sws_scale(sws, frame->data, frame->linesize, 0, codech, converted->data, converted->linesize);
-        sws_freeContext(sws);
-      
-        av_image_copy_to_buffer(buffer, buffer_size, converted->data, converted->linesize, AV_PIX_FMT_RGB24, codecw, codech, 1);
-        av_frame_free(&frame);
-        av_frame_free(&converted);
-        av_packet_unref(&packet);
-        avcodec_close(codec);
-        avformat_close_input(&format);
-      
-        int width = 1024;
-        int height = codech * width / codecw;
-      
-        Magick::Image image;
-        image.read(codecw, codech, "RGB", Magick::CharPixel, buffer);
-        image.zoom(Magick::Geometry(width, height));
-      
-        std::string action = kgramstats.randomSentence(rand() % 15 + 5);
-        Magick::Image textimage(Magick::Geometry(width, height), "transparent");
-        Magick::Image shadowimage(Magick::Geometry(width, height), "transparent");
-        layoutText(textimage, shadowimage, width, height, action, fonts);
-        image.composite(shadowimage, 0, 0, Magick::OverCompositeOp);
-        image.composite(textimage, 0, 0, Magick::OverCompositeOp);
-      
-        image.magick("jpeg");
-        
-        Magick::Blob outputimg;
-        image.write(&outputimg);
-      
-        delete[] buffer;
-        
-        std::cout << "Generated image." << std::endl << "Tweeting..." << std::endl;
-        
-        try
-        {
-          long media_id = client.uploadMedia("image/jpeg", (const char*) outputimg.data(), outputimg.length());
-          client.updateStatus("", {media_id});
-    
-          std::cout << "Done!" << std::endl << "Waiting..." << std::endl << std::endl;
-        } catch (const twitter::twitter_error& error)
-        {
-          std::cout << "Twitter error: " << error.what() << std::endl;
-        }
-      
-        break;
-      }
+      std::cout << "Image error: " << ex.what() << std::endl;
+    } catch (const twitter::twitter_error& ex)
+    {
+      std::cout << "Twitter error: " << ex.what() << std::endl;
+
+      std::this_thread::sleep_for(std::chrono::hours(1));
     }
-    
-    std::this_thread::sleep_for(std::chrono::hours(1));
+
+    std::cout << std::endl;
   }
-  
-  return 0;
+}
+
+void sap::sendTweet(Magick::Image image) const
+{
+  Magick::Blob outputimg;
+  image.magick("jpeg");
+  image.write(&outputimg);
+
+  long media_id = client_->uploadMedia("image/jpeg",
+    static_cast<const char*>(outputimg.data()), outputimg.length());
+
+  client_->updateStatus("", {media_id});
 }
@@ -0,0 +1,34 @@
+#ifndef SAP_H_11D8D668
+#define SAP_H_11D8D668
+
+#include <random>
+#include <string>
+#include <memory>
+#include <Magick++.h>
+#include <twitter.h>
+#include <rawr.h>
+#include "designer.h"
+#include "director.h"
+
+class sap {
+public:
+
+  sap(
+    std::string configFile,
+    std::mt19937& rng);
+
+  void run() const;
+
+private:
+
+  void sendTweet(Magick::Image image) const;
+
+  std::mt19937& rng_;
+  std::unique_ptr<twitter::client> client_;
+  rawr kgramstats_;
+  std::unique_ptr<designer> layout_;
+  std::unique_ptr<director> director_;
+
+};
+
+#endif /* end of include guard: SAP_H_11D8D668 */
@@ -0,0 +1,60 @@
+#ifndef UTIL_H_1F6A84F6
+#define UTIL_H_1F6A84F6
+
+#include <string>
+#include <sstream>
+#include <iterator>
+
+template <class InputIterator>
+std::string implode(
+  InputIterator first,
+  InputIterator last,
+  std::string delimiter)
+{
+  std::stringstream result;
+
+  for (InputIterator it = first; it != last; it++)
+  {
+    if (it != first)
+    {
+      result << delimiter;
+    }
+
+    result << *it;
+  }
+
+  return result.str();
+}
+
+template <class OutputIterator>
+void split(std::string input, std::string delimiter, OutputIterator out)
+{
+  while (!input.empty())
+  {
+    int divider = input.find(delimiter);
+    if (divider == std::string::npos)
+    {
+      *out = input;
+      out++;
+
+      input = "";
+    } else {
+      *out = input.substr(0, divider);
+      out++;
+
+      input = input.substr(divider+delimiter.length());
+    }
+  }
+}
+
+template <class Container>
+Container split(std::string input, std::string delimiter)
+{
+  Container result;
+
+  split(input, delimiter, std::back_inserter(result));
+
+  return result;
+}
+
+#endif /* end of include guard: UTIL_H_1F6A84F6 */
-Subproject ba25493b55b4e4e35de3fca69afd15ddcbaa545
+Subproject 247ee4de24eab5ecd030542724db9f69aaa1ed1