forge (steel) v1.2.1

DEVELOPMENT.md

@@ -8,7 +8,7 @@ build         build project into build/forge
 run           run project with test args
 demo          run project with demo mode
 valgrind      valgrind analysis
-clean-release remove autoconf/automake files
+full-clean    remove build files and untracked files
 test-release  try to build release
 release-%     make full release of version %
 release-arch  make arch-linux release package
@@ -124,7 +124,7 @@ make -f Makefile.dev release-arch
   - [x] (clean) static functions at top of files
   - [x] Configurable key codes
   - [x] Monitor improvements
-  - [ ] Ignore some values in auto random
+  - [x] Ignore some values in auto random
   - [x] build without video in
   - [ ] Update README monitor/keymap
   - [x] Auto reconnect midi input

Makefile.dev

@@ -7,7 +7,7 @@ SHELL := /bin/bash
 clean:
 	@rm -rf build
 
-build:
+build/$(TARGET):
 	@mkdir -p build
 	gcc \
 		src/*.h src/*.c \
@@ -25,6 +25,9 @@ build:
 		-o build/$(TARGET) \
 		-g -Og
 
+.PHONY: build
+build: build/$(TARGET)
+
 .PHONY: build-no-video
 build-no-video:
 	@mkdir -p build
@@ -48,26 +51,28 @@ format:
 	clang-format -i src/*
 
 .PHONY: run
-run: build
+run: build/$(TARGET)
 	./build/$(TARGET) $(RUN_ARGS)
 
 .PHONY: sample
-sample: build
+sample: build/$(TARGET)
-	./build/$(TARGET) --project=sample
+	./build/$(TARGET) --project=sample $(RUN_ARGS)
 
 .PHONY: valgrind
-valgrind: build
+valgrind: build/$(TARGET)
 	valgrind \
 		--show-realloc-size-zero=no \
 		--undef-value-errors=no \
 		./build/$(TARGET) $(RUN_ARGS)
 
-.PHONY: clean-release
+.PHONY: full-clean
-clean-release:
+full-clean:
 	git clean -f -x
+	rm -rf */*/.deps
+	rm -rf */.deps
 
 .PHONY: test-release
-test-release: clean clean-release
+test-release: clean full-clean
 	aclocal
 	autoconf
 	automake --add-missing
@@ -77,7 +82,7 @@ test-release: clean clean-release
 	cp $(TARGET)-steel-*.tar.gz build/
 
 .PHONY: release-%
-release-%: clean clean-release
+release-%: clean full-clean
 	git pull origin main
 	sed -i -E "s/[0-9]+\\.[0-9]+\\.[0-9]+/$*/g" configure.ac
 	aclocal

PKGBUILD

@@ -1,12 +1,12 @@
 pkgname=forge-steel
-pkgver=1.1.0
+pkgver=1.2.1
 pkgrel=1
 pkgdesc="Fusion Of Real Time Generative Effects"
 arch=('i686' 'pentium4' 'x86_64' 'arm' 'armv7h' 'armv6h' 'aarch64' 'riscv64')
 depends=('glfw>=1:3', 'v4l-utils>=1.32', 'alsa-lib>=1.2', 'libglvnd>=1.7')
 url="https://git.klemek.fr/klemek/forge-steel"
 source=("${pkgname}-steel-${pkgver}.tar.gz::https://git.klemek.fr/klemek/forge-steel/releases/download/v${pkgver}/${pkgname}-${pkgver}.tar.gz")
-sha256sums=('794fb0f170cff19872acfba8a556e2a08c55a78e497ac0b330eca6db65343529')
+sha256sums=('57559bde7a524e3c9e70de4bc9b675a5a086590a8d85697cebd80c0ebd09f149')
 srcdir=build
 backup=("usr/share/${pkgname}")
 

README.md

