multimedia_paradise 1.1.314

data/lib/multimedia_paradise/audio/to_mp3.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === MultimediaParadise::Audio::ToMp3
+#
+# This class can convert the given input to a .mp3 file. The input is
+# assumed to be an audio-file.
+# =========================================================================== #
+# require 'multimedia_paradise/audio/to_mp3.rb'
+# =========================================================================== #
+require 'multimedia_paradise/audio/base.rb'
+
+module MultimediaParadise
+
+module Audio
+
+class ToMp3 < MultimediaParadise::AudioBase # === MultimediaParadise::Audio::ToMp3
+
+  # ========================================================================= #
+  # === BITRATE_TO_USE
+  # ========================================================================= #
+  BITRATE_TO_USE = '128k'
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(*i)
+    reset
+    set_files(i)
+    run
+  end
+
+  # ========================================================================= #
+  # === reset
+  # ========================================================================= #
+  def reset
+    super()
+    # ======================================================================= #
+    # === @prepend_this_string_to_the_filename
+    # ======================================================================= #
+    @prepend_this_string_to_the_filename = 'output_'
+  end
+
+  # ========================================================================= #
+  # === filter_away_commandline_arguments_from_this_input
+  #
+  # We assume the input to this method will be an Array.
+  # ========================================================================= #
+  def filter_away_commandline_arguments_from_this_input(i)
+    selection = i.select {|entry| entry.start_with? '--' }
+    set_commandline_arguments(selection)
+    return i.reject {|entry| entry.start_with? '--' }
+  end
+
+  # ========================================================================= #
+  # === set_files
+  # ========================================================================= #
+  def set_files(i)
+    i = [i].flatten.compact
+    i = filter_away_commandline_arguments_from_this_input(i)
+    if i and i.is_a?(Array) and i.flatten.empty?
+      # ===================================================================== #
+      # Try to use all .wav files in the current directory in this case.
+      # ===================================================================== #
+      i = Dir['*.wav']
+    end
+    @files = i
+  end
+
+  # ========================================================================= #
+  # === menu                                                       (menu tag)
+  # ========================================================================= #
+  def menu(
+      i = @commandline_arguments
+    )
+    if i.is_a? Array
+      i.flatten.each {|entry| menu(entry) }
+    else
+      case i # case tag
+      # ===================================================================== #
+      # === tomp3 * --basic-output-name
+      # ===================================================================== #
+      when /^-?-?basic(-|_)?output(-|_)?name$/i
+        @prepend_this_string_to_the_filename = ''
+      end
+    end
+  end
+
+  # ========================================================================= #
+  # === process_the_files
+  # ========================================================================= #
+  def process_the_files(
+      i = @files
+    )
+    i.each {|this_file|
+      output_filename = @prepend_this_string_to_the_filename+
+                        File.basename(this_file).
+                             sub(/#{File.extname(this_file)}$/,'').delete('()')+
+                             '.mp3'
+      if this_file.include? '(' or this_file.include?(' ')
+        this_file = '"'+this_file+'"'
+      end
+      _ = 'ffmpeg -i '+this_file+
+          ' -vn -ar 44100 -ac 2 -ab '+BITRATE_TO_USE+' -f mp3 '+
+          output_filename
+      e "The output file will be called: #{sfile(output_filename)}"
+      e
+      esystem _, colour: :royalblue # <- Pass the command into this system()-variant.
+      e
+      output_filename # <- And return it here.
+    }
+  end
+
+  # ========================================================================= #
+  # === run
+  # ========================================================================= #
+  def run
+    menu
+    process_the_files
+  end
+
+end; end
+
+# =========================================================================== #
+# === MultimediaParadise.to_mp3
+#
+# Simpler top-level API to convert the given input towards a .mp3 file.
+# =========================================================================== #
+def self.to_mp3(*i)
+  MultimediaParadise::Audio::ToMp3.new(i)
+end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  MultimediaParadise::Audio::ToMp3.new(ARGV)
+end # to_mp3

data/lib/multimedia_paradise/audio/to_ogg.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === MultimediaParadise::ToOgg
+#
+# Convert an audio file into .ogg format.
+#
+# Usage example:
+#   MultimediaParadise::ToOgg.new
+# =========================================================================== #
+# require 'multimedia_paradise/audio/to_ogg.rb'
+# =========================================================================== #
+require 'multimedia_paradise/audio/base.rb'
+
+module MultimediaParadise
+
+class ToOgg < ::MultimediaParadise::AudioBase # === MultimediaParadise::ToOgg
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(
+      i           = nil,
+      run_already = true
+    )
+    reset
+    set_input(i)
+    run if run_already
+  end
+
+  # ========================================================================= #
+  # === reset                                                     (reset tag)
+  # ========================================================================= #
+  def reset
+    super()
+  end
+
+  # ========================================================================= #
+  # === set_input
+  # ========================================================================= #
+  def set_input(i = '')
+    i = i.first if i.is_a? Array
+    i = i.to_s.dup if i
+    @input = i
+  end
+
+  # ========================================================================= #
+  # === input?
+  # ========================================================================= #
+  def input?
+    @input
+  end
+
+  # ========================================================================= #
+  # === return_input_name
+  # ========================================================================= #
+  def return_input_name
+    input?.gsub(/#{File.extname(input?)}$/, '')
+  end
+
+  # ========================================================================= #
+  # === output_file?
+  # ========================================================================= #
+  def output_file?
+    'output_'+return_input_name+'.ogg'
+  end
+
+  # ========================================================================= #
+  # === cleanup_old_files
+  # ========================================================================= #
+  def cleanup_old_files
+    if File.exist? output_file?
+      File.delete(output_file?)
+    end
+  end
+
+  # ========================================================================= #
+  # === report_that_we_are_done_now
+  # ========================================================================= #
+  def report_that_we_are_done_now
+    e "Finished creating the file #{sfile(output_file?)}"
+  end
+
+  # ========================================================================= #
+  # === run                                                         (run tag)
+  # ========================================================================= #
+  def run
+    cleanup_old_files
+    _ = 'ffmpeg'.dup
+    _ << ' -i '+input?
+    _ << ' -strict -2' # So that ffmpeg does not complain about vorbis being experimental.
+    _ << ' -acodec libvorbis'
+    _ << ' -aq 100 '
+    _ << output_file? 
+    esystem _
+    report_that_we_are_done_now
+  end
+
+end; end
+
+if __FILE__ == $PROGRAM_NAME
+  MultimediaParadise::ToOgg.new(ARGV)
+end # to_ogg

data/lib/multimedia_paradise/audio/wav_to_mp3.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === MultimediaParadise::Audio::WavToMp3
+#
+# Convert a .wav file into a .mp3 file.
+#
+# Usage example:
+#
+#   require 'multimedia_paradise/audio/wav_to_mp3.rb'
+#   MultimediaParadise::Audio::WavToMp3.new
+#
+# =========================================================================== #
+# require 'multimedia_paradise/audio/wav_to_mp3.rb'
+# =========================================================================== #
+module MultimediaParadise
+
+module Audio
+
+class WavToMp3 # === MultimediaParadise::Audio::WavToMp3
+
+  require 'multimedia_paradise/conversions/conversions.rb'
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(
+      i = nil, run_already = true
+    )
+    reset
+    set_input(i)
+    run if run_already
+  end
+
+  # ========================================================================= #
+  # === reset
+  # ========================================================================= #
+  def reset # (reset tag)
+  end
+
+  # ========================================================================= #
+  # === set_input
+  # ========================================================================= #
+  def set_input(i = '')
+    i = i[0] if i.is_a? Array
+    i = i.to_s.dup if i
+    @input = i
+  end
+
+  # ========================================================================= #
+  # === input?
+  # ========================================================================= #
+  def input?
+    @input
+  end
+
+  # ========================================================================= #
+  # === input_file_without_extension?
+  # ========================================================================= #
+  def input_file_without_extension?
+    input?.gsub(/#{File.extname(input?)}/, '')
+  end
+
+  # ========================================================================= #
+  # === output?
+  # ========================================================================= #
+  def output?
+    'output_'+input_file_without_extension?+'.mp3'
+  end; alias output_file? output? # === output_file?
+
+  # ========================================================================= #
+  # === run
+  # ========================================================================= #
+  def run # (run tag)
+    result = MultimediaParadise.wav_to_mp3(
+      input?,
+      output: output_file?
+    )
+    return result
+  end
+
+end; end; end
+
+if __FILE__ == $PROGRAM_NAME
+  MultimediaParadise::Audio::WavToMp3.new(ARGV)
+end # wavtomp3

data/lib/multimedia_paradise/audio/waveform/class.rb

@@ -0,0 +1,341 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'multimedia_paradise/audio/waveform/class.rb'
+# =========================================================================== #
+require 'multimedia_paradise/audio/waveform/constants.rb'
+require 'multimedia_paradise/audio/waveform/log.rb'
+require 'multimedia_paradise/base/base.rb'
+
+module MultimediaParadise
+
+class Waveform < Base # === MultimediaParadise::Waveform
+
+  begin
+    require 'ruby-audio'
+  rescue LoadError; end
+
+  # ========================================================================= #
+  # === NAMESPACE
+  # ========================================================================= #
+  NAMESPACE = inspect
+
+  begin
+    require 'oily_png'
+  rescue LoadError
+    begin
+      require 'chunky_png'
+    rescue LoadError
+      # ===================================================================== #
+      # If we are on my home system, report that chunky_png is missing.
+      # ===================================================================== #
+      if ENV['IS_ROEBE'].to_s == '1'
+        opn(namespace: NAMESPACE)
+        puts 'chunky_png is missing - please install it.'
+      end
+    end
+  end
+
+  # ========================================================================= #
+  # Scope these under Waveform so you can catch the ones generated by
+  # just this class.
+  # ========================================================================= #
+  class RuntimeError  < ::RuntimeError;  end
+  class ArgumentError < ::ArgumentError; end
+
+  # ========================================================================= #
+  # === MultimediaParadise::Waveform.generate                  (generate tag)
+  #
+  # This method will generate a waveform image.
+  #
+  # The first argument will be the input-filename of the .wav file in
+  # question.
+  #
+  # The second argument shall be the output name of the newly generated
+  # filename.
+  #
+  # The third argument shall be the options.
+  #
+  # Available options, all of which are optional, are these here:
+  #
+  #   :method => The method used to read sample frames, available methods
+  #     are peak and rms. peak is probably what you're used to seeing, it
+  #     uses the maximum amplitude per sample to generate the waveform, so
+  #     the waveform looks more dynamic. RMS gives a more fluid waveform
+  #     and probably more accurately reflects what you hear, but isn't as
+  #     pronounced (typically).
+  #
+  #     Can be :rms or :peak
+  #
+  #     Default is :peak.
+  #
+  #   :width => The width (in pixels) of the final waveform image.
+  #
+  #     Default is 1800.
+  #
+  #   :height => The height (in pixels) of the final waveform image.
+  #
+  #     Default is 280.
+  #
+  #   :background_color => Hex code of the background color of the
+  #     generated waveform image.
+  #     Default is #666666 (gray).
+  #
+  #   :color => Hex code of the color to draw the waveform, or can pass
+  #     :transparent to render the waveform transparent (use w/ a solid
+  #     color background to achieve a "cutout" effect).
+  #     Default is #00ccff (cyan-ish).
+  #
+  #   :force => Force generation of waveform, overwriting WAV or PNG file.
+  # 
+  #   :logger => IOStream to log progress to.
+  #
+  # Usage examples:
+  #
+  #   x = MultimediaParadise::Waveform.generate('foo.wav')
+  #   x = MultimediaParadise::Waveform.generate('foo.wav', 'BOTY.png')
+  #   x = MultimediaParadise::Waveform.generate('Kickstart My Heart.wav', "Kickstart My Heart.png")
+  #   x = MultimediaParadise::Waveform.generate('Kickstart My Heart.wav', "Kickstart My Heart.png", :method => :rms)
+  #   x = MultimediaParadise::Waveform.generate('Kickstart My Heart.wav', "Kickstart My Heart.png", :color => "#ff00ff", :logger => $stdout)
+  #
+  # ========================================================================= #
+  def self.generate(
+      source,
+      filename = :guess_from_given_source,
+      options  = {}
+    )
+    options = DEFAULT_OPTIONS.merge(options)
+    case filename
+    when :guess_from_given_source, :default # Replace.
+      filename = source.gsub(/\.wav$/,'')+'.png'
+    end
+    raise ArgumentError.new(
+      'No source audio filename given, must be an existing sound file.'
+    ) unless source
+    raise ArgumentError.new(
+      'No destination filename given for waveform.'
+    ) unless filename
+    raise RuntimeError.new(
+      "Source audio file '#{source}' not found."
+    ) unless File.exist?(source)
+    raise RuntimeError.new(
+      "Destination file #{filename} exists. Use --force if you want to automatically remove it."
+    ) if File.exist?(filename) && !options[:force] === true
+
+    if source.end_with? '.mp3' # User did input a .mp3 file.
+      # ===================================================================== #
+      # === Tap into the toplevel-method MultimediaParadise.mp3_to_wav next
+      # ===================================================================== #
+      source = MultimediaParadise.mp3_to_wav(source)
+    end
+
+    # ======================================================================= #
+    # === Start the logger classer
+    # ======================================================================= #
+    @log = Log.new(options[:logger])
+    @log.start!
+    # ======================================================================= #
+    # Frames gives the amplitudes for each channel, for our waveform we're
+    # saying the "visual" amplitude is the average of the amplitude across
+    # all the channels. This might be a little weird w/ the "peak" method
+    # if the frames are very wide (i.e. the image width is very small) --
+    # I *think* the larger the frames are, the more "peaky" the waveform
+    # should get, perhaps to the point of inaccurately reflecting the
+    # actual sound.
+    # ======================================================================= #
+    samples = frames(source, options[:width], options[:method]).map { |frame|
+      frame.inject(0.0) { |sum, peak| sum + peak } / frame.size
+    }
+
+    @log.timed("\nDrawing...") {
+      # ===================================================================== #
+      # Don't remove the file even if force is true until we're sure
+      # the source was readable.
+      # ===================================================================== #
+      if File.exist?(filename) && options[:force] === true
+        @log.out("Output file #{filename} encountered. Removing.")
+        File.delete(filename)
+      end
+      image = draw(samples, options)
+      image.save(filename)
+    }
+    @log.done!("Generated waveform '#{filename}'")      
+  end
+
+  # ========================================================================= #
+  # === Wavelength.draw
+  #
+  # Draws the given samples using the given options.
+  #
+  # Will return a ChunkyPNG::Image.
+  # ========================================================================= #
+  def self.draw(samples, options)
+    image = ChunkyPNG::Image.new(options[:width], options[:height],
+      options[:background_color] == :transparent ? ChunkyPNG::Color::TRANSPARENT : options[:background_color]
+    )
+
+    case options[:color]
+    # ======================================================================= #
+    # === :transparent
+    # ======================================================================= #
+    when :transparent
+      color = transparent = ChunkyPNG::Color.from_hex(
+        # =================================================================== #
+        # Have to do this little bit because it's possible the color we were
+        # intending to use a transparency mask *is* the background color,
+        # and then we would end up wiping out the whole image.
+        # =================================================================== #
+        options[:background_color].downcase == TRANSPARENCY_MASK ? TRANSPARENCY_ALTERNATE : TRANSPARENCY_MASK
+      )
+    else # Delegate towards class ChunkyPNG next.
+      color = ChunkyPNG::Color.from_hex(options[:color])
+    end
+
+    # ======================================================================= #
+    # Calling "zero" the middle of the waveform, like there's positive
+    # and negative amplitude
+    # ======================================================================= #
+    zero = options[:height] / 2.0
+
+    samples.each_with_index { |sample, x|
+      # ===================================================================== #
+      # Half the amplitude goes above zero, half below
+      # ===================================================================== #
+      amplitude = sample * options[:height].to_f / 2.0
+      # ===================================================================== #
+      # If you give ChunkyPNG floats for pixel positions all sorts of
+      # things go haywire.
+      # ===================================================================== #
+      image.line(x, (zero - amplitude).round, x, (zero + amplitude).round, color)
+    }
+
+    # ======================================================================= #
+    # Simple transparency masking, it just loops over every pixel and
+    # makes ones which match the transparency mask color completely clear.
+    # ======================================================================= #
+    if transparent
+      (0..image.width - 1).each { |x|
+        (0..image.height - 1).each { |y|
+          image[x, y] = ChunkyPNG::Color.rgba(0, 0, 0, 0) if image[x, y] == transparent
+        }
+      }
+    end
+    image
+  end
+
+  # ========================================================================= #
+  # === source?
+  # ========================================================================= #
+  def source?
+    @source
+  end; alias source source? # === source
+
+  class << self
+
+    private
+
+    # ======================================================================= #
+    # === Wavelength.frames
+    #    
+    # Returns a sampling of frames from the given RubyAudio::Sound using the
+    # given method the sample size is determined by the given pixel width --
+    # we want one sample frame per horizontal pixel.
+    # ======================================================================= #
+    def frames(source, width, method = :peak)
+      unless %i( peak rms ).include?(method)
+        raise ArgumentError.new("Unknown sampling method #{method}")
+      end 
+
+      frames = []
+
+      RubyAudio::Sound.open(source) { |audio|
+        frames_per_sample = (audio.info.frames.to_f / width.to_f).to_i
+        sample = RubyAudio::Buffer.new("float", frames_per_sample, audio.info.channels)
+        @log.timed("Sampling #{frames_per_sample} frames per sample: ") {
+          while(audio.read(sample)) > 0
+            frames << send(method, sample, audio.info.channels)
+            @log.out('.')
+          end
+        }
+      }
+      frames # Return the found frames here.
+    rescue RubyAudio::Error => e
+      raise e unless e.message == 'File contains data in an unknown format.'
+      raise Waveform::RuntimeError.new(
+        "Source audio file #{source} could not be read by RubyAudio "\
+        "library -- Hint: non-WAV files are no longer supported, convert "\
+        "to WAV first using something like ffmpeg (RubyAudio: #{e.message})"
+      )
+    end
+
+    # ======================================================================= #
+    # === Wavelength.peak
+    #
+    # Returns an array of the peak of each channel for the given collection
+    # of frames -- the peak is individual to the channel, and the returned
+    # collection of peaks are not (necessarily) from the same frame(s).
+    # ======================================================================= #
+    def peak(frames, channels = 1)
+      peak_frame = []
+      (0..channels-1).each { |channel|
+        peak_frame << channel_peak(frames, channel)
+      }
+      peak_frame
+    end
+
+    # ======================================================================= #
+    # === Wavelength.rms
+    #
+    # Returns an array of rms values for the given frameset where each
+    # rms value is the rms value for that channel.
+    # ======================================================================= #
+    def rms(frames, channels = 1)
+      rms_frame = []
+      (0..channels-1).each { |channel|
+        rms_frame << channel_rms(frames, channel)
+      }
+      rms_frame
+    end
+
+    # ======================================================================= #
+    # === Wavelength.channel_peak
+    #
+    # Returns the peak voltage reached on the given channel in the given
+    # collection of frames.
+    # 
+    # TODO:
+    #
+    # Could lose some resolution and only sample every other frame, would
+    # likely still generate the same waveform as the waveform is so
+    # comparitively low resolution to the original input (in most cases),
+    # and would increase the analyzation speed (maybe).
+    # ======================================================================= #
+    def channel_peak(frames, channel = 0)
+      peak = 0.0
+      frames.each { |frame|
+        next if frame.nil?
+        frame = Array(frame)
+        peak = frame[channel].abs if frame[channel].abs > peak
+      }
+      peak
+    end
+
+    # ======================================================================= #
+    # === Wavelength.channel_rms
+    #
+    # Returns the rms value across the given collection of frames
+    # for the given channel.
+    # ======================================================================= #
+    def channel_rms(frames, channel = 0)
+      Math.sqrt(frames.inject(0.0){ |sum, frame|
+        sum += (frame ? Array(frame)[channel] ** 2 : 0) } / frames.size
+      )
+    end
+  end
+
+end; end
+
+if __FILE__ == $PROGRAM_NAME
+  MultimediaParadise::Waveform.generate(ARGV.first)
+end