tef-animation 0.1.0

data/lib/tef/ProgramSelection/ProgramSelector.rb

@@ -0,0 +1,76 @@
+
+require_relative 'ProgramID.rb'
+
+module TEF
+	module ProgramSelection
+		class Selector
+			attr_accessor :group_weights
+
+			def initialize()
+				@known_programs = {} # Hash based on titles
+				@known_groups = {}
+
+				@group_weights = {}
+			end
+
+			def register_ID(program, pgroups = [], pvariant = nil)
+				if program.is_a? String
+					program = ID.new(program, pgroups, pvariant)
+				end
+
+				proglist = (@known_programs[program.title] ||= [])
+
+				if found_prog = proglist.find { |prg| prg == program }
+					return found_prog
+				end
+
+				proglist << program
+
+				program.groups.each { |group| @known_groups[group] = true }
+
+				program
+			end
+
+			def fetch_ID(title, group_weights = {})
+				return nil if @known_programs[title].nil?
+
+				weights = @group_weights.merge(group_weights)
+
+				current_best = nil;
+				current_list = [];
+
+				@known_programs[title].each do |prg|
+					p_score = prg.get_scoring(weights);
+					current_best ||= p_score
+
+					next if current_best > p_score
+
+					if current_best == p_score
+						current_list << prg
+					else
+						current_best = p_score
+						current_list = [prg]
+					end
+				end
+
+				current_list.sample
+			end
+
+			def fetch_string(str)
+				title, groups = str.split(" from ");
+				groups ||= "";
+				groups = groups.split(" and ").map { |g| [g, 2] }.to_h
+
+				fetch_ID(title, groups)
+			end
+
+			def all_titles()
+				@known_programs.keys
+			end
+
+			def all_groups()
+				@known_groups.keys
+			end
+		end
+	end
+end

data/lib/tef/ProgramSelection/SequenceCollection.rb

@@ -0,0 +1,75 @@
+
+require_relative '../Sequencing/SheetSequence.rb'
+require_relative 'ProgramID.rb'
+
+module TEF
+	module ProgramSelection
+		class SequenceCollection
+			attr_reader :sheet_opts
+
+			def self.current_collection
+				@current_collection
+			end
+			def self.current_collection=(n_collection)
+				@current_collection = n_collection
+			end
+
+			def initialize(program_selector, sequence_runner)
+				@program_selector = program_selector
+				@sequence_runner = sequence_runner
+
+				@known_programs = {}
+				@sheet_opts = {}
+
+				self.class.current_collection = self
+			end
+
+			def [](key)
+				@known_programs[key]
+			end
+			def []=(key, n_program)
+				key = @program_selector.register_ID key
+				@known_programs[key] = n_program
+			end
+
+			def play(key)
+				prog = @known_programs[key]
+				return unless prog
+
+				prog_key = prog.program_key if prog.is_a? ProgramSheet
+
+				if prog.is_a? Sequencing::Sheet
+					opts = @sheet_opts[key] || {}
+					opts[:sheet] = prog
+					opts[:program_key] = key
+
+					prog = Sequencing::SheetSequence.new(Time.now(), 1, **opts)
+				end
+				prog_key ||= 'default'
+
+				@sequence_runner[prog_key] = prog
+			end
+		end
+
+		class ProgramSheet < TEF::Sequencing::Sheet
+			attr_accessor :program_key
+
+			def initialize()
+				super()
+
+				yield(self) if block_given?
+			end
+
+			## TODO Give option to add multiple keys with options-hash
+
+			def add_key(title, groups = [], variation = '.mp3')
+				prog_collection = SequenceCollection.current_collection
+				raise "No program collection was instantiated yet!" unless prog_collection
+
+				id = ID.new(title, groups, variation)
+
+				prog_collection[id] = self
+			end
+		end
+	end
+end

data/lib/tef/ProgramSelection/SoundCollection.rb

@@ -0,0 +1,108 @@
+
+require_relative 'ProgramSelector.rb'
+
+require 'yaml'
+
+module TEF
+	module ProgramSelection
+		class SoundCollection
+			attr_reader :silence_maps
+			attr_reader :soundmap
+			attr_reader :load_config
+
+			def initialize(program_handler)
+				@handler = program_handler
+				@soundmap = {}
+
+				@load_config  = {};
+				@silence_maps = {}
+
+				if File.file? './sounds/soundconfig.yml'
+					@load_config = YAML.load File.read './sounds/soundconfig.yml'
+				end
+
+				if File.file? './sounds/silence_maps.yml'
+					@silence_maps = YAML.load File.read './sounds/silence_maps.yml'
+				end
+
+				`find ./`.split("\n").each { |fn| add_file fn };
+
+				File.write('./sounds/silence_maps.yml', YAML.dump(@silence_maps));
+
+				@play_pids = {};
+			end
+
+			def generate_silences(fname)
+				return if @silence_maps[fname]
+
+				ffmpeg_str = `ffmpeg -i #{fname} -af silencedetect=n=0.1:d=0.1 -f null - 2>&1`
+
+				out_event = {}
+
+				ffmpeg_str.split("\n").each do |line|
+					if line =~ /silence_start: ([\d\.-]*)/
+						out_event[$1.to_f] = 0
+					elsif line =~ /silence_end: ([\d\.-]*)/
+						out_event[$1.to_f] = 1
+					elsif line =~ /Duration: (\d+):(\d+):([\d\.]+)/
+						out_event[$1.to_f * 3600 + $2.to_f * 60 + $3.to_f] = 0
+					end
+				end
+
+				out_event = out_event.sort.to_h
+
+				if(out_event.empty?)
+					out_event[0.01] = 1
+				elsif (k = out_event.keys[0]) < 0
+					out_event.delete k
+					out_event[0.01] = 0
+				else
+					out_event[0.01] = 1
+				end
+
+				out_event = out_event.sort.to_h
+
+				@silence_maps[fname] = out_event
+			end
+
+			def add_file(fname)
+				rMatch = /^\.\/sounds\/(?<groups>(?:[a-z_]+[\/-])*)(?<title>[a-z_]+)(?<variant>(?:-\d+)?\.(?:ogg|mp3|wav))/.match fname;
+				return unless rMatch;
+
+				title = rMatch[:title].gsub('_', ' ');
+				groups = rMatch[:groups].gsub('_', ' ').gsub('-','/').split('/');
+
+				groups = ["default"] if groups.empty?
+
+				id = @handler.register_ID(title, groups, rMatch[:variant])
+
+				@soundmap[id] = fname
+
+				generate_silences fname
+			end
+
+			def silences_for(key)
+				@silence_maps[@soundmap[key]]
+			end
+
+			def play(id, collection_id = 'default')
+				sound_name = @soundmap[id]
+				return if sound_name.nil?
+
+				collection_id ||= id;
+
+				if old_pid = @play_pids[collection_id]
+					Process.kill('QUIT', old_pid)
+				end
+
+				Thread.new do
+					fork_pid = spawn(*%W{play -q --volume 0.3 #{sound_name}});
+
+					@play_pids[collection_id] = fork_pid;
+					Process.waitpid fork_pid;
+					@play_pids.delete collection_id
+				end
+			end
+		end
+	end
+end

data/lib/tef/Sequencing/BaseSequence.rb

@@ -0,0 +1,72 @@
+
+require_relative 'EventCollector.rb'
+
+module TEF
+	module Sequencing
+		class BaseSequence
+			attr_reader :start_time
+			attr_reader :end_time
+
+			attr_reader :offset
+			attr_reader :slope
+
+			attr_reader :state
+
+			def initialize(offset, slope, **options)
+				@start_time ||= options[:start_time] || 0;
+				@end_time   ||= options[:end_time];
+
+				@offset = offset;
+				@slope  = slope;
+
+				@state = :uninitialized
+
+				@opts_hash = options;
+			end
+
+			def parent_start_time
+				@offset + @start_time / @slope
+			end
+
+			def setup()
+				raise 'Program had to be uninitialized!' unless @state == :uninitialized
+				@state = :running
+			end
+
+			def teardown()
+				return unless @state == :running
+				@state = :torn_down
+
+				@opts_hash = nil;
+			end
+
+			def append_events(collector)
+				local_collector = collector.offset_collector(@offset, @slope);
+
+				return if local_collector.has_events? &&
+							 local_collector.event_time < @start_time
+				return if @state == :torn_down
+
+				if @state == :uninitialized
+					local_collector.add_event({
+						time: @start_time,
+						code: proc { self.setup() }
+					});
+				end
+
+				if @state == :running
+					overload_append_events(local_collector)
+				end
+
+				if !@end_time.nil?
+					local_collector.add_event({
+						time: @end_time,
+						code: proc { self.teardown }
+					})
+				end
+			end
+
+			def overload_append_events(_collector) end
+		end
+	end
+end

data/lib/tef/Sequencing/EventCollector.rb

@@ -0,0 +1,127 @@
+
+require 'xasin_logger'
+
+module TEF
+	module Sequencing
+		class OffsetCollector
+			attr_reader :parent
+
+			attr_reader :total_offset
+			attr_reader :total_slope
+
+			def initialize(parent, total_offset, total_slope)
+				@parent = parent
+				@total_offset = total_offset
+				@total_slope  = total_slope
+			end
+
+			def convert_to_local(global_time)
+				return nil if global_time.nil?
+
+				(global_time - @total_offset) * @total_slope
+			end
+			def convert_to_global(local_time)
+				return nil if local_time.nil?
+
+				@total_offset + (local_time.to_f / @total_slope)
+			end
+
+			def start_time
+				convert_to_local @parent.start_time
+			end
+
+			def event_time
+				convert_to_local @parent.event_time
+			end
+
+			def has_events?
+				return @parent.has_events?
+			end
+
+			def add_event(event)
+				event = event.clone
+
+				event[:time] = convert_to_global event[:time]
+
+				@parent.add_event event
+			end
+
+			def add_events(list)
+				list.each { |event| add_event event }
+			end
+
+			def offset_collector(offset, slope)
+				OffsetCollector.new(@parent, convert_to_global(offset), @total_slope * slope)
+			end
+		end
+
+		class EventCollector
+			include XasLogger::Mix
+
+			attr_accessor :start_time
+			attr_reader   :event_time
+
+			attr_reader :current_events
+
+			def initialize()
+				@current_events = []
+				@start_time = Time.at(0);
+				@event_time = nil;
+
+				init_x_log("Sequence Player")
+			end
+
+			def add_event(event)
+				return if event[:time] <= @start_time
+				return if (!@event_time.nil?) && (event[:time] > @event_time)
+
+				if (!@event_time.nil?) && (event[:time] == @event_time)
+					@current_events << event
+				else
+					@current_events = [event]
+					@event_time = event[:time]
+				end
+			end
+
+			def has_events?
+				!@current_events.empty?
+			end
+
+			def wait_until_event
+				return unless has_events?
+
+				t_diff = @event_time - Time.now();
+
+				if t_diff < -0.5
+					x_logf('Sequence long overdue!')
+				elsif t_diff < -0.1
+					x_logw('Sequencing overdue')
+				end
+
+				sleep t_diff if t_diff > 0
+			end
+
+			def execute!
+				return unless has_events?
+
+				wait_until_event
+
+				@current_events.each do |event|
+					event[:code].call()
+				end
+
+				@start_time = @event_time
+				restart();
+			end
+
+			def restart()
+				@current_events = []
+				@event_time = nil;
+			end
+
+			def offset_collector(offset, slope)
+				OffsetCollector.new(self, offset, slope);
+			end
+		end
+	end
+end