castaway 1.0.0

data/lib/castaway/interpolation/linear.rb

@@ -0,0 +1,26 @@
+module Castaway
+  module Interpolation
+
+    # A linear interpolation between two values
+    class Linear
+      attr_reader :start, :finish
+
+      def initialize(start, finish)
+        @start = start
+        @finish = finish
+        @delta = finish - start
+      end
+
+      def [](t)
+        if t < 0
+          @start
+        elsif t > 1
+          @finish
+        else
+          @delta * t + @start
+        end
+      end
+    end
+
+  end
+end

data/lib/castaway/point.rb

@@ -0,0 +1,63 @@
+module Castaway
+
+  class Point < Struct.new(:x, :y)
+    def self.make(*args)
+      if args.length == 1 && args[0].is_a?(Array)
+        new(args[0][0], args[0][1])
+      elsif args.length == 1 && args[0].is_a?(Point)
+        args[0]
+      else
+        raise ArgumentError, "can't make a point from #{args.inspect}"
+      end
+    end
+
+    def *(factor)
+      if factor.respond_to?(:x)
+        Point.new(x * factor.x, y * factor.y)
+      elsif factor.respond_to?(:width)
+        Point.new(x * factor.width, y * factor.height)
+      else
+        Point.new(x * factor, y * factor)
+      end
+    end
+
+    def -(pt)
+      Point.new(x - pt.x, y - pt.y)
+    end
+
+    def +(pt)
+      Point.new(x + pt.x, y + pt.y)
+    end
+
+    def zero?
+      x == 0 && y == 0
+    end
+
+    def translate(dx, dy)
+      Point.new(x + dx, y + dy)
+    end
+
+    def scale(sx, sy = sx)
+      Point.new(x * sx, y * sy)
+    end
+
+    def rotate(radians)
+      cos = Math.cos(radians)
+      sin = Math.sin(radians)
+
+      nx = x * cos - y * sin
+      ny = y * cos + x * sin
+
+      Point.new(nx, ny)
+    end
+
+    def to_s
+      format('(%.2f, %.2f)', x, y)
+    end
+
+    def to_geometry
+      format('+%.2f+%.2f', x, y)
+    end
+  end
+
+end

data/lib/castaway/production.rb

