Merge branch 'dev_frame_objects' into feature_plugins_shader_gadgets

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))
 
 class ModulationReceiverPlugin(Plugin):
     def __init__(self, plugin_collection):
@@ -259,6 +260,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)
-                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):

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

@@ -268,203 +268,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
-