bpl-derivatives 0.2.0

data/lib/bpl/derivatives/processors/video.rb

@@ -0,0 +1,10 @@
+module BPL::Derivatives::Processors
+  module Video
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Processor
+      autoload :Config
+    end
+  end
+end

data/lib/bpl/derivatives/processors/video/config.rb

@@ -0,0 +1,66 @@
+module BPL::Derivatives::Processors::Video
+  class Config
+    attr_writer :video_bitrate, :video_attributes, :size_attributes, :audio_attributes
+
+    def video_bitrate
+      @video_bitrate ||= default_video_bitrate
+    end
+
+    def video_attributes
+      @video_attributes ||= default_video_attributes
+    end
+
+    def size_attributes
+      @size_attributes ||= default_size_attributes
+    end
+
+    def audio_attributes
+      @audio_attributes ||= default_audio_attributes
+    end
+
+    def mpeg4
+      audio_encoder = BPL::Derivatives::AudioEncoder.new
+      @mpeg4 ||= CodecConfig.new("-vcodec libx264 -acodec #{audio_encoder.audio_encoder}")
+    end
+
+    def webm
+      @webm ||= CodecConfig.new('-vcodec libvpx -acodec libvorbis')
+    end
+
+    def mkv
+      @mkv ||= CodecConfig.new('-vcodec ffv1')
+    end
+
+    def jpeg
+      @jpeg ||= CodecConfig.new('-vcodec mjpeg')
+    end
+
+    class CodecConfig
+      attr_writer :codec
+
+      def initialize(default)
+        @codec = default
+      end
+
+      attr_reader :codec
+    end
+
+    protected
+
+      def default_video_bitrate
+        '345k'
+      end
+
+      def default_video_attributes
+        "-g 30 -b:v #{video_bitrate}"
+      end
+
+      def default_size_attributes
+        "320x240"
+      end
+
+      def default_audio_attributes
+        "-ac 2 -ab 96k -ar 44100"
+      end
+  end
+end

data/lib/bpl/derivatives/processors/video/processor.rb

@@ -0,0 +1,41 @@
+module BPL::Derivatives::Processors
+  module Video
+    class Processor < BPL::Derivatives::Processors::Processor
+      include Ffmpeg
+
+      cattr_accessor :config
+      self.config = Config.new
+
+      protected
+
+        def options_for(format)
+          input_options = ""
+          output_options = "-s #{config.size_attributes} #{codecs(format)}"
+
+          if format == "jpg"
+            input_options += " -itsoffset -2"
+            output_options += " -vframes 1 -an -f rawvideo"
+          else
+            output_options += " #{config.video_attributes} #{config.audio_attributes}"
+          end
+
+          { Ffmpeg::OUTPUT_OPTIONS => output_options, Ffmpeg::INPUT_OPTIONS => input_options }
+        end
+
+        def codecs(format)
+          case format
+          when 'mp4'
+            config.mpeg4.codec
+          when 'webm'
+            config.webm.codec
+          when "mkv"
+            config.mkv.codec
+          when "jpg"
+            config.jpeg.codec
+          else
+            raise ArgumentError, "Unknown format `#{format}'"
+          end
+        end
+    end
+  end
+end

data/lib/bpl/derivatives/runners/audio_derivatives.rb

@@ -0,0 +1,7 @@
+module BPL::Derivatives
+  class AudioDerivatives < Runner
+    def self.processor_class
+      Processors::Audio
+    end
+  end
+end

data/lib/bpl/derivatives/runners/document_derivatives.rb

@@ -0,0 +1,7 @@
+module BPL::Derivatives
+  class DocumentDerivatives < Runner
+    def self.processor_class
+      Processors::Document
+    end
+  end
+end

data/lib/bpl/derivatives/runners/image_derivatives.rb

@@ -0,0 +1,15 @@
+module BPL::Derivatives
+  class ImageDerivatives < Runner
+    # Adds format: 'png' as the default to each of the directives
+    def self.transform_directives(options)
+      options.each do |directive|
+        directive.reverse_merge!(format: 'jpg')
+      end
+      options
+    end
+
+    def self.processor_class
+      Processors::Image
+    end
+  end
+end

data/lib/bpl/derivatives/runners/jpeg2k_image_derivatives.rb

@@ -0,0 +1,15 @@
+module BPL::Derivatives
+  class Jpeg2kImageDerivatives < Runner
+    # # Adds format: 'png' as the default to each of the directives
+    def self.transform_directives(options)
+      options.each do |directive|
+        directive.reverse_merge!(format: 'jp2')
+      end
+      options
+    end
+
+    def self.processor_class
+      Processors::Jpeg2kImage
+    end
+  end
+end

data/lib/bpl/derivatives/runners/pdf_derivatives.rb

@@ -0,0 +1,4 @@
+module BPL::Derivatives
+  class PdfDerivatives < ImageDerivatives
+  end
+end