@@ -0,0 +1,124 @@
+require 'fileutils'
+require 'castaway/range'
+require 'castaway/size'
+require 'castaway/timeline'
+require 'ruby-progressbar'
+
+require 'castaway/production/class_methods'
+require 'castaway/production/audio'
+require 'castaway/production/scenes'
+
+module Castaway
+  class Production
+    extend Castaway::Production::ClassMethods
+    include Castaway::Production::Audio
+    include Castaway::Production::Scenes
+
+    attr_reader :options
+    attr_reader :current_scene, :scenes
+    attr_reader :resolution, :fps
+
+    def initialize(options = {})
+      @options = options
+      @resolution = _translate_resolution(options[:resolution] || '480p')
+      @deliverable = options[:deliverable]
+      @fps = options[:fps] || 30
+
+      _build_scenes
+    end
+
+    def produce(range = Castaway::Range.new(self))
+      FileUtils.mkdir_p(self.class.output_path)
+
+      timeline = _construct_timeline
+      _produce_frames(timeline, range)
+      soundtrack = _produce_soundtrack(range)
+      _produce_movie(soundtrack)
+    end
+
+    def deliverable
+      @deliverable ||= begin
+        if self.class.name
+          self.class.name.split(/::/).last.
+            gsub(/([^A-Z]+)([A-Z]+)/) { "#{$1}-#{$2.downcase}" }.
+            gsub(/([^0-9]+)([0-9]+)/) { "#{$1}-#{$2}" }.
+            downcase + '.mp4'
+        else
+          'production.mp4'
+        end
+      end
+    end
+
+    def _construct_timeline
+      Castaway::Timeline.new(resolution, fps).tap do |timeline|
+        @scenes.each { |scene| scene.construct(timeline) }
+      end
+    end
+
+    def _template(ext = nil)
+      File.join(self.class.output_path, format('frame-%s%s', '%05d', ext))
+    end
+
+    def _produce_frames(timeline, range)
+      template = _template
+
+      start_frame = range.start_frame
+      end_frame   = range.end_frame
+
+      progress_end = end_frame - start_frame + 1
+      progress = ProgressBar.create(starting_at: 0, total: progress_end)
+
+      start_frame.upto(end_frame) do |f|
+        timeline.render_frame(f, name: format(template, f - start_frame))
+        progress.increment
+      end
+    end
+
+    def _produce_movie(soundtrack)
+      FileUtils.rm_f(deliverable)
+
+      ffmpeg = Chaussettes::Tool.new('ffmpeg')
+      ffmpeg << '-thread_queue_size' << 8192
+      ffmpeg << '-r' << fps << '-s' << resolution.to_resolution
+      ffmpeg << '-i' << _template('.png') << '-i' << soundtrack
+      ffmpeg << '-vcodec' << 'libx264'
+      ffmpeg << '-preset' << 'veryslow' << '-tune' << 'stillimage'
+      ffmpeg << '-crf' << 23 << '-pix_fmt' << 'yuv420p' << '-acodec' << 'aac'
+      ffmpeg << deliverable
+
+      puts ffmpeg.to_s
+      system(ffmpeg.to_s)
+    end
+
+    def _construct_scene(scene, definition)
+      instance_exec(scene, &definition)
+    ensure
+      @current_scene = nil
+    end
+
+    def _translate_resolution(res)
+      case res
+      when Castaway::Size then res
+      when Array then Castaway::Size.new(res.first.to_i, res.last.to_i)
+      when /^(\d+)p$/ then _hd_resolution(Regexp.last_match(1))
+      when Integer then _hd_resolution(res)
+      when /^(\d+)x(\d+)$/ then
+        Castaway::Size.new(Regexp.last_match(1).to_i, Regexp.last_match(2).to_i)
+      else raise ArgumentError,
+                 "don't know how to turn #{res.inspect} into resolution"
+      end
+    end
+
+    def _hd_resolution(rows)
+      rows = rows.to_i
+      cols = rows * 16 / 9.0
+      Castaway::Size.new(cols.ceil, rows)
+    end
+
+    def _next_filename(ext = nil)
+      @next_filename ||= 0
+      File.join(self.class.output_path,
+                format('__%04d%s', @next_filename += 1, ext))
+    end
+  end
+end

data/lib/castaway/production/audio.rb

