fet 0.2.0

data/lib/fet/generator/singing.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Fet
+  module Generator
+    # Class that generates MIDI files for the singing exercises
+    class Singing
+      def initialize(tempo:, pause:, directory_prefix: "")
+        self.tempo = tempo
+        self.pause = pause
+        self.midi_range = HIGH_SINGING_OCTAVE_RANGE
+        self.directory_prefix = directory_prefix
+      end
+
+      def generate
+        generate_major
+        generate_minor
+      end
+
+      private
+
+      attr_accessor :tempo, :pause, :midi_range, :directory_prefix
+
+      def generate_major
+        MusicTheory::MAJOR_KEYS.each do |root_note_name|
+          root_midi_value = MAJOR_ROOT_MIDI_VALUES[root_note_name]
+          midi_range.each do |note_midi_value|
+            create_midi_file("major", root_note_name, root_midi_value, note_midi_value)
+          end
+        end
+      end
+
+      def generate_minor
+        MusicTheory::MINOR_KEYS.each do |root_note_name|
+          root_midi_value = MINOR_ROOT_MIDI_VALUES[root_note_name]
+          midi_range.each do |note_midi_value|
+            create_midi_file("minor", root_note_name, root_midi_value, note_midi_value)
+          end
+        end
+      end
+
+      def create_midi_file(key_type, root_note_name, root_midi_value, note_midi_value)
+        progression = Fet::ChordProgression.new(offset: root_midi_value, template_type: key_type).with_offset
+        Fet::MidilibInterface.new(
+          tempo: tempo, progression: progression, notes: [note_midi_value],
+          info: generate_midi_info(key_type, root_note_name, root_midi_value, note_midi_value),
+          filename: full_filename(key_type, root_note_name, root_midi_value, note_midi_value),
+        ).create_singing_midi_file(pause)
+      end
+
+      def generate_midi_info(key_type, root_note_name, root_midi_value, note_midi_value)
+        note_name = note_name(root_note_name, root_midi_value, note_midi_value)
+        note_octave_value = Fet::MidiNote.new(note_midi_value).octave_number
+        result = [
+          "Key: [#{root_note_name} #{key_type}]",
+          "Degree: [#{degree_name(root_note_name, root_midi_value, note_midi_value)}]",
+          "Note: [#{note_name}#{note_octave_value}]",
+        ]
+        return result.join(" ")
+      end
+
+      def full_filename(key_type, root_note_name, root_midi_value, note_midi_value)
+        result = File.join(*[directory_prefix, "singing", key_type].reject(&:empty?))
+        filename = root_note_name # note, e.g. Db
+        filename += key_type == "major" ? "M" : "m" # type of note, M or m
+        filename += "_" # delimiter
+        filename += degree_name(root_note_name, root_midi_value, note_midi_value) # degree, e.g. b7
+        filename += ".mid" # extension
+        return File.join(result, filename)
+      end
+
+      def root_degrees_instance(root_note_name, root_midi_value)
+        root_octave_value = Fet::MidiNote.new(root_midi_value).octave_number
+        return Fet::Degrees.new(root_name: root_note_name, octave_value: root_octave_value)
+      end
+
+      def degree_name(root_note_name, root_midi_value, note_midi_value)
+        degrees_instance = root_degrees_instance(root_note_name, root_midi_value)
+        return degrees_instance.degree_names_of_midi_value(note_midi_value).last
+      end
+
+      def note_name(root_note_name, root_midi_value, note_midi_value)
+        degrees_instance = root_degrees_instance(root_note_name, root_midi_value)
+        return degrees_instance.note_name_of_degree(
+          degree_name(root_note_name, root_midi_value, note_midi_value),
+        )
+      end
+    end
+  end
+end

