troubleshooting capture issue

actions.py

@@ -62,8 +62,12 @@ class Actions(object):
         self.shaders.shaders_menu.navigate_menu_up()
 
     def enter_on_shaders_selection(self):
-        is_shader, selected_shader = self.shaders.enter_on_shaders_selection()
+        ##want to select shader if its not selected, and want to enter 'param' mode if it already is
-        if is_shader and selected_shader['shad_type'] == 'gen' and self.shaders.selected_status == '▶':
+        is_shader, is_selected_shader, selected_shader = self.shaders.enter_on_shaders_selection()
+        print('is selected shader: {}'.format(is_selected_shader))
+        if is_selected_shader and selected_shader['param_number'] > 0:
+            self.set_shader_param_mode()
+        elif is_shader and selected_shader['shad_type'] == 'gen' and self.shaders.selected_status == '▶':
             self.video_driver.current_player.toggle_pause()
 
     def clear_all_slots(self):
@@ -421,6 +425,22 @@ class Actions(object):
         self.quit_the_program()
         os.execv('/usr/bin/python3', [sys.argv[0],'/home/pi/r_e_c_u_r/r_e_c_u_r.py'])
         
+    def set_shader_param_mode(self):
+        self.data.control_mode = 'SHADER_PARAM'
+        self.message_handler.set_message('INFO', '[ ]: focus  < >: level ■: back')
+        self.shaders.focused_param = 0
+
+    def increase_this_param(self):
+        self.shaders.increase_this_param()
+
+    def decrease_this_param(self):
+        self.shaders.decrease_this_param()
+
+    def increase_param_focus(self):
+        self.shaders.focused_param = (self.shaders.focused_param + 1)%self.shaders.selected_shader['param_number']
+
+    def decrease_param_focus(self):
+        self.shaders.focused_param = (self.shaders.focused_param - 1)%self.shaders.selected_shader['param_number']
 
     def set_fixed_length(self, value):
         self.data.control_mode = 'LENGTH_SET'
@@ -430,8 +450,9 @@ class Actions(object):
 
     def return_to_default_control_mode(self):
         if self.data.control_mode == 'LENGTH_SET':
-            pass
+            self.data.control_mode = 'NAV_SETTINGS'
-        self.data.control_mode = 'NAV_SETTINGS'
+        if self.data.control_mode == 'SHADER_PARAM':
+            self.data.control_mode = 'NAV_SHADERS'
 
     def record_fixed_length(self):
         if self.fixed_length_setter:

display_centre/display.py

@@ -152,7 +152,10 @@ class Display(object):
             (self.shaders.selected_status,shader['shad_type'][0], \
             format(shader['shad_index'],'02d'), shader['name'][0:17] ))
         for i in range(min(4,shader['param_number'])):
-            self.display_text.insert(END, 'x{}:{num:02d} '.format(i, num=self.shaders.selected_param_values[i]))
+            display_param = self.format_param_value(self.shaders.selected_param_values[i])
+            if display_param == 100:
+                display_param == 99
+            self.display_text.insert(END, 'x{}:{:02d}'.format(i, display_param))
         self.display_text.insert(END,'\n')
         self.display_text.tag_add("COLUMN_NAME", 5.0, 6.0)
         ## showing list of other shaders:
@@ -317,3 +320,10 @@ class Display(object):
             return ''
         else:
             return value
+
+    @staticmethod
+    def format_param_value(value):
+        display_param = int(100 * value)
+        if display_param == 100:
+            display_param = 99
+        return display_param

json_objects/keypad_action_mapping.json

@@ -4,30 +4,35 @@
 		"PLAYER": ["seek_back_on_player"],
 		"NAV_SETTINGS": ["move_settings_selection_up"],
 		"NAV_SHADERS": ["move_shaders_selection_up"],
-        "LENGTH_SET": ["return_to_default_control_mode"]
+        "LENGTH_SET": ["return_to_default_control_mode"],
+        "SHADER_PARAM": ["decrease_this_param"]
 	},
 	"b": {
 		"NAV_BROWSER": ["move_browser_selection_down"],
 		"PLAYER": ["seek_forward_on_player"],
 		"NAV_SETTINGS": ["move_settings_selection_down"],
 		"NAV_SHADERS": ["move_shaders_selection_down"],
-        "LENGTH_SET": ["return_to_default_control_mode"]
+        "LENGTH_SET": ["return_to_default_control_mode"],
+        "SHADER_PARAM": ["increase_this_param"]
 	},
 	"c": {
 		"NAV_BROWSER": ["enter_on_browser_selection"],
 		"PLAYER": ["toggle_action_on_player","toggle_show_on_player"],
 		"NAV_SETTINGS": ["enter_on_settings_selection"],
 		"NAV_SHADERS": ["enter_on_shaders_selection"],
-        "LENGTH_SET": ["record_fixed_length"]
+        "LENGTH_SET": ["record_fixed_length"],
+        "SHADER_PARAM": ["return_to_default_control_mode"]
 	},
 	"d": {
 		"DEFAULT": ["switch_to_next_player", "toggle_player_mode"]
 	},
 	"e": {
-		"DEFAULT": ["set_playing_sample_start_to_current_duration", "clear_playing_sample_start_time"]
+		"DEFAULT": ["set_playing_sample_start_to_current_duration", "clear_playing_sample_start_time"],
+        "SHADER_PARAM": ["decrease_param_focus"]
 	},
 	"f": {
-		"DEFAULT": ["set_playing_sample_end_to_current_duration", "clear_playing_sample_end_time"]
+		"DEFAULT": ["set_playing_sample_end_to_current_duration", "clear_playing_sample_end_time"],
+        "SHADER_PARAM": ["increase_param_focus"]
 	},
 	"g": {
         "DEFAULT": ["toggle_capture_preview", "toggle_capture_recording"]},

