castaway 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a112c82c587c36cded9e5a12357b32afccda2b23
+  data.tar.gz: 9d309a240a441890b9cd8fc21d7385d96c28de67
+SHA512:
+  metadata.gz: d8c360c1446343694d4ad4cf7b869dd60f338759d81e2d5101d4bae9ba7eebf393b83b4afc48565c7839d0a6341a7a15bf59f31660074ef02b8adc99ce7347b2
+  data.tar.gz: 6ee19bbf94daa6a12d7155c4219be4e96bb84d613df584d5c9d567b73a40153b05999beebec6c48db58a819bc2667d463c1f470493be786e122a9988b1d8b45c

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Jamis Buck
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,123 @@
+# Castaway
+
+Want to create an online presentation or screencast, but are frustrated by
+complicated interfaces or expensive tools? Maybe you're using one that _almost_
+does what you need, but that one feature it's missing is a deal-breaker?
+
+_Castaway_ to the rescue! Write your scripts, mix your audio, and render your
+video, all via a simple-yet-powerful DSL.
+
+Want to re-render your video with a different resolution or frame rate? No
+problem--just run the script with different parameters.
+
+Is that arrow pointing at the wrong point, or does that animation start at the
+wrong time? Easy-peasy. Change the position or timing in your script, and rerun
+it.
+
+Screen-casting just got a whole lot easier.
+
+
+## Installation
+
+Castaway depends on a few external tools to do the heavy lifting. You'll need to
+make sure you have the following tools installed:
+
+* [ImageMagick](https://www.imagemagick.org/script/binary-releases.php) is used
+  to render video frames and special effects. _(Tested with version 6.9.5)_
+* [Sox](https://sourceforge.net/projects/sox/files/sox/) is used to edit and mix
+  audio. _(Tested with version 14.4.2)_
+* [FFmpeg](https://ffmpeg.org/download.html) is used to combine the frames and
+  audio into a single video file. _(Tested with version 3.2.2)_
+
+Once you've met those requirements, installing Castaway itself is simple:
+
+    $ gem install castaway
+
+And you're good to go!
+
+
+## Usage
+
+_Watch a four-minute introduction to Castaway--created with Castaway!--on YouTube, here: [https://www.youtube.com/watch?v=F5ShAdLvVIk](https://www.youtube.com/watch?v=F5ShAdLvVIk) ._
+
+Scripts are written in a DSL in Ruby. You declare scenes and sound clips,
+and describe what comprises those scenes and sound clips. Here's a simple
+example:
+
+```ruby
+soundclip :theme, resource('music.wav')
+
+soundtrack do |clip|
+  clip.in soundclip(:theme)
+  # fade in the theme music
+  clip.chain.fade(5, type: :linear)
+end
+
+scene 'Title Screen' do
+  start '0:00'
+  script 'Hello, and welcome to our new screencast!'
+
+  plan do
+    # start with a black screen
+    matte(:black).
+      exit(1)
+
+    # dissolve-in our title screen
+    still('title.png').
+      enter(0.5).
+      in(:dissolve, speed: 0.5)
+  end
+end
+
+finish '0:10'
+```
+
+This declares a sound track that fades in over five seconds, as well as a
+single scene that displays a still frame, dissolved in at the 0.5 second mark.
+The whole finishes at the ten second mark. If this were saved as `script.rb`,
+you could generate the video like so:
+
+    $ castaway build script.rb
+
+This will generate the frames, mix the audio, and compose the whole together
+into a video called `script.mp4` (it uses the name of the script file as the
+default for naming the video).
+
+To name it something else:
+
+    $ castaway build -o movie.mp4 script.rb
+
+By default, the video will be rendered at 540p (960x540 pixels). Change this
+with the `--resolution` parameter:
+
+    $ castaway build --resolution 1080p script.rb
+
+You can specify either HD-style resolutions (1080p, 540p, etc.) or WIDTHxHEIGHT
+resolutions (e.g. 960x540).
+
+Also by default, video will be rendered at NTSC-standard 29.97 frames/second.
+To change the number of frames per second, use the `--fps` parameter:
+
+    $ castaway build --fps 10 script.rb
+
+This can be useful for previewing a build quickly, before building the final
+movie.
+
+
+## Caveats
+
+This is a work in progress, and will probably not do everything you need just
+yet. Documentation and examples are severely lacking.
+
+But stay tuned!
+
+
+## Author
+
+Castaway was written by Jamis Buck (jamis@jamisbuck.org).
+
+
+## License
+
+Castaway is distributed under the MIT license. (See the `MIT-LICENSE` file for
+details).

data/bin/castaway

@@ -0,0 +1,5 @@
+#!/bin/sh ruby
+
+require 'castaway/cli/main'
+
+Castaway::CLI::Main.run(ARGV)

data/lib/castaway.rb

@@ -0,0 +1 @@
+require 'castaway/production'

data/lib/castaway/animation.rb

@@ -0,0 +1,37 @@
+require 'castaway/interpolation'
+
+module Castaway
+
+  class Animation
+    attr_reader :from, :to, :duration
+
+    def self.from_options(options)
+      factory = Castaway::Interpolation.lookup(options)
+      initial = options[:initial] || 0.0
+      final = options[:final] || (initial + 1.0)
+      interpolator = factory.new(initial, final)
+
+      from  = options[:from] ||
+              raise(ArgumentError, 'animations require `from` time')
+      to    = options[:to] ||
+              (options[:length] ? from + options[:length] : nil) ||
+              raise(ArgumentError, 'animations require `to` or `length`')
+
+      new(interpolator, from, to)
+    end
+
+    def initialize(interpolator, from, to)
+      @interpolator = interpolator
+      @from = from.to_f
+      @to = to.to_f
+      @duration = @to - @from
+    end
+
+    def [](t)
+      # adjust t to 0..1
+      adjusted_t = duration.zero? ? 1.0 : (t - from) / duration.to_f
+      @interpolator[adjusted_t]
+    end
+  end
+
+end

data/lib/castaway/box.rb

@@ -0,0 +1,77 @@
+require 'castaway/point'
+
+module Castaway
+  class Box
+    def self.from_size(size)
+      new(
+        Point.new(0, 0),
+        Point.new(size.width - 1, 0),
+        Point.new(size.width - 1, size.height - 1),
+        Point.new(0, size.height - 1))
+    end
+
+    def initialize(a, b, c, d, other = {})
+      @a = a
+      @b = b
+      @c = c
+      @d = d
+      @other_points = other.dup
+    end
+
+    def []=(id, point_of_interest)
+      @other_points[id] = point_of_interest
+      self
+    end
+
+    def [](id)
+      @other_points[id]
+    end
+
+    def scale(factor)
+      a = @a * factor
+      b = @b * factor
+      c = @c * factor
+      d = @d * factor
+
+      others = @other_points.each_with_object({}) do |(k, v), h|
+        h[k] = v * factor
+      end
+
+      Box.new(a, b, c, d, others)
+    end
+
+    def rotate(degrees)
+      rads = degrees * Math::PI / 180.0
+
+      a = @a.rotate(rads)
+      b = @b.rotate(rads)
+      c = @c.rotate(rads)
+      d = @d.rotate(rads)
+
+      others = @other_points.each_with_object({}) do |(k, v), h|
+        h[k] = v.rotate(rads)
+      end
+
+      Box.new(a, b, c, d, others)
+    end
+
+    def bounds
+      x1, x2 = [ @a.x, @b.x, @c.x, @d.x ].minmax
+      y1, y2 = [ @a.y, @b.y, @c.y, @d.y ].minmax
+
+      # translate to origin
+      x2 -= x1
+      y2 -= y1
+      others = @other_points.each_with_object({}) do |(k, v), h|
+        h[k] = v.translate(-x1, -y1)
+      end
+
+      Box.new(Point.new(0, 0), Point.new(x2, 0),
+              Point.new(x2, y2), Point.new(0, y2), others)
+    end
+
+    def to_s
+      "#{@a}-#{@b}-#{@c}-#{@d}"
+    end
+  end
+end

data/lib/castaway/cli/build.rb

@@ -0,0 +1,83 @@
+require 'castaway/production'
+require 'castaway/range'
+
+module Castaway
+  module CLI
+    class Build
+      extend GLI::App
+
+      def self.description
+        'Builds the given castaway production'
+      end
+
+      def self.define(command)
+        command.desc 'The resolution at which to generate the frames'
+        command.flag %i(r resolution), default_value: '540p'
+
+        command.desc 'How many frames per second to generate'
+        command.flag %i(f fps), default_value: 29.97, type: Float
+
+        command.desc 'The frame from which to start producing frames'
+        command.flag %i(start-frame), default_value: 0, type: Integer
+
+        command.desc 'The frame after which to stop producing frames'
+        command.flag %i(end-frame), type: Integer
+
+        command.desc 'The scene from which to start producing frames'
+        command.flag %i(start-scene)
+
+        command.desc 'The scene after which to stop producing frames'
+        command.flag %i(end-scene)
+
+        command.desc 'The time from which to start producing frames'
+        command.flag %i(start-time)
+
+        command.desc 'The time after which to stop producing frames'
+        command.flag %i(end-time)
+
+        command.desc 'What to call the resulting movie'
+        command.flag %i(o output)
+
+        command.action do |_globals, options, args|
+          exit_now!('you have to supply a castaway program') if args.empty?
+
+          definition = Castaway::Production.from_script(args.first)
+          new(definition, args.first, options)
+        end
+      end
+
+      def initialize(definition, name, options)
+        deliverable = File.basename(name, File.extname(name)) + '.mp4'
+
+        production = definition.new(
+          resolution: options[:resolution],
+          fps: options[:fps],
+          deliverable: options[:output] || deliverable)
+
+        range = Castaway::Range.new(production)
+
+        if options['start-time']
+          range.start_time = options['start-time']
+        elsif options['start-scene']
+          range.start_scene = options['start-scene']
+        elsif options['start-frame']
+          range.start_frame = options['start-frame']
+        end
+
+        if options['end-time']
+          range.end_time = options['end-time']
+        elsif options['end-scene']
+          range.end_scene = options['end-scene']
+        elsif options['end-frame']
+          range.end_frame = options['end-frame']
+        end
+
+        production.produce(range)
+      rescue Exception => e
+        puts "#{e.class} (#{e.message})"
+        puts e.backtrace
+        abort
+      end
+    end
+  end
+end

data/lib/castaway/cli/main.rb

@@ -0,0 +1,24 @@
+require 'gli'
+require 'castaway'
+require 'castaway/cli/build'
+require 'castaway/cli/script'
+require 'castaway/cli/version'
+
+module Castaway
+  module CLI
+    class Main
+      extend GLI::App
+
+      program_desc 'Build screencasts from a script'
+
+      desc Castaway::CLI::Script.description
+      command(:build) { |c| Castaway::CLI::Build.define(c) }
+
+      desc Castaway::CLI::Script.description
+      command(:script) { |c| Castaway::CLI::Script.define(c) }
+
+      desc Castaway::CLI::Version.description
+      command(:version) { |c| Castaway::CLI::Version.define(c) }
+    end
+  end
+end

data/lib/castaway/cli/script.rb

@@ -0,0 +1,28 @@
+require 'castaway/production'
+
+module Castaway
+  module CLI
+    class Script
+      extend GLI::App
+
+      def self.description
+        'Display the given program as a script'
+      end
+
+      def self.define(command)
+        command.action do |_globals, _options, args|
+          exit_now!('you have to supply a castaway program') if args.empty?
+
+          production = Castaway::Production.from_script(args.first)
+
+          production.new.scenes.each.with_index do |scene, idx|
+            mark = scene.start || "##{idx}"
+            puts "[#{mark}] #{scene.title}"
+            puts scene.script if scene.script
+            puts
+          end
+        end
+      end
+    end
+  end
+end

data/lib/castaway/cli/version.rb

@@ -0,0 +1,17 @@
+require 'castaway/version'
+
+module Castaway
+  module CLI
+    class Version
+      def self.description
+        "Report the current version (#{Castaway::VERSION})"
+      end
+
+      def self.define(command)
+        command.action do |_globals, _options, _args|
+          puts "v#{Castaway::VERSION}"
+        end
+      end
+    end
+  end
+end

data/lib/castaway/effect.rb

@@ -0,0 +1,59 @@
+module Castaway
+  module Effect
+
+    @effects = {}
+    def self.register(name, &implementation)
+      @effects[name] = implementation
+    end
+
+    def self.invoke(name, element, options)
+      @effects.fetch(name).call(element, options)
+    end
+
+    register :dissolve_in do |element, options|
+      element.animate(:alpha,
+                      from: 0.0, to: options[:speed],
+                      initial: 0.0, final: 1.0)
+    end
+
+    register :dissolve_out do |element, options|
+      element.animate(:alpha,
+                      from: element.tail(options[:speed]), to: element.tail,
+                      initial: 1.0, final: 0.0)
+    end
+
+    register :pan do |element, options|
+      dx = case options[:horizontal]
+           when nil then 0
+           when true, 1, :right then
+             element.production.resolution.width - element.size.width
+           when false, -1, :left then
+             element.size.width - element.production.resolution.width
+           else
+             raise ArgumentError,
+                   "unsupported horizontal: #{options[:horizontal].inspect}"
+           end
+
+      dy = case options[:vertical]
+           when nil then 0
+           when true, 1, :down then
+             element.production.resolution.height - element.size.height
+           when false, -1, :up then
+             element.size.height - element.production.resolution.height
+           else
+             raise ArgumentError,
+                   "unsupported vertical: #{options[:vertical].inspect}"
+           end
+
+      type = options[:type] || :linear
+      from = options[:from] || 0.0
+      to   = options[:to]   || element.duration
+
+      p0 = Castaway::Point.new(0, 0)
+      p1 = Castaway::Point.new(dx, dy)
+
+      element.animate(:position, type: type, from: from, to: to,
+                                 initial: p0, final: p1)
+    end
+  end
+end