data/lib/fet/generator/single_note_listening.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Fet
+  module Generator
+    # Class that generates MIDI files for the single note listening exercises
+    class SingleNoteListening
+      def initialize(tempo:, directory_prefix: "")
+        self.tempo = tempo
+        self.note = Fet::Note.new("C")
+        self.octave_value = 4
+        self.midi_value = MidiNote.from_note(note.full_note, octave_value).midi_value
+        self.directory_prefix = directory_prefix
+      end
+
+      def generate
+        MusicTheory::MAJOR_KEYS.each do |root_note_name|
+          root_midi_value = MAJOR_ROOT_MIDI_VALUES[root_note_name]
+          create_midi_file("major", root_note_name, root_midi_value)
+        end
+
+        MusicTheory::MINOR_KEYS.each do |root_note_name|
+          root_midi_value = MINOR_ROOT_MIDI_VALUES[root_note_name]
+          create_midi_file("minor", root_note_name, root_midi_value)
+        end
+      end
+
+      private
+
+      attr_accessor :tempo, :note, :octave_value, :midi_value, :directory_prefix
+
+      def create_midi_file(key_type, root_note_name, root_midi_value)
+        progression = Fet::ChordProgression.new(offset: root_midi_value, template_type: key_type).with_offset
+        Fet::MidilibInterface.new(
+          tempo: tempo, progression: progression, notes: [midi_value],
+          info: generate_midi_info(key_type, root_note_name, root_midi_value),
+          filename: full_filename(key_type, root_note_name, root_midi_value),
+        ).create_listening_midi_file
+      end
+
+      def generate_midi_info(key_type, root_note_name, root_midi_value)
+        result = [
+          "Key: [#{root_note_name} #{key_type}]",
+          "Degree: [#{degree_name(root_note_name, root_midi_value)}]",
+          "Note: [#{note.full_note}#{octave_value}]",
+        ]
+        return result.join(" ")
+      end
+
+      def full_filename(key_type, root_note_name, root_midi_value)
+        result = File.join(*[directory_prefix, "listening_single_note", key_type].reject(&:empty?))
+        filename = root_note_name # note, e.g. Db
+        filename += key_type == "major" ? "M" : "m" # type of note, M or m
+        filename += "_" # delimiter
+        filename += degree_name(root_note_name, root_midi_value) # degree, e.g. b7
+        filename += ".mid" # extension
+        return File.join(result, filename)
+      end
+
+      def degree_name(root_note_name, root_midi_value)
+        root_octave_value = Fet::MidiNote.new(root_midi_value).octave_number
+        degrees_instance = Fet::Degrees.new(root_name: root_note_name, octave_value: root_octave_value)
+        degree_name = degrees_instance.degree_names_of_midi_value(midi_value).last
+        return degree_name
+      end
+    end
+  end
+end

data/lib/fet/hardcoded_midi_values.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "midi_note"
+
+module Fet
+  MAJOR_ROOT_MIDI_VALUES = {
+    "C#" => MidiNote.from_note("C#", 4).midi_value,
+    "F#" => MidiNote.from_note("F#", 3).midi_value,
+    "B" => MidiNote.from_note("B", 3).midi_value,
+    "E" => MidiNote.from_note("E", 3).midi_value,
+    "A" => MidiNote.from_note("A", 3).midi_value,
+    "D" => MidiNote.from_note("D", 4).midi_value,
+    "G" => MidiNote.from_note("G", 3).midi_value,
+    "C" => MidiNote.from_note("C", 4).midi_value,
+    "F" => MidiNote.from_note("F", 3).midi_value,
+    "Bb" => MidiNote.from_note("Bb", 3).midi_value,
+    "Eb" => MidiNote.from_note("Eb", 4).midi_value,
+    "Ab" => MidiNote.from_note("Ab", 3).midi_value,
+    "Db" => MidiNote.from_note("Db", 4).midi_value,
+    "Gb" => MidiNote.from_note("Gb", 3).midi_value,
+    "Cb" => MidiNote.from_note("Cb", 3).midi_value,
+  }.deep_freeze
+  MINOR_ROOT_MIDI_VALUES = MusicTheory::MINOR_KEYS.zip(MAJOR_ROOT_MIDI_VALUES.values.map { |i| i - 3 }).to_h.deep_freeze
+end