shader_experiments/capture_output.txt

@@ -0,0 +1,18 @@
+pi@raspberrypi:~ $ pivideo -q all -v
+PiVideo Version 1.13
+Port used for video processor is:  i2c1
+PiCapture SD1 is ready
+No active video detected
+Selected video source is:  auto
+Active video source is:  video1
+Raspberry Pi camera port is not active
+Video processor firmware version:  07-07811E
+Video processor hardware id:  583F861021C29880
+
+pi@raspberrypi:~ $ raspivid -md 6 -awbg 1.0,1.0 -awb off -ex off -o
+mmal: mmal_vc_component_create: failed to create component 'vc.ril.camera' (1:ENOMEM)
+mmal: mmal_component_create_core: could not create component 'vc.ril.camera' (1)
+mmal: Failed to create camera component
+mmal: main: Failed to create camera component
+mmal: Camera is not detected. Please check carefully the camera module is installed correctly
+

video_centre/capture.py

@@ -27,6 +27,7 @@ class Capture(object):
             self.update_capture_settings()
             try:
                 self.device = picamera.PiCamera(resolution=self.resolution, framerate=self.framerate, sensor_mode = self.sensor_mode)
+                self.message_handler.set_message('INFO', 'capture didnt error ?')
             except picamera.exc.PiCameraError as e:
                 self.use_capture = False
                 print('camera exception is {}'.format(e))

video_centre/shaders.py

@@ -3,6 +3,7 @@ import os
 
 class Shaders(object):
     MENU_HEIGHT = 10
+    PARAM_STEP = 0.2
     EMPTY_SHADER = dict(name='none',is_shader=True,shad_type='-',param_number=0,path='-',shad_index=0)
     def __init__(self, root, osc_client, message_handler, data):
         self.root = root
@@ -11,13 +12,14 @@ class Shaders(object):
         self.data = data
         self.shaders_menu = menu.ShadersMenu(self.data, self.message_handler, self.MENU_HEIGHT )
         self.selected_shader = self.EMPTY_SHADER
+        self.focused_param = None
         self.shaders_menu_list = self.generate_shaders_list()
         print(self.shaders_menu_list)
         if self.shaders_menu_list is not None:
             pass
                  
         self.selected_status = '-' ## going to try using symbols for this : '-' means empty, '▶' means running, '■' means not running, '!' means error
-        self.selected_param_values = [0,0,0,0]
+        self.selected_param_values = [0.0,0.0,0.0,0.0]
         #self.load_selected_shader()
 
     def generate_shaders_list(self):
@@ -67,6 +69,7 @@ class Shaders(object):
 
     def load_selected_shader(self):
         print(self.selected_shader)
+        self.selected_param_values = [0.0,0.0,0.0,0.0]
         is_pro = self.selected_shader['shad_type'] == 'pro'
         self.osc_client.send_message("/shader/load", [self.selected_shader['path'],is_pro,self.selected_shader['param_number']])
         if not self.selected_status == '▶':
@@ -84,10 +87,39 @@ class Shaders(object):
         index = self.shaders_menu.selected_list_index
         is_file, name = self.shaders_menu.extract_file_type_and_name_from_menu_format(
             self.shaders_menu_list[index]['name'])
-        if is_file:
+        is_selected_shader = False
+        if is_file and name == self.selected_shader['name']:
+            is_selected_shader = True
+        elif is_file:
             self.selected_shader = self.shaders_menu_list[index]
             self.load_selected_shader()
         else:
             self.shaders_menu.update_open_folders(name)
         self.shaders_menu_list = self.generate_shaders_list()
-        return is_file, self.selected_shader
+        return is_file, is_selected_shader, self.selected_shader
+
+    def increase_this_param(self):
+        param = self.focused_param
+        current_amount = self.selected_param_values[param]
+        amount = self.get_new_param_amount(current_amount,self.PARAM_STEP)
+        self.set_param_to_amount(param, amount)
+
+    def decrease_this_param(self):
+        param = self.focused_param
+        current_amount = self.selected_param_values[param]
+        amount = self.get_new_param_amount(current_amount,-self.PARAM_STEP)
+        self.set_param_to_amount(param, amount)
+    
+    @staticmethod
+    def get_new_param_amount(current, change):
+        if current + change > 1:
+            return 1
+        elif current + change < 0:
+            return 0
+        else: 
+            return current + change
+    
+    def set_param_to_amount(self, param, amount):
+        self.osc_client.send_message("/shader/param", [param, amount] )
+        self.selected_param_values[param] = amount
+