inevitable_cacophony 0.0.0

data/lib/inevitable_cacophony/parser/sectioned_text.rb

@@ -0,0 +1,60 @@
+# Splits text into a sequence of delimited sections,
+# and knows how to find the one you want.
+#
+# Used to parse complex paragraph structures without
+# having to handle every single paragraph type,
+# and without crashing if an expected type is missing.
+
+module InevitableCacophony
+        module Parser
+        	class SectionedText
+        
+        		PARAGRAPH_DELIMITER = "\n\n"
+        		SENTENCE_DELIMITER = /\.\s+/
+        
+        		# @param description [String] The description to parse
+        		# @param delimiter [String,Regex] The delimiter between string sections. Defaults to splitting by paragraphs.
+        		def initialize(description, delimiter=PARAGRAPH_DELIMITER)
+        		        @sections = description.split(delimiter).map(&:strip)
+        		end
+        
+        		attr_accessor :sections
+        
+        		# Find a section (paragraph, sentence, etc.) of the description
+        		# matching a given regular expression.
+        		# @param key [Regex]
+        		# @return [String]
+        		def find(key)
+        		        find_all(key).first
+        		end
+        
+        		# Find all sections matching a given key
+        		# @param key [Regex]
+        		# @return [Array<String>]
+        		def find_all(key)
+        		        @sections.select { |s| key.match?(s) } || raise("No match for #{key.inspect} in #{@sections.inspect}")
+        		end
+        
+        		# Find a paragraph within the description, and break it up into sentences.
+        		# @param key [Regex]
+        		# @return [SectionedText] The paragraph, split into sentences.
+        		def find_paragraph(key)
+        		        find_all_paragraphs(key).first
+        		        find_all_paragraphs(key).first
+        		end
+        
+        		# As above but finds all matching paragraphs.
+        		# @param key [Regex]
+        		# @return [Array<SectionedText>]
+        		def find_all_paragraphs(key)
+        		        find_all(key).map do |string|
+        		                SectionedText.new(string, SENTENCE_DELIMITER)
+        		        end
+        		end
+        
+        		def inspect
+        		        "<SectionedText: #{@sections.inspect}>"
+        		end
+        	end
+        end
+end

data/lib/inevitable_cacophony/phrase.rb

@@ -0,0 +1,16 @@
+# Represents a "phrase", by which I mean a sequence of notes
+# with common performance instructions (tempo, volume, etc.)
+
+module InevitableCacophony
+        class Phrase
+        
+        	# @param notes [Array<Note>] The notes to play (what you'd write on the bar lines, mostly)
+        	# @param tempo [Numeric] Tempo in beats per minute.
+        	def initialize(*notes, tempo: raise)
+        		@tempo = tempo
+        		@notes = notes
+        	end
+        
+        	attr_reader :notes, :tempo
+        end
+end

data/lib/inevitable_cacophony/polyrhythm.rb

