use arrays

src/forge.c

@@ -22,8 +22,8 @@ static SharedContext *context;
 static ShaderProgram program;
 static Window *window_output;
 static Window *window_monitor;
-static VideoCapture inputs[ARRAY_SIZE];
+static VideoCaptureArray inputs;
-static File fragment_shaders[ARRAY_SIZE];
+static FileArray fragment_shaders;
 static File common_shader_code;
 static Timer timer;
 static ConfigFile config;
@@ -84,10 +84,10 @@ static void init_context(Parameters params, unsigned int in_count,
   memset(context->input_fps, 0, sizeof(context->input_fps));
 
   for (i = 0; i < in_count; i++) {
-    if (!inputs[i].error) {
+    if (!inputs.values[i].error) {
-      context->input_widths[i] = inputs[i].width;
+      context->input_widths[i] = inputs.values[i].width;
-      context->input_heights[i] = inputs[i].height;
+      context->input_heights[i] = inputs.values[i].height;
-      context->input_formats[i] = inputs[i].pixelformat;
+      context->input_formats[i] = inputs.values[i].pixelformat;
     }
   }
 }
@@ -106,9 +106,9 @@ static void hot_reload() {
   }
 
   for (i = 0; i < program.frag_count; i++) {
-    if (force_update || file_should_update(fragment_shaders[i])) {
+    if (force_update || file_should_update(fragment_shaders.values[i])) {
-      file_update(&fragment_shaders[i]);
+      file_update(&fragment_shaders.values[i]);
-      file_prepend(&fragment_shaders[i], common_shader_code);
+      file_prepend(&fragment_shaders.values[i], common_shader_code);
 
       shaders_update(program, fragment_shaders, i);
     }
@@ -133,13 +133,15 @@ File read_fragment_shader_file(char *frag_path, unsigned int i) {
 static void init_files(char *frag_path, unsigned int frag_count) {
   unsigned int i;
 
+  fragment_shaders.length = frag_count;
+
   for (i = 0; i < frag_count + 1; i++) {
     if (i == 0) {
       common_shader_code = read_fragment_shader_file(frag_path, i);
     } else {
-      fragment_shaders[i - 1] = read_fragment_shader_file(frag_path, i);
+      fragment_shaders.values[i - 1] = read_fragment_shader_file(frag_path, i);
 
-      file_prepend(&fragment_shaders[i - 1], common_shader_code);
+      file_prepend(&fragment_shaders.values[i - 1], common_shader_code);
     }
   }
 }
@@ -148,7 +150,7 @@ static void free_files(unsigned int frag_count) {
   unsigned int i;
 
   for (i = 0; i < frag_count; i++) {
-    file_free(&fragment_shaders[i], true);
+    file_free(&fragment_shaders.values[i], true);
   }
 
   file_free(&common_shader_code, true);
@@ -158,8 +160,10 @@ static void init_inputs(char *video_in[MAX_VIDEO], unsigned int input_count,
                         unsigned int video_size) {
   unsigned int i;
 
+  inputs.length = input_count;
+
   for (i = 0; i < input_count; i++) {
-    inputs[i] = video_init(video_in[i], video_size);
+    inputs.values[i] = video_init(video_in[i], video_size);
   }
 }
 
@@ -167,7 +171,8 @@ static bool start_video_captures(unsigned int video_count) {
   unsigned int i;
 
   for (i = 0; i < video_count; i++) {
-    if (!inputs[i].error && !video_background_read(&inputs[i], context, i)) {
+    if (!inputs.values[i].error &&
+        !video_background_read(&inputs.values[i], context, i)) {
       return false;
     }
   }
@@ -179,9 +184,9 @@ static void free_video_captures(unsigned int video_count) {
   unsigned int i;
 
   for (i = 0; i < video_count; i++) {
-    shaders_free_input(program, inputs[i]);
+    shaders_free_input(program, inputs.values[i]);
 
-    video_free(inputs[i]);
+    video_free(inputs.values[i]);
   }
 }
 
@@ -288,8 +293,7 @@ void forge_run(Parameters params) {
     window_use(window_output, context);
 
     program = shaders_init(fragment_shaders, config, context, inputs,
-                           params.video_in_count, state_config.state_max,
+                           state_config, NULL);
-                           state_config.src_count, NULL);
   } else {
     window_output = NULL;
   }
@@ -301,9 +305,8 @@ void forge_run(Parameters params) {
 
     window_use(window_monitor, context);
 
-    program = shaders_init(fragment_shaders, config, context, inputs,
+    program =
-                           params.video_in_count, state_config.state_max,
+        shaders_init(fragment_shaders, config, context, inputs, state_config,
-                           state_config.src_count,
                      window_output != NULL ? &program : NULL);
   } else {
     window_monitor = NULL;

src/shaders.c

@@ -112,16 +112,16 @@ static void link_input_to_texture(ShaderProgram *program, VideoCapture *input,
 }
 
 static void init_input(ShaderProgram *program, ConfigFile config,
-                       VideoCapture *inputs, unsigned int input_count) {
+                       VideoCaptureArray inputs) {
   unsigned int i;
   unsigned tex_i;
   char name[256];
 
   for (i = 0; i < program->in_count; i++) {
-    if (i < input_count && !inputs[i].error) {
+    if (i < inputs.length && !inputs.values[i].error) {
       sprintf(name, "IN_%d_OUT", i + 1);
       tex_i = config_file_get_int(config, name, 0);
-      link_input_to_texture(program, &inputs[i], tex_i);
+      link_input_to_texture(program, &inputs.values[i], tex_i);
     } else {
       log_warn("Cannot link input %d", i + 1);
     }
@@ -212,7 +212,7 @@ static bool compile_shader(GLuint shader_id, char *name, char *source_code) {
   return status_params == GL_TRUE;
 }
 
-static void init_shaders(ShaderProgram *program, File *fragment_shaders) {
+static void init_shaders(ShaderProgram *program, FileArray fragment_shaders) {
   unsigned int i;
 
   // compile vertex shader
@@ -223,9 +223,9 @@ static void init_shaders(ShaderProgram *program, File *fragment_shaders) {
   // compile fragment shaders
   for (i = 0; i < program->frag_count; i++) {
     program->fragment_shaders[i] = glCreateShader(GL_FRAGMENT_SHADER);
-    program->error |=
+    program->error |= !compile_shader(program->fragment_shaders[i],
-        !compile_shader(program->fragment_shaders[i], fragment_shaders[i].path,
+                                      fragment_shaders.values[i].path,
-                        fragment_shaders[i].content);
+                                      fragment_shaders.values[i].content);
 
     if (program->error) {
       return;
@@ -348,11 +348,9 @@ static void init_programs(ShaderProgram *program, ConfigFile config) {
   }
 }
 
-ShaderProgram shaders_init(File *fragment_shaders, ConfigFile config,
+ShaderProgram shaders_init(FileArray fragment_shaders, ConfigFile config,
-                           SharedContext *context, VideoCapture *inputs,
+                           SharedContext *context, VideoCaptureArray inputs,
-                           unsigned int input_count,
+                           StateConfig state_config, ShaderProgram *previous) {
-                           unsigned int sub_variant_count,
-                           unsigned int active_count, ShaderProgram *previous) {
   ShaderProgram program;
 
   if (previous == NULL) {
@@ -367,8 +365,8 @@ ShaderProgram shaders_init(File *fragment_shaders, ConfigFile config,
         config_file_get_int(config, "FRAG_MONITOR", 1) - 1;
     program.sub_type_count = config_file_get_int(config, "SUB_TYPE_COUNT", 0);
     program.in_count = config_file_get_int(config, "IN_COUNT", 0);
-    program.sub_variant_count = sub_variant_count;
+    program.sub_variant_count = state_config.state_max;
-    program.active_count = active_count;
+    program.active_count = state_config.src_count;
 
     if (program.frag_count > MAX_FRAG) {
       log_error("FRAG_COUNT over %d", MAX_FRAG);
@@ -386,7 +384,7 @@ ShaderProgram shaders_init(File *fragment_shaders, ConfigFile config,
 
     init_textures(&program, context);
 
-    init_input(&program, config, inputs, input_count);
+    init_input(&program, config, inputs);
 
     init_framebuffers(&program, config);
 
@@ -405,12 +403,13 @@ ShaderProgram shaders_init(File *fragment_shaders, ConfigFile config,
   return program;
 }
 
-void shaders_update(ShaderProgram program, File *fragment_shaders,
+void shaders_update(ShaderProgram program, FileArray fragment_shaders,
                     unsigned int i) {
   bool result;
 
-  result = compile_shader(program.fragment_shaders[i], fragment_shaders[i].path,
+  result = compile_shader(program.fragment_shaders[i],
-                          fragment_shaders[i].content);
+                          fragment_shaders.values[i].path,
+                          fragment_shaders.values[i].content);
 
   if (result) {
     glLinkProgram(program.programs[i]);

src/shaders.h

@@ -3,13 +3,11 @@
 #ifndef SHADERS_H
 #define SHADERS_H
 
-ShaderProgram shaders_init(File *fragment_shaders, ConfigFile config,
+ShaderProgram shaders_init(FileArray fragment_shaders, ConfigFile config,
-                           SharedContext *context, VideoCapture *inputs,
+                           SharedContext *context, VideoCaptureArray inputs,
-                           unsigned int input_count,
+                           StateConfig state_config, ShaderProgram *previous);
-                           unsigned int sub_variant_count,
-                           unsigned int active_count, ShaderProgram *previous);
 
-void shaders_update(ShaderProgram program, File *fragment_shaders,
+void shaders_update(ShaderProgram program, FileArray fragment_shaders,
                     unsigned int i);
 
 void shaders_compute(ShaderProgram program, SharedContext *context,

src/types.h

@@ -47,6 +47,11 @@ typedef struct File {
   time_t last_write;
 } File;
 
+typedef struct FileArray {
+  File values[ARRAY_SIZE];
+  unsigned int length;
+} FileArray;
+
 typedef struct ShaderProgram {
   bool error;
 
@@ -114,6 +119,11 @@ typedef struct VideoCapture {
   EGLImageKHR dma_image;
 } VideoCapture;
 
+typedef struct VideoCaptureArray {
+  VideoCapture values[ARRAY_SIZE];
+  unsigned int length;
+} VideoCaptureArray;
+
 typedef GLFWwindow Window;
 
 typedef struct SharedContext {