abrizer 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56c129ae5143fedefa8b41cd5c98ccf2a370bf72
-  data.tar.gz: 6162f79282a5576b77bdc9b74cf6c7ff0c74044b
+  metadata.gz: 4d43d0ec149f4116eeb8410a53dcc50841194a3b
+  data.tar.gz: ecaa1720869d608df837186fc7edbc5975fa212d
 SHA512:
-  metadata.gz: a14b4b77761e7f0cd2de95264f2232856cb3da83c431be859b602567491762baeda3eae4855bfd66094be2f9dd5091cee548accaa08f9f800d504c89415bd439
-  data.tar.gz: 0c36ba67ab3d170df18fe87b748f6de4bf96e930fe97b6beef316bfd50ca0c14bdc10610e92900808faedcc7050dd3fbd92a0891fe46035542e21ad965ac3c12
+  metadata.gz: 66f82d54378336839f9864e9d2fc2ca1de68c6a976b522837a4e7f7f1a370d7f9cfcdcf9715b8618a938297ac4c38ab1abc999b225b97a2bd0e727760f6bb5ca
+  data.tar.gz: fc6fd76b62a2cb8f1a5e59dddbd6aaf332847e9eee452d73593503477f9fdc0bbe8d54b70f08152ca42fa1ad929a2db2e7aadb97499eb4d04a980453f240a14d

data/README.md