data/lib/fet/instrument_ranges.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "midi_note"
+
+module Fet
+  PIANO_RANGE = (MidiNote.from_note("A", 0).midi_value..MidiNote.from_note("C", 8).midi_value).to_a.deep_freeze
+  REDUCED_BY_OCTAVE_PIANO_RANGE = (MidiNote.from_note("A", 1).midi_value..MidiNote.from_note("C", 7).midi_value).to_a.deep_freeze
+  GUITAR_RANGE = (MidiNote.from_note("E", 2).midi_value..MidiNote.from_note("E", 6).midi_value).to_a.deep_freeze
+  # Ranges according to Wikipedia:
+  # Bass: E2 - E4
+  # Baritone: G2 - G4
+  # Tenor: C3 - C5
+  # Countertenor: E3 - E5
+  # Contralto: F3 - F5
+  # Mezzo-soprano: A3 - A5
+  # Soprano: C4 - C6
+  LOW_SINGING_OCTAVE_RANGE = (MidiNote.from_note("D", 3).midi_value...MidiNote.from_note("D", 4).midi_value).to_a.deep_freeze
+  HIGH_SINGING_OCTAVE_RANGE = (MidiNote.from_note("D", 4).midi_value...MidiNote.from_note("D", 5).midi_value).to_a.deep_freeze
+end

data/lib/fet/midi_note.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "music_theory"
+
+module Fet
+  # Class that handles MIDI values that represent notes
+  class MidiNote
+    attr_reader :midi_value
+
+    def initialize(midi_value)
+      self.midi_value = midi_value
+      validate_midi_value!
+    end
+
+    def self.from_note(note_name, octave_number)
+      midi_value_for_c = 12 * (1 + octave_number)
+      midi_value = midi_value_for_c + MusicTheory.semitones_from_c(note_name)
+      return new(midi_value)
+    end
+
+    def octave_number
+      return (midi_value - 12) / 12
+    end
+
+    # NOTE: This is not strictly correct because e.g. the midi value of 63 can be D#4 or Eb4, which affects
+    # what degree it actually is. However, without additional information, this is good enough.
+    def degree(root_midi_value)
+      return (midi_value - root_midi_value) % 12
+    end
+
+    private
+
+    attr_writer :midi_value
+
+    def validate_midi_value!
+      # In MIDI, the minimum note value is 0 (which is C(-1)) and the maximum note value is 127 (which is G(9))
+      raise InvalidMidiNote.new(midi_value) if midi_value.negative? || midi_value > 127
+    end
+  end
+end

data/lib/fet/midilib_interface.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "midilib/sequence"
+require "midilib/consts"
+
+module Fet
+  # Interface with the midilib library to generate MIDI files
+  class MidilibInterface
+    def initialize(tempo:, progression:, notes:, info:, filename:)
+      self.tempo = tempo
+      self.progression = progression
+      self.notes = notes
+      self.info = info
+      self.filename = filename
+      self.sequence = MIDI::Sequence.new
+      self.track = generate_instrument_track
+    end
+
+    def create_listening_midi_file
+      # Play the chord progression
+      set_progression_on_track
+
+      add_rest(2 * quarter_note_length)
+      play_notes_as_chord(notes, quarter_note_length)
+
+      add_rest(6 * quarter_note_length)
+      play_notes_sequentially(notes, quarter_note_length)
+
+      write_sequence_to_file
+    end
+
+    def create_singing_midi_file(sleep_duration)
+      # Play the chord progression
+      set_progression_on_track
+
+      # Play the note after waiting for a specified amount of time
+      add_seconds_of_rest(sleep_duration) do
+        play_notes_sequentially(notes, quarter_note_length)
+      end
+
+      write_sequence_to_file
+    end
+
+    private
+
+    attr_accessor :tempo, :progression, :notes, :info, :filename, :sequence, :track
+
+    def write_sequence_to_file
+      directory_name = File.dirname(filename)
+      FileUtils.mkdir_p(directory_name)
+      File.open(filename, "wb") { |file| sequence.write(file) }
+    end
+
+    def add_seconds_of_rest(seconds)
+      # Change tempo to 60 so that sleep_duration quarter notes corresponds to number of seconds
+      with_temporary_tempo_change(60) do
+        # Sleep for the requested duration
+        add_rest(seconds * quarter_note_length)
+        yield
+      end
+    end
+
+    def play_notes_as_chord(the_notes, rest_after_chord)
+      the_notes.each do |note|
+        track.events << MIDI::NoteOn.new(0, note, 127, 0) # track number, note, volume, time to add
+      end
+
+      the_notes.each.with_index do |note, index|
+        time_interval = index.zero? ? rest_after_chord : 0
+        track.events << MIDI::NoteOff.new(0, note, 127, time_interval)
+      end
+    end
+
+    def play_notes_sequentially(the_notes, rest_between_notes)
+      the_notes.each do |note|
+        track.events << MIDI::NoteOn.new(0, note, 127, 0) # track number, note, volume, time to add
+        track.events << MIDI::NoteOff.new(0, note, 127, rest_between_notes)
+      end
+    end
+
+    def add_rest(duration)
+      track.events << MIDI::NoteOff.new(0, 0, 0, duration)
+    end
+
+    def with_temporary_tempo_change(new_tempo)
+      change_tempo(new_tempo)
+      yield
+      change_tempo(tempo)
+    end
+
+    def change_tempo(new_tempo)
+      track.events << MIDI::Tempo.new(MIDI::Tempo.bpm_to_mpq(new_tempo))
+    end
+
+    def generate_instrument_track
+      create_info_track
+      return create_instrument_track
+    end
+
+    def set_progression_on_track
+      # Create the progression
+      progression.each do |chord|
+        play_notes_as_chord(chord, quarter_note_length)
+      end
+
+      return track
+    end
+
+    def create_info_track
+      # Create a first track for the sequence. This holds tempo events and meta info.
+      track = MIDI::Track.new(sequence)
+      sequence.tracks << track
+      track.events << MIDI::Tempo.new(MIDI::Tempo.bpm_to_mpq(tempo))
+      track.events << MIDI::MetaEvent.new(MIDI::META_SEQ_NAME, info)
+      return track
+    end
+
+    def create_instrument_track
+      # Create a track to hold the notes. Add it to the sequence.
+      track = MIDI::Track.new(sequence)
+      sequence.tracks << track
+      track.name = info
+      track.instrument = MIDI::GM_PATCH_NAMES[0] # This is the piano patch
+      track.events << MIDI::ProgramChange.new(0, 1, 0) # Specify instrument as 2nd argument - see consts in midilib
+      return track
+    end
+
+    def quarter_note_length
+      # NOTE: magic constant will freeze strings, but apparently midilib needs "quarter" to NOT be frozen,
+      # so calling dup on it will generate a non-frozen version
+      return sequence.note_to_delta("quarter".dup)
+    end
+  end
+end

