multimedia_paradise 1.1.314

data/lib/multimedia_paradise/multimedia/merge_multimedia.rb

@@ -0,0 +1,125 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === MultimediaParadise::MergeMultimedia
+#
+# This file will delegate towards the multimedia merge functionality
+# which is available in MultimediaConversions.merge().
+#
+# Usage examples:
+#   MultimediaParadise::MergeMultimedia.new
+#   mergemultimedia
+# =========================================================================== #
+# require 'multimedia_paradise/multimedia/merge_multimedia.rb'
+# MultimediaParadise::MergeMultimedia.new
+# =========================================================================== #
+require 'multimedia_paradise/base/base.rb'
+
+module MultimediaParadise
+
+class MergeMultimedia < ::MultimediaParadise::Base # === MultimediaParadise::MergeMultimedia
+
+  require 'multimedia_paradise/toplevel_methods/merge_multimedia_file.rb'
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(
+      merge_these_files = nil,
+      run_already       = true
+    )
+    reset
+    set_merge_these_files(
+      merge_these_files
+    )
+    run if run_already
+  end
+
+  # ========================================================================= #
+  # === reset                                                     (reset tag)
+  # ========================================================================= #
+  def reset
+    super()
+    # ======================================================================= #
+    # === @output_file
+    # ======================================================================= #
+    @output_file = nil
+  end
+
+  # ========================================================================= #
+  # === set_merge_these_files
+  # ========================================================================= #
+  def set_merge_these_files(
+      i = ''
+    )
+    i = i.dup if i
+    case i
+    when '*'
+      i = Dir['*'].select {|entry| is_this_a_multimedia_file?(entry) }
+    end
+    i.compact! if i.is_a? Array
+    @merge_these_files = i
+  end
+
+  # ========================================================================= #
+  # === check_whether_the_files_exist
+  # ========================================================================= #
+  def check_whether_the_files_exist(
+      these_files = @merge_these_files
+    )
+    these_files.each {|entry|
+      if File.exist? entry
+      else
+        ewarn 'The file at `'+sfile(entry)+'` does not exist.'
+      end
+    }
+  end
+
+  # ========================================================================= #
+  # === which_files?
+  # ========================================================================= #
+  def which_files?
+    @merge_these_files
+  end
+
+  # ========================================================================= #
+  # === set_output_file
+  # ========================================================================= #
+  def set_output_file(i)
+    @output_file = i
+  end
+
+  # ========================================================================= #
+  # === output_file?
+  # ========================================================================= #
+  def output_file?
+    @output_file
+  end; alias output? output_file? # === output?
+
+  # ========================================================================= #
+  # === merge
+  # ========================================================================= #
+  def merge(
+      these_files = which_files?
+    )
+    if these_files.is_a? Array
+      check_whether_the_files_exist
+      result = MultimediaParadise.merge_multimedia_file(these_files) # bl conversions.rb
+      set_output_file(result)
+    end
+  end
+
+  # ========================================================================= #
+  # === run                                                         (run tag)
+  # ========================================================================= #
+  def run
+    merge
+  end
+
+end; end
+
+if __FILE__ == $PROGRAM_NAME
+  MultimediaParadise::MergeMultimedia.new(ARGV)
+end # merge_multimedia
+    # merge_multimedia a.webm b.webm

data/lib/multimedia_paradise/multimedia/note.rb