@@ -0,0 +1,161 @@
+require 'chaussettes'
+
+module Castaway
+  class Production
+    module Audio
+
+      # Returns the filename associated with the soundclip with the given id.
+      # If the soundclip was declared with a block, the block will be evaluated
+      # with a new `Chaussettes::Clip` instance, and the a temporary filename
+      # containing the resulting audio will be returned,
+      def soundclip(id)
+        @soundclips ||= {}
+        @soundclips[id] ||= begin
+          definition = self.class.soundclip(id)
+          raise "no soundclip #{id.inspect}" unless definition
+
+          case definition
+          when String then
+            definition
+          when Proc then
+            _next_filename('.aiff').tap do |filename|
+              Chaussettes::Clip.new do |clip|
+                instance_exec(clip, &definition)
+                clip.out(filename)
+                clip.run
+              end
+            end
+          else
+            raise ArgumentError, "can't use #{definition.inspect} as soundclip"
+          end
+        end
+      end
+
+      # Ducks the `basis` audio beneath the given `overlays`. Each overlay
+      # should be a hash containing at least a `:clip` key, corresponding to
+      # a filename to be used for the overlay clip. Additional keys are:
+      #
+      # * `:at` (default 0, where in `basis` the overlay should be applied)
+      # * `:adjust` (default 0.5, how much the basis audio should be reduced)
+      # * `:speed` (default 0.5, how many seconds the fade in/out should take)
+      #
+      # Returns a new filename representing the results of the duck operation.
+      def duck(basis, *overlays)
+        _next_filename('.aiff').tap do |result|
+          Chaussettes::Clip.new do |clip|
+            clip.mix.out result
+
+            count = overlays.reduce(0) do |total, options|
+              total + _duck(clip, basis, options)
+            end
+
+            # restore volume
+            clip.chain.vol count
+
+            clip.run
+          end
+        end
+      end
+
+      def _duck(clip, basis, options)
+        adjust = options[:adjust] || 0.5
+        speed = options[:speed] || 0.5
+
+        state = {
+          input: basis, overtrack: options[:clip],
+          at: options[:at] || 0,
+          adjust: adjust, speed: speed,
+          info: Chaussettes::Info.new(options[:clip]),
+          right_delay: adjust * speed, left_delay: (1 - adjust) * speed
+        }
+
+        count =  _build_intro(clip, state)
+        count += _build_middle(clip, state)
+        count += _build_last(clip, state)
+        count +  _build_overlay(clip, state)
+      end
+
+      def _build_intro(clip, state)
+        Chaussettes::Clip.new do |c|
+          c.in(state[:input])
+          c.out(device: :stdout).type(:aiff).rate(48_000).channels(2)
+          c.chain.fade(0, state[:at] + state[:right_delay],
+                       state[:speed], type: :linear)
+
+          clip.in(c).type :aiff
+        end
+
+        1
+      end
+
+      def _build_middle(clip, state)
+        Chaussettes::Clip.new do |c|
+          c.in(state[:input])
+          c.out(device: :stdout).type(:aiff).rate(48_000).channels(2)
+          c.chain.
+            trim(state[:at], state[:info].duration).
+            vol(state[:adjust]).
+            pad(state[:at])
+
+          clip.in(c).type :aiff
+        end
+
+        1
+      end
+
+      def _build_last(clip, state)
+        return 0 unless state[:at] + state[:info].duration < duration
+
+        Chaussettes::Clip.new do |c|
+          c.in(state[:input])
+          c.out(device: :stdout).type(:aiff).rate(48_000).channels(2)
+          c.chain.trim(state[:at] + state[:info].duration - state[:left_delay]).
+            fade(state[:speed], type: :linear).
+            pad(state[:at] + state[:info].duration - state[:left_delay])
+
+          clip.in(c).type :aiff
+        end
+
+        1
+      end
+
+      def _build_overlay(clip, state)
+        Chaussettes::Clip.new do |c|
+          c.in(state[:overtrack])
+          c.out(device: :stdout).type(:aiff).rate(48_000).channels(2)
+          c.chain.pad(state[:at])
+
+          clip.in(c).type :aiff
+        end
+
+        1
+      end
+
+      def _produce_soundtrack(range)
+        block = self.class.soundtrack
+        return nil unless block
+
+        _next_filename('.aiff').tap do |filename|
+          real_filename = filename
+          filename = range.truncated? ? _next_filename('.aiff') : real_filename
+
+          Chaussettes::Clip.new do |clip|
+            instance_exec(clip, &block)
+            clip.out(filename)
+            clip.run
+          end
+
+          if range.truncated?
+            Chaussettes::Clip.new do |clip|
+              clip.in(filename)
+              clip.chain.trim range.start_time, range.end_time - range.start_time
+              clip.out(real_filename)
+              clip.run
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/castaway/production/class_methods.rb