data/lib/bpl/derivatives/runners/runner.rb

@@ -0,0 +1,59 @@
+module BPL
+  module Derivatives
+    class Runner
+      class << self
+        attr_writer :output_file_service
+      end
+
+      # Use the output service configured for this class or default to the global setting
+      def self.output_file_service
+        @output_file_service || BPL::Derivatives.config.output_file_service
+      end
+
+      class << self
+        attr_writer :source_file_service
+      end
+
+      # Use the source service configured for this class or default to the global setting
+      def self.source_file_service
+        @source_file_service || BPL::Derivatives.config.source_file_service
+      end
+
+      # @param [String, ActiveFedora::Base] object_or_filename path to the source file, or an object
+      # @param [Hash] options options to pass to the encoder
+      # @options options [Array] :outputs a list of desired outputs, each entry is a hash that has :label (optional), :format and :url
+      def self.create(object_or_filename, options)
+        io_object = input_object(object_or_filename, options)
+        source_file(io_object, options) do |f|
+          io_object.source_path = f.path
+          transform_directives(options.delete(:outputs)).each do |instructions|
+            processor_class.new(io_object,
+                                instructions.merge(source_file_service: source_file_service),
+                                output_file_service: output_file_service).process
+          end
+        end
+      end
+
+      def self.input_object(object_or_filename, options)
+        if options.key?(:source_datastream)
+          return BPL::Derivatives::DatastreamDecorator.new(object_or_filename, options.fetch(:source_datastream))
+        else
+          return BPL::Derivatives::InputObjectDecorator.new(object_or_filename)
+        end
+      end
+
+      # Override this method if you need to add any defaults
+      def self.transform_directives(options)
+        options
+      end
+
+      def self.source_file(object_or_filename, options, &block)
+        source_file_service.call(object_or_filename, options, &block)
+      end
+
+      def self.processor_class
+        raise "Overide the processor_class method in a sub class"
+      end
+    end
+  end
+end

data/lib/bpl/derivatives/runners/video_derivatives.rb

@@ -0,0 +1,7 @@
+module BPL::Derivatives
+  class VideoDerivatives < Runner
+    def self.processor_class
+      Processors::Video::Processor
+    end
+  end
+end

data/lib/bpl/derivatives/services/capability_service.rb

@@ -0,0 +1,17 @@
+require 'open3'
+
+module BPL::Derivatives
+  class CapabilityService
+    attr_accessor :ffmpeg_output
+    def capture_output
+      @ffmpeg_output = Open3.capture3('ffmpeg -codecs').to_s
+    rescue StandardError
+      BPL::Dervivatives.base_logger.warn('Unable to find ffmpeg')
+      @ffmpeg_output = ""
+    end
+
+    def fdk_aac?
+      @ffmpeg_output.include?('--enable-libfdk-aac') || @ffmpeg_output.include?('--with-fdk-aac')
+    end
+  end
+end

data/lib/bpl/derivatives/services/mime_type_service.rb

@@ -0,0 +1,14 @@
+require 'mime/types'
+
+module BPL::Derivatives
+  module MimeTypeService
+    # @param [String] file_path path to a file
+    def self.mime_type(file_path)
+      MIME::Types.type_for(file_path).first.to_s
+    end
+
+    def self.type_lookup(m_type)
+      MIME::Types[m_type].first
+    end
+  end
+end

data/lib/bpl/derivatives/services/persist_basic_contained_output_file_service.rb

@@ -0,0 +1,73 @@
+module BPL::Derivatives
+  # This Service is an implementation of the Hydra::Derivatives::PeristOutputFileService
+  # It supports basic contained files, which is the behavior associated with Fedora 3 file datastreams that were migrated to Fedora 4
+  # and, at the time that this class was authored, corresponds to the behavior of ActiveFedora::Base.attach_file and ActiveFedora::Base.attached_files
+  ### Rename this
+  class PersistBasicContainedOutputFileService < PersistOutputFileService
+    # This method conforms to the signature of the .call method on Hydra::Derivatives::PeristOutputFileService
+    # * Persists the file within the object at destination_name
+    #
+    # NOTE: Uses basic containment. If you want to use direct containment (ie. with PCDM) you must use a different service (ie. Hydra::Works::AddFileToGenericFile Service)
+    #
+    # @param [BPL::Derivatives::OutputObjectDecorator] content the data to be persisted
+    # @param [Hash] directives directions which can be used to determine where to persist to.
+    # @option directives [String] url This can determine the path of the object.
+    # @option directives [String] format The file extension (e.g. 'jpg')
+    def self.call(object, directives)
+      file = io(object.content, directives)
+      remote_file = retrieve_remote_file(directives)
+      remote_file.content = file
+      remote_file.mime_type = determine_mime_type(file)
+      remote_file.original_name = determine_original_name(file)
+      remote_file.save
+    end
+
+    # @param file [Hydra::Derivatives::IoDecorator]
+    def self.determine_original_name(file)
+      if file.respond_to? :original_filename
+        file.original_filename
+      else
+        "derivative"
+      end
+    end
+
+    # @param file [Hydra::Derivatives::IoDecorator]
+    def self.determine_mime_type(file)
+      if file.respond_to? :mime_type
+        file.mime_type
+      else
+        "appliction/octet-stream"
+      end
+    end
+
+    # Override this implementation if you need a remote file from a different location
+    # @return [OutputObjectDelegator]
+    def self.retrieve_remote_file(directives)
+      uri = URI(directives.fetch(:url))
+      raise ArgumentError, "#{uri} is not an http uri" unless uri.scheme == 'http'
+      BPL::Derivatives.config.output_file_class.constantize.new(uri.to_s)
+    end
+    private_class_method :retrieve_remote_file
+
+    # @param [IO,String] content the data to be persisted
+    # @param [Hash] directives directions which can be used to determine where to persist to.
+    # @return [Hydra::Derivatives::IoDecorator]
+    def self.io(content, directives)
+      charset = charset(content) if directives[:format] == 'txt' || !directives.fetch(:binary, true)
+      BPL::Derivatives::IoDecorator.new(content, new_mime_type(directives.fetch(:format), charset))
+    end
+    private_class_method :io
+
+    def self.new_mime_type(extension, charset = nil)
+      fmt = mime_format(extension)
+      fmt += "; charset=#{charset}" if charset
+      fmt
+    end
+
+    # Strings (from FullText) have encoding. Retrieve it
+    def self.charset(content)
+      content.encoding.name if content.respond_to?(:encoding)
+    end
+    private_class_method :charset
+  end
+end

data/lib/bpl/derivatives/services/persist_datastream_output_service.rb

@@ -0,0 +1,30 @@
+module BPL::Derivatives
+  class PersistDatastreamOutputService < PersistOutputFileService
+    def self.call(object, directives)
+      datastream = retrieve_datastream(object.original_object, directives)
+      datastream.content = object.content
+      datastream.mimeType = determine_mime_type(directives.fetch(:format))
+      datastream.save
+    end
+
+    def self.determine_mime_type(format)
+      mime_format(format)
+    end
+
+    def self.retrieve_datastream(object, directives)
+      dsid = directives.fetch(:dsid)
+      raise ArgumentError, "#{dsid} is blank" if dsid.blank?
+      output_datastream(object, dsid)
+    end
+    private_class_method :retrieve_datastream
+
+
+    def self.output_datastream(object, dsid)
+      return object.datastreams[dsid] if object.datastreams[dsid]
+      ds = BPL::Derivatives.config.output_file_class.new(object.inner_object, dsid) #ActiveFedora::Datastream
+      object.add_datastream(ds)
+      ds
+    end
+    private_class_method :output_datastream
+  end
+end

data/lib/bpl/derivatives/services/persist_file_system_output_service.rb

@@ -0,0 +1,31 @@
+module BPL::Derivatives
+  class PersistFileSystemOutputService < PersistOutputFileService
+    def self.call(object, directives)
+      filename = determine_original_name(object.content)
+      write_file(object.content, directives, filename)
+    end
+
+    # @param file [Hydra::Derivatives::IoDecorator]
+    def self.determine_original_name(file)
+      if file.respond_to? :original_filename
+        file.original_filename
+      else
+        "derivative"
+      end
+    end
+
+    def self.write_file(content, directives, filename)
+      path = directives.fetch(:path)
+      fmt = directives.fetch(:format)
+      full_file_name = File.join(path, "#{filename}.#{fmt}")
+      raise ArgumentError, "path directive is blank" if path.blank?
+      raise ArgumentError, "format directive is blank" if fmt.blank?
+      File.open(full_file_name, "w+") do |f|
+        f.write(content)
+      end
+    end
+    private_class_method :write_file
+
+
+  end
+end

data/lib/bpl/derivatives/services/persist_output_file_service.rb

@@ -0,0 +1,24 @@
+module BPL::Derivatives
+  class PersistOutputFileService
+    # Persists the file within the object at destination_name.  Uses basic containment.
+    # If you want to use direct containment (ie. with PCDM) you must use a different service (ie. Hydra::Works::AddFileToGenericFile Service)
+    # @param [String] file_path the path to the file to be added
+    # @param [Hash] directives directions which can be used to determine where to persist to.
+    # @option directives [String] url This can determine the path of the object.
+    def self.call(__object_or_file_path, _directives)
+      raise NotImplementedError, "PersistOutputFileService is an abstract class. Implement `call' on #{self.class.name}"
+    end
+
+    def self.mime_format(extension)
+      case extension
+      when 'mp4'
+        'video/mp4' # default is application/mp4
+      when 'webm'
+        'video/webm' # default is audio/webm
+      else
+        MIME::Types.type_for(extension).first.to_s
+      end
+    end
+    private_class_method :mime_format
+  end
+end