@@ -28,44 +28,58 @@ Or install it yourself as:
 
 See [Vagrant](#vagrant) below for one way to install dependencies and run the scripts.
 
+## Versioning
+
+API may change in breaking ways in minor versions until version 1.0.0 when breaking changes will update the major version number.
+
 ## Usage
 
-Abrizer knows how to run various processes which can take a master or mezzanine video and create DASH and HLS streaming formats along with other derivatives like a fallback MP4 and WebM. The gem is opinionated about what formats to create and what settings to use. The intention is to provide a relatively complete but simple solution for delivering video over HTTP.
+Abrizer knows how to run various processes which can take a master or mezzanine video and create various access derivative formats including DASH and HLS streaming formats as well as fallback MP4 and WebM (VP9). The gem is opinionated about what formats to create and what settings to use. The intention is to provide a relatively complete but simple solution for delivering video over HTTP for HTML5 video.
+
+Some steps must be run after others as they have preconditions in order for subsequent steps to run. You can see the latest full set of processes Abrizer can run by looking in `lib/abrizer/all.rb`. The initial commands before `process` need to run with the mezzanine file as input. The current order is:
 
-Some steps must be run after others as they have preconditions in order for subsequent steps to run. Later cleaning steps will remove intermediate and log files. You can see the latest full set of processes Abrizer can run by looking in `lib/abrizer/cli.rb` for the `abr` method. The current order is:
+- `ffprobe`: Saves the output of ffprobe to `ffprobe.json`. This way the mezzanine file does not have to be present for some later steps.
+- `adaptations`: Saves the precomputed adaptations that will be created in later processes to `adaptations.json`.
+- `captions`: Copies over captions.
+- `vp9`: Process a progressive download WebM VP9 from original. This takes a long time.
+- `mp3`: Create a progressive download MP3 audio file.
+- `sprites`: Create video thumbnail sprites and metadata WebVTT file retaining all the images in order for a human to later pick a poster image.
+  - `poster`: Copies over a temporary poster image from the output of the `sprites` command.
+- `process`: Process the adaptations that will be repackaged into ABR formats. Beyond this point the remaining processes can be run without the mezzanine file present.
+  - `mp4`: Process a progressive download MP4 from next to highest quality adaptation.
+  - `package dash`: Package DASH (and HLS with fMP4) using output of `process`.
+  - `package hls`: Package HLS (TS) using output of `process`.
+- `canvas`:
+- `data`:
+- `clean`: Clean out the intermediate and log files including MP4 files used for packaging but not required for delivery.
 
-- `process`: Process the adaptations that will be repackaged into ABR formats
-- `package dash`: Package DASH (and HLS with fMP4) using output of `process`
-- `package hls`: Package HLS (TS) using output of `process`
-- `mp4`: Process a progressive download MP4 from original
-- `vp9`: Process a progressive download WebM VP9 from original
-- `sprites`: Create video sprites and metadata WebVTT file retaining all the images in order for a human to later pick a poster image
-- `poster`: Copies over a temporary poster image from the output of the sprites
-- `clean`: Clean out the intermediate and log files including MP4 files used for packaging but not required for delivery
+### Media Sharing
 
-All of the above commands require the path to the original video file and an output directory.
+The `canvas` and `data` create files that aid in sharing media. They create `canvas.json` and `data.json` files respectively. You must know the base URL that will be used to serve up the media files. The `canvas.json` is experimental support for the developing [IIIF A/V technical specification](http://iiif.io/community/groups/av/) for canvases. Note that this work is done in advance of a draft standard for including video in a IIIF manifest. The `data.json` file is a simplified version of the information about the available media.
+
+In order to get information about the files being shared these steps either need the presence of the original video file or the presence of the `ffprobe.json` and `adaptations.json` files. In addition these information files are only useful if some media has already been processed. In other words these processes can be run without the presence of the mezzanine file if some preconditions are already met.
 
 ### Command Line
 
 From the command line you can see help with: `abrizer`
 
-To see help for a particular command run: `abrizer help abr`
+To see help for a particular command run: `abrizer help all`
 
 You can run all steps with:
-`abrizer all /path/to/video.mp4 /path/to/output_directory`
+`abrizer all -i /path/to/video.mp4 -o /path/to/output_directory -u http://localhost:8088/v`
 
 Or just create various adaptations needed for repackaging to DASH and HLS:
-`abrizer process /path/to/video.mp4 /path/to/output_directory`
+`abrizer process -i /path/to/video.mp4 -o /path/to/output_directory`
 
 Then once `process` is run it is possible to do packaging to adaptive bitrate formats like DASH:
 
-`abrizer package dash /path/to/video.mp4 /path/to/output_directory`
+`abrizer package dash -o /path/to/output_directory`
 
 The output for DASH will go in the `fmp4` directory as the fragmented MP4 can be used for both DASH (stream.mpd) and the latest HLS on iOS 10+ (master.m3u8).
 
 HLS with MPEG-2 TS files can also be created after `process` is run with the output in the `hls` directory:
 
-`abrizer package hls /path/to/video.mp4 /path/to/output_directory`
+`abrizer package hls -o /path/to/output_directory`
 
 ### Using as a Library
 
@@ -74,18 +88,15 @@ If you simply want to run all the steps, you can use the `Abrizer::All` class li
 ```ruby
 video_path = "/path/to/video.mp4"
 output_directory = "/path/to/output_directory"
-Abrizer::All.new(video_path, output_directory).run
+base_url = "http://localhost:8088/v"
+Abrizer::All.new(video_path, output_directory, base_url).run
 ```
 
 Take a look at `lib/abrizer/all.rb` for how to use the various classes provided. You can also see more examples in `lib/abrizer/cli.rb`. All classes expect to be passed the fully expanded path.
 
-### Canvas
-
-Experimental support is provided for creating a IIIF Canvas. Note that this work is done in advance of a draft standard for including video in a IIIF manifest. It can be created after other steps with `abrizer help canvas` for more information.
-
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests (when there are tests!). You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
@@ -97,7 +108,9 @@ This includes a web server that can be used for local testing of streams and vid
 
 ```shell
 cd /vagrant
-bundle exec exe/abrizer all test/videos/FullHDCinemaCountdown720p-8sec.mp4 tmp/countdown http://localhost:8088/v
+bundle exec exe/abrizer all \
+-i test/videos/FullHDCinemaCountdown720p-8sec.mp4 \
+-o tmp/countdown -u http://localhost:8088/v
 ```
 
 Now visit http://localhost:8088/v/countdown/ to see the files that were created. You can then test any of the videos or streams.

data/lib/abrizer.rb

@@ -2,37 +2,43 @@ require 'yajl'
 require 'multi_json'
 MultiJson.use :yajl
 MultiJson.dump_options = {pretty: true}
+
 require 'jbuilder'
 require 'video_sprites'
 require 'ostruct'
-require "abrizer/version"
-require 'abrizer/filepath_helpers'
-require 'abrizer/read_adaptations'
-require 'abrizer/debug_settings'
-require 'abrizer/identifier_helpers'
-require 'abrizer/information_helpers'
-require 'abrizer/package_dash_shaka'
-require 'abrizer/package_hls_shaka'
-require 'abrizer/package_dash_bento'
-require 'abrizer/package_hls_bento'
-require 'abrizer/adaptation'
-require 'abrizer/adaptation_finder'
-require 'abrizer/adaptations_file'
-require 'abrizer/ffmpeg_processor'
-require 'abrizer/ffprobe_informer'
-require 'abrizer/ffprobe_file'
-require 'abrizer/processor'
-require 'abrizer/cleaner'
-require 'abrizer/progressive_mp4'
-require 'abrizer/progressive_vp9'
-require 'abrizer/progressive_mp3'
-require 'abrizer/sprites'
-require 'abrizer/captions'
-require 'abrizer/canvas'
-require 'abrizer/data'
-require 'abrizer/temporary_poster'
-require 'abrizer/all'
 
+%w[
+  version
+  errors
+  filepath_helpers
+  read_adaptations
+  debug_settings
+  identifier_helpers
+  information_helpers
+  package_dash_shaka
+  package_hls_shaka
+  package_dash_bento
+  package_hls_bento
+  adaptation
+  adaptation_finder
+  adaptations_file
+  ffmpeg_processor
+  ffprobe_informer
+  ffprobe_file
+  processor
+  cleaner
+  progressive_mp4
+  progressive_vp9
+  progressive_mp3
+  sprites
+  captions
+  canvas
+  data
+  temporary_poster
+  all
+].each do |dependency|
+  require "abrizer/#{dependency}"
+end
 
 
 module Abrizer

data/lib/abrizer/adaptation.rb

@@ -19,7 +19,7 @@ module Abrizer
           -an -c:v libx264 -x264opts 'keyint=48:min-keyint=48:no-scenecut' \
           -b:v #{bitrate}k -preset faster -pix_fmt yuv420p |
       if pass == 2
-        cmd += %Q| -maxrate #{constrained_bitrate}k -bufsize #{bitrate}k -pass 2 #{filepath(input, output_directory)} |
+        cmd += %Q| -maxrate #{constrained_bitrate}k -bufsize #{bitrate}k -pass 2 #{filepath(output_directory)} |
       else
         cmd += " -pass 1 -f mp4 /dev/null "
       end
@@ -31,19 +31,17 @@ module Abrizer
       @bitrate * 1.1
     end
 
-    def outfile_basename(input)
-      extname = File.extname input
-      basename = File.basename input, extname
-      "#{basename}-#{width}x#{height}-#{bitrate}"
+    def outfile_basename
+      "adaptation-#{width}x#{height}-#{bitrate}"
     end
 
-    def filepath(input, output_directory)
-      name = "#{outfile_basename(input)}.mp4"
+    def filepath(output_directory)
+      name = "#{outfile_basename}.mp4"
       File.join output_directory, name
     end
 
-    def filepath_fragmented(input, output_directory)
-      name = "#{outfile_basename(input)}-frag.mp4"
+    def filepath_fragmented(output_directory)
+      name = "#{outfile_basename}-frag.mp4"
       File.join output_directory, name
     end
 

data/lib/abrizer/adaptation_finder.rb

@@ -11,9 +11,10 @@ module Abrizer
   # through our workflow, so there might be some missing.
   class AdaptationFinder
     attr_reader :adaptations, :info
-    def initialize(filename)
-      @filename = filename
-      @informer = Abrizer::FfprobeInformer.new(filename)
+    def initialize(filepath: nil, output_directory: nil)
+      # TODO: raise an error if both filepath and output_directory
+      # are both nil.
+      @informer = Abrizer::FfprobeInformer.new(filepath: filepath, output_directory: output_directory)
       find_adaptations
     end
 
@@ -32,7 +33,7 @@ module Abrizer
       @adaptations = adaptations.select{|adaptation| adaptation.width <= @informer.width}
     end
 
-    # The bitrates here are based on H.264 encoding. 
+    # The bitrates here are based on H.264 encoding.
     def ar_4_3_adaptations
       [
         {width: 224, height: 168, bitrate: 200},

data/lib/abrizer/adaptations_file.rb

@@ -6,10 +6,11 @@ module Abrizer
     def initialize(filepath, output_directory)
       @filepath = filepath
       @output_directory = output_directory
+      FileUtils.mkdir_p @output_directory unless File.exist? @output_directory
     end
 
     def adaptations
-      adapt = Abrizer::AdaptationFinder.new(@filepath).adaptations
+      adapt = Abrizer::AdaptationFinder.new(filepath: @filepath, output_directory: @output_directory).adaptations
       adapt_dump = adapt.map{|a| a.to_hash}
       File.open(adaptations_filepath, 'w') do |fh|
         fh.puts MultiJson.dump(adapt_dump)

data/lib/abrizer/all.rb

@@ -1,28 +1,29 @@
 module Abrizer
   class All
 
-    def initialize(filename, output_dir, base_url)
+    def initialize(filename, output_dir, base_url, vp9=false)
       @filename = filename
       @output_directory = output_dir
       FileUtils.mkdir_p @output_directory
       @base_url = base_url
+      @vp9 = vp9
     end
 
     def run
       Abrizer::FfprobeFile.new(@filename, @output_directory).run
-      Abrizer::AdaptationsFile.new(@filename, @output_directory).adaptations
-      Abrizer::Processor.process(@filename, @output_directory)
-      Abrizer::ProgressiveMp4.new(@filename, @output_directory).create
-      # Abrizer::ProgressiveVp9.new(@filename, @output_directory).create
-      Abrizer::ProgressiveMp3.new(@filename, @output_directory).create
-      Abrizer::PackageDashBento.new(@filename, @output_directory).package
-      Abrizer::PackageHlsBento.new(@filename, @output_directory).package
+      Abrizer::AdaptationsFile.new(nil, @output_directory).adaptations
       Abrizer::Captions.new(@filename, @output_directory).copy
+      Abrizer::ProgressiveVp9.new(@filename, @output_directory).create if @vp9
+      Abrizer::ProgressiveMp3.new(@filename, @output_directory).create
       Abrizer::Sprites.new(@filename, @output_directory).create
       Abrizer::TemporaryPoster.new(@output_directory).copy
-      Abrizer::Canvas.new(@filename, @output_directory, @base_url).create
-      Abrizer::Data.new(@filename, @output_directory, @base_url).create
-      Abrizer::Cleaner.new(@filename, @output_directory).clean
+      Abrizer::Processor.process(@filename, @output_directory)
+      Abrizer::ProgressiveMp4.new(@output_directory).create
+      Abrizer::PackageDashBento.new(@output_directory).package
+      Abrizer::PackageHlsBento.new(@output_directory).package
+      Abrizer::Canvas.new(@output_directory, @base_url).create
+      Abrizer::Data.new(@output_directory, @base_url).create
+      Abrizer::Cleaner.new(@output_directory).clean
     end
 
   end

data/lib/abrizer/canvas.rb

@@ -5,20 +5,17 @@ module Abrizer
     include FilepathHelpers
     include IdentifierHelpers
     include InformationHelpers
-      include ReadAdaptations
+    include ReadAdaptations
 
     # TODO: allow control of items/versions listed on canvas
-    def initialize(filepath, output_directory, base_url)
-      @filepath = filepath
+    def initialize(output_directory, base_url)
       @output_directory = output_directory
+      FileUtils.mkdir_p output_directory unless File.exist? output_directory
       @base_url = base_url
-      # finder = AdaptationFinder.new(@filename)
-      # @adaptations = finder.adaptations
       read_adaptations
     end
 
     def create
-      FileUtils.mkdir_p output_directory unless File.exist? output_directory
       File.open(canvas_filepath, 'w') do |fh|
         fh.puts create_json
       end
@@ -33,7 +30,7 @@ module Abrizer
         json.height max_height
         json.duration duration
         thumbnail_json(json)
-        media_json(json)
+        media_json(json) if media_content?
       end
     end
 
@@ -47,6 +44,10 @@ module Abrizer
       end
     end
 
+    def media_content?
+      all_media_paths.any? { |f| File.exist? f }
+    end
+
     def media_json(json)
       json.content do
         json.child! do

data/lib/abrizer/captions.rb

@@ -1,8 +1,7 @@
 module Abrizer
   # Copies over any WebVTT captions that are beside the original video resource
   # into the destination folder.
-  # TODO: This may only be needed if fMP4 derivatives aren't created since
-  # captions are copied over.
+  # TODO: This may only be needed if fMP4 derivatives aren't created since captions are copied over.
   # TODO: Allow for more than one captions/subtitle file to be copied over.
   class Captions
 

data/lib/abrizer/cleaner.rb

@@ -3,10 +3,9 @@ module Abrizer
 
     include FilepathHelpers
 
-    def initialize(filename, output_dir=nil)
-      @filename = filename
+    def initialize(output_dir)
       @output_directory = output_dir
-      @adaptations = Abrizer::AdaptationFinder.new(@filename).adaptations
+      @adaptations = Abrizer::AdaptationFinder.new(output_directory: @output_directory).adaptations
     end
 
     def clean
@@ -17,7 +16,7 @@ module Abrizer
 
     def delete_adaptations(adapts)
       adapts.map do |adaptation|
-        filepath = adaptation.filepath_fragmented(@filename, output_directory)
+        filepath = adaptation.filepath_fragmented(output_directory)
         FileUtils.rm filepath if File.exist? filepath
       end
     end

data/lib/abrizer/cli.rb

@@ -7,125 +7,180 @@ end
 module Abrizer
   class CLI < Thor
 
-    desc 'all <filepath> <output_directory> <base_url>', 'Run all processes including creating ABR streams, progressive download versions, and images and video sprites.'
-    def all(filepath, output_dir, base_url)
-      filepath = File.expand_path filepath
-      output_dir = File.expand_path output_dir
-      Abrizer::All.new(filepath, output_dir, base_url).run
-    end
+    # Adapted from http://stackoverflow.com/a/24829698/620065
+    # Add a name for the option that allows for more variability
+    class << self
+      def add_shared_option(name, option_name, options = {})
+        @shared_options = {} if @shared_options.nil?
+        @shared_options[name] = [option_name, options]
+      end
 
-    desc 'ffprobe <filepath> <output_directory>', 'Save the output of ffprobe to a file as JSON'
-    def ffprobe(filepath, output_dir)
-      filepath = File.expand_path filepath
-      output_dir = File.expand_path output_dir
-      Abrizer::FfprobeFile.new(filepath, output_dir).run
-    end
+      def shared_options(*names)
+        names.each do |name|
+          opt =  @shared_options[name]
+          raise "Tried to access shared option '#{option_name}' but it was not previously defined" if opt.nil?
+          method_option *opt
+        end
+      end
 
-    desc 'abr <filepath> <output_directory>', 'From file create ABR streams, includes processing MP4 adaptations for packaging'
-    def abr(filepath, output_dir=nil)
-      filepath = File.expand_path filepath
-      output_dir = File.expand_path output_dir
-      Abrizer::Processor.process(filepath, output_dir)
-      Abrizer::PackageDashBento.new(filepath, output_dir).package
-      Abrizer::PackageHlsBento.new(filepath, output_dir).package
+      def input_banner
+        'INPUT_FILEPATH'
+      end
+
+      def input_desc
+        'Full or relative path to a mezzanine video file.'
+      end
     end
 
-    desc 'process <filepath> <output_directory>', 'From mezzanine or preservation file create intermediary adaptations'
-    def process(filepath, output_dir=nil)
-      filepath = File.expand_path filepath
-      output_dir = File.expand_path output_dir
-      Abrizer::Processor.process(filepath, output_dir)
+    no_commands do
+      def expand_path(path)
+        File.expand_path path if path
+      end
     end
 
-    desc 'mp4 <filepath> <output_directory>', 'Create a single progressive download version as an MP4 from the next to largest adaptation and audio. The adaptation and audio file must already exist.'
-    def mp4(filepath, output_dir=nil)
-      filepath = File.expand_path filepath
-      output_dir = File.expand_path output_dir
-      Abrizer::ProgressiveMp4.new(filepath, output_dir).create
+    add_shared_option :input_required, :input, aliases: '-i', type: :string, required: true, banner: input_banner, desc: input_desc + ' Input file must be present.'
+    add_shared_option :input_optional, :input, aliases: '-i', type: :string, required: false, banner: input_banner, desc: input_desc + ' May be used without an input file as long as preconditions are met.'
+    add_shared_option :output, :output, aliases: '-o', type: :string, required: true, banner: 'OUTPUT_DIRECTORY', desc: 'Full or relative path to output directory for '
+    add_shared_option :url, :url, aliases: '-u', type: :string, required: true, banner: 'BASE_URL', desc: 'Base URL to use in information files.'
+
+    desc 'all', 'Run all processes including creating ABR streams, progressive download version, and images and video sprites. Optionally create a VP9 progressive download version.'
+    shared_options :input_required, :output, :url
+    method_option :vp9, type: :boolean, default: false
+    def all
+      filepath = expand_path options[:input]
+      output_dir = expand_path options[:output]
+      Abrizer::All.new(filepath, output_dir, options[:url], options[:vp9]).run
     end
 
-    desc 'vp9 <filepath> <output_directory>', 'Create a single VP9 progressive download version from the original video.'
-    def vp9(filepath, output_dir=nil)
-      filepath = File.expand_path filepath
-      output_dir = File.expand_path output_dir
-      Abrizer::ProgressiveVp9.new(filepath, output_dir).create
+    desc 'ffprobe', 'Save the output of ffprobe to a file as JSON'
+    shared_options :input_required, :output
+    def ffprobe
+      filepath = expand_path options[:input]
+      output_dir = expand_path options[:output]
+      Abrizer::FfprobeFile.new(filepath, output_dir).run
     end
 
-    desc 'adaptations <filepath> <output_directory>', 'Output which adaptations will be created from input file to a JSON file and output to console'
-    def adaptations(filepath, output_directory=nil)
-      adaptations = Abrizer::AdaptationsFile.new(filepath, output_directory).adaptations
+    desc 'adaptations', 'Output which adaptations will be created from input file to a JSON file and output to console'
+    shared_options :input_optional, :output
+    def adaptations
+      input = expand_path options[:input]
+      output = expand_path options[:output]
+      adaptations = Abrizer::AdaptationsFile.new(input, output).adaptations
       puts adaptations
     end
 
-    desc 'inform <filepath>', 'Display information about the video/audio file'
-    def inform(filepath)
-      informer = FfprobeInformer.new(filepath)
+    desc 'inform', 'Display raw ffprobe information about the video/audio file'
+    shared_options :input_required
+    def inform
+      input = expand_path options[:input]
+      informer = FfprobeInformer.new(filepath: input)
       puts informer.json_result
       puts informer
     end
 
-    desc 'package <dash_or_hls> <filepath> <output_directory>', "Package dash or hls from adaptations"
-    def package(dash_or_hls, filepath, output_dir=nil)
-      filepath = File.expand_path filepath
-      output_dir = File.expand_path output_dir
-      case dash_or_hls
-      when "dash"
-        Abrizer::PackageDashBento.new(filepath, output_dir).package
-      when "hls"
-        Abrizer::PackageHlsBento.new(filepath, output_dir).package
-      when "all"
-        Abrizer::PackageDashBento.new(filepath, output_dir).package
-        Abrizer::PackageHlsBento.new(filepath, output_dir).package
-      else
-        puts "Not a valid packaging value. Try dash or hls."
-      end
+    desc 'captions', 'Captions and subtitles files with the same basename as the video file and with a .vtt extension are copied over into the output directory'
+    # TODO: Make input optional if packaging includes a VTT file already.
+    shared_options :input_required, :output
+    def captions
+      filepath = expand_path options[:input]
+      output_dir = expand_path options[:output]
+      Abrizer::Captions.new(filepath, output_dir).copy
+    end
+
+    desc 'vp9', 'Create a single VP9 progressive download version from the original video.'
+    shared_options :input_required, :output
+    def vp9
+      filepath = expand_path options[:input]
+      output_dir = expand_path options[:output]
+      Abrizer::ProgressiveVp9.new(filepath, output_dir).create
     end
 
-    desc 'mp3 <filepath> <output_directory>', 'Create a progressive MP3 file from the audio of the original media'
-    def mp3(filepath, output_directory)
-      # TODO: repeating expanding filepath and output_directory is probably the
-      # most annoying thing in this library. DRY this up somehow.
-      filepath = File.expand_path filepath
-      output_dir = File.expand_path output_directory
+    desc 'mp3', 'Create a progressive MP3 file from the audio of the original media'
+    shared_options :input_required, :output
+    def mp3
+      filepath = expand_path options[:input]
+      output_dir = expand_path options[:output]
       Abrizer::ProgressiveMp3.new(filepath, output_dir).create
     end
 
-    desc 'sprites <filepath> <output_directory>', 'Create image sprites and metadata WebVTT file'
-    def sprites(filepath, output_dir=nil)
-      filepath = File.expand_path filepath
-      output_dir = File.expand_path output_dir
+    desc 'sprites', 'Create image sprites and metadata WebVTT file'
+    shared_options :input_required, :output
+    def sprites
+      filepath = expand_path options[:input]
+      output_dir = expand_path options[:output]
       Abrizer::Sprites.new(filepath, output_dir).create
     end
 
-    desc 'poster <output_directory>', 'Copy over a temporary poster image based on the sprite images'
-    def poster(output_dir=nil)
-      output_dir = File.expand_path output_dir
+    desc 'poster', 'Copy over a temporary poster image based on the sprite images'
+    shared_options :output
+    def poster
+      output_dir = expand_path options[:output]
       Abrizer::TemporaryPoster.new(output_dir).copy
     end
 
-    desc 'captions <filepath> <output_directory>', 'Captions and subtitles files with the same basename as the video file and with a .vtt extension are copied over into the output directory'
-    def captions(filepath, output_dir=nil)
-      filepath = File.expand_path filepath
-      output_dir = File.expand_path output_dir
-      Abrizer::Captions.new(filepath, output_dir).copy
+    desc 'abr', 'From file create ABR streams, includes processing various fragmented MP4 adaptations for packaging first.'
+    shared_options :input_required, :output
+    def abr
+      filepath = expand_path options[:input]
+      output_dir = expand_path options[:output]
+      Abrizer::Processor.process(filepath, output_dir)
+      Abrizer::PackageDashBento.new(filepath, output_dir).package
+      Abrizer::PackageHlsBento.new(filepath, output_dir).package
+    end
+
+    desc 'process', 'From mezzanine or preservation file create intermediary adaptations'
+    shared_options :input_required, :output
+    def process
+      filepath = expand_path options[:input]
+      output_dir = expand_path options[:output]
+      Abrizer::Processor.process(filepath, output_dir)
+    end
+
+    desc 'mp4', 'Create a single progressive download version as an MP4 from the next to largest adaptation and audio. The adaptation and audio file must already exist.'
+    shared_options :output
+    def mp4
+      output_dir = expand_path options[:output]
+      Abrizer::ProgressiveMp4.new(output_dir).create
+    end
+
+    desc 'package <dash_or_hls>', "Package dash or hls from adaptations. Fragmented files, adaptions.json, and ffprobe.json must be present."
+    shared_options :output
+    def package(dash_or_hls)
+      output_dir = expand_path options[:output]
+      case dash_or_hls
+      when "dash"
+        Abrizer::PackageDashBento.new(output_dir).package
+      when "hls"
+        Abrizer::PackageHlsBento.new(output_dir).package
+      when "all"
+        Abrizer::PackageDashBento.new(output_dir).package
+        Abrizer::PackageHlsBento.new(output_dir).package
+      else
+        puts "Not a valid packaging value. Try dash or hls."
+      end
     end
 
-    desc 'canvas <filepath_or_identifier> <output_directory> <base_url>', 'Creates a IIIF Canvas JSON-LD document as an API into the resources'
-    def canvas(filepath, output_directory, base_url)
-      filepath = File.expand_path filepath
-      output_directory = File.expand_path output_directory
-      Abrizer::Canvas.new(filepath, output_directory, base_url).create
+    desc 'canvas', 'Creates a IIIF Canvas JSON-LD document as an API into the resources'
+    shared_options :input_optional, :output, :url
+    def canvas
+      filepath = expand_path options[:input]
+      output_directory = expand_path options[:output]
+      Abrizer::Canvas.new(filepath, output_directory, options[:url]).create
     end
 
-    desc 'data <filepath_or_identifier> <output_directory> <base_url>', 'Creates a JSON file with data about the video resources.'
-    def data(filepath, output_directory, base_url)
-      output_directory = File.expand_path output_directory
-      Abrizer::Data.new(filepath, output_directory, base_url).create
+    desc 'data', 'Creates a JSON file with data about the video resources.'
+    shared_options :input_optional, :output, :url
+    def data
+      filepath = expand_path options[:input]
+      output_directory = expand_path options[:output]
+      Abrizer::Data.new(filepath, output_directory, options[:url]).create
     end
 
-    desc 'clean <filepath> <output_directory>', 'Clean up intermediary files'
-    def clean(filepath, output_dir=nil)
-      Abrizer::Cleaner.new(filepath, output_dir).clean
+    desc 'clean', 'Clean up intermediary files'
+    shared_options :output
+    def clean
+      output_dir = expand_path options[:output]
+      Abrizer::Cleaner.new(output_dir).clean
     end
   end
 end

data/lib/abrizer/data.rb

@@ -7,23 +7,12 @@ module Abrizer
     include InformationHelpers
     include ReadAdaptations
 
-    def initialize(filepath, output_directory, base_url)
-      @filepath = filepath
-      # This is kind of hacky, but if the @output_directory is set then we can
-      # use that to look up the vp9_filepath
+    def initialize(output_directory, base_url)
       @output_directory = output_directory
       @base_url = base_url
-
-      # This sets @filename in some cases and more importantly sets @adaptations
-      # based on the filepath or identifier that's passed in.
       read_adaptations
     end
 
-    def find_adaptations
-      finder = AdaptationFinder.new(@filename)
-      @adaptations = finder.adaptations
-    end
-
     def create
       FileUtils.mkdir_p output_directory unless File.exist? output_directory
       File.open(data_filepath, 'w') do |fh|

data/lib/abrizer/errors.rb

@@ -0,0 +1,25 @@
+module Abrizer
+
+  # This error is raised if Abrizer::ReadAdaptations is unable to determine
+  # the adaptations that have or will be created for a given mezzanine file.
+  class ReadAdaptationsError < StandardError
+    def initialize
+      msg = "Unable to read adaptations. Either inlude the path to a master file or an identifier. If passing just the identifier you must have created an adaptations.json file to read in or as a final fallback have already created a VP9 derivative."
+      super(msg)
+    end
+  end
+
+  class FfprobeError < StandardError
+    def initialize
+      msg = "Unable to find file to run ffprobe on or unable to read in ffprobe.json file."
+      super(msg)
+    end
+  end
+
+  class Mp4AdaptationNotFoundError < StandardError
+    def initialize
+      msg = "The fragmented adaptation used to create the progressive MP4 access derivative was not found. You must run `process` before this."
+    end
+  end
+
+end

data/lib/abrizer/ffmpeg_processor.rb

@@ -5,10 +5,10 @@ module Abrizer
     include FilepathHelpers
     include DebugSettings
 
-    def initialize(filename, output_dir=nil)
+    def initialize(filename, output_dir)
       @filename = filename
       @output_directory = output_dir
-      @adaptation_finder = Abrizer::AdaptationFinder.new(@filename)
+      @adaptation_finder = Abrizer::AdaptationFinder.new(filepath: @filename)
     end
 
     def process
@@ -24,7 +24,7 @@ module Abrizer
     end
 
     def first_pass_adaptation
-      adaptations = Abrizer::AdaptationFinder.new(@filename).adaptations
+      adaptations = Abrizer::AdaptationFinder.new(filepath: @filename).adaptations
       sorted = adaptations.sort_by do |adaptation|
        adaptation.width
       end
@@ -46,8 +46,8 @@ module Abrizer
         cmd = adaptation.ffmpeg_cmd(@filename, output_directory, 2)
         puts cmd
         `#{cmd}`
-        `mp4fragment #{adaptation.filepath(@filename, output_directory)} #{adaptation.filepath_fragmented(@filename, output_directory)}`
-        FileUtils.rm adaptation.filepath(@filename, output_directory)
+        `mp4fragment #{adaptation.filepath(output_directory)} #{adaptation.filepath_fragmented(output_directory)}`
+        FileUtils.rm adaptation.filepath(output_directory)
       end
     end
 

data/lib/abrizer/ffprobe_file.rb

@@ -4,13 +4,14 @@ module Abrizer
     include FilepathHelpers
 
     def initialize(filename, output_directory)
-      @informer = FfprobeInformer.new(filename)
+      @informer = FfprobeInformer.new(filepath: filename)
       @output_directory = output_directory
+      FileUtils.mkdir_p @output_directory unless File.exist? @output_directory
     end
 
     def run
       File.open(ffprobe_filepath, 'w') do |fh|
-        fh.puts @informer.json_result
+        fh.puts @informer.to_json
       end
     end
   end

data/lib/abrizer/ffprobe_informer.rb

@@ -1,12 +1,31 @@
 module Abrizer
   class FfprobeInformer
+
+    include FilepathHelpers
+
     attr_reader :json_result, :info
-    def initialize(filename)
-      @filename = filename
+    def initialize(filepath: nil, output_directory: nil)
+      @filepath = filepath
+      @output_directory = output_directory
       get_info
     end
 
     def get_info
+      if @filepath && File.exist?(@filepath) && !File.directory?(@filepath)
+        get_info_with_command
+      elsif @output_directory && File.exist?(ffprobe_filepath)
+        get_info_from_file
+      else
+        raise FfprobeError
+      end
+    end
+
+    def get_info_from_file
+      @json_result = File.read ffprobe_filepath
+      @info = MultiJson.load @json_result
+    end
+
+    def get_info_with_command
       @json_result = `#{ffmpeg_info_cmd}`
       @info = MultiJson.load @json_result
     end
@@ -20,7 +39,11 @@ module Abrizer
     end
 
     def duration
-      video_stream['duration'] if video_stream
+      if probe_format && probe_format['duration']
+        probe_format['duration']
+      elsif video_stream && video_stream['duration']
+        video_stream['duration']
+      end
     end
 
     def display_aspect_ratio #dar
@@ -54,6 +77,10 @@ module Abrizer
       end
     end
 
+    def probe_format
+      @info['format']
+    end
+
     def audio_stream
       @info['streams'].find do |stream|
         stream['codec_type'] == 'audio'
@@ -61,7 +88,7 @@ module Abrizer
     end
 
     def ffmpeg_info_cmd
-      "ffprobe -v error -print_format json -show_format -show_streams #{@filename}"
+      "ffprobe -v error -print_format json -show_format -show_streams #{@filepath}"
     end
 
     def to_s
@@ -69,5 +96,13 @@ module Abrizer
       "#{width}x#{height} DAR:#{display_aspect_ratio}"
     end
 
+    def to_json
+      information = @info
+      info_filename = information['format']['filename']
+      truncated_filename = File.basename info_filename
+      information['format']['filename'] = truncated_filename
+      MultiJson.dump information
+    end
+
   end
 end

data/lib/abrizer/filepath_helpers.rb

@@ -1,23 +1,30 @@
 module Abrizer
   module FilepathHelpers
+
+    def all_media_paths
+      [mpd_filepath, hlsts_filepath, vp9_filepath, mp4_filepath, captions_filepath, sprites_filepath]
+    end
+
     def audio_filepath
-      File.join output_directory, "#{basename}-audio.m4a"
+      File.join output_directory, "adaptation-audio.m4a"
     end
 
     def audio_filepath_fragmented
-      File.join output_directory, "#{basename}-audio-frag.m4a"
+      File.join output_directory, "adaptation-audio-frag.m4a"
     end
 
+    # TODO: webvtt_input_filepath should look multiple places in case vtt
+    # file(s) already copied over.    
     def webvtt_input_filepath
-      File.join filename_directory, "#{basename}.vtt"
+      File.join filename_directory, "#{basename}.vtt" if @filename
     end
 
     def output_directory
-      if @output_directory
+      # if @output_directory
         @output_directory
-      else
-        File.join filename_directory, basename
-      end
+      # else
+      #   File.join filename_directory, basename
+      # end
     end
 
     def output_directory_basename

data/lib/abrizer/information_helpers.rb

@@ -1,8 +1,10 @@
 module Abrizer
   module InformationHelpers
 
+    # TODO: Could this be more flexible to potentially use a file
+    # other than the mp4_filepath?
     def duration
-      informer = Abrizer::FfprobeInformer.new(mp4_filepath)
+      informer = Abrizer::FfprobeInformer.new(filepath: mp4_filepath, output_directory: @output_directory)
       informer.duration.to_f
     end
 

data/lib/abrizer/package_dash_bento.rb

@@ -3,10 +3,9 @@ module Abrizer
 
     include FilepathHelpers
 
-    def initialize(filename, output_dir=nil)
-      @filename = filename
+    def initialize(output_dir)
       @output_directory = output_dir
-      @adaptations = Abrizer::AdaptationFinder.new(@filename).adaptations
+      @adaptations = Abrizer::AdaptationFinder.new(output_directory: @output_directory).adaptations
     end
 
     def package
@@ -17,13 +16,13 @@ module Abrizer
 
     def video_inputs
       @adaptations.map do |adaptation|
-        adaptation.filepath_fragmented(@filename, output_directory)
+        adaptation.filepath_fragmented(output_directory)
       end
     end
 
     def bento_cmd
       cmd = %Q|mp4dash --output-dir=fmp4 --force --use-segment-template-number-padding --profiles=live --hls |
-      if File.exist? webvtt_input_filepath
+      if webvtt_input_filepath && File.exist?(webvtt_input_filepath)
         cmd += %Q| [+format=webvtt,+language=eng]#{webvtt_input_filepath} |
       end
       cmd += %Q| #{video_inputs.join(' ')} [+language=eng]#{audio_filepath_fragmented} |

data/lib/abrizer/package_dash_shaka.rb

@@ -5,7 +5,7 @@ module Abrizer
 
     def initialize(filename, output_dir=nil)
       @filename = filename
-      @adaptations = Abrizer::AdaptationFinder.new(@filename).adaptations
+      @adaptations = Abrizer::AdaptationFinder.new(filepath: @filename).adaptations
     end
 
     def package

data/lib/abrizer/package_hls_bento.rb

@@ -3,10 +3,9 @@ module Abrizer
 
     include FilepathHelpers
 
-    def initialize(filename, output_dir=nil)
-      @filename = filename
+    def initialize(output_dir)
       @output_directory = output_dir
-      @adaptations = Abrizer::AdaptationFinder.new(@filename).adaptations
+      @adaptations = Abrizer::AdaptationFinder.new(output_directory: @output_directory).adaptations
     end
 
     def package
@@ -17,13 +16,13 @@ module Abrizer
 
     def video_inputs
       @adaptations.map do |adaptation|
-        adaptation.filepath_fragmented(@filename, output_directory)
+        adaptation.filepath_fragmented(output_directory)
       end
     end
 
     def bento_cmd
       cmd = %Q|mp4hls --output-dir=hls --force --output-single-file |
-      if File.exist? webvtt_input_filepath
+      if webvtt_input_filepath && File.exist?(webvtt_input_filepath)
         cmd += %Q| [+format=webvtt,+language=eng]#{webvtt_input_filepath} |
       end
       cmd += %Q| #{video_inputs.join(' ')} [+language=eng]#{audio_filepath_fragmented} |

data/lib/abrizer/package_hls_shaka.rb

@@ -5,7 +5,7 @@ module Abrizer
 
     def initialize(filename, output_dir=nil)
       @filename = filename
-      @adaptations = Abrizer::AdaptationFinder.new(@filename).adaptations
+      @adaptations = Abrizer::AdaptationFinder.new(filepath: @filename).adaptations
     end
 
     def package

data/lib/abrizer/progressive_mp3.rb

@@ -1,4 +1,5 @@
 module Abrizer
+  # TODO: Allow MP3 to be created from the adaptation audio
   class ProgressiveMp3
 
     include FilepathHelpers

data/lib/abrizer/progressive_mp4.rb

@@ -3,18 +3,21 @@ module Abrizer
 
     include FilepathHelpers
 
-    def initialize(filename, output_dir=nil)
-      @filename = filename
+    def initialize(output_dir)
       @output_directory = output_dir
       find_adaptation
     end
 
     def create
-      `#{ffmpeg_cmd}`
+      if File.exist? input_video_filepath
+        `#{ffmpeg_cmd}`
+      else
+        raise Mp4AdaptationNotFoundError
+      end
     end
 
     def find_adaptation
-      adaptations = Abrizer::AdaptationFinder.new(@filename).adaptations
+      adaptations = Abrizer::AdaptationFinder.new(output_directory: @output_directory).adaptations
       sorted = adaptations.sort_by do |adaptation|
        adaptation.width
       end
@@ -22,7 +25,7 @@ module Abrizer
     end
 
     def input_video_filepath
-      @adaptation.filepath_fragmented(@filename, output_directory)
+      @adaptation.filepath_fragmented(@output_directory)
     end
 
     def ffmpeg_cmd

data/lib/abrizer/progressive_vp9.rb

@@ -22,7 +22,7 @@ module Abrizer
     end
 
     def find_adaptation
-      adaptations = Abrizer::AdaptationFinder.new(@filename).adaptations
+      adaptations = Abrizer::AdaptationFinder.new(filepath: @filename).adaptations
       sorted = adaptations.sort_by do |adaptation|
         adaptation.width
       end

data/lib/abrizer/read_adaptations.rb

@@ -1,15 +1,13 @@
 module Abrizer
   module ReadAdaptations
 
-
-
     def read_adaptations
       # Either we have a filepath to an original or we make the assumption we
       # really have an identifier instead of a filepath and we use that
       # identifier to look for an adaptations.json file. Failing finding the
       # adaptations.json file we just use the adaptations based on the
       # vp9_filepath.
-      if File.exist?(File.expand_path(@filepath)) && !File.directory?(@filepath)
+      if @filepath && File.exist?(@filepath) && !File.directory?(@filepath)
         @filename = @filepath
         find_adaptations
       elsif File.exist? adaptations_filepath
@@ -27,8 +25,14 @@ module Abrizer
         @filename = vp9_filepath
         find_adaptations
       else
-        raise "Neither original file or VP9 version exist."
+        raise ReadAdaptationsError
       end
     end
+
+    def find_adaptations
+      finder = AdaptationFinder.new(filepath: @filename)
+      @adaptations = finder.adaptations
+    end
+
   end
 end

data/lib/abrizer/version.rb

@@ -1,3 +1,3 @@
 module Abrizer
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abrizer
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Jason Ronallo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-30 00:00:00.000000000 Z
+date: 2017-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -213,6 +213,7 @@ files:
 - lib/abrizer/cli.rb
 - lib/abrizer/data.rb
 - lib/abrizer/debug_settings.rb
+- lib/abrizer/errors.rb
 - lib/abrizer/ffmpeg_processor.rb
 - lib/abrizer/ffprobe_file.rb
 - lib/abrizer/ffprobe_informer.rb