carrierwave-audio 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 996e33c9cb030bee7964d4db792e9f1895de8c65
-  data.tar.gz: abb3d0ca6e0c6a1e0140a0376ebdb3eb3b89eedd
+  metadata.gz: 7be11dce3db2c4671534890d709b8c722552194b
+  data.tar.gz: 982706f2ba999761581f510862c7bb9da9a594db
 SHA512:
-  metadata.gz: 7575f6521c1acdb52b41d6e1055b41ce08781ce029d1083230f28c7740161026c4147dccb2a1282dd711bbf5ab700c2893502562ba844d876a9b533fafe3dc4a
-  data.tar.gz: eae7eddc4a4088da30e36897258e178c07a7196fcc9c955833f91f0a5b092ceb142642b397bc61d1627c5c6760d0d5c8302c2e9c31bbb4c02a7dcdec28c45fec
+  metadata.gz: 9aa03b8e0299a9c7862bda92ee5cee76919c0e57fe9a55643e7117c37ae99bc4313cbf8a0ac8c6fdb3aeb76ba87c45e708831fa516163d3303321198edb58b26
+  data.tar.gz: 6e69134f3fc3437b1cdca8eb2eb66ef1fe680d658a1a3afddb171845a079a04414bfc39b0e8f10e33017375f71ffe59eea15bb12a48491184cc427d9b8014827

data/lib/carrierwave/audio.rb

@@ -1,96 +1,42 @@
 require 'carrierwave'
-require 'ruby-sox'
-require 'soxi/wrapper'
+require 'carrierwave/audio/processor'
 
 module CarrierWave
   module Audio
     module ClassMethods
       extend ActiveSupport::Concern
 
-      def convert output_format = :mp3, output_options = {}
-        process convert: [ output_format, output_options ]
+      def convert options={}
+        process convert: [ options ]
       end
 
-      def watermark watermark_file_path, output_format = :mp3, output_options = {}
-        process watermark: [ watermark_file_path, output_format, output_options ]
+      def watermark options={}
+        process watermark: [ options ]
       end
     end
 
-    def convert output_format = :mp3, output_options = {}
+    def convert options={}
       cache_stored_file! if !cached?
-      format = sanitized_format(output_format)
-      ext = File.extname(current_path)
-      input_options = { type: ext.gsub(/\./, '') }
-      current_filename_without_extension = File.basename(current_path, ext)
-      tmp_path = File.join File.dirname(current_path), "tmp_#{current_filename_without_extension}_#{Time.current.to_i}.#{format}"
-      convert_file(current_path, input_options, tmp_path, default_output_options(format).merge(output_options))
-      File.rename tmp_path, current_path
-      set_content_type format
+
+      audio_filename = Processor.convert(current_path, options)
+      extension = File.extname(audio_filename)
+      File.rename audio_filename, current_path
+      set_content_type extension
     end
 
-    def watermark watermark_file_path, output_format = :mp3, output_options = {}
+    def watermark options={}
       cache_stored_file! if !cached?
-      format = sanitized_format(output_format)
-      ext = File.extname(current_path)
-      watermark_ext = File.extname(watermark_file_path)
-      input_options = { type: ext.gsub(/\./, '') }
-      watermark_options = { type: watermark_ext.gsub(/\./, '') }
-      current_filename_without_extension = File.basename(current_path, ext)
-
-      # Normalize file to -6dB
-      normalized_tmp_path = File.join File.dirname(current_path), "tmp_norm_#{current_filename_without_extension}_#{Time.current.to_i}.#{input_options[:type]}"
-      convert_file(current_path, input_options, normalized_tmp_path, default_output_options(input_options[:type]), { gain: "-n -6" })
 
-      # Combine normalized file and watermark, normalizing final product to 0dB
-      final_tmp_path = File.join File.dirname(current_path), "tmp_wtmk_#{current_filename_without_extension}_#{Time.current.to_i}.#{format}"
-      combiner = Sox::Cmd.new(combine: :mix)
-      combiner.add_input normalized_tmp_path, input_options
-      combiner.add_input watermark_file_path, watermark_options
-      combiner.set_output final_tmp_path, default_output_options(format).merge(output_options)
-      combiner.set_effects({ trim: "0 #{Soxi::Wrapper.file(current_path).seconds}", gain: "-n" })
-      combiner.run
-      File.rename final_tmp_path, current_path
-      set_content_type format
+      audio_filename = Processor.watermark(current_path, options)
+      extension = File.extname(audio_filename)
+      File.rename audio_filename, current_path
+      set_content_type extension
     end
 
     private
 