@@ -0,0 +1,148 @@
+require 'castaway/times'
+
+module Castaway
+  class Production
+    module ClassMethods
+      include Castaway::Times
+
+      # Returns an Array of Castaway::Scene objects corresponding to the
+      # scenes that have been defined.
+      def scenes
+        @scenes ||= []
+      end
+
+      # Returns a Hash, mapping ids to either direct values (path names), or
+      # blocks (which are intended to configure a soundclip).
+      def soundclips
+        @soundclips ||= {}
+      end
+
+      # Declare a new soundclip with the given `id`. If a `value` is given, it
+      # is expected to be a path to a sound file. For example:
+      #
+      #     soundclip :narration, resource('narration.mp3')
+      #
+      # If a block is given, it is expected to accept a single parameter
+      # (a Chaussettes::Clip instance), and configure the soundclip on that
+      # instance.
+      #
+      #     soundclip :theme do |clip|
+      #       clip.in resource('theme.mp3')
+      #       clip.chain.
+      #         trim(0, 15).     # grab the first 15s of the clip
+      #         fade(0.5, 0, 5)  # fade in 0.5s, and then out 5s at the end
+      #     end
+      def soundclip(id, value = nil, &block)
+        if value.nil? && !block
+          soundclips[id]
+        else
+          soundclips[id] = value || block
+        end
+      end
+
+      # Declare the soundtrack for the production. Every production may have
+      # zero or one soundtracks. The block you provide here should accept a
+      # single parameter--a `Chausettes::Clip` instance--which must be populated
+      # with the desired audio for the production.
+      #
+      #     soundtrack do |clip|
+      #       clip.in(
+      #         duck(soundclip(:theme),
+      #              clip: soundclip[:narration], at: 3)
+      #       )
+      #     end
+      def soundtrack(&block)
+        if block
+          @soundtrack = block
+        else
+          @soundtrack
+        end
+      end
+
+      # Returns a list of paths that will be searched for resources. By
+      # default, the searched paths are 'sounds' and 'images'. See the
+      # #resource method for how to add paths to this list.
+      def resource_paths
+        @resource_paths ||= %w( sounds images )
+      end
+
+      # Returns the output path to be used for generated files, like frames and
+      # intermediate audio. It defaults to 'build'. See the #output method for
+      # how to set this value.
+      def output_path
+        @output_path ||= 'build'
+      end
+
+      # Adds the given path to the list of paths that will be searched by
+      # Castaway for resources. (See #resource_paths)
+      def resource_path(path)
+        resource_paths << path
+      end
+
+      # Looks for a file with the given name in the defined resource paths
+      # (see #resource_paths). Returns the path to the file if it is found in
+      # one of the paths, otherwise raises `Errno::ENOENT`.
+      def resource(name)
+        resource_paths.each do |path|
+          full = File.join(path, name)
+          return full if File.exist?(full)
+        end
+
+        raise Errno::ENOENT, "no such resource #{name} found"
+      end
+
+      # Declares the directory to be used for storing intermediate media, like
+      # frames and audio. (See #output_path)
+      def output(path)
+        @output_path = path
+      end
+
+      # Declares a new scene with the given name. Although it is not required
+      # that all scenes have unique names, it is recommended. The given block
+      # is invoked, without arguments, when the scene is constructed. (See
+      # Castaway::Scene)
+      def scene(name, &block)
+        scenes << [name, block]
+      end
+
+      # Declares the end-time of the production. If this is not set, your final
+      # scene will likely be truncated.
+      def finish(finish)
+        scene(nil) { start finish }
+      end
+
+      # Parses the given value into a float representing a number of seconds.
+      # See Castaway::Times.
+      def time(value)
+        _parse_time(value)
+      end
+
+      # Declares a pointer using the image at the given `path`. If an `:id`
+      # option is given, it will be used to identify the pointer. Otherwise,
+      # it will use the default identifier. See Castaway::Scene.
+      def pointer(path, options = {})
+        id = options[:id] || :default
+        pointers[id] = [path, options]
+      end
+
+      # Returns a Hash of pointer declarations, mapping ids to path/option
+      # data.
+      def pointers
+        @pointers ||= {}
+      end
+
+      # Treats the given `file` as a Castaway script, and evaluates it in the
+      # context of a new, anonymous subclass of Castaway::Production. This new
+      # subclass is returned.
+      def from_script(file)
+        Class.new(self) do
+          class_eval File.read(file), file
+        end
+      rescue Exception => e
+        puts "#{e.class} (#{e.message})"
+        puts e.backtrace
+        abort
+      end
+    end
+  end
+end