@@ -0,0 +1,169 @@
+# Represents a rhythm that combines two or more simpler rhythms.
+
+require 'set'
+
+require 'inevitable_cacophony/rhythm'
+
+module InevitableCacophony
+        class Polyrhythm < Rhythm
+        
+        	# Creates a new polyrhythm by combining two simpler component rhythms.
+        	# It will have the same duration as the primary rhythm, but include
+        	# beats from both it and all the secondaries.
+        	#
+        	# TODO: do I want to emphasise the primary rhythm more?
+        	#
+        	# @param primary [Rhythm] The rhythm that will be considered the primary.
+        	# @param secondaries [Array<Rhythm>] The other component rhythms.
+        	def initialize(primary, secondaries)
+        		@primary = primary
+        		@secondaries = secondaries
+        
+        		unscaled_beats = beats_from_canonical(canonical)
+        		scaled_beats = scale_beats(unscaled_beats, @primary.duration)
+        		super(scaled_beats)
+        	end
+        
+        	attr_accessor :primary, :secondaries
+        
+        	# @return [Array<Rhythm>] All the component rhythms that make up this polyrhythm
+        	def components
+        		[primary, *secondaries]
+        	end
+        
+        	# Calculates the canonical form by combining the two component rhythms.
+        	# @return [Array<Float>]
+        	def canonical
+        
+        		sounding = Set.new
+        		first, *rest = aligned_components
+        		unnormalised = first.zip(*rest).map do |beats_at_tick|
+        			beat, sounding = update_sounding_beats(sounding, beats_at_tick)
+        			beat
+        		end
+        
+        		# Renormalise to a maximum volume of 100%
+        		max_amplitude = unnormalised.compact.max.to_f
+        		unnormalised.map { |b| b && b / max_amplitude }
+        	end
+        
+        	def == other
+        		self.class == other.class &&
+        			self.primary == other.primary &&
+        			self.secondaries == other.secondaries
+        	end
+        
+        
+        	private
+        
+        	# Calculate a set of beats with timings from the given canonical rhythm.
+        	# TODO: properly account for pre-existing durations.
+        	#
+        	# @param canonical [Array<Float,NilClass>]
+        	# @return [Array<Beat>]
+        	def beats_from_canonical(canonical)
+        		[].tap do |beats|
+        			amplitude = canonical.shift || 0
+        
+        			duration = 1 # to account for the first timeslot that we just shifted off.
+        			canonical.each do |this_beat|
+        				if this_beat.nil?
+        					duration += 1
+        				else
+        					beats << Beat.new(amplitude, duration, 0)
+        
+        					# Now start collecting time for the next beat.
+        					duration = 1
+        					amplitude = this_beat
+        				end
+        			end
+        
+        			beats << Beat.new(amplitude, duration, 0)
+        		end
+        	end
+        
+        	# Returns the "canonical" forms of the component rhythms, but stretched
+        	# all to the same length, so corresponding beats in each rhythm have the
+        	# same index.
+        	# @return [Array<Array<Float, NilClass>>]
+        	def aligned_components
+        		canon_components = components.map(&:canonical)
+        		common_multiple = canon_components.map(&:length).inject(1, &:lcm)
+        
+        		# Stretch each component rhythm to the right length, and return them.
+        		canon_components.map do |component|
+        			stretch_factor = common_multiple / component.length
+        
+        			unless stretch_factor == stretch_factor.to_i
+        				raise "Expected dividing LCM of lengths by one length to be an integer."
+        			end
+        
+        			space_between_beats = stretch_factor - 1
+        
+        			component.map { |beat| [beat] + Array.new(space_between_beats) }.flatten
+        		end
+        	end
+        
+        	# Given several channels and the set of beats currently playing,
+        	# calculate the beat that should now start/stop/continue playing.
+        	#
+        	# @param sounding [Set{Integer}] The channels with a beat currently playing.
+        	# @param current_channel_state [Array<Float>] The beat each channel has at this tick.
+        	# 						(+nil+) means continuing an earlier beat.
+        	# @return [Array<[Float, NilClass],Set{Integer}] A two-element array like +[beat, sounding]+,
+        	# 		where +beat+ is the amplitude to play now (+nil+ to hold last note; 0 to stop),
+        	# 		and +sounding+ is the Set of channels still playing.
+        	def update_sounding_beats(sounding, current_channel_states)
+        
+        		beat = nil
+        
+        		# If we're starting new beats, they interrupt whatever came before.
+        		new_beats = indices_of(current_channel_states) { |b| b && b > 0 }
+        		if new_beats.any?
+        			sounding = new_beats.to_set
+        			beat = current_channel_states.compact.sum
+        		else
+        
+        			# If every beat has now stopped, go silent.
+        			# Otherwise, keep playing what's still sounding.
+        			finished_beats = indices_of(current_channel_states, 0)
+        			sounding.subtract(finished_beats)
+        
+        			if finished_beats.any? && sounding.empty?
+        				beat = 0
+        			end
+        		end
+        
+        		[beat, sounding]
+        	end
+        
+        	# TODO: should really be in some other class.
+        	# Returns all indices of an array where the given value can be found,
+        	# or all that match the given block
+        	#
+        	# @param array An object responding to #each_index and #[<index>]
+        	# @param condition The object we're looking for in the array
+        	# @return Array<Integer> indices into `array` matching the conditions.
+        	#
+        	# Source: steenslag at Stack Overflow (https://stackoverflow.com/a/13660352/10955118); CC-BY-SA
+        	def indices_of(array, condition=nil, &block)
+        		block ||= condition.method(:==)
+        
+        		array.each_index.select do |index|
+        			block.call(array[index])
+        		end
+        	end
+        
+        	# Scales each beat in the given list so the list has the given total duration.
+        	#
+        	# @param beats [Array<Beat>]
+        	# @param duration [Float]
+        	def scale_beats(beats, total_duration)
+        		scale_factor = total_duration.to_f / beats.map(&:duration).sum
+        
+        		beats.map do |beat|
+        			Beat.new(beat.amplitude, beat.duration * scale_factor, beat.timing)
+        		end
+        	end
+        end
+end