-    def convert_file input_file_path, input_options, output_file_path, output_options, fx = {}
-      converter = Sox::Cmd.new
-      converter.add_input input_file_path, input_options
-      converter.set_output output_file_path, output_options
-      converter.set_effects fx
-      converter.run
-    end
-
-    def sanitized_format format
-      supported_formats = [:mp3]
-      if supported_formats.include?(format.to_sym)
-        format.to_s
-      else
-        raise CarrierWave::ProcessingError.new("Unsupported audio format #{format}. Only conversion to #{supported_formats.to_sentence} allowed.")
-      end
-    end
-
-    def default_output_options format
-      if format.to_sym == :mp3
-        {
-          type: format.to_s,
-          rate: 44100,
-          channels: 2,
-          compression: 128
-        }
-      else
-        {
-          type: format.to_s,
-          rate: 44100,
-          channels: 2
-        }
-      end
-    end
-
-    def set_content_type format
-      case format.to_sym
+    def set_content_type extension
+      case extension.to_sym
       when :mp3
         self.file.instance_variable_set(:@content_type, "audio/mpeg3")
       end

data/lib/carrierwave/audio/processor.rb

@@ -0,0 +1,226 @@
+require 'ruby-sox'
+require 'soxi/wrapper'
+require 'fileutils'
+
+module CarrierWave
+  module Audio
+    class Processor
+      DefaultConvertOptions = {
+        output_format: :mp3,
+        logger: nil
+      }
+      DefaultWatermarkOptions = {
+        output_format: :mp3,
+        logger: nil
+      }
+
+      # Scope these under Processor so you can catch the ones generated by just this
+      # class.
+      class RuntimeError < ::RuntimeError;end;
+      class ArgumentError < ::ArgumentError;end;
+
+      class << self
+        # Convert an audio file at the given filename with the given options.
+        #
+        # Available options (all optional) are:
+        #
+        #   :output_format => Output file format
+        #
+        #     Currently only :mp3 supported
+        #     Default is :mp3.
+        #
+        #   :logger => IOStream to log progress to.
+        #
+        # Example:
+        #   CarrierWave::Audio::Processor.convert("Kickstart My Heart.wav")
+        #   CarrierWave::Audio::Processor.generate("Kickstart My Heart.wav", :output_format => :wav)
+        #
+        def convert(source, options={})
+          options = DefaultConvertOptions.merge(options)
+          format = sanitized_format(options[:output_format])
+
+          @log = Log.new(options[:logger])
+          @log.start!
+
+          ext = File.extname(source)
+          input_options = { type: ext.gsub(/\./, '') }
+          final_filename = tmp_filename(source: source, format: format)
+          @log.timed("\nConverting...") do
+            convert_file(
+              input_file_path: source, 
+              input_options: input_options, 
+              output_file_path: final_filename, 
+              output_options: output_options_for_format(format)
+            )
+          end
+
+          @log.done!("Converted audio file '#{final_filename}'")
+
+          final_filename
+        end
+
+        # Watermark an audio file at the given filename with the given options.
+        #
+        # Available options are:
+        #
+        #   :watermark_file => (REQUIRED) Watermark audio file path
+        #
+        #   :output_format => (Optional) Output file format
+        #
+        #     Currently only :mp3 supported
+        #     Default is :mp3.
+        #
+        #   :logger => (Optional) IOStream to log progress to.
+        #
+        # Example:
+        #   CarrierWave::Audio::Processor.watermark("Kickstart My Heart.wav", { watermark_file: "#{Rails.root}/db/watermark.mp3" })
+        #
+        def watermark(source, options={})
+          options = DefaultWatermarkOptions.merge(options)
+          format = sanitized_format(options[:output_format])
+          watermark_file_path = options[:watermark_file]
+
+          raise ArgumentError.new("No watermark filename given, must be a path to an existing sound file.") unless watermark_file_path
+          raise RuntimeError.new("Watermark file '#{watermark_file_path}' not found.") unless File.exist?(watermark_file_path)
+
+          @log = Log.new(options[:logger])
+          @log.start!
+
+          ext = File.extname(source)
+          input_options = { type: ext.gsub(/\./, '') }
+          normalized_filename = tmp_filename(source: source, format: format, prefix: "norm")
+          @log.timed("\nNormalizing file to -6dB...") do
+            convert_file(
+              input_file_path: source, 
+              input_options: input_options, 
+              output_file_path: normalized_filename, 
+              output_options: output_options_for_format(input_options[:type]), 
+              fx: { gain: "-n -6" }
+            )
+          end
+
+          watermark_ext = File.extname(watermark_file_path)
+          watermark_options = { type: watermark_ext.gsub(/\./, '') }
+          final_filename = tmp_filename(source: source, format: format, prefix: "wtmk")
+          @log.timed("\nCombining normalized file and watermark, normalizing final output to 0dB...") do
+            combiner = Sox::Cmd.new(combine: :mix)
+            combiner.add_input normalized_filename, input_options
+            combiner.add_input watermark_file_path, watermark_options
+            combiner.set_output final_filename, output_options_for_format(format)
+            combiner.set_effects({ trim: "0 =#{Soxi::Wrapper.file(source).seconds}", gain: "-n" })
+            combiner.run
+          end
+
+          @log.done!("Watermarked audio file '#{final_filename}'")
+
+          final_filename
+        end
+
+        private
+
+        # Convert file using options
+        def convert_file input_file_path:, input_options:, output_file_path:, output_options:, fx: {}
+          converter = Sox::Cmd.new
+          converter.add_input input_file_path, input_options
+          converter.set_output output_file_path, output_options
+          converter.set_effects fx
+          converter.run
+        end
+
+        def sanitized_format format
+          supported_formats = [:mp3]
+          if supported_formats.include?(format.to_sym)
+            format.to_s
+          else
+            raise ArgumentError.new("Unsupported audio format #{format}. Only conversion to #{supported_formats.to_sentence} allowed.")
+          end
+        end
+
+        def output_options_for_format format
+          shared_options = {
+            channels: 2
+          }
+
+          if format.to_sym == :mp3
+            {
+              type: format.to_s,
+              rate: 44100,
+              compression: 128
+            }.merge(shared_options)
+          else
+            {
+              type: format.to_s,
+              rate: 44100
+            }.merge(shared_options)
+          end
+        end
+
+        # Generate a temporary filename
+        def tmp_filename source:, format:, prefix: nil
+          ext = File.extname(source)
+          source_filename_without_ext = File.basename(source, ext)
+          File.join File.dirname(source), "tmp#{prefix.present? ? '_' + prefix : ''}_#{source_filename_without_ext}_#{Time.now.to_i}.#{format}"
+        end
+
+        # A simple class for logging + benchmarking, nice to have good feedback on a
+        # long batch operation.
+        #
+        # There's probably 10,000,000 other bechmarking classes, but writing this was
+        # easier than using Google.
+        class Log
+          attr_accessor :io
+
+          def initialize(io=$stdout)
+            @io = io
+          end
+
+          # Prints the given message to the log
+          def out(msg)
+            io.print(msg) if io
+          end
+
+          # Prints the given message to the log followed by the most recent benchmark
+          # (note that it calls .end! which will stop the benchmark)
+          def done!(msg="")
+            out "#{msg} (#{self.end!}s)\n"
+          end
+
+          # Starts a new benchmark clock and returns the index of the new clock.
+          #
+          # If .start! is called again before .end! then the time returned will be
+          # the elapsed time from the next call to start!, and calling .end! again
+          # will return the time from *this* call to start! (that is, the clocks are
+          # LIFO)
+          def start!
+            (@benchmarks ||= []) << Time.now
+            @current = @benchmarks.size - 1
+          end
+
+          # Returns the elapsed time from the most recently started benchmark clock
+          # and ends the benchmark, so that a subsequent call to .end! will return
+          # the elapsed time from the previously started benchmark clock.
+          def end!
+            elapsed = (Time.now - @benchmarks[@current])
+            @current -= 1
+            elapsed
+          end
+
+          # Returns the elapsed time from the benchmark clock w/ the given index (as
+          # returned from when .start! was called).
+          def time?(index)
+            Time.now - @benchmarks[index]
+          end
+
+          # Benchmarks the given block, printing out the given message first (if
+          # given).
+          def timed(message=nil, &block)
+            start!
+            out(message) if message
+            yield
+            done!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carrierwave/audio/version.rb

@@ -1,5 +1,5 @@
 module CarrierWave
   module Audio
-    VERSION = '1.0.2'
+    VERSION = '1.0.3'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: carrierwave-audio
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Trevor Hinesley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-20 00:00:00.000000000 Z
+date: 2016-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: carrierwave
@@ -91,6 +91,7 @@ files:
 - README.md
 - lib/carrierwave-audio.rb
 - lib/carrierwave/audio.rb
+- lib/carrierwave/audio/processor.rb
 - lib/carrierwave/audio/version.rb
 homepage: https://github.com/TrevorHinesley/carrierwave-audio
 licenses: