inevitable_cacophony 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 23972ffb2207ab73ee426746749fbef9f92b0a4481deef7201de95b3b8522a56
+  data.tar.gz: c8735fccc00b5815308a13b95c6be437ae2fbc0782df3beeaf7a05874b2b9c88
+SHA512:
+  metadata.gz: 9905f4be065544add64a03acd8b5cb4777204fc087736a8945fd21822a77cb6e48c200084e46e5aa15001e9d1f82eb617de779581eca1087f8b7b0f331edef8d
+  data.tar.gz: 922a493d81a05e53a66ae086a2ad32dfa8fcd73376aeec6b703f679006f72fb64e0b7433076ced6d3bf7405a2c494f8c38bac3e233927db8a437cdbfb0428661

data/bin/inevitable_cacophony

@@ -0,0 +1,175 @@
+#!/usr/bin/env/ruby
+
+require 'optparse'
+require 'stringio'
+
+require 'inevitable_cacophony/parser/rhythms'
+require 'inevitable_cacophony/octave_structure'
+require 'inevitable_cacophony/midi_generator'
+require 'inevitable_cacophony/tone_generator'
+require 'inevitable_cacophony/phrase'
+require 'inevitable_cacophony/version'
+
+command = -> {
+	octave = InevitableCacophony::OctaveStructure.new(input)
+
+        3.times.map do
+		chord_notes = []
+                rhythm.each_beat.map do |beat|
+			chords = octave.chords.values
+			if chord_notes.empty?
+				chord_notes = chords.sample(random: rng).note_scalings.dup
+			end
+
+			note = InevitableCacophony::Note.new(chord_notes.shift, beat)
+			InevitableCacophony::Phrase.new(note, tempo: options[:tempo])
+		end
+        end.flatten
+}
+
+render = -> (phrases) {
+        tone = InevitableCacophony::ToneGenerator.new(options[:tonic])
+        phrases.each { |phrase| tone.add_phrase(phrase) }
+
+        # Have to buffer output so wavefile can seek back to the beginning to write format info
+        output_buffer = StringIO.new
+        tone.write(output_buffer)
+        $stdout.write(output_buffer.string)
+}
+
+def input
+	@input ||= $stdin.read
+end
+
+def options
+	@options ||= {
+                tempo: 120, # beats per minute
+                tonic: 440 # Hz; middle A
+	}
+end
+
+def rng
+	@rng ||= Random.new(options[:seed] || Random.new_seed)
+end
+
+def midi_generator
+        @midi_generator ||= begin
+                octave_structure = InevitableCacophony::OctaveStructure.new(input)
+                InevitableCacophony::MidiGenerator.new(octave_structure, options[:tonic])
+        end
+end
+
+def rhythm
+	@rhythm ||= begin
+		all_rhythms = InevitableCacophony::Parser::Rhythms.new.parse(input)
+
+		# InevitableCacophony::Pick the first rhythm mentioned in the file, which should be the one
+		# used by the first section of the piece.
+		rhythm_name = all_rhythms.keys.sort_by { |name| input.index(name.to_s) }.first
+
+		if all_rhythms[rhythm_name]
+			all_rhythms[rhythm_name]
+		else
+
+			# InevitableCacophony::If no rhythms are mentioned, parse any rhythm string we can find in the input.
+			rhythm_score = input.match(/(\|( |\`)((-|x|X|!)( |\`|\'))+)+\|/).to_s
+			InevitableCacophony::Parser::RhythmLine.new.parse(rhythm_score)
+		end
+	end
+end
+
+OptionParser.new do |opts|
+
+	opts.banner = 'Usage: ruby -Ilib cacophony.rb [options]'
+
+	opts.on('-b', '--beat', 'Play a beat in the given rhythm') do
+		command = -> {
+			notes = 3.times.map do
+				rhythm.each_beat.map do |beat|
+					InevitableCacophony::Note.new(1, beat)
+				end
+			end.flatten
+
+			[InevitableCacophony::Phrase.new(*notes, tempo: options[:tempo])]
+		}
+	end
+
+	opts.on('-s', '--scale', 'Play a scale in the given style') do
+		command = -> {
+			octave = InevitableCacophony::OctaveStructure.new(input)
+
+			scale = if options[:chromatic]
+					octave.chromatic_scale
+				else
+					octave.scales.values.first
+				end
+
+			rising_and_falling = scale.open.note_scalings + scale.note_scalings.reverse
+		        notes = rising_and_falling.map do |factor|
+				InevitableCacophony::Note.new(factor, InevitableCacophony::Rhythm::Beat.new(1, 1, 0))
+		        end
+
+			[InevitableCacophony::Phrase.new(*notes, tempo: options[:tempo])]
+		}
+	end
+
+	opts.on('-p', '--polyrhythm RATIO', "Rather than loading rhythm normally, use a polyrhythm in the given ratio (e.g 7:11, 2:3:4).") do |ratio|
+		components = ratio.split(':').map do |length|
+			InevitableCacophony::Rhythm.new([InevitableCacophony::Rhythm::Beat.new(1, 1, 0)] * length.to_i)
+		end
+
+		primary, *secondaries = components
+		@rhythm = InevitableCacophony::Polyrhythm.new(primary, secondaries)
+	end
+
+	opts.on('-e', '--eval FORM', 'Parse FORM rather than reading a form description from stdin') do |form|
+		@input = form
+	end
+
+	opts.on('--chromatic', 'Use "chromatic" scales (all notes in the form) rather than the named scales typical of the form') do
+		options[:chromatic] = true
+	end
+
+	opts.on('-h', '--help', 'Prints this help') do
+		puts opts
+		exit
+	end
+
+	opts.on('-v', '--version', 'Show version and exit') do
+		puts "Inevitable Cacophony version #{InevitableCacophony::VERSION}"
+		exit
+	end
+
+  opts.on('-t', '--tempo TEMPO', "Play at the given tempo in beats per minute (default #{options[:tempo]}). For polyrhythms, this applies to whatever number is given first: at the same tempo, a 2:3 rhythm will play faster than a 3:2.") do |tempo|
+		options[:tempo] = tempo.to_i
+	end
+
+	opts.on('-S', '--seed SEED', 'Generate random melodies with the given seed, for repeatable results.') do |seed|
+		int_seed = seed.to_i
+		raise "Expected seed to be a number" unless seed == int_seed.to_s
+
+		options[:seed] = int_seed
+	end
+
+        opts.on('-m', '--midi', 'Generate output in MIDI rather than WAV format (needs file from -M to play in tune)') do
+                render = -> (phrases) {
+                        phrases.each do |phrase|
+                                midi_generator.add_phrase(phrase)
+                        end
+                        midi_generator.write($stdout)
+                }
+        end
+
+        opts.on('-M', '--midi-tuning', 'Instead of music, generate a Scala (Timidity-compatible) tuning file for use with MIDI output from --midi') do
+                command = -> {
+                        midi_generator.frequency_table
+                }
+                render = -> (frequencies) {
+                        frequencies.table.each do |frequency|
+                                $stdout.puts (frequency * 1000).round
+                        end
+                }
+        end
+end.parse!
+
+render.call(command.call)

data/lib/inevitable_cacophony.rb

@@ -0,0 +1,2 @@
+module InevitableCacophony
+end

data/lib/inevitable_cacophony/midi_generator.rb

@@ -0,0 +1,118 @@
+# Converts Inevitable Cacophony internal note representation
+# into MIDI messages usable by an external synthesizer.
+# Based on examples in the `midilib` gem.
+
+require 'midilib/sequence'
+require 'midilib/consts'
+
+require 'inevitable_cacophony/midi_generator/frequency_table'
+
+module InevitableCacophony
+        class MidiGenerator
+        
+                # Set up a MIDI generator for a specific octave structure and tonic
+                # We need to know the octave structure because it determines
+                # how we allocate MIDI note indices to frequencies.
+                def initialize(octave_structure, tonic)
+                        @frequency_table = FrequencyTable.new(octave_structure, tonic)
+                end
+        
+                attr_reader :frequency_table
+        
+                # Add a phrase to the MIDI output we will generate.
+                def add_phrase(phrase)
+                        @phrases ||= []
+                        @phrases << phrase
+                end
+        
+                # @return [Midi::Track] Notes to be output to MIDI; mainly for testing.
+                def notes_track(sequence=build_sequence)
+                        build_notes_track(sequence, @phrases)
+                end
+        
+                # Write MIDI output to the given stream.
+                def write(io)
+                        sequence = build_sequence
+                        sequence.tracks << notes_track(sequence)
+        
+                        # Buffer output so this method can be called on stdout.
+                        buffer = StringIO.new
+                        sequence.write(buffer)
+        
+                        io.write(buffer.string)
+                end
+        
+                private
+        
+                def build_sequence
+                        seq = MIDI::Sequence.new
+                        seq.tracks << meta_track(seq)
+                        seq
+                end
+        
+                # TODO: why do I have to pass `seq` in,
+                # when I'm then later adding the track back to seq.tracks?
+                def meta_track(seq)
+                        track = MIDI::Track.new(seq)
+        
+                        # TODO: handle tempo changes (how?)
+                        track.events << MIDI::Tempo.new(
+                                MIDI::Tempo.bpm_to_mpq(@phrases.first.tempo)
+                        )
+                        track.events << MIDI::MetaEvent.new(
+                                MIDI::META_SEQ_NAME,
+                                'TODO: name sequence'
+                        )
+        
+                        track
+                end
+        
+                # TODO: multiple instruments?
+                def build_notes_track(seq, phrases)
+                        track = MIDI::Track.new(seq)
+                        track.name = 'Cacophony'
+        
+                        # TODO: why this particular instrument.
+                        track.instrument = MIDI::GM_PATCH_NAMES[0]
+        
+                        # TODO: what's this for?
+                        track.events << MIDI::ProgramChange.new(0, 1, 0)
+        
+                        # Inter-note delay from the end of the previous beat.
+                        leftover_delay = 0
+        
+                        phrases.each do |phrase|
+                                phrase.notes.each do |note|
+                                        track.events += midi_events_for_note(leftover_delay, note, seq)
+                                        leftover_delay = seq.length_to_delta(note.beat.after_delay)
+                                end
+                        end
+        
+                        track
+                end
+        
+                # TODO: code smell to pass in seq
+                def midi_events_for_note(delay_before, note, seq)
+                        midi_note = @frequency_table.index_for_ratio(note.ratio)
+                        beat = note.beat
+        
+                        [
+                                MIDI::NoteOn.new(
+                                        0,
+                                        midi_note,
+                                        (beat.amplitude * 127).ceil,
+                                        # TODO: can notes be out of order?
+                                        # Beat duration 1 conveniently matches
+                                        # midilib's quarter-note = 1.
+                                        seq.length_to_delta(beat.start_delay) + delay_before
+                                ),
+                                MIDI::NoteOff.new(
+                                        0,
+                                        midi_note,
+                                        127,
+                                        seq.length_to_delta(beat.sounding_time)
+                                )
+                        ]
+                end
+        end
+end

data/lib/inevitable_cacophony/midi_generator/frequency_table.rb

@@ -0,0 +1,126 @@
+# A frequency table maps Dwarf fortress notes (specific frequencies) to
+# MIDI indices for use in MIDI indexes.
+#
+# Where possible we use the standard MIDI values for DF notes; where that
+# won't work, we try to keep as close to the MIDI structure as the DF scale
+# system will allow.
+
+# Using for OctaveStructure::OCTAVE_RATIO; may be better to just use +2+.
+require 'inevitable_cacophony/octave_structure'
+
+module InevitableCacophony
+        class MidiGenerator
+                class FrequencyTable
+        
+                        # Raised when there is no MIDI index available for
+                        # a note we're trying to output
+                        class OutOfRange < StandardError
+                                def initialize(frequency, table)
+                                        super("Not enough MIDI indices to represent #{frequency} Hz. "\
+                                              "Available range is  #{table.inspect}")
+                                end
+                        end
+        
+                        # Range of allowed MIDI 1 indices.
+                        MIDI_RANGE = 0..127
+        
+                        # Middle A in MIDI
+                        MIDI_TONIC = 69
+        
+                        # Standard western notes per octave assumed by MIDI
+                        MIDI_OCTAVE_NOTES = 12
+        
+                        # 12TET values of those notes.
+                        STANDARD_MIDI_FREQUENCIES = MIDI_OCTAVE_NOTES.times.map do |index|
+                                OctaveStructure::OCTAVE_RATIO ** (index / MIDI_OCTAVE_NOTES.to_f)
+                        end
+        
+                        # Maximum increase/decrease between two frequencies we still treat as
+                        # "equal". Approximately 1/30th of human Just Noticeable Difference
+                        # for pitch.
+                        FREQUENCY_FUDGE_FACTOR = (1.0/10_000)
+        
+                        # Create a frequency table with a given structure and tonic.
+                        #
+                        # @param octave_structure [OctaveStructure]
+                        # @param tonic [Integer] The tonic frequency in Hertz.
+                        #                        This will correspond to Cacophony frequency 1,
+                        #                        and MIDI pitch 69
+                        def initialize(octave_structure, tonic)
+                                @tonic = tonic
+                                @table = build_table(octave_structure, tonic)
+                        end
+        
+                        attr_reader :table
+        
+                        # @param ratio [Float] The given note as a ratio to the tonic
+                        #                       (e.g. A above middle A = 2.0)
+                        def index_for_ratio(ratio)
+                                # TODO: not reliable for approximate matching
+                                frequency = @tonic * ratio
+        
+                                if (match = table.index(frequency))
+                                        match
+                                else
+                                        raise OutOfRange.new(frequency, table)
+                                end
+                        end
+        
+                        private
+        
+                        def build_table(octave_structure, tonic)
+                                chromatic = octave_structure.chromatic_scale.open.note_scalings
+                                octave_breakdown = best_match_ratios(chromatic)
+        
+                                MIDI_RANGE.map do |index|
+                                        tonic_offset = index - MIDI_TONIC
+                                        octave_offset, note = tonic_offset.divmod(octave_breakdown.length)
+        
+                                        bottom_of_octave = tonic * OctaveStructure::OCTAVE_RATIO**octave_offset
+                                        bottom_of_octave * octave_breakdown[note]
+                                end
+                        end
+        
+                        # Pick a MIDI index within the octave for each given frequency.
+                        #
+                        # If there are few enough (<12) frequencies in the generated scale,
+                        # we try to keep as much of the normal MIDI tuning as possible, and
+                        # only re-tune what we need. If the DF scale is a subset of 12TET,
+                        # this should return the standard MIDI tuning.
+                        #
+                        # Other than that it isn't guaranteed to be optimal; currently it's
+                        # a fairly naieve greedy algorithm.
+                        #
+                        # @return [Array] Re-tuned ratios for each position in the MIDI octave.
+                        def best_match_ratios(frequencies_to_cover)
+                                standard_octave = STANDARD_MIDI_FREQUENCIES.dup
+                                ratios = []
+        
+                                while (next_frequency = frequencies_to_cover.shift)
+        
+                                        # Skip ahead (padding slots with 12TET frequencies from low to high) until:
+                                        #
+                                        # * the next 12TET frequency would be sharper, or
+                                        # * any more padding will leave us without enough space.
+                                        while (standard = standard_octave.shift) &&
+                                                        sounds_flatter?(standard, next_frequency) &&
+                                                        standard_octave.length > frequencies_to_cover.length
+        
+                                                ratios << standard
+                                        end
+        
+                                        # Use this frequency in this slot.
+                                        ratios << next_frequency
+                                end
+        
+                                ratios
+                        end
+        
+                        # Like < but considers values within FREQUENCY_FUDGE_FACTOR equal
+                        def sounds_flatter?(a, b)
+                                threshold = b * (1 - FREQUENCY_FUDGE_FACTOR)
+                                a < threshold
+                        end
+                end
+        end
+end

data/lib/inevitable_cacophony/note.rb

@@ -0,0 +1,39 @@
+# Represents a single note of a tune
+
+# TODO: only for Beat class
+require 'inevitable_cacophony/rhythm'
+
+module InevitableCacophony
+        class Note < Struct.new(:ratio, :beat)
+        
+        	# @param ratio [Numeric] Note frequency, as a multiple of the tonic.
+                # @param amplitude [Rhythm::Beat] A Beat object defining amplitude and timing
+        	def initialize(ratio, beat)
+        		super(ratio, beat)
+        	end
+        
+        	# Create a rest for the duration of the given beat.
+        	# @param beat [Beat]
+        	def self.rest(beat)
+        
+        		# Can't set ratio to 0 as it causes divide-by-zero errors
+        		new(1, Rhythm::Beat.new(0, beat.duration, beat.timing))
+        	end
+        
+        	def start_delay
+        		beat.start_delay
+        	end
+        
+        	def after_delay
+        		beat.after_delay
+        	end
+        
+        	def duration
+        		beat.duration
+        	end
+        
+                def frequency
+                       ratio
+                end
+        end
+end