@@ -1,4 +1,4 @@
-[![](https://git.klemek.fr/klemek/forge-steel/actions/workflows/lint.yml/badge.svg?branch=main&style=flat-square)](https://git.klemek.fr/klemek/forge-steel/actions?workflow=lint.yml) [![](https://git.klemek.fr/klemek/forge-steel/actions/workflows/build.yml/badge.svg?branch=main&style=flat-square)](https://git.klemek.fr/klemek/forge-steel/actions?workflow=build.yml) ![LOC](https://img.shields.io/badge/cloc-3.4k-blue?style=flat-square)
+[![](https://git.klemek.fr/klemek/forge-steel/actions/workflows/lint.yml/badge.svg?branch=main&style=flat-square)](https://git.klemek.fr/klemek/forge-steel/actions?workflow=lint.yml) [![](https://git.klemek.fr/klemek/forge-steel/actions/workflows/build.yml/badge.svg?branch=main&style=flat-square)](https://git.klemek.fr/klemek/forge-steel/actions?workflow=build.yml) ![LOC](https://img.shields.io/badge/cloc-3.6k-blue?style=flat-square)
 
 <!-- omit from toc -->
 # F.O.R.G.E. (Steel)
@@ -174,9 +174,9 @@ These are configurable in the [`forge_project.cfg`](#forge_projectcfg).
 ### CLI arguments
 
 ```txt
-forge steel-VERSION
+forge steel-dev
 
-usage: forge [-h] [-v] [-p=PROJECT_PATH] [-c=CFG_FILE] [-hr] [-s=SCREEN] [-m=SCREEN] [-mo] [-w] [-t=TEMPO] [-d] [-ar / -nar] [-arc=CYCLES] [-vi=FILE] [-vs=SIZE] [-vb=COUNT] [-vr / -nvr] [-is=SIZE] [-ls / -nls] [-ss / -nss] [-mr / -nmr] [-tm] [-tf]
+usage: forge [-h] [-v] [-p=PROJECT_PATH] [-c=CFG_FILE] [-hr] [-s=SCREEN] [-m=SCREEN] [-mo] [-w] [-t=TEMPO] [-d] [-ar / -nar] [-arc=CYCLES] [-vi=FILE] [-vs=SIZE] [-vb=COUNT] [-vr / -nvr] [-vf=FOURCC] [-is=SIZE] [-ls / -nls] [-ss / -nss] [-mr / -nmr] [-tm] [-tf]
 
 Fusion Of Real-time Generative Effects.
 
@@ -196,10 +196,11 @@ options:
   -nar, --no-auto-random      do not randomize state (default)
   -arc, --auto-random-cycle   auto random cycle length (default: 4)
   -vi, --video-in             path to video capture device (multiple allowed)
-  -vb, --video-buffers        number of video buffers to use (default: 2)
+  -vb, --video-buffers        number of video buffers to use (default: 1)
   -vs, --video-size           video capture desired height (default: internal texture height)
   -vr, --video-reconnect      auto-reconnect video (default)
   -nvr, --no-video-reconnect  do not auto-reconnect video
+  -vf, --video-fourcc         video codec fourcc (default: YUYV)
   -is, --internal-size        internal texture height (default: 720)
   -ls, --load-state           load saved state (default)
   -nls, --no-load-state       do not load saved state
@@ -247,7 +248,7 @@ Working with pages and items, you can use the following predefined sources and e
 | **1** | **0** | Feedback + Thru   | _Hue_             | _Saturation_    | _Light_            | Thru             | _Hue_           | _Saturation_  | _Light_        |
 |       | **1** | Lines             | _Thick. / Dezoom_ | _Rotation_      | _Distortion_       | Feedback + Shift | _Zoom / Dezoom_ | _X Shift_     | _Y Shift_      |
 |       | **2** | Dots              | _Zoom_            | _Rotation_      | _Lens_             | Shift            | _Zoom / Dezoom_ | _X Shift_     | _Y Shift_      |
-|       | **3** | Circuit             | _Zoom_         | _H. connect_     | _V. connect_ | Colorize         | _Black Color_   | _White Color_ | _Shift_        |
+|       | **3** | Bacteria          | _Zoom_            | _Details_       | _Delta details_    | Colorize         | _Black Color_   | _White Color_ | _Shift_        |
 |       | **4** | Noise             | _Zoom_            | _Voronoi dist._ | _Details_          | Quantize         | _Pixel Size_    | _Bit Depth_   | _Blur_         |
 | **2** | **5** | Video In 1 + Thru | _Hue_             | _Saturation_    | _Light_            | Dithering        | _Pixel Size_    | _Bit Depth_   | _Blur_         |
 |       | **6** | CP437             | _Zoom_            | _Charset_       | _Char. Delta_      | TV               | _Lens_          | _Horz. Noise_ | _Dezoom_       |
@@ -262,6 +263,28 @@ Working with pages and items, you can use the following predefined sources and e
 
 See the [printable version](./docs/forge_default_mapping.pdf).
 
+### Available hotkeys
+
+| Hotkey | Function |
+| ------ | -------- |
+| <kbd>Shift</kbd> + <kbd>F</kbd> | Switch between shader-decoded or hardware decoded YUYV |
+| <kbd>M</kbd> | Projection mapping 1 |
+| <kbd>Shift</kbd> + <kbd>M</kbd> | Projection mapping 2 |
+| <kbd>Ctrl</kbd> + <kbd>M</kbd> | Projection mapping 3 |
+| <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>M</kbd> | Projection mapping 4 |
+
+### Projection Mappings
+
+In any of the projection mapping mode, use the nanoKONTROL2 last 4 columns to control 4 on-screen points:
+
+| Midi Control | Function |
+| ------ | -------- |
+| Fader N | point N - X position |
+| Knob N | point N - Y position |
+| Last column top button | activate projection mapping |
+| Last column middle button | invert projection mapping |
+| Last column bottom button | show projection borders |
+
 ## Making your own FORGE project
 
 You want to embrace the "user" in "user-defined"? It's time to make your own project.
@@ -499,7 +522,7 @@ You can check your device real FPS on [V4L2 UCP](https://github.com/HedgeHawk/v4
 
 ### My video feed got strange lines
 
-You need to decode the [V4L2 YUYV format](https://www.kernel.org/doc/html/v4.8/media/uapi/v4l/pixfmt-yuyv.html).
+You may need to decode the [V4L2 YUYV format](https://www.kernel.org/doc/html/v4.8/media/uapi/v4l/pixfmt-yuyv.html).
 
 The code is available in the default project [default/inc_yuyv.glsl](./default/inc_yuyv.glsl)
 

configure.ac

@@ -1,4 +1,4 @@
-AC_INIT([forge], [steel-1.1.0], [klemek.dev@proton.me])
+AC_INIT([forge], [steel-1.2.1], [klemek.dev@proton.me])
 AM_INIT_AUTOMAKE
 AC_PROG_CC
 
@@ -11,7 +11,6 @@ AC_CHECK_HEADERS([stdlib.h])
 AC_CHECK_HEADERS([sys/ioctl.h])
 AC_CHECK_HEADERS([sys/mman.h])
 AC_CHECK_HEADERS([sys/stat.h])
-AC_CHECK_HEADERS([sys/time.h])
 AC_CHECK_HEADERS([sys/types.h])
 AC_CHECK_HEADERS([sys/wait.h])
 

default/forge_project.cfg

@@ -115,13 +115,13 @@ FRAG_FILE_PREFIX=frag
 FRAG_COUNT=10
 
 # To which texture will the shader fragX.glsl will render to
-FRAG_1_OUT=5
+FRAG_1_OUT=3
-FRAG_2_OUT=6
+FRAG_2_OUT=4
-FRAG_3_OUT=7
+FRAG_3_OUT=5
-FRAG_4_OUT=8
+FRAG_4_OUT=6
-FRAG_5_OUT=9
+FRAG_5_OUT=7
-FRAG_6_OUT=10
+FRAG_6_OUT=8
-FRAG_7_OUT=11
+FRAG_7_OUT=9
 FRAG_8_OUT=0
 # Which fragment shader renders to output window
 FRAG_OUTPUT=9
@@ -235,10 +235,14 @@ GROUP_1_6_Y=19
 GROUP_1_6_Z=
 
 # Same for group 2
-GROUP_2_ACTIVE_COUNT=3
+GROUP_2_ACTIVE_COUNT=7
 GROUP_2_ACTIVE_1=36
 GROUP_2_ACTIVE_2=68
 GROUP_2_ACTIVE_3=52
+GROUP_2_ACTIVE_4=1077
+GROUP_2_ACTIVE_5=11077
+GROUP_2_ACTIVE_6=101077
+GROUP_2_ACTIVE_7=111077
 GROUP_2_COUNT=7
 GROUP_2_1_X=37
 GROUP_2_1_Y=53
@@ -269,7 +273,72 @@ GROUP_3_1_Y=58
 GROUP_3_1_Z=
 GROUP_3_2_X=0
 GROUP_3_2_Y=16
-GROUP_3_2_Z=
+GROUP_3_2_Z=11089
+
+# Auto-Random Ignore (ARI) prefixes
+ARI_COUNT=62
+ARI_1=GROUP_3_1_Y
+ARI_2=GROUP_3_2_Z
+ARI_3=GROUP_2_5_4
+ARI_4=GROUP_2_5_4
+ARI_5=GROUP_2_5_4
+ARI_6=GROUP_2_2_X_4
+ARI_7=GROUP_2_2_Y_4
+ARI_8=GROUP_2_2_Z_4
+ARI_9=GROUP_2_4_X_4
+ARI_10=GROUP_2_4_Y_4
+ARI_11=GROUP_2_4_Z_4
+ARI_12=GROUP_2_6_X_4
+ARI_13=GROUP_2_6_Y_4
+ARI_14=GROUP_2_6_Z_4
+ARI_15=GROUP_2_7_X_4
+ARI_16=GROUP_2_7_Y_4
+ARI_17=GROUP_2_7_Z_4
+ARI_18=GROUP_2_5_5
+ARI_19=GROUP_2_5_5
+ARI_20=GROUP_2_5_5
+ARI_21=GROUP_2_2_X_5
+ARI_22=GROUP_2_2_Y_5
+ARI_23=GROUP_2_2_Z_5
+ARI_24=GROUP_2_4_X_5
+ARI_25=GROUP_2_4_Y_5
+ARI_26=GROUP_2_4_Z_5
+ARI_27=GROUP_2_6_X_5
+ARI_28=GROUP_2_6_Y_5
+ARI_29=GROUP_2_6_Z_5
+ARI_30=GROUP_2_7_X_5
+ARI_31=GROUP_2_7_Y_5
+ARI_32=GROUP_2_7_Z_5
+ARI_33=GROUP_2_5_6
+ARI_34=GROUP_2_5_6
+ARI_35=GROUP_2_5_6
+ARI_36=GROUP_2_2_X_6
+ARI_37=GROUP_2_2_Y_6
+ARI_38=GROUP_2_2_Z_6
+ARI_39=GROUP_2_4_X_6
+ARI_40=GROUP_2_4_Y_6
+ARI_41=GROUP_2_4_Z_6
+ARI_42=GROUP_2_6_X_6
+ARI_43=GROUP_2_6_Y_6
+ARI_44=GROUP_2_6_Z_6
+ARI_45=GROUP_2_7_X_6
+ARI_46=GROUP_2_7_Y_6
+ARI_47=GROUP_2_7_Z_6
+ARI_48=GROUP_2_5_7
+ARI_49=GROUP_2_5_7
+ARI_50=GROUP_2_5_7
+ARI_51=GROUP_2_2_X_7
+ARI_52=GROUP_2_2_Y_7
+ARI_53=GROUP_2_2_Z_7
+ARI_54=GROUP_2_4_X_7
+ARI_55=GROUP_2_4_Y_7
+ARI_56=GROUP_2_4_Z_7
+ARI_57=GROUP_2_6_X_7
+ARI_58=GROUP_2_6_Y_7
+ARI_59=GROUP_2_6_Z_7
+ARI_60=GROUP_2_7_X_7
+ARI_61=GROUP_2_7_Y_7
+ARI_62=GROUP_2_7_Z_7
 
 # =====
 # OTHER

default/frag1.glsl

@@ -2,8 +2,8 @@
 
 // VIDEO 1
 // -----------
-// IN: 1+3 (RAW IN A)
+// IN: 1 (RAW IN A)
-// OUT: 5 (IN A)
+// OUT: 3 (IN A)
 
 in vec2 vUV;
 out vec4 fragColor;
@@ -14,16 +14,14 @@ uniform sampler2D iTex0;
 uniform sampler2D iTex1;
 uniform sampler2D iTex3;
 uniform int iInputFormat1;
-uniform int iInputSwap1;
 uniform vec2 iInputResolution1;
+uniform vec3 iGroup3_1[2];
 
 void main() {
-    if (iInputFormat1 == YUYV_FOURCC) {
+    if (iGroup3_1[1].z > 0) {
-        if (iInputSwap1 > 0) {
+        fragColor = texture(iTex1, vUV * vec2(1, -1));
-            fragColor = yuyvTex(iTex3, vUV, int(iInputResolution1.x));
+    } else if (iInputFormat1 == YUYV_FOURCC) {
-        } else {
         fragColor = yuyvTex(iTex1, vUV, int(iInputResolution1.x));
-        }
     } else {
         fragColor = texture(iTex0, vUV);
     }

default/frag10.glsl

@@ -9,13 +9,13 @@ out vec4 fragColor;
 #include inc_debug.glsl
 
 uniform sampler2D iTex0;
+uniform sampler2D iTex3;
+uniform sampler2D iTex4;
 uniform sampler2D iTex5;
 uniform sampler2D iTex6;
 uniform sampler2D iTex7;
 uniform sampler2D iTex8;
 uniform sampler2D iTex9;
-uniform sampler2D iTex10;
-uniform sampler2D iTex11;
 uniform int iFPS;
 uniform int iInputFPS1;
 uniform int iInputFPS2;
@@ -26,18 +26,90 @@ float s(vec2 uv, float x0, float y0) {
 }
 
 const int texts[12][5] = {
-    {0x49, 0x4E, 0x20, 0x41, 0x00}, // IN A
+        {
-    {0x49, 0x4E, 0x20, 0x42, 0x00}, // IN B
+            0x49,
-    {0x53, 0x52, 0x43, 0x20, 0x41}, // SRC A
+            0x4E,
-    {0x53, 0x52, 0x43, 0x20, 0x42}, // SRC B
+            0x20,
-    {0x46, 0x58, 0x20, 0x41, 0x00}, // FX A
+            0x41,
-    {0x46, 0x58, 0x20, 0x42, 0x00}, // FX B
+            0x00
-    {0x41, 0x2B, 0x42, 0x00, 0x00}, // A+B
+        }, // IN A
-    {0x4D, 0x46, 0x58, 0x00, 0x00}, // MFX
+        {
-    {0x46, 0x50, 0x53, 0x00, 0x00}, // FPS
+            0x49,
-    {0x4F, 0x46, 0x46, 0x00, 0x00}, // OFF
+            0x4E,
-    {0x44, 0x45, 0x4D, 0x4F, 0x00}, // DEMO
+            0x20,
-    {0x4C, 0x49, 0x56, 0x45, 0x00}, // LIVE
+            0x42,
+            0x00
+        }, // IN B
+        {
+            0x53,
+            0x52,
+            0x43,
+            0x20,
+            0x41
+        }, // SRC A
+        {
+            0x53,
+            0x52,
+            0x43,
+            0x20,
+            0x42
+        }, // SRC B
+        {
+            0x46,
+            0x58,
+            0x20,
+            0x41,
+            0x00
+        }, // FX A
+        {
+            0x46,
+            0x58,
+            0x20,
+            0x42,
+            0x00
+        }, // FX B
+        {
+            0x41,
+            0x2B,
+            0x42,
+            0x00,
+            0x00
+        }, // A+B
+        {
+            0x4D,
+            0x46,
+            0x58,
+            0x00,
+            0x00
+        }, // MFX
+        {
+            0x46,
+            0x50,
+            0x53,
+            0x00,
+            0x00
+        }, // FPS
+        {
+            0x4F,
+            0x46,
+            0x46,
+            0x00,
+            0x00
+        }, // OFF
+        {
+            0x44,
+            0x45,
+            0x4D,
+            0x4F,
+            0x00
+        }, // DEMO
+        {
+            0x4C,
+            0x49,
+            0x56,
+            0x45,
+            0x00
+        }, // LIVE
     };
 
 void main() {
@@ -50,14 +122,14 @@ void main() {
 
     vec4 c = vec4(0);
 
-    c += s(uv2, 1, 2) * texture(iTex7, uv2);
+    c += s(uv2, 1, 2) * texture(iTex5, uv2);
-    c += s(uv2, 2, 2) * texture(iTex9, uv2);
+    c += s(uv2, 2, 2) * texture(iTex7, uv2);
 
-    c += s(uv2, 1, 0) * texture(iTex8, uv2);
+    c += s(uv2, 1, 0) * texture(iTex6, uv2);
-    c += s(uv2, 2, 0) * texture(iTex10, uv2);
+    c += s(uv2, 2, 0) * texture(iTex8, uv2);
 
     c += s(uv2, 0, 1) * debug(mod(uv2, 1));
-    c += s(uv2, 1, 1) * texture(iTex11, uv2);
+    c += s(uv2, 1, 1) * texture(iTex9, uv2);
     c += s(uv2, 2, 1) * texture(iTex0, uv2);
 
     float sel = 0;
@@ -77,7 +149,7 @@ void main() {
     t += write_5(uv3, vec2(-37, 28), texts[0]);
 
     if (iInputFormat1 == YUYV_FOURCC) {
-        c += s(uv2, 0, 2) * texture(iTex5, uv2);
+        c += s(uv2, 0, 2) * texture(iTex3, uv2);
         f += rect(uv3, vec2(-35, 26.75), vec2(2.8, 0.7));
         t += write_int(uv3, vec2(-37.6, 26.1), iInputFPS1, 2);
         t += write_5(uv3, vec2(-35.1, 26.1), texts[8]);
@@ -90,7 +162,7 @@ void main() {
     t += write_5(uv3, vec2(-37, -12), texts[1]);
 
     if (iInputFormat2 == YUYV_FOURCC) {
-        c += s(uv2, 0, 0) * texture(iTex6, uv2);
+        c += s(uv2, 0, 0) * texture(iTex4, uv2);
         f += rect(uv3, vec2(-35, -13.25), vec2(2.8, 0.7));
         t += write_int(uv3, vec2(-37.6, -13.9), iInputFPS2, 2);
         t += write_5(uv3, vec2(-35.1, -13.9), texts[8]);

default/frag2.glsl

@@ -2,8 +2,8 @@
 
 // VIDEO 2
 // -----------
-// IN: 2+4 (RAW IN B)
+// IN: 2 (RAW IN B)
-// OUT: 6 (IN B)
+// OUT: 4 (IN B)
 
 in vec2 vUV;
 out vec4 fragColor;
@@ -14,16 +14,14 @@ uniform sampler2D iTex0;
 uniform sampler2D iTex2;
 uniform sampler2D iTex4;
 uniform int iInputFormat2;
-uniform int iInputSwap2;
 uniform vec2 iInputResolution2;
+uniform vec3 iGroup3_1[2];
 
 void main() {
-    if (iInputFormat2 == YUYV_FOURCC) {
+    if (iGroup3_1[1].z > 0) {
-        if (iInputSwap2 > 0) {
+        fragColor = texture(iTex2, vUV * vec2(1, -1));
-            fragColor = yuyvTex(iTex4, vUV, int(iInputResolution2.x));
+    } else if (iInputFormat2 == YUYV_FOURCC) {
-        } else {
         fragColor = yuyvTex(iTex2, vUV, int(iInputResolution2.x));
-        }
     } else {
         fragColor = texture(iTex0, vUV);
     }

default/frag3.glsl

@@ -3,7 +3,7 @@
 
 // SRC A
 // -----------
-// OUT: 7 (FX A)
+// OUT: 5 (FX A)
 
 in vec2 vUV;
 out vec4 fragColor;

default/frag4.glsl

@@ -2,7 +2,7 @@
 
 // SRC B
 // -----------
-// OUT: 8 (FX B)
+// OUT: 6 (FX B)
 
 in vec2 vUV;
 out vec4 fragColor;

default/frag5.glsl

@@ -2,20 +2,20 @@
 
 // FX A
 // -------------
-// IN: 7 (SRC A)
+// IN: 5 (SRC A)
-// IN: 9 (FX A)
+// IN: 7 (FX A)
-// OUT: 9 (A+B)
+// OUT: 7 (A+B)
 
 in vec2 vUV;
 out vec4 fragColor;
 
 #include inc_fx.glsl
 
+uniform sampler2D iTex5;
 uniform sampler2D iTex7;
-uniform sampler2D iTex9;
 uniform int iSeed5;
 uniform vec3 iGroup2_1[7];
 
 void main() {
-    fragColor = fx_stage(vUV, iTex7, iTex9, iSeed5, iGroup2_1[0], iGroup2_1[1].xy, iGroup2_1[2], iGroup2_1[3].xy, iGroup2_1[4], iGroup2_1[5].xy, iGroup2_1[6]);
+    fragColor = fx_stage(vUV, iTex5, iTex7, iSeed5, iGroup2_1[0], iGroup2_1[1].xy, iGroup2_1[2], iGroup2_1[3].xy, iGroup2_1[4], iGroup2_1[5].xy, iGroup2_1[6]);
 }

default/frag6.glsl

@@ -2,20 +2,20 @@
 
 // FX B
 // -------------
-// IN: 8 (SRC B)
+// IN: 6 (SRC B)
-// IN: 10 (FX B)
+// IN: 8 (FX B)
-// OUT: 10 (A+B)
+// OUT: 8 (A+B)
 
 in vec2 vUV;
 out vec4 fragColor;
 
 #include inc_fx.glsl
 
+uniform sampler2D iTex6;
 uniform sampler2D iTex8;
-uniform sampler2D iTex10;
 uniform int iSeed6;
 uniform vec3 iGroup2_2[7];
 
 void main() {
-    fragColor = fx_stage(vUV, iTex8, iTex10, iSeed6, iGroup2_2[0], iGroup2_2[1].xy, iGroup2_2[2], iGroup2_2[3].xy, iGroup2_2[4], iGroup2_2[5].xy, iGroup2_2[6]);
+    fragColor = fx_stage(vUV, iTex6, iTex8, iSeed6, iGroup2_2[0], iGroup2_2[1].xy, iGroup2_2[2], iGroup2_2[3].xy, iGroup2_2[4], iGroup2_2[5].xy, iGroup2_2[6]);
 }

default/frag7.glsl

@@ -2,9 +2,9 @@
 
 // A+B
 // ------------
-// IN: 9 (FX A)
+// IN: 7 (FX A)
-// IN: 10 (FX B)
+// IN: 8 (FX B)
-// OUT: 11 (MFX)
+// OUT: 9 (MFX)
 
 in vec2 vUV;
 out vec4 fragColor;
@@ -13,8 +13,8 @@ out vec4 fragColor;
 #include inc_functions.glsl
 
 uniform int iDemo;
-uniform sampler2D iTex9;
+uniform sampler2D iTex7;
-uniform sampler2D iTex10;
+uniform sampler2D iTex8;
 uniform int iSeed7;
 uniform vec3 iGroup3_1[2];
 
@@ -22,8 +22,8 @@ void main() {
     float mix_value = magic(iGroup3_1[1].xy, vec3(1, 0, 0), iSeed7);
     bool mix_type = magic_trigger(vec3(iGroup3_1[0].x, 0, 0), iSeed7 + 10);
 
-    vec4 color_a = texture(iTex9, vUV);
+    vec4 color_a = texture(iTex7, vUV);
-    vec4 color_b = texture(iTex10, vUV);
+    vec4 color_b = texture(iTex8, vUV);
 
     float k = mean(color_a);
 

default/frag8.glsl

@@ -2,7 +2,7 @@
 
 // MFX
 // ------------
-// IN: 11 (A+B)
+// IN: 9 (A+B)
 // IN: 0 (OUT)
 // OUT: 0 (OUT)
 
@@ -11,20 +11,16 @@ out vec4 fragColor;
 
 #include inc_fx.glsl
 
-uniform sampler2D iTex11;
+uniform sampler2D iTex9;
 uniform sampler2D iTex0;
 uniform int iSeed8;
 uniform vec3 iGroup2_3[7];
 uniform vec3 iGroup3_1[2];
-uniform int iDemo;
-uniform int iAutoRand;
 
 void main() {
-    vec4 color = fx_stage(vUV, iTex11, iTex0, iSeed8, iGroup2_3[0], iGroup2_3[1].xy, iGroup2_3[2], iGroup2_3[3].xy, iGroup2_3[4], iGroup2_3[5].xy, iGroup2_3[6]);
+    vec4 color = fx_stage(vUV, iTex9, iTex0, iSeed8, iGroup2_3[0], iGroup2_3[1].xy, iGroup2_3[2], iGroup2_3[3].xy, iGroup2_3[4], iGroup2_3[5].xy, iGroup2_3[6]);
 
-    if (iDemo < 1 && iAutoRand < 1) {
     color = mix(color, vec4(0), iGroup3_1[0].y);
-    }
 
     fragColor = color;
 }

default/frag9.glsl

@@ -6,8 +6,109 @@
 in vec2 vUV;
 out vec4 fragColor;
 
+#include inc_map.glsl
+
 uniform sampler2D iTex0;
+uniform vec3 iGroup2_4[7];
+uniform vec3 iGroup2_5[7];
+uniform vec3 iGroup2_6[7];
+uniform vec3 iGroup2_7[7];
 
 void main() {
-    fragColor = texture(iTex0, vUV);
+    bool visible = (iGroup2_4[4].x + iGroup2_5[4].x + iGroup2_6[4].x + iGroup2_7[4].x) > 0;
+    bool invert = (iGroup2_4[4].y + iGroup2_5[4].y + iGroup2_6[4].y + iGroup2_7[4].y) > 0;
+    float rect = clamp(iGroup2_4[4].z + iGroup2_5[4].z + iGroup2_6[4].z + iGroup2_7[4].z, 0, 1);
+    bool modified = false;
+
+    vec2 uv = mix(vec2(0), vUV, base_mask(vUV));
+
+    if (iGroup2_4[4].x > 0) {
+        vec2 p11 = vec2(iGroup2_4[6].xy);
+        vec2 p12 = vec2(iGroup2_4[1].xy);
+        vec2 p13 = vec2(iGroup2_4[3].xy);
+        vec2 p14 = vec2(iGroup2_4[5].xy);
+
+        p12.x = 1 - p12.x;
+        p13.y = 1 - p13.y;
+        p14.x = 1 - p14.x;
+        p14.y = 1 - p14.y;
+
+        vec2 uv1 = project_4p(vUV, p11, p12, p13, p14);
+        uv1 = mix(vec2(0), uv1, base_mask(uv1));
+        uv = uv1;
+        modified = true;
+    }
+
+    if (iGroup2_5[4].x > 0) {
+        vec2 p21 = vec2(iGroup2_5[6].xy);
+        vec2 p22 = vec2(iGroup2_5[1].xy);
+        vec2 p23 = vec2(iGroup2_5[3].xy);
+        vec2 p24 = vec2(iGroup2_5[5].xy);
+
+        p22.x = 1 - p22.x;
+        p23.y = 1 - p23.y;
+        p24.x = 1 - p24.x;
+        p24.y = 1 - p24.y;
+
+        vec2 uv2 = project_4p(vUV, p21, p22, p23, p24);
+        uv2 = mix(vec2(0), uv2, base_mask(uv2));
+        if (modified) {
+            uv = mix(uv, uv2, step(0.0001, length(uv2)));
+        } else {
+            uv = uv2;
+        }
+        modified = true;
+    }
+
+    if (iGroup2_6[4].x > 0) {
+        vec2 p31 = vec2(iGroup2_6[6].xy);
+        vec2 p32 = vec2(iGroup2_6[1].xy);
+        vec2 p33 = vec2(iGroup2_6[3].xy);
+        vec2 p34 = vec2(iGroup2_6[5].xy);
+
+        p32.x = 1 - p32.x;
+        p33.y = 1 - p33.y;
+        p34.x = 1 - p34.x;
+        p34.y = 1 - p34.y;
+
+        vec2 uv3 = project_4p(vUV, p31, p32, p33, p34);
+        uv3 = mix(vec2(0), uv3, base_mask(uv3));
+        if (modified) {
+            uv = mix(uv, uv3, step(0.0001, length(uv3)));
+        } else {
+            uv = uv3;
+        }
+        modified = true;
+    }
+
+    if (iGroup2_7[4].x > 0) {
+        vec2 p41 = vec2(iGroup2_7[6].xy);
+        vec2 p42 = vec2(iGroup2_7[1].xy);
+        vec2 p43 = vec2(iGroup2_7[3].xy);
+        vec2 p44 = vec2(iGroup2_7[5].xy);
+
+        p42.x = 1 - p42.x;
+        p43.y = 1 - p43.y;
+        p44.x = 1 - p44.x;
+        p44.y = 1 - p44.y;
+
+        vec2 uv4 = project_4p(vUV, p41, p42, p43, p44);
+        uv4 = mix(vec2(0), uv4, base_mask(uv4));
+        if (modified) {
+            uv = mix(uv, uv4, step(0.0001, length(uv4)));
+        } else {
+            uv = uv4;
+        }
+        modified = true;
+    }
+
+    vec4 color = texture(iTex0, invert ? vUV : uv);
+
+    if (visible) {
+        float mask = step(0.0001, length(uv));
+        color *= mix(mask, 1 - mask, invert ? 1 : 0);
+        color = mix(color, color + mask * vec4(1), rect * (step(uv.x, 0.01) + step(uv.y, 0.01) + step(1 - uv.y, 0.01) + step(1 - uv.x, 0.01)));
+    }
+
+    fragColor = color;
 }

default/inc_functions.glsl

@@ -83,8 +83,7 @@ vec3 shift3(vec3 c, float f) {
 
 vec3 mix3(vec3 c1, vec3 c2, vec3 c3, float x) {
     return istep(0.5, x) * mix(c1, c2, x * 2)
-        + step(0.5, x) * mix(c2, c3, x * 2 - 1)
+        + step(0.5, x) * mix(c2, c3, x * 2 - 1);
-    ;
 }
 
 vec3 mix4(vec3 c1, vec3 c2, vec3 c3, vec3 c4, float x) {
@@ -98,8 +97,7 @@ vec3 mix5(vec3 c1, vec3 c2, vec3 c3, vec3 c4, vec3 c5, float x) {
     return istep(0.25, x) * mix(c1, c2, x * 4)
         + step(0.25, x) * istep(0.5, x) * mix(c2, c3, x * 4 - 1)
         + step(0.5, x) * istep(0.75, x) * mix(c3, c4, x * 4 - 2)
-        + step(0.75, x) * mix(c4, c5, x * 4 - 3)
+        + step(0.75, x) * mix(c4, c5, x * 4 - 3);
-    ;
 }
 
 vec3 mix6(vec3 c1, vec3 c2, vec3 c3, vec3 c4, vec3 c5, vec3 c6, float x) {
@@ -107,8 +105,7 @@ vec3 mix6(vec3 c1, vec3 c2, vec3 c3, vec3 c4, vec3 c5, vec3 c6, float x) {
         + step(0.2, x) * istep(0.4, x) * mix(c2, c3, x * 5 - 1)
         + step(0.4, x) * istep(0.6, x) * mix(c3, c4, x * 5 - 2)
         + step(0.6, x) * istep(0.8, x) * mix(c4, c5, x * 5 - 3)
-        + step(0.8, x) * mix(c5, c6, x * 5 - 4)
+        + step(0.8, x) * mix(c5, c6, x * 5 - 4);
-    ;
 }
 
 float mean(vec3 v)
@@ -182,15 +179,15 @@ float v_index(vec2 uv) {
     return floor(uv.x) + floor(uv.y) * 45;
 }
 
-vec2 v_pos(float i) {
+vec2 v_pos(float i, int seed, float time) {
-    int iTimeId = int(iBeats);
+    int iTimeId = int(time);
-    float iTimeV = iBeats - iTimeId;
+    float iTimeV = time - iTimeId;
 
-    float x0 = rand(i + 823 + iTimeId);
+    float x0 = rand(i + seed + iTimeId);
-    float y0 = rand(i + 328 + iTimeId);
+    float y0 = rand(i + seed + 10 + iTimeId);
 
-    float x1 = rand(i + 823 + iTimeId + 1);
+    float x1 = rand(i + seed + iTimeId + 1);
-    float y1 = rand(i + 328 + iTimeId + 1);
+    float y1 = rand(i + seed + 10 + iTimeId + 1);
 
     return vec2(
         mix(x0, x1, ease(ease(iTimeV))),
@@ -198,7 +195,7 @@ vec2 v_pos(float i) {
     );
 }
 
-vec4 voronoi(vec2 uv, float dist) {
+vec4 voronoi(vec2 uv, float dist, int seed, float time) {
     vec4 o = vec4(0, 0, 2, 0);
     vec4 t = vec4(0, 0, 2, 0);
     float d, i;
@@ -207,7 +204,7 @@ vec4 voronoi(vec2 uv, float dist) {
         for (int dy = -1; dy <= 1; dy++) {
             uv2 = vec2(floor(uv.x) + dx, floor(uv.y) + dy);
             i = v_index(uv2);
-            p = uv2 + v_pos(i) * dist;
+            p = uv2 + v_pos(i, seed, time) * dist;
             d = length(p - uv);
             if (d < o.z) {
                 t = o;
@@ -281,7 +278,16 @@ float line(vec2 uv, vec2 p1, vec2 p2, float thick) {
     }
 }
 
-const mat2x2 ISOMETRIC_MATRIX = {{0.5, 1}, {0.5, -1}};
+const mat2x2 ISOMETRIC_MATRIX = {
+        {
+            0.5,
+            1
+        },
+        {
+            0.5,
+            -1
+        }
+    };
 
 vec2 iso(vec2 p) {
     return p * ISOMETRIC_MATRIX;

default/inc_map.glsl

@@ -0,0 +1,30 @@
+#ifndef INC_MAP
+#define INC_MAP
+
+vec2 project_4p(vec2 uv, vec2 p1, vec2 p2, vec2 p3, vec2 p4) {
+    float k1 = (p4.y - p3.y) / (p2.y - p3.y);
+    float k2 = (p3.y - p1.y) / (p2.y - p3.y);
+    float a = (p4.x - p3.x + k1 * p3.x - k1 * p2.x) / (p1.x - p3.x - k2 * p3.x + k2 * p2.x);
+    float b = k1 + a * k2;
+    float c = 1 - a - b;
+    // https://math.stackexchange.com/questions/296794/finding-the-transform-matrix-from-4-projected-points-with-javascript/339033#339033
+    mat3 projection_a = mat3(
+            a * p1.x, a * p1.y, a,
+            b * p2.x, b * p2.y, b,
+            c * p3.x, c * p3.y, c
+        );
+    mat3 projection_a_prime = inverse(projection_a);
+    mat3 projection_b = mat3(
+            0, 0, -1,
+            1, 0, 1,
+            0, 1, 1
+        );
+    vec3 tmp = projection_b * projection_a_prime * vec3(uv, 1);
+    return tmp.xy / tmp.z;
+}
+
+float base_mask(vec2 uv) {
+    return step(0, uv.x) * step(-1, -uv.x) * step(0, uv.y) * step(-1, -uv.y);
+}
+
+#endif

default/inc_src.glsl

@@ -8,8 +8,8 @@
 uniform int iDemo;
 
 uniform sampler2D iTex0;
-uniform sampler2D iTex5;
+uniform sampler2D iTex3;
-uniform sampler2D iTex6;
+uniform sampler2D iTex4;
 
 subroutine vec4 src_stage_sub(vec2 vUV, int seed, vec3 b1, vec2 f1, vec3 b2, vec2 f2, vec3 b3, vec2 f3);
 
@@ -101,7 +101,139 @@ subroutine ( src_stage_sub ) vec4 src_3(vec2 vUV, int seed, vec3 b1, vec2 f1, ve
     return vec4(f);
 }
 
-// SRC 4 : circuit
+// // SRC 4 : circuit
+// subroutine ( src_stage_sub ) vec4 src_4(vec2 vUV, int seed, vec3 b1, vec2 f1, vec3 b2, vec2 f2, vec3 b3, vec2 f3)
+// {
+//     // start
+
+//     vec2 uv0 = vUV.st;
+//     float ratio = iResolution.x / iResolution.y;
+//     vec2 uv1 = (uv0 - .5) * vec2(ratio, 1);
+
+//     // controls
+
+//     float z = 10 + magic(f1, b1, 123) * 20;
+//     float h = magic(f2, b2, seed + 20) * 0.8 + 0.1;
+//     float v = magic_reverse(f3, b3, seed + 30) * 0.8 + 0.1;
+
+//     // logic
+
+//     uv1 *= z;
+//     uv1 += iBeats;
+
+//     float s0 = rand(floor(mod(uv1, 1000))) * 1000;
+//     float s1 = rand(floor(mod(uv1 + vec2(0, 1), 1000))) * 1000;
+//     float s2 = rand(floor(mod(uv1 - vec2(1, 0), 1000))) * 1000;
+
+//     bool up = rand(s1 + 1) < h;
+//     bool left = rand(s2 + 2) < v;
+//     bool down = rand(s0 + 1) < h;
+//     bool right = rand(s0 + 2) < v;
+//     bool up_down = up && down;
+//     bool left_right = left && right;
+
+//     uv1 = mod(uv1, 1.0) - 0.5;
+
+//     const float t = 0.1;
+
+//     float f = 0;
+//     int c = 0;
+
+//     if (up) {
+//         f += stripe(uv1.x, -t * 0.5, t * 0.5) * step(-t * 0.5, uv1.y);
+//         c += 1;
+//     }
+
+//     if (down) {
+//         f += stripe(uv1.x, -t * 0.5, t * 0.5) * istep(t * 0.5, uv1.y);
+//         c += 1;
+//     }
+
+//     if (left) {
+//         f += stripe(uv1.y, -t * 0.5, t * 0.5) * istep(t * 0.5, uv1.x);
+//         c += 1;
+//     }
+
+//     if (right) {
+//         f += stripe(uv1.y, -t * 0.5, t * 0.5) * step(-t * 0.5, uv1.x);
+//         c += 1;
+//     }
+
+//     if (c == 1) {
+//         f += istep(t, length(uv1));
+//     }
+
+//     f = min(f, 1);
+
+//     if ((up_down ^^ left_right) && c == 2) {
+//         if (up_down) {
+//             uv1.xy = uv1.yx;
+//         }
+//         if (rand(s0 + 3) < 0.5) {
+//             uv1.x = -uv1.x;
+//         }
+//         float k = rand(s0 + 4) * 60;
+//         f -= rect(uv1, vec2(0), vec2(t * 3, t));
+//         f = max(0, f);
+//         if (k < 10) { // resistor
+//             f += line(uv1, vec2(-t * 3.25, -t * 0.5), vec2(-t * 2.5, t * 2), t * 0.75);
+//             f += line(uv1, vec2(-t * 2.5, t * 2), vec2(-t * 1.5, -t * 2), t * 0.75);
+//             f += line(uv1, vec2(-t * 1.5, -t * 2), vec2(-t * 0.5, t * 2), t * 0.75);
+//             f += line(uv1, vec2(-t * 0.5, t * 2), vec2(t * 0.5, -t * 2), t * 0.75);
+//             f += line(uv1, vec2(t * 0.5, -t * 2), vec2(t * 1.5, t * 2), t * 0.75);
+//             f += line(uv1, vec2(t * 1.5, t * 2), vec2(t * 2.5, -t * 2), t * 0.75);
+//             f += line(uv1, vec2(t * 2.5, -t * 2), vec2(t * 3.25, t * 0.5), t * 0.75);
+//         } else if (k < 20) { // capacitor
+//             f += rect(uv1, vec2(-t * 2, 0), vec2(t, t * 0.5));
+//             f += rect(uv1, vec2(t * 2, 0), vec2(t, t * 0.5));
+//             f += rect(uv1, vec2(t, 0), vec2(t * 0.5, t * 3.5));
+//             f += rect(uv1, vec2(-t, 0), vec2(t * 0.5, t * 3.5));
+//         } else if (k < 30) { // diode
+//             f += line(uv1, vec2(-t * 2, t * 2.5), vec2(t * 2, 0), t);
+//             f += line(uv1, vec2(-t * 2, -t * 2.5), vec2(t * 2, 0), t);
+//             f += rect(uv1, vec2(t * 2.5, 0), vec2(t * 0.5, t * 3));
+//             f += rect(uv1, vec2(-t * 2.5, 0), vec2(t * 0.5, t * 3));
+//         } else if (k < 40) { // lamp
+//             f += istep(t * 3.5, length(uv1));
+//             f -= istep(t * 2.5, length(uv1));
+//             f += line(uv1, vec2(-t * 2), vec2(t * 2), t);
+//             f += line(uv1, vec2(-t * 2, t * 2), vec2(t * 2, -t * 2), t);
+//         } else if (k < 50) { // inductor
+//             f += istep(t * 2, length(uv1 - vec2(t * 2.5, 0)));
+//             f += istep(t * 2, length(uv1 - vec2(0, 0)));
+//             f += istep(t * 2, length(uv1 - vec2(-t * 2.5, 0)));
+//             f -= 2 * istep(t, length(uv1 - vec2(t * 2.5, 0)));
+//             f -= 2 * istep(t, length(uv1 - vec2(0, 0)));
+//             f -= 2 * istep(t, length(uv1 - vec2(-t * 2.5, 0)));
+//             f *= step(-t * 0.5, uv1.y);
+//         } else if (k < 60) { // switch
+//             f += istep(t, length(uv1 - vec2(t * 2.5, 0)));
+//             f += istep(t, length(uv1 + vec2(t * 2.5, 0)));
+//             f += line(uv1, vec2(t * 2, 0), vec2(-t * 2.5, t * (k < 55 ? 3 : 1)), t);
+//         }
+//     } else if (c == 3) {
+//         if (left_right) {
+//             uv1.xy = uv1.yx;
+//             if (up) {
+//                 uv1.x = -uv1.x;
+//             }
+//         } else if (right) {
+//             uv1.x = -uv1.x;
+//         }
+//         float k = rand(s0 + 4) * 20;
+//         if (k < 10) {
+//             f -= rect(uv1, vec2(0), vec2(t * 3));
+//             f = max(0, f);
+//             f += rect(uv1, vec2(-t * 3, 0), vec2(t * 0.5, t * 3));
+//             f += line(uv1, vec2(t * 0.25, t * 3.25), vec2(-t * 3, t), t);
+//             f += line(uv1, vec2(t * 0.25, -t * 3.25), vec2(-t * 3, -t), t);
+//         }
+//     }
+
+//     return vec4(f);
+// }
+
+// SRC 4 : bacteria
 subroutine ( src_stage_sub ) vec4 src_4(vec2 vUV, int seed, vec3 b1, vec2 f1, vec3 b2, vec2 f2, vec3 b3, vec2 f3)
 {
     // start
@@ -112,123 +244,19 @@ subroutine ( src_stage_sub ) vec4 src_4(vec2 vUV, int seed, vec3 b1, vec2 f1, ve
 
     // controls
 
-    float z = 10 + magic(f1, b1, 123) * 20;
+    float zoom = 2 + magic(f1, b1, seed + 10) * 20;
-    float h = magic(f2, b2, seed + 20) * 0.8 + 0.1;
+    float details = 5 * magic(f2, b2, seed + 20);
-    float v = magic_reverse(f3, b3, seed + 30) * 0.8 + 0.1;
+    float delta = magic(f3, b3, seed + 30);
 
     // logic
 
-    uv1 *= z;
+    uv1 *= zoom;
-    uv1 += iBeats;
 
-    float s0 = rand(floor(mod(uv1, 1000))) * 1000;
+    vec4 data = voronoi(uv1, 1, seed + 40, iBeats * 0.25);
-    float s1 = rand(floor(mod(uv1 + vec2(0, 1), 1000))) * 1000;
-    float s2 = rand(floor(mod(uv1 - vec2(1, 0), 1000))) * 1000;
 
-    bool up = rand(s1 + 1) < h;
+    float f = ease(data.x) + ease(data.y);
-    bool left = rand(s2 + 2) < v;
-    bool down = rand(s0 + 1) < h;
-    bool right = rand(s0 + 2) < v;
-    bool up_down = up && down;
-    bool left_right = left && right;
 
-    uv1 = mod(uv1, 1.0) - 0.5;
+    f = saw(f * (1 + data.x * details) - delta * 2.0);
-
-    const float t = 0.1;
-
-    float f = 0;
-    int c = 0;
-
-    if (up) {
-        f += stripe(uv1.x, -t * 0.5, t * 0.5) * step(-t * 0.5, uv1.y);
-        c += 1;
-    }
-
-    if (down) {
-        f += stripe(uv1.x, -t * 0.5, t * 0.5) * istep(t * 0.5, uv1.y);
-        c += 1;
-    }
-
-    if (left) {
-        f += stripe(uv1.y, -t * 0.5, t * 0.5) * istep(t * 0.5, uv1.x);
-        c += 1;
-    }
-
-    if (right) {
-        f += stripe(uv1.y, -t * 0.5, t * 0.5) * step(-t * 0.5, uv1.x);
-        c += 1;
-    }
-
-    if (c == 1) {
-        f += istep(t, length(uv1));
-    }
-
-    f = min(f, 1);
-
-    if ((up_down ^^ left_right) && c == 2) {
-        if (up_down) {
-            uv1.xy = uv1.yx;
-        }
-        if (rand(s0 + 3) < 0.5) {
-            uv1.x = -uv1.x;
-        }
-        float k = rand(s0 + 4) * 60;
-        f -= rect(uv1, vec2(0), vec2(t * 3, t));
-        f = max(0, f);
-        if (k < 10) { // resistor
-            f += line(uv1, vec2(-t * 3.25, -t * 0.5), vec2(-t * 2.5, t * 2), t * 0.75);
-            f += line(uv1, vec2(-t * 2.5, t * 2), vec2(-t * 1.5, -t * 2), t * 0.75);
-            f += line(uv1, vec2(-t * 1.5, -t * 2), vec2(-t * 0.5, t * 2), t * 0.75);
-            f += line(uv1, vec2(-t * 0.5, t * 2), vec2(t * 0.5, -t * 2), t * 0.75);
-            f += line(uv1, vec2(t * 0.5, -t * 2), vec2(t * 1.5, t * 2), t * 0.75);
-            f += line(uv1, vec2(t * 1.5, t * 2), vec2(t * 2.5, -t * 2), t * 0.75);
-            f += line(uv1, vec2(t * 2.5, -t * 2), vec2(t * 3.25, t * 0.5), t * 0.75);
-        } else if (k < 20) { // capacitor
-            f += rect(uv1, vec2(-t * 2, 0), vec2(t, t * 0.5));
-            f += rect(uv1, vec2(t * 2, 0), vec2(t, t * 0.5));
-            f += rect(uv1, vec2(t, 0), vec2(t * 0.5, t * 3.5));
-            f += rect(uv1, vec2(-t, 0), vec2(t * 0.5, t * 3.5));
-        } else if (k < 30) { // diode
-            f += line(uv1, vec2(-t * 2, t * 2.5), vec2(t * 2, 0), t);
-            f += line(uv1, vec2(-t * 2, -t * 2.5), vec2(t * 2, 0), t);
-            f += rect(uv1, vec2(t * 2.5, 0), vec2(t * 0.5, t * 3));
-            f += rect(uv1, vec2(-t * 2.5, 0), vec2(t * 0.5, t * 3));
-        } else if (k < 40) { // lamp
-            f += istep(t * 3.5, length(uv1));
-            f -= istep(t * 2.5, length(uv1));
-            f += line(uv1, vec2(-t * 2), vec2(t * 2), t);
-            f += line(uv1, vec2(-t * 2, t * 2), vec2(t * 2, -t * 2), t);
-        } else if (k < 50) { // inductor
-            f += istep(t * 2, length(uv1 - vec2(t * 2.5, 0)));
-            f += istep(t * 2, length(uv1 - vec2(0, 0)));
-            f += istep(t * 2, length(uv1 - vec2(-t * 2.5, 0)));
-            f -= 2 * istep(t, length(uv1 - vec2(t * 2.5, 0)));
-            f -= 2 * istep(t, length(uv1 - vec2(0, 0)));
-            f -= 2 * istep(t, length(uv1 - vec2(-t * 2.5, 0)));
-            f *= step(-t * 0.5, uv1.y);
-        } else if (k < 60) { // switch
-            f += istep(t, length(uv1 - vec2(t * 2.5, 0)));
-            f += istep(t, length(uv1 + vec2(t * 2.5, 0)));
-            f += line(uv1, vec2(t * 2, 0), vec2(-t * 2.5, t * (k < 55 ? 3 : 1)), t);
-        }
-    } else if (c == 3) {
-        if (left_right) {
-            uv1.xy = uv1.yx;
-            if (up) {
-                uv1.x = -uv1.x;
-            }
-        } else if (right) {
-            uv1.x = -uv1.x;
-        }
-        float k = rand(s0 + 4) * 20;
-        if (k < 10) {
-            f -= rect(uv1, vec2(0), vec2(t * 3));
-            f = max(0, f);
-            f += rect(uv1, vec2(-t * 3, 0), vec2(t * 0.5, t * 3));
-            f += line(uv1, vec2(t * 0.25, t * 3.25), vec2(-t * 3, t), t);
-            f += line(uv1, vec2(t * 0.25, -t * 3.25), vec2(-t * 3, -t), t);
-        }
-    }
 
     return vec4(f);
 }
@@ -254,7 +282,7 @@ subroutine ( src_stage_sub ) vec4 src_5(vec2 vUV, int seed, vec3 b1, vec2 f1, ve
     vec2 uv2 = uv1;
     uv2 *= zoom * 20 + 3;
     uv2.x += iBeats;
-    vec4 data = voronoi(uv2, voronoi_distort);
+    vec4 data = voronoi(uv2, voronoi_distort, seed + 50, iBeats);
     float f = data.x / (data.x + data.y);
     f = sin(f * PI * (details * 20)) * 0.5 + 1;
     int nf = int(noise_factor * 6);
@@ -270,7 +298,7 @@ subroutine ( src_stage_sub ) vec4 src_6(vec2 vUV, int seed, vec3 b1, vec2 f1, ve
         return src_2(vUV, seed, b1, f1, b2, f2, b3, f3);
     }
 
-    return src_thru(vUV, iTex5, seed, b1, f1, b2, f2, b3, f3);
+    return src_thru(vUV, iTex3, seed, b1, f1, b2, f2, b3, f3);
 }
 
 #include inc_cp437.glsl
@@ -434,7 +462,7 @@ subroutine ( src_stage_sub ) vec4 src_11(vec2 vUV, int seed, vec3 b1, vec2 f1, v
         return src_3(vUV, seed, b1, f1, b2, f2, b3, f3);
     }
 
-    return src_thru(vUV, iTex6, seed, b1, f1, b2, f2, b3, f3);
+    return src_thru(vUV, iTex4, seed, b1, f1, b2, f2, b3, f3);
 }
 
 // SRC 12 : Scales

default/inc_yuyv.glsl

@@ -3,11 +3,27 @@
 
 const int YUYV_FOURCC = 1448695129;
 
-const mat3x3 yuyv_to_rgb = {{1,1,1},{0,-0.39465,2.03211},{1.13983,-0.5806,0}};
+// https://en.wikipedia.org/wiki/Y%E2%80%B2UV
+const mat3x3 yuyv_to_rgb_bt709 = {
+        {
+            1,
+            1,
+            1
+        },
+        {
+            0,
+            -0.21482,
+            2.12798
+        },
+        {
+            1.28033,
+            -0.38059,
+            0
+        }
+    };
 
 vec4 yuyvTex(sampler2D tex, vec2 vUV, int base_width) {
     float w = base_width - 1;
-
     int x = int(vUV.x * w);
 
     int xU = x - x % 2;
@@ -22,7 +38,7 @@ vec4 yuyvTex(sampler2D tex, vec2 vUV, int base_width) {
             tV.y - 0.5
         );
 
-    return vec4(yuyv_to_rgb * yuv, 1.0);
+    return vec4(yuyv_to_rgb_bt709 * yuv, 1.0);
 }
 
 #endif

src/args.c

@@ -34,6 +34,7 @@ static void print_help(int status_code) {
       "[-vs=SIZE] "
       "[-vb=COUNT] "
       "[-vr / -nvr] "
+      "[-vf=FOURCC] "
 #endif /* VIDEO_IN */
       "[-is=SIZE] "
       "[-ls / -nls] "
@@ -65,11 +66,12 @@ static void print_help(int status_code) {
       "  -vi, --video-in             path to video capture device (multiple "
       "allowed)\n"
       "  -vb, --video-buffers        number of video buffers to use (default: "
-      "2)\n"
+      "1)\n"
       "  -vs, --video-size           video capture desired height (default: "
       "internal texture height)\n"
       "  -vr, --video-reconnect      auto-reconnect video (default)\n"
       "  -nvr, --no-video-reconnect  do not auto-reconnect video\n"
+      "  -vf, --video-fourcc         video codec fourcc (default: YUYV)\n"
 #endif /* VIDEO_IN */
       "  -is, --internal-size        internal texture height (default: 720)\n"
       "  -ls, --load-state           load saved state (default)\n"
@@ -114,7 +116,7 @@ static unsigned int parse_uint(const char *arg, const char *value) {
 
   tmp_value = (unsigned long long)atoll(value);
 
-  if (tmp_value >= UINT_MAX) {
+  if (tmp_value > UINT_MAX) {
     invalid_value(arg, value);
   }
 
@@ -139,9 +141,10 @@ void args_parse(Parameters *params, int argc, char **argv) {
   params->auto_random_cycle = 4;
 #ifdef VIDEO_IN
   params->video_in.length = 0;
-  params->video_buffers = 2;
+  params->video_buffers = 1;
   params->video_size = 0;
   params->video_reconnect = true;
+  strlcpy(params->video_fourcc, "YUYV", 5);
 #endif /* VIDEO_IN */
   params->internal_size = 720;
   params->load_state = true;
@@ -159,8 +162,14 @@ void args_parse(Parameters *params, int argc, char **argv) {
       puts(PACKAGE " " VERSION);
       exit(EXIT_SUCCESS);
     } else if (is_arg(arg, "-p") || is_arg(arg, "--project")) {
+      if (strlen(value) == 0) {
+        invalid_value(arg, value);
+      }
       strlcpy(params->project_path, value, STR_LEN);
     } else if (is_arg(arg, "-c") || is_arg(arg, "--config")) {
+      if (strlen(value) == 0) {
+        invalid_value(arg, value);
+      }
       strlcpy(params->config_file, value, STR_LEN);
     } else if (is_arg(arg, "-hr") || is_arg(arg, "--hot-reload")) {
       params->hot_reload = true;
@@ -218,6 +227,9 @@ void args_parse(Parameters *params, int argc, char **argv) {
           log_error("maximum video input reached");
           exit(EXIT_FAILURE);
         }
+        if (strlen(value) == 0) {
+          invalid_value(arg, value);
+        }
         strlcpy(params->video_in.values[params->video_in.length++], value,
                 STR_LEN);
       } else if (is_arg(arg, "-vb") || is_arg(arg, "--video-buffers")) {
@@ -234,6 +246,11 @@ void args_parse(Parameters *params, int argc, char **argv) {
         params->video_reconnect = true;
       } else if (is_arg(arg, "-nvr") || is_arg(arg, "--no-video-reconnect")) {
         params->video_reconnect = false;
+      } else if (is_arg(arg, "-vf") || is_arg(arg, "--video-fourcc")) {
+        if (strlen(value) == 0) {
+          invalid_value(arg, value);
+        }
+        strlcpy(params->video_fourcc, value, 5);
       } else {
         invalid_arg(arg);
       }

src/arr.c

@@ -12,7 +12,21 @@ unsigned int arr_uint_index_of(UintArray array, unsigned int value) {
   return ARRAY_NOT_FOUND;
 }
 
+bool arr_string_match(StringArray array, const char *needle) {
+  for (unsigned int i = 0; i < array.length; i++) {
+    if (strncmp(array.values[i], needle, strlen(array.values[i])) == 0) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 unsigned int arr_uint_remap_index(UintArray offsets, unsigned int *index) {
+  if (offsets.length == 0) {
+    return 0;
+  }
+
   for (unsigned int i = offsets.length - 1; i > 0; i--) {
     if (*index >= offsets.values[i]) {
       *index -= offsets.values[i];

src/arr.h

@@ -7,4 +7,6 @@ unsigned int arr_uint_index_of(UintArray array, unsigned int value);
 
 unsigned int arr_uint_remap_index(UintArray offsets, unsigned int *index);
 
+bool arr_string_match(StringArray array, const char *needle);
+
 #endif /* ARR_H */

src/config_file.c

@@ -68,8 +68,7 @@ void config_file_read(ConfigFile *config, const char *path) {
   char *line;
   char *rest;
 
-  config->map = hashmap_new(sizeof(ConfigFileItem), 0, 0, 0, item_hash,
+  config->map = NULL;
-                            item_compare, NULL, NULL);
 
   file_read(&file, path);
 
@@ -78,6 +77,9 @@ void config_file_read(ConfigFile *config, const char *path) {
     return;
   }
 
+  config->map = hashmap_new(sizeof(ConfigFileItem), 0, 0, 0, item_hash,
+                            item_compare, NULL, NULL);
+
   config->error = false;
 
   line = strtok_r(file.content, "\n", &rest);
@@ -138,4 +140,8 @@ unsigned int config_file_get_int(const ConfigFile *config, const char *key,
   return (unsigned int)atoi(item->value);
 }
 
-void config_file_free(const ConfigFile *config) { hashmap_free(config->map); }
+void config_file_free(const ConfigFile *config) {
+  if (config->map != NULL) {
+    hashmap_free(config->map);
+  }
+}

src/constants.h

@@ -3,7 +3,7 @@
 #ifndef CONSTANTS_H
 #define CONSTANTS_H
 
-static char *vertex_shader_text =
+static const char *vertex_shader_text =
     "#version 460\n"
     "const mat4 mvp = "
     "{{2.,0.,0.,0.},{0.,2.,0.,0.},{0.,0.,2.,0.},{-1.,-1.,1.,1.}};\n"

src/file.c

@@ -26,6 +26,7 @@ bool file_should_update(const File *file) {
 
 bool file_update(File *file) {
   long length;
+  size_t read_length;
   FILE *file_pointer;
 
   // free remaining data
@@ -47,6 +48,12 @@ bool file_update(File *file) {
   // read file length
   fseek(file_pointer, 0, SEEK_END);
   length = ftell(file_pointer);
+  if (length == -1L) {
+    file->error = true;
+    fclose(file_pointer);
+    log_error("Cannot get file length for '%s'", file->path);
+    return false;
+  }
   // init buffer
   fseek(file_pointer, 0, SEEK_SET);
   file->content = malloc(length + 1);
@@ -57,7 +64,13 @@ bool file_update(File *file) {
     return false;
   }
   // read file
-  fread(file->content, sizeof(char), length, file_pointer);
+  read_length = fread(file->content, sizeof(char), length, file_pointer);
+  if (read_length != (unsigned)length) {
+    file->error = true;
+    fclose(file_pointer);
+    log_error("Cannot read complete file '%s'", file->path);
+    return false;
+  }
   // close file
   fclose(file_pointer);
   // append null byte
@@ -117,8 +130,9 @@ void file_write(const char *path, const StringArray *lines) {
   fclose(file_pointer);
 }
 
-void file_free(const File *file) {
+void file_free(File *file) {
-  if (!file->error) {
+  if (!file->error && file->content != NULL) {
     free(file->content);
+    file->content = NULL;
   }
 }

src/file.h

@@ -13,6 +13,6 @@ void file_write(const char *path, const StringArray *lines);
 
 void file_dump(const char *path, const char *content);
 
-void file_free(const File *file);
+void file_free(File *file);
 
 #endif /* FILE_H */

src/forge.c

@@ -85,7 +85,8 @@ static void init_inputs() {
 
   for (unsigned int i = 0; i < init_params.video_in.length; i++) {
     video_init(&video_captures.values[i], init_params.video_in.values[i],
-               init_params.video_size, init_params.video_buffers);
+               init_params.video_size, init_params.video_buffers,
+               init_params.video_fourcc, true);
 
     if (!video_captures.values[i].error) {
       context.input_resolutions[i][0] = video_captures.values[i].width;
@@ -101,15 +102,19 @@ static void start_video_background_read(VideoCapture *video_capture,
                                         Context *context, int input_index,
                                         bool trace_fps) {
   pthread_t thread;
-  struct VideoBackgroundReadArgs *process_args =
+  VideoBackgroundReadArgs *process_args =
-      (struct VideoBackgroundReadArgs *)malloc(
+      (VideoBackgroundReadArgs *)malloc(sizeof(VideoBackgroundReadArgs));
-          sizeof(struct VideoBackgroundReadArgs));
   process_args->capture = video_capture;
   process_args->context = context;
   process_args->input_index = input_index;
   process_args->trace_fps = trace_fps;
-  pthread_create(&thread, NULL, video_background_read, (void *)process_args);
+  if (pthread_create(&thread, NULL, video_background_read,
+                     (void *)process_args) == 0) {
     pthread_detach(thread);
+  } else {
+    log_error("background video acquisition failed to start");
+    free(process_args);
+  }
 }
 
 static void *
@@ -121,7 +126,8 @@ background_reconnect_video_captures(__attribute__((unused)) void *args) {
       if (video_captures.values[i].disconnected) {
         video_free(&video_captures.values[i]);
         video_init(&video_captures.values[i], init_params.video_in.values[i],
-                   init_params.video_size, init_params.video_buffers);
+                   init_params.video_size, init_params.video_buffers,
+                   init_params.video_fourcc, false);
 
         if (!video_captures.values[i].error) {
           context.input_resolutions[i][0] = video_captures.values[i].width;
@@ -147,8 +153,12 @@ static void start_video_captures() {
     }
   }
   if (init_params.video_reconnect) {
-    pthread_create(&thread, NULL, background_reconnect_video_captures, NULL);
+    if (pthread_create(&thread, NULL, background_reconnect_video_captures,
+                       NULL) == 0) {
       pthread_detach(thread);
+    } else {
+      log_info("background video capture reconnect failed to start");
+    }
   }
 }
 
@@ -192,26 +202,34 @@ static void midi_callback(unsigned char code, unsigned char value) {
 
 static void start_state_background_write() {
   pthread_t thread;
-  struct StateBackgroundWriteArgs *process_args =
+  StateBackgroundWriteArgs *process_args =
-      (struct StateBackgroundWriteArgs *)malloc(
+      (StateBackgroundWriteArgs *)malloc(sizeof(StateBackgroundWriteArgs));
-          sizeof(struct StateBackgroundWriteArgs));
   process_args->context = &context;
   process_args->state_config = project.state_config;
   process_args->midi = &midi;
-  pthread_create(&thread, NULL, state_background_write, process_args);
+  if (pthread_create(&thread, NULL, state_background_write, process_args) ==
+      0) {
     pthread_detach(thread);
+  } else {
+    log_error("background writing failed to start");
+    free(process_args);
+  }
 }
 
 static void start_midi_background_listen() {
   pthread_t thread;
-  struct MidiBackgroundListenArgs *process_args =
+  MidiBackgroundListenArgs *process_args =
-      (struct MidiBackgroundListenArgs *)malloc(
+      (MidiBackgroundListenArgs *)malloc(sizeof(MidiBackgroundListenArgs));
-          sizeof(struct MidiBackgroundListenArgs));
   process_args->device = &midi;
   process_args->context = &context;
   process_args->event_callback = midi_callback;
-  pthread_create(&thread, NULL, midi_background_listen, process_args);
+  if (pthread_create(&thread, NULL, midi_background_listen, process_args) ==
+      0) {
     pthread_detach(thread);
+  } else {
+    log_error("background midi acquisition failed to start");
+    free(process_args);
+  }
 }
 
 static void *background_reconnect_midi(__attribute__((unused)) void *args) {
@@ -219,7 +237,8 @@ static void *background_reconnect_midi(__attribute__((unused)) void *args) {
   while (!context.stop) {
     sleep(1);
     if (!midi.connected) {
-      midi_open(&midi, config_file_get_str(&project.config, "MIDI_HW", "hw"));
+      midi_open(&midi, config_file_get_str(&project.config, "MIDI_HW", "hw"),
+                false);
       if (midi.connected) {
         start_midi_background_listen();
       }
@@ -231,15 +250,18 @@ static void *background_reconnect_midi(__attribute__((unused)) void *args) {
 static void init_midi() {
   pthread_t thread;
 
-  midi_open(&midi, config_file_get_str(&project.config, "MIDI_HW", "hw"));
+  midi_open(&midi, config_file_get_str(&project.config, "MIDI_HW", "hw"), true);
 
   if (midi.connected) {
     start_midi_background_listen();
   }
 
   if (init_params.midi_reconnect) {
-    pthread_create(&thread, NULL, background_reconnect_midi, NULL);
+    if (pthread_create(&thread, NULL, background_reconnect_midi, NULL) == 0) {
       pthread_detach(thread);
+    } else {
+      log_error("background midi reconnect failed to start");
+    }
   }
 }
 
@@ -266,6 +288,7 @@ static bool init(const Parameters *params) {
 
   window_startup(error_callback);
 
+  context.tex_resolution[0] = params->internal_size;
   context.tex_resolution[1] = params->internal_size;
 
   if (params->output) {
@@ -292,6 +315,10 @@ static bool init(const Parameters *params) {
   }
 
 #ifdef VIDEO_IN
+  if (params->output && params->monitor) {
+    window_use(window_output, &context);
+  }
+
   shaders_link_inputs(&program, &project, &video_captures,
                       init_params.video_buffers);
 #endif /* VIDEO_IN */
@@ -363,8 +390,6 @@ static void shutdown() {
     state_save(&context, project.state_config);
   }
 
-  shaders_free(&program);
-
   if (window_output != NULL) {
     window_use(window_output, &context);
 
@@ -377,6 +402,8 @@ static void shutdown() {
     shaders_free_window(&program, init_params.output);
   }
 
+  shaders_free(&program);
+
 #ifdef VIDEO_IN
   free_video_captures();
 #endif /* VIDEO_IN */

src/midi.c

@@ -6,21 +6,32 @@
 
 #include "config.h"
 
-void midi_open(MidiDevice *device, const char *name) {
+void snd_no_log(__attribute__((unused)) int prio,
+                __attribute__((unused)) int interface,
+                __attribute__((unused)) const char *file,
+                __attribute__((unused)) int line,
+                __attribute__((unused)) const char *function,
+                __attribute__((unused)) int errcode,
+                __attribute__((unused)) const char *fmt,
+                __attribute__((unused)) va_list arg) {}
+
+void midi_open(MidiDevice *device, const char *name, bool log_error) {
   strlcpy(device->name, name, STR_LEN);
+  device->connected = false;
   device->input = NULL;
   device->output = NULL;
 
-  snd_rawmidi_open(&device->input, &device->output, name, SND_RAWMIDI_NONBLOCK);
+  device->connected = snd_rawmidi_open(&device->input, &device->output, name,
-
+                                       SND_RAWMIDI_SYNC) == 0 &&
-  device->connected = device->input != NULL && device->output != NULL;
+                      device->input != NULL && device->output != NULL;
-
+  if (log_error) {
     if (device->connected) {
       log_info("(%s) MIDI open", name);
     } else {
       log_warn("(%s) MIDI open failed", name);
     }
   }
+}
 
 void midi_write(MidiDevice device, unsigned char code, unsigned char value) {
   if (!device.connected) {
@@ -45,7 +56,7 @@ void midi_close(MidiDevice *device) {
 }
 
 void *midi_background_listen(void *args) {
-  MidiBackgroundReadArgs *process_args = (MidiBackgroundReadArgs *)args;
+  MidiBackgroundListenArgs *process_args = (MidiBackgroundListenArgs *)args;
   MidiDevice *device = process_args->device;
   Context *context = process_args->context;
 
@@ -57,6 +68,12 @@ void *midi_background_listen(void *args) {
 
   snd_rawmidi_info_malloc(&info);
 
+  if (info == NULL) {
+    log_error("(%s) failed to allocate MIDI info", device->name);
+    free(process_args);
+    pthread_exit(NULL);
+  }
+
   while (!context->stop && snd_rawmidi_info(device->output, info) == 0) {
     bytes_read = snd_rawmidi_read(device->input, buffer, 3);
     if (bytes_read == 3) {
@@ -73,5 +90,6 @@ void *midi_background_listen(void *args) {
     log_info("(%s) background acquisition stopped after error", device->name);
     midi_close(device);
   }
+  free(process_args);
   pthread_exit(NULL);
 }

src/midi.h

@@ -3,7 +3,7 @@
 #ifndef MIDI_H
 #define MIDI_H
 
-void midi_open(MidiDevice *device, const char *name);
+void midi_open(MidiDevice *device, const char *name, bool log_error);
 void midi_write(MidiDevice device, unsigned char code, unsigned char value);
 void *midi_background_listen(void *args);
 void midi_close(MidiDevice *device);

src/project.c

@@ -48,6 +48,8 @@ static bool parse_fragment_shader_file(Project *project, unsigned int i) {
         include_end - project->fragment_shaders[i][0].content,
         tmp_file.content);
 
+    free(project->fragment_shaders[i][0].content);
+
     project->fragment_shaders[i][0].content = new_content;
 
     file_free(&tmp_file);
@@ -102,6 +104,12 @@ void project_init(Project *project, const char *project_path,
 
   project->sub_counts.length = project->frag_count;
 
+  for (unsigned int i = 0; i < project->frag_count; i++) {
+    for (unsigned int j = 0; j < MAX_SUB_FILE + 1; j++) {
+      project->fragment_shaders[i][j].content = NULL;
+    }
+  }
+
   for (unsigned int i = 0; i < project->frag_count; i++) {
     project->sub_counts.values[i] = 0;
     if (!read_fragment_shader_file(project, frag_prefix, i)) {
@@ -134,9 +142,10 @@ void project_reload(Project *project, void (*reload_callback)(unsigned int)) {
   }
 }
 
-void project_free(const Project *project) {
+void project_free(Project *project) {
   for (unsigned int i = 0; i < project->frag_count; i++) {
     file_free(&project->fragment_shaders[i][0]);
+    // other sub files contents are freed at parse_fragment_shader_file
   }
 
   config_file_free(&project->config);

src/project.h

@@ -8,6 +8,6 @@ void project_init(Project *project, const char *project_path,
 
 void project_reload(Project *project, void (*reload_callback)(unsigned int));
 
-void project_free(const Project *project);
+void project_free(Project *project);
 
 #endif /* PROJECT_H */

src/rand.c

@@ -4,7 +4,7 @@ static unsigned long long mcg_state = 0xcafef00dd15ea5e5u; // Must be odd
 static unsigned long long const multiplier = 6364136223846793005u;
 
 // https://en.wikipedia.org/wiki/Permuted_congruential_generator
-static unsigned long rand(void) {
+static unsigned long fast_rand(void) {
   unsigned long long x = mcg_state;
   unsigned count = (unsigned)(x >> 61);
 
@@ -15,9 +15,9 @@ static unsigned long rand(void) {
 
 void rand_set_seed(unsigned long long seed) {
   mcg_state = 2 * seed + 1;
-  (void)rand();
+  (void)fast_rand();
 }
 
 unsigned int rand_uint(const unsigned int max) {
-  return max == 0 ? 0 : (unsigned int)(rand() % max);
+  return max == 0 ? 0 : (unsigned int)(fast_rand() % max);
 }

src/shaders.c

@@ -24,7 +24,7 @@
 #include <GLFW/glfw3native.h>
 #endif /* VIDEO_IN */
 
-static const GLuint unused_uniform = (GLuint)-1;
+static const GLint UNUSED_UNIFORM = -1;
 
 static bool check_glerror_ro(const char *context) {
   unsigned int code;
@@ -66,7 +66,7 @@ static bool check_eglerror_ro(const char *context) {
 
   code = eglGetError();
 
-  if (code > 0 && code != EGL_SUCCESS) {
+  if (code != EGL_SUCCESS) {
     log_warn("EGL Error: %04x (%s)", code, context);
     return true;
   }
@@ -245,12 +245,6 @@ static bool link_input_to_texture(ShaderProgram *program, VideoCapture *input,
     return false;
   }
 
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, input->width, input->height, 0, GL_RGB,
-               GL_UNSIGNED_BYTE, 0);
-  if (check_glerror(program, "link_input_to_texture/glTexImage2D")) {
-    return false;
-  }
-
   // https://registry.khronos.org/OpenGL/extensions/EXT/EXT_EGL_image_storage.txt
   glEGLImageTargetTexStorageEXT(GL_TEXTURE_2D, dma_image, NULL);
   if (check_eglerror(program,
@@ -411,7 +405,7 @@ static bool compile_shader(GLuint shader_id, const char *name,
   glGetShaderiv(shader_id, GL_COMPILE_STATUS, &status_params);
   check_glerror_ro("compile_shader/glGetShaderiv");
 
-  glGetShaderInfoLog(shader_id, 1024, NULL, (GLchar *)&log);
+  glGetShaderInfoLog(shader_id, STR_LEN, NULL, (GLchar *)log);
   check_glerror_ro("compile_shader/glGetShaderInfoLog");
 
   if (status_params == GL_FALSE) {
@@ -462,6 +456,8 @@ static bool init_single_program(ShaderProgram *program, unsigned int i,
   unsigned int index2;
   char name[STR_LEN];
   const char *prefix;
+  GLint link_status;
+  char link_log[STR_LEN];
 
   program->programs[i] = glCreateProgram();
   if (check_glerror(program, "init_single_program/glCreateProgram")) {
@@ -479,6 +475,19 @@ static bool init_single_program(ShaderProgram *program, unsigned int i,
     return false;
   }
 
+  glGetProgramiv(program->programs[i], GL_LINK_STATUS, &link_status);
+  if (check_glerror(program, "init_single_program/glGetProgramiv")) {
+    return false;
+  }
+  if (link_status != GL_TRUE) {
+    glGetProgramInfoLog(program->programs[i], STR_LEN, NULL, link_log);
+    if (check_glerror(program, "init_single_program/glGetProgramInfoLog")) {
+      return false;
+    }
+    log_error("Program %d link error: %s", i + 1, link_log);
+    return false;
+  }
+
   // create uniforms pointers
   program->itime_locations[i] = glGetUniformLocation(
       program->programs[i],
@@ -651,27 +660,27 @@ static void update_viewport(ShaderProgram *program, const Context *context) {
   }
 }
 
-static void write_uniform_1f(GLuint location, float value) {
+static void write_uniform_1f(GLint location, float value) {
-  if (location != unused_uniform) {
+  if (location != UNUSED_UNIFORM) {
     glUniform1f(location, value);
   }
 }
 
-static void write_uniform_1i(GLuint location, unsigned int value) {
+static void write_uniform_1i(GLint location, unsigned int value) {
-  if (location != unused_uniform) {
+  if (location != UNUSED_UNIFORM) {
     glUniform1i(location, (const GLint)value);
   }
 }
 
-static void write_uniform_2f(GLuint location, const vec2 *value) {
+static void write_uniform_2f(GLint location, const vec2 *value) {
-  if (location != unused_uniform) {
+  if (location != UNUSED_UNIFORM) {
     glUniform2fv(location, 1, (const GLfloat *)value);
   }
 }
 
-static void write_uniform_multi_3f(GLuint location, unsigned int count,
+static void write_uniform_multi_3f(GLint location, unsigned int count,
                                    const vec3 *value) {
-  if (location != unused_uniform) {
+  if (location != UNUSED_UNIFORM) {
     glUniform3fv(location, count, (const GLfloat *)value);
   }
 }
@@ -759,7 +768,7 @@ static void use_program(const ShaderProgram *program, int i, bool output,
     if (program->sub_locations[i * program->sub_variant_count *
                                    program->sub_type_count +
                                j * program->sub_variant_count + k] !=
-        unused_uniform) {
+        UNUSED_UNIFORM) {
       subroutines[subcount++] =
           program->sub_locations[i * program->sub_variant_count *
                                      program->sub_type_count +
@@ -935,6 +944,12 @@ void shaders_free(const ShaderProgram *program) {
   }
   check_glerror_ro("shaders_free/glDeleteProgram");
 
+  glDeleteShader(program->vertex_shader);
+  for (unsigned int i = 0; i < program->frag_count; i++) {
+    glDeleteShader(program->fragment_shaders[i]);
+  }
+  check_glerror_ro("shaders_free/glDeleteShader");
+
   glDeleteFramebuffers(program->frag_count, program->frame_buffers);
   check_glerror_ro("shaders_free/glDeleteFramebuffers");
 

src/state.c

@@ -98,14 +98,18 @@ static void randomize(Context *context, StateConfig state_config) {
       l = state_config.values_offsets.values[part] +
           k * state_config.group_counts.values[part] + j;
 
+      if (arr_uint_index_of(state_config.random_ignored, (l * 3) + (i % 3)) ==
+          ARRAY_NOT_FOUND) {
         if (arr_uint_index_of(state_config.fader_codes,
-                            state_config.codes.values[i]) != ARRAY_NOT_FOUND) {
+                              state_config.codes.values[i]) !=
+            ARRAY_NOT_FOUND) {
           context->values[l][i % 3] = (float)rand_uint(MIDI_MAX + 1) / MIDI_MAX;
         } else {
           context->values[l][i % 3] = rand_uint(2) == 1 ? 1 : 0;
         }
       }
     }
+  }
 
   for (unsigned int i = 0; i < context->state.length; i++) {
     context->state.values[i] = rand_uint(state_config.state_max);
@@ -184,29 +188,65 @@ static void save_to_file(const Context *context, StateConfig state_config,
 
   snprintf(lines.values[lines.length++], STR_LEN, "tempo=%d",
            (unsigned int)context->tempo.tempo);
+  if (lines.length > ARRAY_SIZE) {
+    log_error("Too many values to save");
+    return;
+  }
   snprintf(lines.values[lines.length++], STR_LEN, "page=%d", context->page);
+  if (lines.length > ARRAY_SIZE) {
+    log_error("Too many values to save");
+    return;
+  }
   snprintf(lines.values[lines.length++], STR_LEN, "selected=%d",
            context->selected);
+  if (lines.length > ARRAY_SIZE) {
+    log_error("Too many values to save");
+    return;
+  }
 
   for (unsigned int i = 0; i < context->state.length; i++) {
     snprintf(lines.values[lines.length++], STR_LEN, "seed_%d=%d", i,
              context->seeds[i]);
+    if (lines.length > ARRAY_SIZE) {
+      log_error("Too many values to save");
+      return;
+    }
     snprintf(lines.values[lines.length++], STR_LEN, "state_%d=%d", i,
              context->state.values[i]);
+    if (lines.length > ARRAY_SIZE) {
+      log_error("Too many values to save");
+      return;
+    }
   }
 
   for (unsigned int i = 0; i < state_config.group_active_counts.length; i++) {
     snprintf(lines.values[lines.length++], STR_LEN, "active_%d=%d", i,
              context->active[i]);
+    if (lines.length > ARRAY_SIZE) {
+      log_error("Too many values to save");
+      return;
+    }
   }
 
   for (unsigned int i = 0; i < state_config.value_count; i++) {
     snprintf(lines.values[lines.length++], STR_LEN, "value_%d_x=%d", i,
              (unsigned int)(context->values[i][0] * MIDI_MAX));
+    if (lines.length > ARRAY_SIZE) {
+      log_error("Too many values to save");
+      return;
+    }
     snprintf(lines.values[lines.length++], STR_LEN, "value_%d_y=%d", i,
              (unsigned int)(context->values[i][1] * MIDI_MAX));
+    if (lines.length > ARRAY_SIZE) {
+      log_error("Too many values to save");
+      return;
+    }
     snprintf(lines.values[lines.length++], STR_LEN, "value_%d_z=%d", i,
              (unsigned int)(context->values[i][2] * MIDI_MAX));
+    if (lines.length > ARRAY_SIZE) {
+      log_error("Too many values to save");
+      return;
+    }
   }
 
   file_write(state_file, &lines);
@@ -234,10 +274,16 @@ static void save_to_index_file(const Context *context, StateConfig state_config,
 void state_parse_config(StateConfig *state_config, const ConfigFile *config) {
   unsigned int offset;
   unsigned int count;
+  unsigned int length;
+  unsigned int value_offset;
+  StringArray ignored_codes;
   char name[STR_LEN];
 
-  state_config->select_page_codes.length =
+  length = config_file_get_int(config, "SELECT_PAGE_COUNT", 0);
-      config_file_get_int(config, "SELECT_PAGE_COUNT", 0);
+  if (length > ARRAY_SIZE) {
+    length = ARRAY_SIZE;
+  }
+  state_config->select_page_codes.length = length;
 
   for (unsigned int i = 0; i < state_config->select_page_codes.length; i++) {
     snprintf(name, STR_LEN, "SELECT_PAGE_%d", i + 1);
@@ -245,8 +291,11 @@ void state_parse_config(StateConfig *state_config, const ConfigFile *config) {
         config_file_get_int(config, name, UNSET_MIDI_CODE);
   }
 
-  state_config->select_item_codes.length =
+  length = config_file_get_int(config, "SELECT_ITEM_COUNT", 0);
-      config_file_get_int(config, "SELECT_ITEM_COUNT", 0);
+  if (length > ARRAY_SIZE) {
+    length = ARRAY_SIZE;
+  }
+  state_config->select_item_codes.length = length;
 
   for (unsigned int i = 0; i < state_config->select_item_codes.length; i++) {
     snprintf(name, STR_LEN, "SELECT_ITEM_%d", i + 1);
@@ -257,8 +306,11 @@ void state_parse_config(StateConfig *state_config, const ConfigFile *config) {
   state_config->state_max = state_config->select_page_codes.length *
                             state_config->select_item_codes.length;
 
-  state_config->select_frag_codes.length =
+  length = config_file_get_int(config, "FRAG_COUNT", 1);
-      config_file_get_int(config, "FRAG_COUNT", 1);
+  if (length > ARRAY_SIZE) {
+    length = ARRAY_SIZE;
+  }
+  state_config->select_frag_codes.length = length;
 
   for (unsigned int i = 0; i < state_config->select_frag_codes.length; i++) {
     snprintf(name, STR_LEN, "SELECT_FRAG_%d", i + 1);
@@ -266,11 +318,26 @@ void state_parse_config(StateConfig *state_config, const ConfigFile *config) {
         config_file_get_int(config, name, UNSET_MIDI_CODE);
   }
 
+  length = config_file_get_int(config, "ARI_COUNT", 0);
+  if (length > ARRAY_SIZE) {
+    length = ARRAY_SIZE;
+  }
+  ignored_codes.length = length;
+
+  for (unsigned int i = 0; i < ignored_codes.length; i++) {
+    snprintf(name, STR_LEN, "ARI_%d", i + 1);
+    strlcpy(ignored_codes.values[i],
+            config_file_get_str(config, name, "unkown"), STR_LEN);
+  }
+
+  length = config_file_get_int(config, "GROUP_COUNT", 0);
+  if (length > ARRAY_SIZE) {
+    length = ARRAY_SIZE;
+  }
   state_config->group_active_counts.length = state_config->group_counts.length =
       state_config->group_active_offsets.length =
           state_config->group_offsets.length =
-              state_config->values_offsets.length =
+              state_config->values_offsets.length = length;
-                  config_file_get_int(config, "GROUP_COUNT", 0);
 
   count = 0;
   for (unsigned int i = 0; i < state_config->group_active_counts.length; i++) {
@@ -307,27 +374,74 @@ void state_parse_config(StateConfig *state_config, const ConfigFile *config) {
 
   state_config->value_count = offset;
 
+  length = count * 3;
+  if (length > ARRAY_SIZE) {
+    length = ARRAY_SIZE;
+  }
   state_config->codes.length = count * 3;
+  state_config->random_ignored.length = 0;
 
   for (unsigned int i = 0; i < state_config->group_counts.length; i++) {
     offset = state_config->group_offsets.values[i];
+    value_offset = state_config->values_offsets.values[i];
     for (unsigned int j = 0; j < state_config->group_counts.values[i]; j++) {
+      if ((offset + j) * 3 < ARRAY_SIZE) {
         snprintf(name, STR_LEN, "GROUP_%d_%d_X", i + 1, j + 1);
         state_config->codes.values[(offset + j) * 3] =
             config_file_get_int(config, name, UNSET_MIDI_CODE);
+        for (unsigned int k = 0;
+             k < state_config->group_active_counts.values[i]; k++) {
+          snprintf(name, STR_LEN, "GROUP_%d_%d_X_%d", i + 1, j + 1, k + 1);
+          if (arr_string_match(ignored_codes, name)) {
+            state_config->random_ignored
+                .values[state_config->random_ignored.length++] =
+                (value_offset + k * state_config->group_counts.values[i] + j) *
+                3;
+          }
+        }
+      }
 
+      if ((offset + j) * 3 + 1 < ARRAY_SIZE) {
         snprintf(name, STR_LEN, "GROUP_%d_%d_Y", i + 1, j + 1);
         state_config->codes.values[(offset + j) * 3 + 1] =
             config_file_get_int(config, name, UNSET_MIDI_CODE);
+        for (unsigned int k = 0;
+             k < state_config->group_active_counts.values[i]; k++) {
+          snprintf(name, STR_LEN, "GROUP_%d_%d_Y_%d", i + 1, j + 1, k + 1);
+          if (arr_string_match(ignored_codes, name)) {
+            state_config->random_ignored
+                .values[state_config->random_ignored.length++] =
+                (value_offset + k * state_config->group_counts.values[i] + j) *
+                    3 +
+                1;
+          }
+        }
+      }
 
+      if ((offset + j) * 3 + 2 < ARRAY_SIZE) {
         snprintf(name, STR_LEN, "GROUP_%d_%d_Z", i + 1, j + 1);
         state_config->codes.values[(offset + j) * 3 + 2] =
             config_file_get_int(config, name, UNSET_MIDI_CODE);
+        for (unsigned int k = 0;
+             k < state_config->group_active_counts.values[i]; k++) {
+          snprintf(name, STR_LEN, "GROUP_%d_%d_Z_%d", i + 1, j + 1, k + 1);
+          if (arr_string_match(ignored_codes, name)) {
+            state_config->random_ignored
+                .values[state_config->random_ignored.length++] =
+                (value_offset + k * state_config->group_counts.values[i] + j) *
+                    3 +
+                2;
+          }
+        }
+      }
     }
   }
 
-  state_config->fader_codes.length =
+  length = config_file_get_int(config, "FADER_COUNT", 0);
-      config_file_get_int(config, "FADER_COUNT", 0);
+  if (length > ARRAY_SIZE) {
+    length = ARRAY_SIZE;
+  }
+  state_config->fader_codes.length = length;
 
   for (unsigned int i = 0; i < state_config->fader_codes.length; i++) {
     snprintf(name, STR_LEN, "FADER_%d", i + 1);
@@ -358,8 +472,11 @@ void state_parse_config(StateConfig *state_config, const ConfigFile *config) {
       config_file_get_int(config, "KEY_TEMPO_UP", 1265);
 
   if (config_file_has(config, "KEY_LOAD_COUNT")) {
-    state_config->key_load.length =
+    length = config_file_get_int(config, "KEY_LOAD_COUNT", 0);
-        config_file_get_int(config, "KEY_LOAD_COUNT", 0);
+    if (length > ARRAY_SIZE) {
+      length = ARRAY_SIZE;
+    }
+    state_config->key_load.length = length;
 
     for (unsigned int i = 0; i < state_config->key_load.length; i++) {
       snprintf(name, STR_LEN, "KEY_LOAD_%d", i + 1);
@@ -380,8 +497,11 @@ void state_parse_config(StateConfig *state_config, const ConfigFile *config) {
   }
 
   if (config_file_has(config, "KEY_SAVE_COUNT")) {
-    state_config->key_save.length =
+    length = config_file_get_int(config, "KEY_SAVE_COUNT", 0);
-        config_file_get_int(config, "KEY_SAVE_COUNT", 0);
+    if (length > ARRAY_SIZE) {
+      length = ARRAY_SIZE;
+    }
+    state_config->key_save.length = length;
 
     for (unsigned int i = 0; i < state_config->key_save.length; i++) {
       snprintf(name, STR_LEN, "KEY_SAVE_%d", i + 1);
@@ -409,6 +529,9 @@ static bool compute_event(Context *context, StateConfig state_config,
   unsigned int j;
   unsigned int k;
   unsigned int part;
+  bool found;
+
+  found = false;
 
   // PAGE CHANGE
   i = arr_uint_index_of(state_config.select_page_codes, code);
@@ -417,7 +540,7 @@ static bool compute_event(Context *context, StateConfig state_config,
       context->page = i;
       update_page(context, state_config, midi);
     }
-    return true;
+    found = true;
   }
 
   // TARGET CHANGE
@@ -427,7 +550,7 @@ static bool compute_event(Context *context, StateConfig state_config,
       context->selected = i;
       update_page(context, state_config, midi);
     }
-    return true;
+    found = true;
   }
 
   // ITEM CHANGE
@@ -438,7 +561,7 @@ static bool compute_event(Context *context, StateConfig state_config,
           context->page * state_config.select_item_codes.length + i;
       update_page(context, state_config, midi);
     }
-    return true;
+    found = true;
   }
 
   // ACTIVE CHANGE
@@ -450,7 +573,7 @@ static bool compute_event(Context *context, StateConfig state_config,
       update_active(context, state_config, midi, true);
       update_values(context, state_config, midi);
     }
-    return true;
+    found = true;
   }
 
   // VALUE CHANGE
@@ -472,7 +595,7 @@ static bool compute_event(Context *context, StateConfig state_config,
         safe_midi_write(midi, code, MIDI_MAX);
       }
     }
-    return true;
+    found = true;
   }
 
   // TAP TEMPO
@@ -481,7 +604,7 @@ static bool compute_event(Context *context, StateConfig state_config,
     if (value > 0) {
       tempo_tap(&context->tempo);
     }
-    return true;
+    found = true;
   }
 
   // OTHER KEYS
@@ -491,7 +614,7 @@ static bool compute_event(Context *context, StateConfig state_config,
       randomize(context, state_config);
       update_values(context, state_config, midi);
     }
-    return true;
+    found = true;
   }
 
   if (code == state_config.key_reset) {
@@ -500,7 +623,7 @@ static bool compute_event(Context *context, StateConfig state_config,
       reset(context);
       update_values(context, state_config, midi);
     }
-    return true;
+    found = true;
   }
 
   if (code == state_config.key_demo) {
@@ -508,17 +631,16 @@ static bool compute_event(Context *context, StateConfig state_config,
       log_info((context->demo ? "[%d] Demo OFF" : "[%d] Demo ON"), code);
       context->demo = !context->demo;
     }
-    return true;
+    found = true;
   }
 
   if (code == state_config.key_autorand) {
     if (value > 0) {
-      log_info((context->auto_random ? "[%d] Auto Random OFF"
-                                     : "[%d] Auto Random ON"),
-               code);
       context->auto_random = !context->auto_random;
+      log_info("[%d] Auto Random %s", code,
+               context->auto_random ? "ON" : "OFF");
     }
-    return true;
+    found = true;
   }
 
   if (code == state_config.key_autorand_down) {
@@ -528,7 +650,7 @@ static bool compute_event(Context *context, StateConfig state_config,
       }
       log_info("[%d] Auto Random Cycle: %d", code, context->auto_random_cycle);
     }
-    return true;
+    found = true;
   }
 
   if (code == state_config.key_autorand_up) {
@@ -536,7 +658,7 @@ static bool compute_event(Context *context, StateConfig state_config,
       context->auto_random_cycle += 1;
       log_info("[%d] Auto Random Cycle: %d", code, context->auto_random_cycle);
     }
-    return true;
+    found = true;
   }
 
   if (code == state_config.key_tempo_up) {
@@ -544,7 +666,7 @@ static bool compute_event(Context *context, StateConfig state_config,
       tempo_set(&context->tempo, context->tempo.tempo + 1);
       log_info("[%d] Tempo: %f", code, context->tempo);
     }
-    return true;
+    found = true;
   }
 
   if (code == state_config.key_tempo_down) {
@@ -552,9 +674,9 @@ static bool compute_event(Context *context, StateConfig state_config,
       if (context->tempo.tempo > 0) {
         tempo_set(&context->tempo, context->tempo.tempo - 1);
       }
-      log_info("[%d] Tempo: %f", code, context->tempo);
+      log_info("[%d] Tempo: %f", code, context->tempo.tempo);
     }
-    return true;
+    found = true;
   }
 
   // LOAD STATE
@@ -565,7 +687,7 @@ static bool compute_event(Context *context, StateConfig state_config,
       log_info("[%d] Loading state %d", code, i + 1);
       load_from_index_file(context, state_config, i + 1);
     }
-    return true;
+    found = true;
   }
 
   // SAVE STATE
@@ -576,10 +698,10 @@ static bool compute_event(Context *context, StateConfig state_config,
       log_info("[%d] Saving state %d", code, i + 1);
       save_to_index_file(context, state_config, i + 1);
     }
-    return true;
+    found = true;
   }
 
-  return false;
+  return found;
 }
 
 void state_midi_event(Context *context, StateConfig state_config,
@@ -643,6 +765,7 @@ void *state_background_write(void *args) {
   }
 
   log_info("(state) background writing stopped by main thread");
+  free(process_args);
   pthread_exit(NULL);
 }
 

src/string.c

@@ -15,7 +15,7 @@ unsigned int string_trim(char *str) {
   start = 0;
   end = strnlen(str, STR_LEN) - 1;
 
-  if (end == 0) {
+  if (end <= 0) {
     return 0;
   }
 
@@ -62,11 +62,19 @@ char *string_replace_at(const char *src, unsigned int from, unsigned int to,
   unsigned long rpl_len;
   char *dst;
 
+  if (to < from) {
+    return "";
+  }
+
   src_len = strnlen(src, STR_LEN * STR_LEN);
   rpl_len = strnlen(rpl, STR_LEN * STR_LEN);
 
   dst = malloc(src_len - (to - from) + rpl_len + 1);
 
+  if (dst == NULL) {
+    return "";
+  }
+
   strlcpy(dst, src, from + 1);
   strlcpy(dst + from, rpl, rpl_len + 1);
   strlcpy(dst + from + rpl_len, src + to, src_len - to + 1);

src/tempo.c

@@ -1,18 +1,18 @@
 #include <math.h>
 #include <string.h>
-#include <sys/time.h>
+#include <time.h>
 
 #include "types.h"
 
 #include "config.h"
 #include "tempo.h"
 
-static long now() {
+static long now_ms() {
-  struct timeval now;
+  struct timespec ts;
-
+  if (clock_gettime(CLOCK_REALTIME, &ts) != 0) {
-  gettimeofday(&now, NULL);
+    return 0;
-
+  }
-  return now.tv_sec * 1000 + now.tv_usec / 1000;
+  return 1000 * ts.tv_sec + ts.tv_nsec / 1e6;
 }
 
 static void reset_tap_chain(Tempo *tempo, long t) {
@@ -93,7 +93,7 @@ static void add_tap_to_chain(Tempo *tempo, long t) {
 void tempo_init(Tempo *tempo, float value) {
   long t;
 
-  t = now();
+  t = now_ms();
 
   reset_tap_chain(tempo, t);
 
@@ -105,7 +105,7 @@ void tempo_set(Tempo *tempo, float value) {
   long t;
   long progress;
 
-  t = now();
+  t = now_ms();
 
   progress = (t - tempo->last_reset) % tempo->beat_length;
 
@@ -118,7 +118,7 @@ void tempo_set(Tempo *tempo, float value) {
 void tempo_tap(Tempo *tempo) {
   long t;
 
-  t = now();
+  t = now_ms();
 
   if (!is_chain_active(*tempo, t)) {
     reset_tap_chain(tempo, t);
@@ -130,7 +130,7 @@ void tempo_tap(Tempo *tempo) {
 double tempo_total(const Tempo *tempo) {
   long t;
 
-  t = now();
+  t = now_ms();
 
   return (double)(t - tempo->last_reset) / (double)tempo->beat_length;
 }

src/timer.c

@@ -1,4 +1,6 @@
-#include <sys/time.h>
+#include <bits/time.h>
+#include <limits.h>
+#include <time.h>
 
 #include "types.h"
 
@@ -7,24 +9,25 @@
 void timer_init(Timer *timer, const unsigned int target) {
   timer->counter = 0;
   timer->target = target;
-
+  clock_gettime(CLOCK_REALTIME, &timer->start);
-  gettimeofday(&timer->start, NULL);
 }
 
 bool timer_inc(Timer *timer) {
   timer->counter += 1;
-  return timer->counter >= timer->target;
+  return timer->counter == UINT_MAX || timer->counter >= timer->target;
 }
 
 double timer_reset(Timer *timer) {
-  struct timeval stop;
+  struct timespec stop;
   double secs;
   double per_secs;
 
-  gettimeofday(&stop, NULL);
+  if (clock_gettime(CLOCK_REALTIME, &stop) != 0) {
+    return 0.0;
+  }
 
-  secs = (double)(stop.tv_usec - timer->start.tv_usec) / 1000000 +
+  secs = (double)(stop.tv_sec - timer->start.tv_sec) +
-         (double)(stop.tv_sec - timer->start.tv_sec);
+         (double)(stop.tv_nsec - timer->start.tv_nsec) / 1e9;
   per_secs = (double)timer->counter / secs;
 
   timer->start = stop;

src/types.h

@@ -50,6 +50,7 @@ typedef struct Parameters {
   unsigned int video_buffers;
   unsigned int video_size;
   bool video_reconnect;
+  char video_fourcc[5];
 #endif /* VIDEO_IN */
   unsigned int internal_size;
   bool load_state;
@@ -100,34 +101,34 @@ typedef struct ShaderProgram {
   GLuint frame_buffers[ARRAY_SIZE];
   GLuint fragment_shaders[ARRAY_SIZE];
 
-  GLuint itime_locations[ARRAY_SIZE];
+  GLint itime_locations[ARRAY_SIZE];
-  GLuint itempo_locations[ARRAY_SIZE];
+  GLint itempo_locations[ARRAY_SIZE];
-  GLuint ibeats_locations[ARRAY_SIZE];
+  GLint ibeats_locations[ARRAY_SIZE];
-  GLuint ifps_locations[ARRAY_SIZE];
+  GLint ifps_locations[ARRAY_SIZE];
-  GLuint ires_locations[ARRAY_SIZE];
+  GLint ires_locations[ARRAY_SIZE];
-  GLuint itexres_locations[ARRAY_SIZE];
+  GLint itexres_locations[ARRAY_SIZE];
-  GLuint iinres_locations[ARRAY_SIZE];
+  GLint iinres_locations[ARRAY_SIZE];
-  GLuint iinfmt_locations[ARRAY_SIZE];
+  GLint iinfmt_locations[ARRAY_SIZE];
-  GLuint iinfps_locations[ARRAY_SIZE];
+  GLint iinfps_locations[ARRAY_SIZE];
-  GLuint idemo_locations[ARRAY_SIZE];
+  GLint idemo_locations[ARRAY_SIZE];
-  GLuint iautorand_locations[ARRAY_SIZE];
+  GLint iautorand_locations[ARRAY_SIZE];
-  GLuint iautorandcycle_locations[ARRAY_SIZE];
+  GLint iautorandcycle_locations[ARRAY_SIZE];
-  GLuint iseed_locations[ARRAY_SIZE];
+  GLint iseed_locations[ARRAY_SIZE];
-  GLuint istate_locations[ARRAY_SIZE];
+  GLint istate_locations[ARRAY_SIZE];
-  GLuint ipage_locations[ARRAY_SIZE];
+  GLint ipage_locations[ARRAY_SIZE];
-  GLuint iselected_locations[ARRAY_SIZE];
+  GLint iselected_locations[ARRAY_SIZE];
-  GLuint iactive_locations[ARRAY_SIZE];
+  GLint iactive_locations[ARRAY_SIZE];
 
   UintArray midi_lengths;
-  GLuint igroup_locations[ARRAY_SIZE];
+  GLint igroup_locations[ARRAY_SIZE];
 
-  GLuint vpos_locations[ARRAY_SIZE];
+  GLint vpos_locations[ARRAY_SIZE];
 
-  GLuint textures_locations[ARRAY_SIZE];
+  GLint textures_locations[ARRAY_SIZE];
 
   unsigned int sub_type_count;
   unsigned int sub_variant_count;
-  GLuint sub_locations[ARRAY_SIZE];
+  GLint sub_locations[ARRAY_SIZE];
 
   unsigned int active_count;
 
@@ -232,7 +233,7 @@ typedef struct MidiBackgroundListenArgs {
   MidiDevice *device;
   Context *context;
   void (*event_callback)(unsigned char code, unsigned char value);
-} MidiBackgroundReadArgs;
+} MidiBackgroundListenArgs;
 
 // state.c
 
@@ -250,6 +251,7 @@ typedef struct StateConfig {
   UintArray codes;
   UintArray fader_codes;
   UintArray values_offsets;
+  UintArray random_ignored;
 
   unsigned int value_count;
 
@@ -279,7 +281,7 @@ typedef struct StateBackgroundWriteArgs {
 // timer.c
 
 typedef struct Timer {
-  struct timeval start;
+  struct timespec start;
   unsigned int counter;
   unsigned int target;
 } Timer;

src/video.c

@@ -16,7 +16,6 @@
 #include "timer.h"
 #include "video.h"
 
-static const unsigned int pixel_format = V4L2_PIX_FMT_YUYV;
 static const enum v4l2_buf_type buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
 static void ioctl_error(VideoCapture *video_capture, const char *operation,
@@ -70,14 +69,31 @@ static void ioctl_error(VideoCapture *video_capture, const char *operation,
   video_capture->error = true;
 }
 
-static void open_device(VideoCapture *video_capture, const char *name) {
+static void fourcc_to_string(unsigned int fourcc, char *str) {
+  str[0] = (char)(fourcc & 0xFF);
+  str[1] = (char)((fourcc >> 8) & 0xFF);
+  str[2] = (char)((fourcc >> 16) & 0xFF);
+  str[3] = (char)((fourcc >> 24) & 0xFF);
+  str[4] = '\0';
+}
+
+static int string_to_fourcc(const char *str) {
+  return (unsigned int)str[0] | ((unsigned int)str[1] << 8) |
+         ((unsigned int)str[2] << 16) | ((unsigned int)str[3] << 24);
+}
+
+static void open_device(VideoCapture *video_capture, const char *name,
+                        bool log_error) {
   strlcpy(video_capture->name, name, STR_LEN);
   video_capture->error = false;
   video_capture->fd = -1;
+  video_capture->buf_count = 0;
 
   video_capture->fd = open(name, O_RDWR | O_NONBLOCK);
   if (video_capture->fd == -1) {
+    if (log_error) {
       log_warn("(%s) Cannot open device", name);
+    }
     video_capture->error = true;
   }
 }
@@ -108,7 +124,8 @@ static bool check_caps(VideoCapture *video_capture) {
 }
 
 static bool get_available_sizes(VideoCapture *video_capture,
-                                unsigned int preferred_height) {
+                                unsigned int preferred_height,
+                                unsigned int pixel_format) {
   struct v4l2_frmsizeenum fmt_enum;
   unsigned int index;
   bool found = false;
@@ -161,8 +178,9 @@ static bool get_available_sizes(VideoCapture *video_capture,
   return true;
 }
 
-static bool set_format(VideoCapture *video_capture) {
+static bool set_format(VideoCapture *video_capture, unsigned int pixel_format) {
   struct v4l2_format fmt;
+  char fourcc[STR_LEN];
 
   memset(&fmt, 0, sizeof(fmt));
 
@@ -183,9 +201,9 @@ static bool set_format(VideoCapture *video_capture) {
   video_capture->pixelformat = fmt.fmt.pix.pixelformat;
   video_capture->bytesperline = fmt.fmt.pix.bytesperline;
 
-  log_info("(%s) Format fourcc:  %c%c%c%c", video_capture->name,
+  fourcc_to_string(fmt.fmt.pix.pixelformat, fourcc);
-           fmt.fmt.pix.pixelformat, fmt.fmt.pix.pixelformat >> 8,
+
-           fmt.fmt.pix.pixelformat >> 16, fmt.fmt.pix.pixelformat >> 24);
+  log_info("(%s) Format fourcc:  %s", video_capture->name, fourcc);
   log_info("(%s) Resolution:  %dx%d", video_capture->name, fmt.fmt.pix.width,
            fmt.fmt.pix.height);
 
@@ -211,6 +229,9 @@ static bool request_buffers(VideoCapture *video_capture,
   log_info("(%s) V4L2 Buffer Count:  %d", video_capture->name, reqbuf.count);
 
   video_capture->buf_count = reqbuf.count;
+  for (unsigned int i = 0; i < reqbuf.count; i++) {
+    video_capture->exp_fd[i] = -1;
+  }
 
   return true;
 }
@@ -262,7 +283,7 @@ static bool open_stream(VideoCapture *video_capture) {
   return true;
 }
 
-static void create_image_buffer(const VideoCapture *video_capture,
+static bool create_image_buffer(VideoCapture *video_capture,
                                 struct v4l2_buffer *buf, unsigned int index) {
   memset(buf, 0, sizeof(*buf));
 
@@ -270,17 +291,26 @@ static void create_image_buffer(const VideoCapture *video_capture,
   buf->memory = V4L2_MEMORY_MMAP;
   buf->index = index;
 
-  ioctl(video_capture->fd, VIDIOC_QBUF, buf);
+  if (ioctl(video_capture->fd, VIDIOC_QBUF, buf) == -1) {
+    ioctl_error(video_capture, "VIDIOC_QBUF", "Could not enqueue buffer");
+    return false;
   }
 
-static void create_image_buffers(VideoCapture *video_capture) {
+  return true;
+}
+
+static bool create_image_buffers(VideoCapture *video_capture) {
   unsigned int i;
 
   for (i = 0; i < video_capture->buf_count; i++) {
-    create_image_buffer(video_capture, &video_capture->buf[i], i);
+    if (!create_image_buffer(video_capture, &video_capture->buf[i], i)) {
+      return false;
     }
   }
 
+  return true;
+}
+
 static void close_stream(const VideoCapture *video_capture) {
   ioctl(video_capture->fd, VIDIOC_STREAMOFF, &buf_type);
 }
@@ -290,12 +320,16 @@ static unsigned int read_video(VideoCapture *video_capture) {
 
   if (ioctl(video_capture->fd, VIDIOC_DQBUF,
             &video_capture->buf[video_capture->buf_index]) != -1) {
-    ioctl(video_capture->fd, VIDIOC_QBUF,
+    if (ioctl(video_capture->fd, VIDIOC_QBUF,
-          &video_capture->buf[video_capture->buf_index]);
+              &video_capture->buf[video_capture->buf_index]) == -1) {
+      video_capture->error = true;
+      return false;
+    } else {
       video_capture->buf_index =
           (video_capture->buf_index + 1) % video_capture->buf_count;
       return true;
     }
+  }
 
   if (ioctl(video_capture->fd, VIDIOC_QUERYCAP, &cap) == -1) {
     video_capture->error = true;
@@ -305,38 +339,56 @@ static unsigned int read_video(VideoCapture *video_capture) {
 }
 
 void video_init(VideoCapture *video_capture, const char *name,
-                unsigned int preferred_height, unsigned int buffer_count) {
+                unsigned int preferred_height, unsigned int buffer_count,
-  open_device(video_capture, name);
+                const char *video_fourcc, bool log_error) {
+  open_device(video_capture, name, log_error);
 
   if (video_capture->error) {
     return;
   }
 
   if (!check_caps(video_capture)) {
+    video_capture->error = true;
+    video_free(video_capture);
     return;
   }
 
-  if (!get_available_sizes(video_capture, preferred_height)) {
+  if (!get_available_sizes(video_capture, preferred_height,
+                           string_to_fourcc(video_fourcc))) {
+    video_capture->error = true;
+    video_free(video_capture);
     return;
   }
 
-  if (!set_format(video_capture)) {
+  if (!set_format(video_capture, string_to_fourcc(video_fourcc))) {
+    video_capture->error = true;
+    video_free(video_capture);
     return;
   }
 
   if (!request_buffers(video_capture, buffer_count)) {
+    video_capture->error = true;
+    video_free(video_capture);
     return;
   }
 
   if (!export_buffers(video_capture)) {
+    video_capture->error = true;
+    video_free(video_capture);
     return;
   }
 
   if (!open_stream(video_capture)) {
+    video_capture->error = true;
+    video_free(video_capture);
     return;
   }
 
-  create_image_buffers(video_capture);
+  if (!create_image_buffers(video_capture)) {
+    video_capture->error = true;
+    video_free(video_capture);
+    return;
+  }
 }
 
 void *video_background_read(void *args) {
@@ -376,20 +428,24 @@ void *video_background_read(void *args) {
              video_capture->name);
     video_capture->disconnected = true;
     context->input_formats[input_index] = 0;
+    context->input_resolutions[input_index][0] = 0;
+    context->input_resolutions[input_index][1] = 0;
   }
+  free(process_args);
   pthread_exit(NULL);
 }
 
 void video_free(const VideoCapture *video_capture) {
   unsigned int i;
 
-  close_stream(video_capture);
-
   for (i = 0; i < video_capture->buf_count; i++) {
+    if (video_capture->exp_fd[i] != -1) {
       close(video_capture->exp_fd[i]);
     }
+  }
 
   if (video_capture->fd != -1) {
+    close_stream(video_capture);
     close(video_capture->fd);
   }
 }

src/video.h

@@ -6,7 +6,8 @@
 #ifdef VIDEO_IN
 
 void video_init(VideoCapture *video_capture, const char *name,
-                unsigned int preferred_height, unsigned int buffer_count);
+                unsigned int preferred_height, unsigned int buffer_count,
+                const char *video_fourcc, bool log_error);
 
 void *video_background_read(void *args);
 

src/window.c

@@ -131,9 +131,10 @@ void window_use(Window *window, Context *context) {
   glfwGetFramebufferSize(window, &width, &height);
   context->resolution[0] = width;
   context->resolution[1] = height;
+  if (height > 0) {
     context->tex_resolution[0] =
-      (int)(context->tex_resolution[1] * context->resolution[0] /
+        (int)(context->tex_resolution[1] * width / height);
-            context->resolution[1]);
+  }
 }
 
 void window_close(Window *window) {