From f44d83ba7e10a7d28cc032bff49c741e709ef2b5 Mon Sep 17 00:00:00 2001 From: Tristan Rowley Date: Tue, 11 Feb 2020 23:15:26 +0000 Subject: [PATCH] Experimental -- need to test if this has worsened performance... automation frames and macros are now handled using objects to represent them. the idea being that this will ultimately lead to being able to add new recording streams easily --- data_centre/plugin_collection.py | 15 +- plugins/ShaderLoopRecordPlugin.py | 45 +++-- plugins/ShaderQuickPresetPlugin.py | 7 +- plugins/frame_manager.py | 278 +++++++++++++++++++++++++++++ video_centre/shaders.py | 200 --------------------- 5 files changed, 324 insertions(+), 221 deletions(-) create mode 100644 plugins/frame_manager.py diff --git a/data_centre/plugin_collection.py b/data_centre/plugin_collection.py index 7e88531..1de558f 100644 --- a/data_centre/plugin_collection.py +++ b/data_centre/plugin_collection.py @@ -3,6 +3,7 @@ import os import pkgutil import re +from plugins.frame_manager import FrameManager, Frame class Plugin(object): """Base class that each plugin must inherit from. within this class @@ -210,16 +211,16 @@ class DisplayPlugin(Plugin): def __init__(self, plugin_collection): super().__init__(plugin_collection) - def is_handled(self, name): + def is_handled(self, name): raise NotImplementedError - def get_display_modes(self): + def get_display_modes(self): raise NotImplementedError - def show_plugin(self, display): - from tkinter import Text, END - #display_text.insert(END, 'test from DisplayPlugin') - display.display_text.insert(END, '{} \n'.format(display.body_title)) + def show_plugin(self, display): + from tkinter import Text, END + #display_text.insert(END, 'test from DisplayPlugin') + display.display_text.insert(END, '{} \n'.format(display.body_title)) # adapted from https://github.com/gdiepen/python_plugin_example @@ -251,6 +252,8 @@ class PluginCollection(object): #self.actions = message_handler.actions self.reload_plugins() + self.fm = FrameManager(self) + def read_json(self, file_name): return self.data._read_plugin_json(file_name) def update_json(self, file_name, data): diff --git a/plugins/ShaderLoopRecordPlugin.py b/plugins/ShaderLoopRecordPlugin.py index 65dc369..c986610 100644 --- a/plugins/ShaderLoopRecordPlugin.py +++ b/plugins/ShaderLoopRecordPlugin.py @@ -1,16 +1,36 @@ import data_centre.plugin_collection from data_centre.plugin_collection import ActionsPlugin, SequencePlugin +from plugins.frame_manager import Frame class ShaderLoopRecordPlugin(ActionsPlugin,SequencePlugin): disabled = False MAX_CLIPS = 8 + frames = [] def __init__(self, plugin_collection): super().__init__(plugin_collection) self.PRESET_FILE_NAME = "ShaderLoopRecordPlugin/frames.json" - self.frames = self.load_presets() + #TODO: this doesnt work + """self.frames = [ + [ + Frame(self.pc).store_copy(f) + for f in [ + z for z in [ + frame for frame in [ + clip for clip in self.load_presets() + ] + ] + ] + ] + ]""" + for clip in self.load_presets(): + c = [] + for frame in clip: + c.append(Frame(self.pc).store_copy(frame)) + self.frames.append(c) + self.reset_ignored() def load_presets(self): @@ -71,7 +91,7 @@ class ShaderLoopRecordPlugin(ActionsPlugin,SequencePlugin): self.save_presets() def get_empty_clip(self, duration = 2000): - return [{}] * (int(duration / self.frequency)) + return [None] * (int(duration / self.frequency)) def get_factory_reset(self): return [ self.get_empty_clip(self.duration) for i in range(self.MAX_CLIPS) ] @@ -99,10 +119,10 @@ class ShaderLoopRecordPlugin(ActionsPlugin,SequencePlugin): def reset_ignored(self): # print("!!!!resetting ignored") - self.ignored = { 'shader_params': [[None]*4,[None]*4,[None]*4] } + self.ignored = Frame(self.pc).store_copy({ 'shader_params': [[None]*4,[None]*4,[None]*4] }) def is_ignoring(self): - return not self.pc.shaders.is_frame_empty(self.ignored) + return not self.pc.fm.is_frame_empty(self.ignored) def select_clip(self, clip): self.selected_clip = clip @@ -128,7 +148,7 @@ class ShaderLoopRecordPlugin(ActionsPlugin,SequencePlugin): if self.DEBUG_FRAMES: print (">>>>>>>>>>>>>>frame at %i%%: %i" % (position*100, current_frame_index)) #print("got frame index %s" % current_frame_index) - current_frame = self.pc.shaders.get_live_frame().copy() + current_frame = self.pc.fm.get_live_frame() #.copy() selected_clip = self.selected_clip if self.DEBUG_FRAMES: print("current_frame copy before recall is %s" % current_frame['shader_params']) @@ -141,25 +161,26 @@ class ShaderLoopRecordPlugin(ActionsPlugin,SequencePlugin): for selected_clip in self.running_clips: saved_frame = self.frames[selected_clip][current_frame_index] if not self.recording or (selected_clip!=self.selected_clip): - self.pc.shaders.recall_frame(saved_frame) + self.pc.fm.recall_frame(saved_frame) if self.recording and selected_clip==self.selected_clip: if self.last_frame is None: self.last_frame = current_frame if self.DEBUG_FRAMES: print("last frame is \t\t%s" % self.last_frame['shader_params']) if self.DEBUG_FRAMES: print("current f is \t\t%s" % current_frame['shader_params']) - diff = self.pc.shaders.get_frame_diff(self.last_frame,current_frame) + diff = self.pc.fm.get_frame_diff(self.last_frame,current_frame) if self.DEBUG_FRAMES: print("diffed frame is \t%s" % diff['shader_params']) if self.overdub and saved_frame: # add the params tweaked this frame to the params to be ignored by recall if self.DEBUG_FRAMES: print("saved frame is \t%s" % saved_frame['shader_params']) - self.ignored = self.pc.shaders.merge_frames(self.ignored, diff) - diff = self.pc.shaders.merge_frames( - self.pc.shaders.get_frame_ignored(saved_frame, self.ignored), + self.ignored = self.pc.fm.merge_frames(self.ignored, diff) + print("about to call get_ignored_frames with %s\n and\n %s" % (saved_frame.f, self.ignored.f)) + diff = self.pc.fm.merge_frames( + self.pc.fm.get_frame_ignored(saved_frame, self.ignored), diff ) #diff = self.pc.shaders.merge_frames(self.pc.shaders.get_live_frame(), diff) - self.pc.shaders.recall_frame(diff) + self.pc.fm.recall_frame(diff) if self.DEBUG_FRAMES: print("after diff2 is: \t%s" % diff['shader_params']) if self.DEBUG_FRAMES: print("||||saving frame \t%s" % (diff['shader_params'])) self.frames[selected_clip][current_frame_index] = diff #self.get_frame_diff(self.last_frame,current_frame) @@ -170,7 +191,7 @@ class ShaderLoopRecordPlugin(ActionsPlugin,SequencePlugin): if self.DEBUG_FRAMES:print("backfilling frame %s" % ((self.last_saved_index+i+1)%len(self.frames[selected_clip]))) self.frames[selected_clip][(self.last_saved_index+i+1)%len(self.frames[selected_clip])] = diff self.last_saved_index = current_frame_index - self.last_frame = self.pc.shaders.get_live_frame() #diff + self.last_frame = self.pc.fm.get_live_frame() #diff if self.DEBUG_FRAMES: print("<<<<<<<<<<<<<< frame at %s" % current_frame_index) """def recall_frame_index(self, index): diff --git a/plugins/ShaderQuickPresetPlugin.py b/plugins/ShaderQuickPresetPlugin.py index 3724760..dfb359e 100644 --- a/plugins/ShaderQuickPresetPlugin.py +++ b/plugins/ShaderQuickPresetPlugin.py @@ -1,6 +1,7 @@ import data_centre.plugin_collection from data_centre.plugin_collection import ActionsPlugin, SequencePlugin import copy +from plugins.frame_manager import Frame class ShaderQuickPresetPlugin(ActionsPlugin): #,SequencePlugin): disabled = False @@ -19,7 +20,7 @@ class ShaderQuickPresetPlugin(ActionsPlugin): #,SequencePlugin): def load_presets(self): print("trying load presets? %s " % self.PRESET_FILE_NAME) - return self.pc.read_json(self.PRESET_FILE_NAME) or ([None]*self.MAX_PRESETS) + return [ Frame(self.pc).store_copy(x) for x in (self.pc.read_json(self.PRESET_FILE_NAME) or ([None]*self.MAX_PRESETS)) ] def save_presets(self): self.pc.update_json(self.PRESET_FILE_NAME, self.presets) @@ -57,7 +58,7 @@ class ShaderQuickPresetPlugin(ActionsPlugin): #,SequencePlugin): if self.selected_preset is None: self.selected_preset = 0 insert_position = self.selected_preset - self.presets[insert_position] = self.pc.shaders.get_live_frame() + self.presets[insert_position] = self.pc.fm.get_live_frame() #print ("stored %s at position %s" % (self.presets[insert_position], insert_position)) self.selected_preset = insert_position self.last_recalled = insert_position @@ -80,5 +81,5 @@ class ShaderQuickPresetPlugin(ActionsPlugin): #,SequencePlugin): preset = self.presets[preset] print ("recalled preset %s" % preset) - self.pc.shaders.recall_frame(preset) + self.pc.fm.recall_frame(preset) diff --git a/plugins/frame_manager.py b/plugins/frame_manager.py new file mode 100644 index 0000000..829f91d --- /dev/null +++ b/plugins/frame_manager.py @@ -0,0 +1,278 @@ +import copy +import json +from json import JSONEncoder + +def _default(self, obj): + if getattr(obj.__class__,'to_json'): + #return _default.default(obj.to_json()) + return obj.to_json() + else: + return _default.default(obj) + +_default.default = JSONEncoder().default +JSONEncoder.default = _default + +class Frame: + f = { 'shader_params': [[None]*4,[None]*4,[None]*4] } + pc = None + + DEBUG_FRAMES = False#True + + def __init__(self, pc): + import copy #from copy import deepcopy + self.pc = pc + + def to_json(self): + return self.f #{ 'f': self.f } + + def store_live(self): + frame = { + 'selected_shader_slots': [ shader.get('slot',None) for shader in self.pc.shaders.selected_shader_list ], + 'shader_params': copy.deepcopy(self.pc.shaders.selected_param_list), + 'layer_active_status': copy.deepcopy(self.pc.shaders.selected_status_list), + 'feedback_active': self.pc.shaders.data.feedback_active, + 'x3_as_speed': self.pc.shaders.data.settings['shader']['X3_AS_SPEED']['value'], + 'shader_speeds': copy.deepcopy(self.pc.shaders.selected_speed_list), + 'strobe_amount': self.pc.shaders.data.settings['shader']['STROBE_AMOUNT']['value'] / 10.0 + } + self.f = frame + #print("built frame: %s" % frame['shader_params']) + return self + + def store_copy(self, f): + print("told to store_copy %s" % f) + if f is not None: + if f.get('f') is not None: #isinstance(f, Frame): + f = f.get('f') + return self.store_copy(f.get('f')) + self.f = f + else: + self.f = {} + return self + + def recall_frame_params(self): + #print("recall_frame_params got: %s" % preset.get('shader_params')) + for (layer, param_list) in enumerate(self.f.get('shader_params',[])): + if param_list: + for param,value in enumerate(param_list): + #if (ignored is not None and ignored['shader_params'][layer][param] is not None): + # print ("ignoring %s,%s because value is %s" % (layer,param,ignored['shader_params'][layer][param])) + # continue + if (value is not None): + #print("recalling layer %s param %s: value %s" % (layer,param,value)) + self.pc.actions.call_method_name('set_the_shader_param_%s_layer_%s_continuous' % (param,layer), value) + + if self.f.get('feedback_active') is not None: + self.pc.data.feedback_active = self.f.get('feedback_active',self.pc.data.feedback_active) + if self.pc.data.feedback_active: + self.pc.actions.call_method_name('enable_feedback') + else: + self.pc.actions.call_method_name('disable_feedback') + + if self.f.get('x3_as_speed') is not None: + self.pc.data.settings['shader']['X3_AS_SPEED']['value'] = self.f.get('x3_as_speed',self.pc.data.settings['shader']['X3_AS_SPEED']['value']) + """if self.data.settings['shader']['X3_AS_SPEED']['value']: + self.data.plugins.actions.call_method_name('enable_x3_as_speed') + else: + self.data.plugins.actions.call_method_name('disable_x3_as_speed')""" + + for (layer, speed) in enumerate(self.f.get('shader_speeds',[])): + if speed is not None: + self.pc.actions.call_method_name('set_shader_speed_layer_%s_amount' % layer, speed) + + if self.f.get('strobe_amount') is not None: + self.pc.actions.set_strobe_amount_continuous(self.f.get('strobe_amount')) + + def recall_frame(self): + preset = self + + if preset.f is None: + return + + self.pc.data.settings['shader']['X3_AS_SPEED']['value'] = preset.f.get('x3_as_speed') + + # x3_as_speed affects preset recall, so do that first + self.recall_frame_params() + + for (layer, slot) in enumerate(preset.f.get('selected_shader_slots',[])): + if slot is not None: + #print("setting layer %s to slot %s" % (layer, slot)) + self.pc.actions.call_method_name('play_shader_%s_%s' % (layer, slot)) + + for (layer, active) in enumerate(preset.f.get('layer_active_status',[])): + # print ("got %s layer with status %s " % (layer,active)) + if active=='▶': + self.pc.actions.call_method_name('start_shader_layer_%s' % layer) + else: + self.pc.actions.call_method_name('stop_shader_layer_%s' % layer) + + def merge(self, frame2): + from copy import deepcopy + f = deepcopy(self.f) #frame1.copy() + #if self.DEBUG_FRAMES: print("merge_frames: got frame1\t%s" % frame1) + #if self.DEBUG_FRAMES: print("merge_frames: got frame2\t%s" % frame2) + for i,f2 in enumerate(frame2.f.get('shader_params')): + for i2,p in enumerate(f2): + if p is not None: + if 'shader_params' not in f: + f['shader_params'] = [[None]*4,[None]*4,[None]*4] + f['shader_params'][i][i2] = p + + if frame2.f.get('feedback_active') is not None: + f['feedback_active'] = frame2['feedback_active'] + + if frame2.f.get('x3_as_speed') is not None: + f['x3_as_speed'] = frame2.f.get('x3_as_speed') + + if f.get('shader_speeds') is None: + if 'shader_speeds' in frame2.f: + f['shader_speeds'] = frame2.f.get('shader_speeds') + else: + for i,s in enumerate(frame2.f.get('shader_speeds')): + if s is not None: + f['shader_speeds'][i] = s + + if frame2.f.get('strobe_amount'): + f['strobe_amount'] = frame2.f.get('strobe_amount') + + if self.DEBUG_FRAMES: print("merge_frames: got return\t%s" % f) + return Frame(self.pc).store_copy(f) + + def get_ignored(self, ignored): + from copy import deepcopy + f = deepcopy(self.f) #frame1.copy() + frame = self.f + ignored = ignored.f + if self.DEBUG_FRAMES: print("get_frame_ignored: got frame\t%s" % self.f) + for i,f2 in enumerate(frame.get('shader_params',[])): + for i2,p in enumerate(f2): + if ignored['shader_params'][i][i2] is not None: + f['shader_params'][i][i2] = None + if ignored.get('feedback_active') is not None: + f['feedback_active'] = None + if ignored.get('x3_as_speed') is not None: + f['x3_as_speed'] = None + if ignored.get('shader_speeds') is not None and frame.get('shader_speeds') is not None: + for i,s in enumerate(frame.get('shader_speeds')): + if ignored['shader_speeds'][i] is not None: + f['shader_speeds'][i] = None + if ignored.get('strobe_amount') is not None: + f['strobe_amount'] = None + if self.DEBUG_FRAMES: print("get_frame_ignored: got return\t%s" % f) + return Frame(self.pc).store_copy(f) + + def is_empty(self): + #from copy import deepcopy + #f = deepcopy(frame) #frame1.copy() + frame = self.f + if self.DEBUG_FRAMES: print("is_frame_empty: got frame\t%s" % frame) + + if frame.get('feedback_active') is not None: + return False + if frame.get('x3_as_speed') is not None: + return False + if frame.get('strobe_amount') is not None: + return False + + for i,f in enumerate(frame['shader_params']): + for i2,p in enumerate(f): + if p is not None: #ignored['shader_params'][i][i2] is not None: + return False + + if frame.get('shader_speeds') is not None: + for i,f in enumerate(frame['shader_speeds']): + if f is not None: + return False + + if self.DEBUG_FRAMES: print("is_frame_empty: got return true") + return True + + def get_diff(self, current_frame): + #if not last_frame: return current_frame + current_frame = current_frame.f + last_frame = self.f + + if self.DEBUG_FRAMES: + print(">>>>get_frame_diff>>>>") + print("last_frame: \t%s" % last_frame['shader_params']) + print("current_frame: \t%s" % current_frame['shader_params']) + + param_values = [[None]*4,[None]*4,[None]*4] + for layer,params in enumerate(current_frame.get('shader_params',[[None]*4]*3)): + #if self.DEBUG_FRAMES: print("got layer %s params: %s" % (layer, params)) + for param,p in enumerate(params): + if p is not None and p != last_frame.get('shader_params')[layer][param]: + if self.DEBUG_FRAMES: print("setting layer %s param %s to %s" % (layer,param,p)) + param_values[layer][param] = p + + if current_frame['feedback_active'] is not None and last_frame['feedback_active'] != current_frame['feedback_active']: + feedback_active = current_frame['feedback_active'] + else: + feedback_active = None + + if current_frame['x3_as_speed'] is not None and last_frame['x3_as_speed'] != current_frame['x3_as_speed']: + x3_as_speed = current_frame['x3_as_speed'] + else: + x3_as_speed = None + + speed_values = [None]*3 + for layer,param in enumerate(current_frame.get('shader_speeds',[None]*3)): + if param is not None and param != last_frame['shader_speeds'][layer]: + speed_values[layer] = param + + if current_frame['strobe_amount'] is not None and last_frame['strobe_amount'] != current_frame['strobe_amount']: + strobe_amount = current_frame['strobe_amount'] + else: + strobe_amount = None + + if self.DEBUG_FRAMES: + print("param_values is\t%s" % param_values) + print("speed_values is\t%s" % speed_values) + + diff = { + 'shader_params': param_values, + 'feedback_active': feedback_active, + 'x3_as_speed': x3_as_speed, + 'shader_speeds': speed_values, + 'strobe_amount': strobe_amount, + } + if self.DEBUG_FRAMES: print("returning\t%s\n^^^^" % diff['shader_params']) + + return Frame(self.pc).store_copy(diff) + + + + + +class FrameManager: + pc = None + + def __init__(self, pc): + self.pc = pc + + def get_live_frame(self): + return Frame(self.pc).store_live() + + def recall_frame_params(self, preset): + if preset is None: + return + preset.recall_frame_params() + + def recall_frame(self, preset): + if preset is None: + return + preset.recall_frame() + + # overlay frame2 on frame1 + def merge_frames(self, frame1, frame2): + return frame1.merge(frame2) + + def get_frame_ignored(self, frame, ignored): + return frame.get_ignored(ignored) + + def is_frame_empty(self, frame): + return frame.is_empty() + + def get_frame_diff(self, last_frame, current_frame): + return last_frame.get_diff(current_frame) + diff --git a/video_centre/shaders.py b/video_centre/shaders.py index 99ae8dd..73b0f74 100644 --- a/video_centre/shaders.py +++ b/video_centre/shaders.py @@ -265,203 +265,3 @@ class Shaders(object): self.osc_client.send_message("/shader/{}/speed".format(str(layer)), amount ) self.selected_speed_list[layer] = amount - # methods for helping dealing with storing and recalling shader parameter frame states - def get_live_frame(self): - #print("get_live_frame: %s" % self.pc.message_handler.shaders.selected_param_list) - import copy #from copy import deepcopy - frame = { - 'selected_shader_slots': [ shader.get('slot',None) for shader in self.selected_shader_list ], - 'shader_params': copy.deepcopy(self.selected_param_list), - 'layer_active_status': copy.deepcopy(self.selected_status_list), - 'feedback_active': self.data.feedback_active, - 'x3_as_speed': self.data.settings['shader']['X3_AS_SPEED']['value'], - 'shader_speeds': copy.deepcopy(self.selected_speed_list), - 'strobe_amount': self.data.settings['shader']['STROBE_AMOUNT']['value'] / 10.0 - } - #print("built frame: %s" % frame['shader_params']) - return frame - - def recall_frame_params(self, preset): - if preset is None: - return - #print("recall_frame_params got: %s" % preset.get('shader_params')) - for (layer, param_list) in enumerate(preset.get('shader_params',[])): - if param_list: - for param,value in enumerate(param_list): - #if (ignored is not None and ignored['shader_params'][layer][param] is not None): - # print ("ignoring %s,%s because value is %s" % (layer,param,ignored['shader_params'][layer][param])) - # continue - if (value is not None): - #print("recalling layer %s param %s: value %s" % (layer,param,value)) - self.data.plugins.actions.call_method_name('set_the_shader_param_%s_layer_%s_continuous' % (param,layer), value) - - if preset.get('feedback_active') is not None: - self.data.feedback_active = preset.get('feedback_active',self.data.feedback_active) - if self.data.feedback_active: - self.data.plugins.actions.call_method_name('enable_feedback') - else: - self.data.plugins.actions.call_method_name('disable_feedback') - - if preset.get('x3_as_speed') is not None: - self.data.settings['shader']['X3_AS_SPEED']['value'] = preset.get('x3_as_speed',self.data.settings['shader']['X3_AS_SPEED']['value']) - """if self.data.settings['shader']['X3_AS_SPEED']['value']: - self.data.plugins.actions.call_method_name('enable_x3_as_speed') - else: - self.data.plugins.actions.call_method_name('disable_x3_as_speed')""" - - for (layer, speed) in enumerate(preset.get('shader_speeds',[])): - if speed is not None: - self.data.plugins.actions.call_method_name('set_shader_speed_layer_%s_amount' % layer, speed) - - if preset.get('strobe_amount') is not None: - self.data.plugins.actions.set_strobe_amount_continuous(preset.get('strobe_amount')) - - def recall_frame(self, preset): - - self.data.settings['shader']['X3_AS_SPEED']['value'] = preset.get('x3_as_speed') - - # x3_as_speed affects preset recall, so do that first - self.recall_frame_params(preset) - - for (layer, slot) in enumerate(preset.get('selected_shader_slots',[])): - if slot is not None: - #print("setting layer %s to slot %s" % (layer, slot)) - self.data.plugins.actions.call_method_name('play_shader_%s_%s' % (layer, slot)) - - for (layer, active) in enumerate(preset.get('layer_active_status',[])): - # print ("got %s layer with status %s " % (layer,active)) - if active=='▶': - self.data.plugins.actions.call_method_name('start_shader_layer_%s' % layer) - else: - self.data.plugins.actions.call_method_name('stop_shader_layer_%s' % layer) - - DEBUG_FRAMES = False - - # overlay frame2 on frame1 - def merge_frames(self, frame1, frame2): - from copy import deepcopy - f = deepcopy(frame1) #frame1.copy() - if self.DEBUG_FRAMES: print("merge_frames: got frame1\t%s" % frame1) - if self.DEBUG_FRAMES: print("merge_frames: got frame2\t%s" % frame2) - for i,f2 in enumerate(frame2['shader_params']): - for i2,p in enumerate(f2): - if p is not None: - f['shader_params'][i][i2] = p - - if frame2['feedback_active'] is not None: - f['feedback_active'] = frame2['feedback_active'] - - if frame2['x3_as_speed'] is not None: - f['x3_as_speed'] = frame2['x3_as_speed'] - - if f.get('shader_speeds') is None: - f['shader_speeds'] = frame2.get('shader_speeds') - else: - for i,s in enumerate(frame2['shader_speeds']): - if s is not None: - f['shader_speeds'][i] = s - - if frame2.get('strobe_amount'): - f['strobe_amount'] = frame2.get('strobe_amount') - - if self.DEBUG_FRAMES: print("merge_frames: got return\t%s" % f) - return f - - def get_frame_ignored(self, frame, ignored): - from copy import deepcopy - f = deepcopy(frame) #frame1.copy() - if self.DEBUG_FRAMES: print("get_frame_ignored: got frame\t%s" % frame) - for i,f2 in enumerate(frame['shader_params']): - for i2,p in enumerate(f2): - if ignored['shader_params'][i][i2] is not None: - f['shader_params'][i][i2] = None - if ignored.get('feedback_active') is not None: - f['feedback_active'] = None - if ignored.get('x3_as_speed') is not None: - f['x3_as_speed'] = None - if ignored.get('shader_speeds') is not None and frame.get('shader_speeds'): - for i,s in enumerate(frame.get('shader_speeds')): - if ignored['shader_speeds'][i] is not None: - f['shader_speeds'][i] = None - if ignored.get('strobe_amount') is not None: - f['strobe_amount'] = None - if self.DEBUG_FRAMES: print("get_frame_ignored: got return\t%s" % f) - return f - - def is_frame_empty(self, frame): - #from copy import deepcopy - #f = deepcopy(frame) #frame1.copy() - if self.DEBUG_FRAMES: print("is_frame_empty: got frame\t%s" % frame) - - if frame.get('feedback_active') is not None: - return False - if frame.get('x3_as_speed') is not None: - return False - if frame.get('strobe_amount') is not None: - return False - - for i,f in enumerate(frame['shader_params']): - for i2,p in enumerate(f): - if p is not None: #ignored['shader_params'][i][i2] is not None: - return False - - if frame.get('shader_speeds') is not None: - for i,f in enumerate(frame['shader_speeds']): - if f is not None: - return False - - if self.DEBUG_FRAMES: print("is_frame_empty: got return true") - return True - - - def get_frame_diff(self, last_frame, current_frame): - if not last_frame: return current_frame - - if self.DEBUG_FRAMES: - print(">>>>get_frame_diff>>>>") - print("last_frame: \t%s" % last_frame['shader_params']) - print("current_frame: \t%s" % current_frame['shader_params']) - - param_values = [[None]*4,[None]*4,[None]*4] - for layer,params in enumerate(current_frame.get('shader_params',[[None]*4]*3)): - #if self.DEBUG_FRAMES: print("got layer %s params: %s" % (layer, params)) - for param,p in enumerate(params): - if p is not None and p != last_frame.get('shader_params')[layer][param]: - if self.DEBUG_FRAMES: print("setting layer %s param %s to %s" % (layer,param,p)) - param_values[layer][param] = p - - if current_frame['feedback_active'] is not None and last_frame['feedback_active'] != current_frame['feedback_active']: - feedback_active = current_frame['feedback_active'] - else: - feedback_active = None - - if current_frame['x3_as_speed'] is not None and last_frame['x3_as_speed'] != current_frame['x3_as_speed']: - x3_as_speed = current_frame['x3_as_speed'] - else: - x3_as_speed = None - - speed_values = [None]*3 - for layer,param in enumerate(current_frame.get('shader_speeds',[None]*3)): - if param is not None and param != last_frame['shader_speeds'][layer]: - speed_values[layer] = param - - if current_frame['strobe_amount'] is not None and last_frame['strobe_amount'] != current_frame['strobe_amount']: - strobe_amount = current_frame['strobe_amount'] - else: - strobe_amount = None - - if self.DEBUG_FRAMES: - print("param_values is\t%s" % param_values) - print("speed_values is\t%s" % speed_values) - - diff = { - 'shader_params': param_values, - 'feedback_active': feedback_active, - 'x3_as_speed': x3_as_speed, - 'shader_speeds': speed_values, - 'strobe_amount': strobe_amount, - } - if self.DEBUG_FRAMES: print("returning\t%s\n^^^^" % diff['shader_params']) - - return diff -