data/lib/fet/music_theory.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative "note"
+
+module Fet
+  # Module in charge of handling music theory concepts
+  module MusicTheory
+    # All 12 degrees
+    DEGREES = ["1", "b2", "2", "b3", "3", "4", "b5", "5", "b6", "6", "b7", "7"].deep_freeze
+
+    # All 15 keys - 7 sharps...0 accidentals...7 flats.
+    MAJOR_KEYS = ["C#", "F#", "B", "E", "A", "D", "G", "C", "F", "Bb", "Eb", "Ab", "Db", "Gb", "Cb"].deep_freeze
+    MINOR_KEYS = ["A#", "D#", "G#", "C#", "F#", "B", "E", "A", "D", "G", "C", "F", "Bb", "Eb", "Ab"].deep_freeze
+
+    MODES_IN_ORDER_OF_DARKNESS = [
+      ["lydian"],
+      ["major", "ionian"],
+      ["mixolydian"],
+      ["dorian"],
+      ["minor", "aeolian"],
+      ["phrygian"],
+      ["locrian"],
+    ].deep_freeze
+
+    DEGREES_OF_MODE = {
+      ["lydian"] => ["1", "2", "3", "#4", "5", "6", "7"],
+      ["major", "ionian"] => ["1", "2", "3", "4", "5", "6", "7"],
+      ["mixolydian"] => ["1", "2", "3", "4", "5", "6", "b7"],
+      ["dorian"] => ["1", "2", "b3", "4", "5", "6", "b7"],
+      ["minor", "aeolian"] => ["1", "2", "b3", "4", "5", "b6", "b7"],
+      ["phrygian"] => ["1", "b2", "b3", "4", "5", "b6", "b7"],
+      ["locrian"] => ["1", "b2", "b3", "4", "b5", "b6", "b7"],
+    }.deep_freeze
+
+    SEMITONES_FROM_C = {
+      "C" => 0,
+      "D" => 2,
+      "E" => 4,
+      "F" => 5,
+      "G" => 7,
+      "A" => 9,
+      "B" => 11,
+    }.deep_freeze
+
+    # NOTE: returns value from 0 to 11
+    def self.semitones_from_c(note_name)
+      note = Note.new(note_name)
+      return (SEMITONES_FROM_C[note.natural_note] + note.accidental_to_semitone_offset) % 12
+    end
+
+    def self.degrees_of_mode(mode_name)
+      mode_info = DEGREES_OF_MODE.detect { |mode_names, _| mode_names.include?(mode_name) }
+      raise InvalidModeName.new(mode_name) if mode_info.nil?
+
+      return mode_info[1]
+    end
+
+    CIRCLE_OF_FIFTHS_WITHOUT_ACCIDENTALS = ["F", "C", "G", "D", "A", "E", "B"].deep_freeze
+    CIRCLE_OF_FIFTHS = [
+      *CIRCLE_OF_FIFTHS_WITHOUT_ACCIDENTALS.map { |note| Note.new(note).flattened_note.flattened_note.flattened_note.full_note },
+      *CIRCLE_OF_FIFTHS_WITHOUT_ACCIDENTALS.map { |note| Note.new(note).flattened_note.flattened_note.full_note },
+      *CIRCLE_OF_FIFTHS_WITHOUT_ACCIDENTALS.map { |note| Note.new(note).flattened_note.full_note },
+      *CIRCLE_OF_FIFTHS_WITHOUT_ACCIDENTALS,
+      *CIRCLE_OF_FIFTHS_WITHOUT_ACCIDENTALS.map { |note| Note.new(note).sharpened_note.full_note },
+      *CIRCLE_OF_FIFTHS_WITHOUT_ACCIDENTALS.map { |note| Note.new(note).sharpened_note.sharpened_note.full_note },
+      *CIRCLE_OF_FIFTHS_WITHOUT_ACCIDENTALS.map { |note| Note.new(note).sharpened_note.sharpened_note.sharpened_note.full_note },
+    ].deep_freeze
+
+    ORDERED_NATURAL_NOTES = CIRCLE_OF_FIFTHS_WITHOUT_ACCIDENTALS.sort.deep_freeze
+    SEMITONES_TO_NEXT_NATURAL_NOTE = {
+      "A" => 2,
+      "B" => 1,
+      "C" => 2,
+      "D" => 2,
+      "E" => 1,
+      "F" => 2,
+      "G" => 2,
+    }.deep_freeze
+
+    # A aeolian -> ["A", "B", "C", "D", "E", "F", "G"]
+    def self.notes_of_mode(note_name, mode_name)
+      relative_major_note_name = relative_major(note_name, mode_name)
+
+      index = CIRCLE_OF_FIFTHS.index(relative_major_note_name)
+      result = CIRCLE_OF_FIFTHS[(index - 1)..(index + 5)]
+      raise UnsupportedRootName.new(note_name) unless result.size == 7
+
+      result = result.sort
+      return result.rotate(result.index(note_name))
+    end
+
+    # A aeolian -> C
+    def self.relative_major(note_name, mode_name)
+      note = Note.new(note_name)
+      index = CIRCLE_OF_FIFTHS.index(note.full_note)
+      raise UnsupportedRootName.new(note_name) if index.nil?
+
+      result_index = index - mode_offset_from_major(mode_name)
+      raise UnsupportedRootName.new(note_name) if result_index.negative?
+
+      result = CIRCLE_OF_FIFTHS[index - mode_offset_from_major(mode_name)]
+      return result
+    end
+
+    class << self
+      private
+
+      def mode_offset_from_major(mode_name)
+        MODES_IN_ORDER_OF_DARKNESS.each.with_index do |mode_names, index|
+          return (index - 1) if mode_names.include?(mode_name)
+        end
+        raise InvalidModeName.new(mode_name)
+      end
+    end
+  end
+end