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

@@ -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):
+    def show_plugin(self, display):
-            from tkinter import Text, END
+        from tkinter import Text, END
-            #display_text.insert(END, 'test from DisplayPlugin')
+        #display_text.insert(END, 'test from DisplayPlugin')
-            display.display_text.insert(END, '{} \n'.format(display.body_title))
+        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):

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)
+                self.ignored = self.pc.fm.merge_frames(self.ignored, diff)
-                diff = self.pc.shaders.merge_frames(
+                print("about to call get_ignored_frames with %s\n and\n %s" % (saved_frame.f, self.ignored.f))
-                        self.pc.shaders.get_frame_ignored(saved_frame, self.ignored),
+                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):

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)
 

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)
+

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
-