data/lib/inevitable_cacophony/rhythm.rb

@@ -0,0 +1,127 @@
+# A rhythm, represented as a sequence of beats of varying length and volume.
+# Beats may be "early" or "late", but internally this is represented by
+# adjusting the durations of surrounding beats.
+
+module InevitableCacophony
+        class Rhythm
+        
+                # Amount of silence before a note, as a fraction of the note's duration
+        	START_DELAY = (0.3).rationalize
+        
+                # Amount of silence after notes, as a fraction  of duration.
+        	AFTER_DELAY = (0.3).rationalize
+        
+        	# Amplitude -- how loud the beat is, on a scale from silent to MAX VOLUME.
+        	# Duration -- how long it is, in arbitrary beat units (think metronome ticks)
+        	# Timing -- how early or late the beat is, relative to the same metaphorical metronome.
+        	class Beat < Struct.new(:amplitude, :duration, :timing)
+        
+        		# How much earlier or later than normal this beat's time slice should start,
+        		# accounting for the standard start/end delays, timing, and duration.
+        		# Negative numbers start earlier, positive ones later.
+        		#
+        		# @return [Float]
+        		def start_offset
+        			standard_start_delay = START_DELAY * duration
+        			start_delay - standard_start_delay
+        		end
+        
+        		# How much silence there is before this note starts,
+        		# after the previous note has finished its time (like padding in CSS).
+        		#
+        		# @return [Float]
+        		def start_delay
+        			start_and_after_delays.first * duration
+        		end
+        
+        		# How much silence there is after this note ends,
+        		# before the next note's timeslot.
+        		#
+        		# @return [Float]
+        		def after_delay
+        			start_and_after_delays.last * duration
+        		end
+        
+                        # How long this note sounds for,
+                        # excluding any start/end delays.
+                        def sounding_time
+                                duration * (1 - start_and_after_delays.sum)
+                        end
+        
+        		private
+        
+        		# Calculate the before-note and after-note delays together,
+        		# to ensure they add up correctly.
+        		def start_and_after_delays
+        			@start_and_after_delays ||= begin
+        
+        				# Positive values from 0 to 1.
+        				# Higher numbers mean move more of this offset to the other side of the note
+        				# (e.g. start earlier for start offset).
+        				start_offset = -[timing, 0].min
+        				end_offset = [timing, 0].max
+        
+        				# This is basically matrix multiplication; multiply [START_DELAY, END_DELAY]
+        				# by [
+        				#	(1 - start_offset)	end_offset
+        				#	start_offset		(1 - end_offset)
+        				# ]
+        				[
+        					((1 - start_offset) * START_DELAY) + (end_offset * AFTER_DELAY),
+        					(start_offset * START_DELAY) +       ((1 - end_offset) * AFTER_DELAY)
+        				]
+        			end
+        		end
+        	end
+        
+        	def initialize(beats)
+        		@beats = beats
+        	end
+        
+        	attr_reader :beats
+        
+        	def each_beat(&block)
+        		@beats.each(&block)
+        	end
+        
+        	# @return [Integer] Total duration of all beats in this rhythm.
+        	def duration
+        		each_beat.sum(&:duration)
+        	end
+        
+        	# @return [Array<Numeric,NilClass>] An array where a[i] is the amplitude of the beat at time-step i
+        	# 				    (rests are 0), or nil if no beat is played then.
+        	# 				    This will be as long as necessary to represent the rhythm accurately,
+        	# 				    including early and late beats.
+        	def canonical
+        		if duration != duration.to_i
+        			raise "Cannot yet canonicalise rhythms with non-integer length"
+        		end
+        
+        		# Figure out the timing offset we need to allow for,
+        		# and space the beats enough to make it work.
+        		timing_offset_denominators = self.beats.map do |beat|
+        			beat.start_offset.rationalize.denominator
+        		end
+        		denominator = timing_offset_denominators.inject(1, &:lcm)
+        
+        		scaled_duration = duration * denominator
+        		Array.new(scaled_duration).tap do |spaced_beats|
+        			self.beats.each_with_index do |beat, index|
+        				offset_index = index + beat.start_offset
+        				scaled_index = offset_index * denominator
+        				spaced_beats[scaled_index] = beat.amplitude
+        			end
+        		end
+        	end
+        
+        	def inspect
+        		"<#Rhythm duration=#{duration} @beats=#{beats.inspect}>"
+        	end
+        
+        	def == other
+        		self.class == other.class &&
+        			self.beats == other.beats
+        	end
+        end
+end