@@ -0,0 +1,500 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === MultimediaParadise::Note
+#
+# Chords can be denoted in different ways.
+#
+# For instance, one can denote a major C# chord not only by just doing
+# "C#" but by also denoting whether it is major or minor, as in:
+#
+#   "C#maj"
+#
+# Usage examples:
+#
+#   include MultimediaParadise
+#   Note.new(698.46) # Creates a note object with the frequency 698.46
+#   Note.new('F#6')  # Creates an F sharp note in the 6th octave
+#   MultimediaParadise::Note.new('Bb3')  # 
+#
+# =========================================================================== #
+require 'multimedia_paradise/base/base.rb'
+
+module MultimediaParadise
+
+class Note < ::MultimediaParadise::Base # MultimediaParadise::Note
+
+  include Comparable # So that we can compare different musical notes.
+
+  attr_accessor :frequency
+
+  # ========================================================================= #
+  # === NOTE_STRINGS
+  #
+  # MultimediaParadise::NOTE_STRINGS
+  # ========================================================================= #
+  NOTE_STRINGS = [
+    'Ab', 'A',  'A#', 'Bb', 'B',
+    'C',  'C#', 'Db', 'D',  'D#',
+    'Eb', 'E',  'F',  'Gb', 'G',
+    'G#'
+  ]
+
+  # ========================================================================= #
+  # === ARRAY_NOTES
+  # ========================================================================= #
+  ARRAY_NOTES = [
+    'C', 'C#/Db', 'D', 'D#/Eb', 'E', 'F',
+    'F#/Gb', 'G', 'G#/Ab', 'A', 'A#/Bb', 'B'
+  ]
+
+  # ========================================================================= #
+  # === CHORD_ALIASES
+  # ========================================================================= #
+  CHORD_ALIASES = {
+    :min   => :minor,
+    :m     => :minor,
+    :maj   => :major,
+    :M     => :major,
+    :p     => :fifth,
+    :pow   => :fifth,
+    :power => :fifth,
+    :'5'   => :fifth,
+    :'5th' => :fifth,
+    :dim   => :diminished,
+    :aug   => :augmented,
+    :'+'   => :augmented,
+
+    # ======================================================================= #
+    # Some aliases for the major seventh chord.
+    # ======================================================================= #
+    :maj_seventh   => :major_seventh,
+    :major_7       => :major_seventh,
+    :major_7th     => :major_seventh,
+    :maj_7         => :major_seventh,
+    :maj_7th       => :major_seventh,
+    :maj7          => :major_seventh,
+    :maj7th        => :major_seventh,
+    :M7            => :major_seventh,
+
+    :min_seventh   => :minor_seventh,
+    :minor_7       => :minor_seventh,
+    :minor_7th     => :minor_seventh,
+    :min_7         => :minor_seventh,
+    :min_7th       => :minor_seventh,
+    :min7          => :minor_seventh,
+    :min7th        => :minor_seventh,
+    :m7            => :minor_seventh,
+
+    :dim_seventh   => :diminished_seventh,
+    :diminished_7  => :diminished_seventh,
+    :diminished_7th => :diminished_seventh,
+    :dim_7         => :diminished_seventh,
+    :dim_7th       => :diminished_seventh,
+    :dim7          => :diminished_seventh,
+    :dim7th        => :diminished_seventh,
+    :d7            => :diminished_seventh,
+
+    :aug_seventh   => :augmented_seventh,
+    :augmented_7   => :augmented_seventh,
+    :augmented_7th => :augmented_seventh,
+    :aug_7         => :augmented_seventh,
+    :aug_7th       => :augmented_seventh,
+    :aug7          => :augmented_seventh,
+    :aug7th        => :augmented_seventh,
+    :'+7'          => :augmented_seventh,
+
+    :half_dim_seventh    => :half_diminished_seventh,
+    :half_diminished_7   => :half_diminished_seventh,
+    :half_diminished_7th => :half_diminished_seventh,
+    :half_dim_7          => :half_diminished_seventh,
+    :half_dim_7th        => :half_diminished_seventh,
+    :half_dim7           => :half_diminished_seventh,
+    :half_dim7th         => :half_diminished_seventh,
+  }
+
+  # ========================================================================= #
+  # === CHORD_INTERVALS
+  # ========================================================================= #
+  CHORD_INTERVALS = {
+    :minor              => [ :minor_third, :perfect_fifth],
+    :major              => [ :major_third, :perfect_fifth],
+    :fifth              => [ :perfect_fifth],
+    :diminished         => [ :minor_third, :diminished_fifth],
+    :augmented          => [ :major_third, :augmented_fifth],
+    :major_seventh      => [ :major_third, :perfect_fifth, :major_seventh],
+    :minor_seventh      => [ :minor_third, :perfect_fifth, :minor_seventh],
+    :diminished_seventh => [ :minor_third, :diminished_fifth, :diminished_seventh],
+    :augmented_seventh  => [ :major_third, :augmented_fifth, :minor_seventh],
+    :half_diminished_seventh => [ :minor_third, :diminished_fifth, :minor_seventh]
+  }
+
+  # ========================================================================= #
+  # === initialize
+  #
+  # This class will create a new note.
+  #
+  # Usage examples:
+  #
+  #   note = MultimediaParadise::Note.new(698.46) # Creates a note object
+  #   with the frequency 698.46
+  #   note = MultimediaParadise::Note.new('F#6') # Creates an F sharp note
+  #   in the 6th octave
+  #
+  # @param [String, Numeric] descriptor Either a string describing the note
+  # (e.g. 'C#4') or a number giving the note's frequency (e.g. 440)
+  # @param [Numeric, nil] assumed_octave If no octive is given in the
+  # descriptor, use this
+  # @returns [Note] Note specified
+  # ========================================================================= #
+  def initialize(descriptor, assumed_octave = nil)
+    reset
+    self.frequency = if descriptor.is_a? Numeric
+      Note.nearest_note_frequency(descriptor)
+    else
+      Note.calculate_frequency(descriptor, assumed_octave)
+    end
+  end
+
+  # ========================================================================= #
+  # === reset
+  # ========================================================================= #
+  def reset
+    super()
+  end
+
+  # ========================================================================= #
+  # === frequency?
+  # ========================================================================= #
+  def frequency?
+    @frequency
+  end
+
+  # ========================================================================= #
+  # === <=>
+  # ========================================================================= #
+  def <=>(other_note)
+    self.frequency <=> other_note.frequency
+  end
+
+  # ========================================================================= #
+  # === hash
+  # ========================================================================= #
+  def hash
+    self.frequency.hash
+  end
+
+  # ========================================================================= #
+  # === eql?
+  # ========================================================================= #
+  def eql?(other_note)
+    self.frequency == other_note.frequency
+  end
+
+  # ========================================================================= #
+  # === to_s
+  # ========================================================================= #
+  def to_s
+    self.note_string
+  end
+
+  # ========================================================================= #
+  # === note_string
+  #
+  # Returns string representing note with letter, accidental, and octave
+  # number e.g. 'C#5'
+  #
+  # @param [boolean] give_flat Should the result give a flat?
+  # (defaults to giving a sharp)
+  # @return [String] The resulting note string.
+  # ========================================================================= #
+  def note_string(give_flat = false)
+    Note.calculate_note(self.frequency, give_flat).join
+  end
+
+  # ========================================================================= #
+  # === letter
+  #
+  # Returns the letter portion of the note e.g. 'C'
+  #
+  # @param [boolean] give_flat Should the result be based on
+  #                  giving a flat? (defaults to giving a sharp)
+  # @return [String] The resulting note letter
+  # ========================================================================= #
+  def letter(give_flat = false)
+    Note.calculate_note(self.frequency, give_flat).first
+  end; alias letter? letter # === letter?
+
+  # ========================================================================= #
+  # === accidental
+  #
+  # Returns the accidental portion of the note e.g. '#' or 'b'
+  #
+  # @param [boolean] give_flat Should the result give a flat? (defaults
+  #                            to giving a sharp)
+  # @return [String] The resulting accidental.
+  # ========================================================================= #
+  def accidental(give_flat = false)
+    Note.calculate_note(self.frequency, give_flat)[1]
+  end
+
+  # ========================================================================= #
+  # === octave
+  #
+  # Returns the octive number of the note e.g. 4.
+  #
+  # @return [Fixnum] The resulting octive number
+  # ========================================================================= #
+  def octave
+    Note.calculate_note(self.frequency)[2]
+  end
+
+  # ========================================================================= #
+  # === prev
+  #
+  # Return the previous note (adjusted by one semitone down)
+  #
+  # @return [Note] The previous note
+  # ========================================================================= #
+  def prev
+    Note.new(Note.frequency_adjustment(self.frequency, -1))
+  end
+
+  # ========================================================================= #
+  # === succ
+  #
+  # Return the next note (adjusted by one semitone up)
+  #
+  # @return [Note] The next note
+  # ========================================================================= #
+  def succ
+    Note.new(Note.frequency_adjustment(self.frequency, 1))
+  end; alias next succ # === next
+
+  # ========================================================================= #
+  # === distance_to
+  #
+  # Return the distance (in semitones) to a note
+  #
+  # @return [Fixnum] Number of semitones
+  # ========================================================================= #
+  def distance_to(note)
+    Note.note_distance(self.note_string, note.note_string)
+  end
+
+  # ========================================================================= #
+  # === adjust_by_semitones
+  #
+  # Return another note adjusted by a given interval
+  #
+  # @param [Fixnum] interval Number of semitones to adjust by
+  # @return [Note] Resulting note after adjustment.
+  # ========================================================================= #
+  def adjust_by_semitones(interval)
+    Note.new(
+      Note.frequency_adjustment(self.frequency, interval)
+    )
+  end
+
+  {
+    :minor_second    => 1,
+    :major_second    => 2,
+    :minor_third     => 3,
+    :major_third     => 4,
+    :perfect_fourth  => 5,
+    :tritone         => 6, :diminished_fifth => 6, :flat_fifth => 6, :augmented_fourth => 6, # Aliases.
+    :perfect_fifth   => 7,
+    :augmented_fifth => 8, :minor_sixth => 8,
+    :major_sixth     => 9, :diminished_seventh => 9,
+    :minor_seventh   => 10,
+    :major_seventh   => 11
+  }.each { |interval, semitones_count|
+    define_method(interval) {
+      adjust_by_semitones(semitones_count)
+    }
+  }
+
+  # ========================================================================= #
+  # === major_scale
+  #
+  # Uses note as key to give major scale
+  #
+  # @returns [Array<Note>] Notes in major scale.
+  # ========================================================================= #
+  def major_scale
+    [self,
+      self.major_second,
+      self.major_third,
+      self.perfect_fourth,
+      self.perfect_fifth,
+      self.major_sixth,
+      self.major_seventh,
+    ]
+  end
+
+  # ========================================================================= #
+  # === minor_scale
+  #
+  # Uses note as key to give minor scale
+  #
+  # @returns [Array<Note>] Notes in minor scale.
+  # ========================================================================= #
+  def minor_scale
+    [self,
+      self.major_second,
+      self.minor_third,
+      self.perfect_fourth,
+      self.perfect_fifth,
+      self.minor_sixth,
+      self.minor_seventh,
+    ]
+  end
+
+  # ========================================================================= #
+  # === chord
+  #
+  # The first argument is the chord description.
+  # ========================================================================= #
+  def chord(description)
+    description = :major if description.to_s.empty?
+
+    description = description.to_s
+    description.downcase! unless %w( M M7 ).include? description
+    description.gsub!(/[\s\-]+/, '_')
+    description = description.to_sym
+    intervals = CHORD_INTERVALS[description] || CHORD_INTERVALS[CHORD_ALIASES[description]]
+    if intervals
+      Chord.new([self] + intervals.collect {|interval| self.send(interval) })
+    end
+  end
+
+  (CHORD_INTERVALS.keys + CHORD_ALIASES.keys).each { |chord_description|
+    define_method "#{chord_description}_chord" do
+      self.chord(chord_description)
+    end
+  }
+
+  # ========================================================================= #
+  # === Class methods start here
+  # ========================================================================= #
+  class << self # Note.parse_note_string
+    def parse_note_string(note_string, assumed_octave = nil)
+      match = note_string.match(/^([A-Ga-g])([#b]?)([0-8]?)$/)
+
+      unless match
+        raise ArgumentError, "Could not recognize the note string: #{note_string}. It may be invalid."
+      end
+      if match[3].empty? && assumed_octave.nil?
+        raise ArgumentError, "No octave found or specified"
+      end
+      if match[3].to_i > 8 || (assumed_octave && !(0..8).include?(assumed_octave))
+        raise ArgumentError
+      end
+      octave = match[3].empty? ? assumed_octave : match[3]
+      [match[1].upcase, match[2] == '' ? nil : match[2], octave.to_i]
+    end
+
+    # ======================================================================= #
+    # === note_distance
+    # ======================================================================= #
+    def note_distance(note_string1, note_string2)
+      letter1, accidental1, octave1 = parse_note_string(note_string1)
+      letter2, accidental2, octave2 = parse_note_string(note_string2)
+
+      get_index = Proc.new { |letter, accidental|
+        ARRAY_NOTES.index { |note|
+          regex = case accidental
+          when '#' then
+            /^#{letter}#/
+          when 'b' then
+            /#{letter}b$/
+          else
+            /^#{letter}$/
+          end
+          note.match(regex)
+        }
+      }
+      index1 = get_index.call(letter1, accidental1)
+      index2 = get_index.call(letter2, accidental2)
+      (index2 - index1) + ((octave2.to_i - octave1.to_i) * ARRAY_NOTES.size)
+    end
+
+    # ======================================================================= #
+    # === frequency_adjustment
+    # ======================================================================= #
+    def frequency_adjustment(start_frequency, distance)
+      result = (start_frequency * (2.0 ** (distance.to_f / ARRAY_NOTES.size)))
+      # Would like to use #round(2), but want to support Ruby 1.8
+      (result * 100.0).round / 100.0
+    end
+
+    # ======================================================================= #
+    # === calculate_frequency
+    # ======================================================================= #
+    def calculate_frequency(*args)
+      case args.size
+      when 1
+        letter, accidental, octave = parse_note_string(args[0])
+      when 2
+        letter, accidental, octave = parse_note_string(args[0], args[1])
+      when 3
+        letter, accidental, octave = args
+      else
+        raise ArgumentError, "Invalid octave of arguments"
+      end
+      distance = note_distance('A4', "#{letter}#{accidental}#{octave}")
+      frequency_adjustment(440.0, distance)
+    end
+
+    # ======================================================================= #
+    # === calculate_note
+    # ======================================================================= #
+    def calculate_note(
+        frequency, give_flat = false
+      )
+      # ===================================================================== #
+      # We could use #log(frequency / 440.0, 2), but then this is
+      # possibly not supported in Ruby 1.8 anymore.
+      # ===================================================================== #
+      frequency_log_base_2 = Math.log(frequency / 440.0) / Math.log(2)
+      distance = (ARRAY_NOTES.size * frequency_log_base_2).round
+      index  = 9 + distance # 9 is index for A
+      octave = 4 + (index / ARRAY_NOTES.size) # 4 is because we're using A4
+      index  = (index % ARRAY_NOTES.size)
+
+      parts = ARRAY_NOTES[index].split('/')
+      note = if give_flat
+        parts.last
+      else
+        parts.first
+      end
+      # "#{note}#{octave}"
+      note_parts = note.split('')
+      note_parts + (note_parts.size == 1 ? [nil] : []) + [octave.to_i]
+    end
+
+    # ======================================================================= #
+    # === nearest_note_frequency
+    # ======================================================================= #
+    def nearest_note_frequency(frequency)
+      Note.calculate_frequency(
+        Note.calculate_note(frequency).join
+      )
+    end
+  end
+
+end; end
+
+if __FILE__ == $PROGRAM_NAME
+  # Testing this class:
+  require 'colours_e/autoinclude'
+  include MultimediaParadise
+  p MultimediaParadise::Note.new(698.46) # Creates a note object with the frequency 698.46
+  p MultimediaParadise::Note.new('F#6')
+  p MultimediaParadise::Note.new('Bb3')
+  e 'The frequency of Bb3 is:'
+  e
+  e '  '+slateblue(Note.new('Bb3').frequency.to_s) # => 233.08
+  e
+end