data/lib/inevitable_cacophony/tone_generator.rb

@@ -0,0 +1,68 @@
+# Converts note information into raw WAV file data
+# Based on examples in {http://wavefilegem.com/examples}
+
+require 'wavefile'
+
+require 'inevitable_cacophony/note'
+
+module InevitableCacophony
+        class ToneGenerator
+        
+                SAMPLE_RATE = 44100 # Hertz
+        
+                # One full revolution of a circle (or one full cycle of a sine wave)
+                TAU = Math::PI * 2
+        
+                # Create a buffer representing a given phrase as an audio sample
+                #
+                # @param phrase [Phrase]
+        	def phrase_buffer(phrase)
+        		samples = phrase.notes.map { |note| note_samples(note, phrase.tempo) }
+                        WaveFile::Buffer.new(samples.flatten, WaveFile::Format.new(:mono, :float, SAMPLE_RATE))
+        	end
+        
+        	def add_phrase(phrase)
+        		@phrases << phrase_buffer(phrase)
+                end
+        
+                def write(io)
+                        WaveFile::Writer.new(io, WaveFile::Format.new(:mono, :pcm_16, SAMPLE_RATE)) do |writer|
+                                @phrases.each do |phrase|
+                                        writer.write(phrase)
+                                end
+                        end
+                end
+        
+                # @param tonic [Numeric] The tonic frequency, in Hertz
+                def initialize(tonic)
+                        @tonic = tonic
+                        @phrases = []
+                end
+        
+        	private
+        
+        	# Create a array of amplitudes representing a single note as a sample.
+        	#
+        	# @param note [Note]
+        	# @param tempo [Numeric] Tempo in BPM to play the note at
+        	# 			 (exact duration will also depend on the beat).
+                def note_samples(note, tempo)
+        		samples_per_wave = SAMPLE_RATE / (note.ratio.to_f * @tonic)
+        		samples_per_beat = (60.0 / tempo) * SAMPLE_RATE
+        		samples = []
+        
+        		start_delay = note.start_delay * samples_per_beat
+        		after_delay = note.after_delay * samples_per_beat
+        		note_length = (note.duration * samples_per_beat) - start_delay - after_delay
+        
+        		samples << ([0.0] * start_delay)
+        
+        		samples << note_length.to_i.times.map do |index|
+        			wave_fraction = index / samples_per_wave.to_f
+        			note.beat.amplitude * Math.sin(wave_fraction * TAU)
+                        end
+        		samples << ([0.0] * after_delay)
+        		samples.flatten
+                end
+        end
+end 

data/lib/inevitable_cacophony/version.rb

@@ -0,0 +1,3 @@
+module InevitableCacophony
+        VERSION = '0.0.0'
+end