diff --git a/plugins/community/repos/cf/Makefile b/plugins/community/repos/cf/Makefile index 80c55336..7f5e9fea 100644 --- a/plugins/community/repos/cf/Makefile +++ b/plugins/community/repos/cf/Makefile @@ -1,9 +1,11 @@ SLUG = cf -VERSION = 0.6.0 +VERSION = 0.6.7 SOURCES += $(wildcard src/*.cpp) DISTRIBUTABLES += $(wildcard LICENSE*) res +DISTRIBUTABLES += $(wildcard LICENSE*) res_b +DISTRIBUTABLES += $(wildcard LICENSE*) playeroscs RACK_DIR ?= ../.. include $(RACK_DIR)/plugin.mk diff --git a/plugins/community/repos/cf/README.md b/plugins/community/repos/cf/README.md index 80845481..5bdf15cc 100644 --- a/plugins/community/repos/cf/README.md +++ b/plugins/community/repos/cf/README.md @@ -1,7 +1,7 @@ -![alt text](/cf060.png) - +![alt text](/screens/cf064.png) +![alt text](/screens/cf064b.png) **trSEQ : tr style 16 steps SEQ with trig input per step** diff --git a/plugins/community/repos/cf/cf060.png b/plugins/community/repos/cf/cf060.png deleted file mode 100644 index 33684990..00000000 Binary files a/plugins/community/repos/cf/cf060.png and /dev/null differ diff --git a/plugins/community/repos/cf/make.objects b/plugins/community/repos/cf/make.objects index 37a3d015..55c6d2bc 100644 --- a/plugins/community/repos/cf/make.objects +++ b/plugins/community/repos/cf/make.objects @@ -1,7 +1,10 @@ COMMON_OBJ= \ - src/AudioFile.o \ + src/ALGEBRA.o \ + src/BUFFER.o \ + src/CHOKE.o \ src/CUBE.o \ src/DAVE.o \ + src/DISTO.o \ src/EACH.o \ src/FOUR.o \ src/L3DS3Q.o \ @@ -12,11 +15,13 @@ COMMON_OBJ= \ src/MONO.o \ src/PATCH.o \ src/PEAK.o \ + src/PLAY.o \ src/PLAYER.o \ src/SLIDERSEQ.o \ src/STEPS.o \ src/STEREO.o \ src/SUB.o \ + src/VARIABLE.o \ src/cf.o \ src/trSEQ.o diff --git a/plugins/community/repos/cf/playeroscs/noisepink.wav b/plugins/community/repos/cf/playeroscs/noisepink.wav new file mode 100644 index 00000000..84c43374 Binary files /dev/null and b/plugins/community/repos/cf/playeroscs/noisepink.wav differ diff --git a/plugins/community/repos/cf/playeroscs/noisewhite.wav b/plugins/community/repos/cf/playeroscs/noisewhite.wav new file mode 100644 index 00000000..1096433c Binary files /dev/null and b/plugins/community/repos/cf/playeroscs/noisewhite.wav differ diff --git a/plugins/community/repos/cf/playeroscs/osc1.wav b/plugins/community/repos/cf/playeroscs/osc1.wav new file mode 100644 index 00000000..9fdd80bd Binary files /dev/null and b/plugins/community/repos/cf/playeroscs/osc1.wav differ diff --git a/plugins/community/repos/cf/playeroscs/osc2.wav b/plugins/community/repos/cf/playeroscs/osc2.wav new file mode 100644 index 00000000..52c16ebc Binary files /dev/null and b/plugins/community/repos/cf/playeroscs/osc2.wav differ diff --git a/plugins/community/repos/cf/playeroscs/osc3.wav b/plugins/community/repos/cf/playeroscs/osc3.wav new file mode 100644 index 00000000..835f3fc1 Binary files /dev/null and b/plugins/community/repos/cf/playeroscs/osc3.wav differ diff --git a/plugins/community/repos/cf/playeroscs/osc4.wav b/plugins/community/repos/cf/playeroscs/osc4.wav new file mode 100644 index 00000000..94eea669 Binary files /dev/null and b/plugins/community/repos/cf/playeroscs/osc4.wav differ diff --git a/plugins/community/repos/cf/playeroscs/osc5.wav b/plugins/community/repos/cf/playeroscs/osc5.wav new file mode 100644 index 00000000..43a42efe Binary files /dev/null and b/plugins/community/repos/cf/playeroscs/osc5.wav differ diff --git a/plugins/community/repos/cf/playeroscs/osc6.wav b/plugins/community/repos/cf/playeroscs/osc6.wav new file mode 100644 index 00000000..0f21b898 Binary files /dev/null and b/plugins/community/repos/cf/playeroscs/osc6.wav differ diff --git a/plugins/community/repos/cf/playeroscs/osc7.wav b/plugins/community/repos/cf/playeroscs/osc7.wav new file mode 100644 index 00000000..822bbb49 Binary files /dev/null and b/plugins/community/repos/cf/playeroscs/osc7.wav differ diff --git a/plugins/community/repos/cf/playeroscs/osc8.wav b/plugins/community/repos/cf/playeroscs/osc8.wav new file mode 100644 index 00000000..3ff4f0ed Binary files /dev/null and b/plugins/community/repos/cf/playeroscs/osc8.wav differ diff --git a/plugins/community/repos/cf/playeroscs/saw.wav b/plugins/community/repos/cf/playeroscs/saw.wav new file mode 100644 index 00000000..0a2fcd88 Binary files /dev/null and b/plugins/community/repos/cf/playeroscs/saw.wav differ diff --git a/plugins/community/repos/cf/res/ALGEBRA.svg b/plugins/community/repos/cf/res/ALGEBRA.svg new file mode 100644 index 00000000..3d61f812 --- /dev/null +++ b/plugins/community/repos/cf/res/ALGEBRA.svg @@ -0,0 +1,55 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res/BUFFER.svg b/plugins/community/repos/cf/res/BUFFER.svg new file mode 100644 index 00000000..bb0f2aa8 --- /dev/null +++ b/plugins/community/repos/cf/res/BUFFER.svg @@ -0,0 +1,153 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res/CHOKE.svg b/plugins/community/repos/cf/res/CHOKE.svg new file mode 100644 index 00000000..03fb4aab --- /dev/null +++ b/plugins/community/repos/cf/res/CHOKE.svg @@ -0,0 +1,79 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res/DAVE.svg b/plugins/community/repos/cf/res/DAVE.svg index 243d1d07..d80046d5 100644 --- a/plugins/community/repos/cf/res/DAVE.svg +++ b/plugins/community/repos/cf/res/DAVE.svg @@ -1,29893 +1,1073 @@ - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +image/svg+xml \ No newline at end of file diff --git a/plugins/community/repos/cf/res/DISTO.svg b/plugins/community/repos/cf/res/DISTO.svg new file mode 100644 index 00000000..ced7101e --- /dev/null +++ b/plugins/community/repos/cf/res/DISTO.svg @@ -0,0 +1,131 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res/L3DS3Q.svg b/plugins/community/repos/cf/res/L3DS3Q.svg index b37bef67..f089fd95 100644 --- a/plugins/community/repos/cf/res/L3DS3Q.svg +++ b/plugins/community/repos/cf/res/L3DS3Q.svg @@ -2,11 +2,11 @@ - + - - - - - - - - - + + + + + + + + + + c1.125,0,1.928,0.262,2.457,0.758c0.541,0.494,0.854,1.196,0.854,2.179c0,0.989-0.308,1.801-0.874,2.358 + c-0.564,0.566-1.503,0.873-2.683,0.873c-0.56,0-1.026-0.027-1.425-0.072v-5.969H71.194z M71.978,58.711 + c0.197,0.036,0.485,0.045,0.793,0.045c1.674,0,2.584-0.937,2.584-2.574c0.011-1.432-0.803-2.34-2.459-2.34 + c-0.402,0-0.711,0.034-0.918,0.08V58.711z"/> - + - - + + - - + - + @@ -82,22 +85,23 @@ c0,1.379-1.212,2.387-3.19,2.387c-1.008,0-1.859-0.264-2.315-0.552L30.583,23.328z"/> + c-0.852,0.708-2.146,1.043-3.73,1.043c-0.947,0-1.619-0.06-2.074-0.12L37.207,17.14L37.207,17.14z M39.042,23.736 + c0.155,0.036,0.407,0.036,0.636,0.036c1.655,0.012,2.734-0.899,2.734-2.831c0.012-1.679-0.972-2.566-2.543-2.566 + c-0.407,0-0.672,0.036-0.827,0.072V23.736L39.042,23.736z"/> - - + diff --git a/plugins/community/repos/cf/res/LEDCalculator.ttf b/plugins/community/repos/cf/res/LEDCalculator.ttf new file mode 100644 index 00000000..f5929994 Binary files /dev/null and b/plugins/community/repos/cf/res/LEDCalculator.ttf differ diff --git a/plugins/community/repos/cf/res/LEDSEQ.svg b/plugins/community/repos/cf/res/LEDSEQ.svg index 101795cb..c2d76410 100644 --- a/plugins/community/repos/cf/res/LEDSEQ.svg +++ b/plugins/community/repos/cf/res/LEDSEQ.svg @@ -2,11 +2,11 @@ - + - + @@ -31,29 +31,30 @@ - - + + c0.803,0,1.271-0.422,1.271-1.032c0-0.565-0.324-0.894-1.144-1.206c-0.99-0.354-1.604-0.864-1.604-1.723 + c0-0.942,0.784-1.646,1.963-1.646c0.621,0,1.071,0.146,1.343,0.297l-0.217,0.642c-0.197-0.107-0.604-0.289-1.15-0.289 + c-0.83,0-1.146,0.496-1.146,0.91c0,0.565,0.369,0.848,1.206,1.17c1.025,0.396,1.549,0.893,1.549,1.783 + c0,0.937-0.691,1.744-2.125,1.744c-0.585,0-1.225-0.171-1.549-0.387L64.658,335.548z"/> - @@ -62,14 +63,14 @@ c0.468,0.162,0.748,0.595,0.892,1.226c0.198,0.847,0.342,1.431,0.468,1.665h-0.81c-0.099-0.171-0.234-0.693-0.405-1.449 c-0.18-0.838-0.504-1.152-1.215-1.18H7.513v2.629H6.73V330.516z M7.513,333.279h0.801c0.837,0,1.369-0.459,1.369-1.152 c0-0.783-0.567-1.126-1.396-1.135c-0.378,0-0.648,0.035-0.774,0.072V333.279z"/> - - + @@ -83,15 +84,15 @@ c1.655,0.012,2.734-0.899,2.734-2.831c0.012-1.679-0.971-2.566-2.542-2.566c-0.408,0-0.672,0.036-0.828,0.072V23.736L39.042,23.736 z"/> diff --git a/plugins/community/repos/cf/res/MASTER.svg b/plugins/community/repos/cf/res/MASTER.svg index 5dcb6634..5cbe1566 100644 --- a/plugins/community/repos/cf/res/MASTER.svg +++ b/plugins/community/repos/cf/res/MASTER.svg @@ -6,9 +6,9 @@ xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="90.135px" height="380px" viewBox="0 0 90.135 380" enable-background="new 0 0 90.135 380" xml:space="preserve"> - - - + + + @@ -19,55 +19,55 @@ + c-0.575-0.015-1.065-0.125-1.275-0.229l0.294-1.479c0.21,0.084,0.434,0.104,0.659,0.104c0.7-0.021,0.938-0.396,1.139-1.981 + l0.229-1.969H45.94v-1.479H45.937L45.937,362.066L45.937,362.066z"/> + c0.63,0,0.963-0.262,0.963-0.646c0-0.378-0.288-0.604-1.018-0.854c-1.009-0.354-1.666-0.904-1.666-1.791 + c0-1.032,0.864-1.825,2.296-1.825c0.684,0,1.188,0.146,1.548,0.312l-0.306,1.104c-0.243-0.115-0.676-0.289-1.27-0.289 + c-0.604,0-0.892,0.271-0.892,0.587c0,0.393,0.351,0.562,1.125,0.854c1.067,0.396,1.575,0.951,1.575,1.812 + c0,1.021-0.782,1.886-2.448,1.886c-0.688,0-1.377-0.184-1.724-0.366L131.11,283.479z"/> - - - + + c-0.354-0.646-0.756-1.438-1.053-2.146l-0.027,0.009c0.037,0.806,0.062,1.657,0.062,2.646v1.826h-1.27V295.146L51.276,295.146z"/> @@ -97,7 +97,7 @@ c-0.11,0.44-0.22,1.001-0.341,1.431l-0.44,1.573H39.676z"/> - - - - - - - - - - + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res/PEAK.svg b/plugins/community/repos/cf/res/PEAK.svg index 249ca57d..e69d4de4 100644 --- a/plugins/community/repos/cf/res/PEAK.svg +++ b/plugins/community/repos/cf/res/PEAK.svg @@ -2,41 +2,13 @@ - + - - - - - - - - - - - - - - - - - - + l0.229-1.962H45.94v-1.485H45.937L45.937,362.066z"/> + c-0.469,0.441-1.159,0.639-1.971,0.639c-0.184,0-0.345-0.009-0.472-0.027v2.169H60.94V161.408z M62.3,164.163 + c0.117,0.027,0.262,0.036,0.46,0.036c0.729,0,1.179-0.369,1.179-0.99c0-0.559-0.387-0.892-1.067-0.892 + c-0.279,0-0.472,0.027-0.565,0.054L62.3,164.163L62.3,164.163z"/> - @@ -94,10 +66,10 @@ C53.783,279.814,53.243,280.697,53.243,281.876z"/> + c1.148,0,1.896,0.207,2.48,0.646c0.63,0.47,1.023,1.218,1.023,2.287c0,1.16-0.424,1.962-1.01,2.457 + c-0.639,0.531-1.607,0.783-2.799,0.783c-0.712,0-1.216-0.046-1.559-0.093V278.9h0.004v0.004H63.124z M64.502,283.857 + c0.117,0.022,0.306,0.022,0.478,0.022c1.242,0.013,2.056-0.675,2.056-2.124c0.01-1.261-0.729-1.928-1.908-1.928 + c-0.31,0-0.504,0.023-0.621,0.055L64.502,283.857L64.502,283.857z"/> @@ -107,13 +79,33 @@ c-0.624,0.588-1.547,0.852-2.626,0.852c-0.24,0-0.456-0.012-0.624-0.036v2.891h-1.811V16.467z M34.336,20.137 c0.156,0.036,0.348,0.048,0.612,0.048c0.971,0,1.571-0.492,1.571-1.319c0-0.743-0.516-1.187-1.427-1.187 c-0.372,0-0.624,0.036-0.756,0.072V20.137z"/> - - + - + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res/PLAY.svg b/plugins/community/repos/cf/res/PLAY.svg new file mode 100644 index 00000000..c11d1e51 --- /dev/null +++ b/plugins/community/repos/cf/res/PLAY.svg @@ -0,0 +1,52 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res/PLAYER.svg b/plugins/community/repos/cf/res/PLAYER.svg index c38e185e..8bbc3734 100644 --- a/plugins/community/repos/cf/res/PLAYER.svg +++ b/plugins/community/repos/cf/res/PLAYER.svg @@ -85,10 +85,10 @@ c-1.801,0-2.854-1.358-2.854-3.088c0-1.818,1.162-3.188,2.953-3.188C108.337,387.3,109.354,388.695,109.354,390.37z M104.971,390.451c0,1.188,0.559,2.025,1.479,2.025c0.927,0,1.458-0.896,1.458-2.062c0-1.09-0.521-2.025-1.471-2.025 C105.512,388.391,104.971,389.271,104.971,390.451z"/> - - @@ -120,7 +120,7 @@ c0.369,0.188,0.938,0.379,1.521,0.379c0.631,0,0.963-0.262,0.963-0.646c0-0.378-0.287-0.604-1.021-0.854 c-1.008-0.354-1.666-0.899-1.666-1.789c0-1.029,0.864-1.82,2.301-1.82c0.688,0,1.188,0.146,1.547,0.312l-0.31,1.104 c-0.239-0.107-0.675-0.285-1.271-0.285c-0.594,0-0.881,0.271-0.881,0.588c0,0.396,0.342,0.562,1.125,0.854 - c1.062,0.396,1.562,0.952,1.562,1.812c0,1.021-0.771,1.887-2.438,1.887c-0.688,0-1.377-0.188-1.729-0.363L69.666,392.15z"/> + c1.062,0.396,1.562,0.952,1.562,1.812c0,1.021-0.771,1.887-2.438,1.887c-0.688,0-1.377-0.188-1.729-0.362L69.666,392.15z"/> @@ -141,12 +141,12 @@ c0.369,0.188,0.937,0.379,1.521,0.379c0.63,0,0.963-0.262,0.963-0.646c0-0.378-0.288-0.604-1.018-0.854 c-1.008-0.354-1.666-0.899-1.666-1.789c0-1.029,0.864-1.82,2.296-1.82c0.684,0,1.188,0.146,1.548,0.312l-0.306,1.104 c-0.243-0.107-0.675-0.285-1.269-0.285c-0.594,0-0.882,0.271-0.882,0.588c0,0.396,0.342,0.562,1.125,0.854 - c1.071,0.396,1.575,0.952,1.575,1.812c0,1.021-0.783,1.887-2.449,1.887c-0.693,0-1.377-0.188-1.719-0.363L39.647,392.15z"/> + c1.071,0.396,1.575,0.952,1.575,1.812c0,1.021-0.783,1.887-2.449,1.887c-0.693,0-1.377-0.188-1.719-0.362L39.647,392.15z"/> + c-0.09,0.355-0.18,0.814-0.279,1.17l-0.36,1.287H51.7z"/> + l2.071,6.066h-0.837l-0.648-1.907H19.221z M21.211,391.053l-0.594-1.746c-0.135-0.396-0.225-0.757-0.315-1.104h-0.018 + c-0.09,0.356-0.189,0.729-0.306,1.104l-0.594,1.758L21.211,391.053L21.211,391.053z"/> - + c-1.107,0-1.909-0.277-2.467-0.817c-0.558-0.521-0.864-1.312-0.855-2.206c0.009-2.02,1.477-3.169,3.466-3.169 + c0.783,0,1.386,0.151,1.684,0.297l-0.288,1.101c-0.333-0.146-0.748-0.262-1.414-0.262c-1.144,0-2.008,0.646-2.008,1.963 + c0,1.252,0.783,1.988,1.909,1.988c0.315,0,0.567-0.035,0.675-0.091v-1.271h-0.937v-1.07h2.26V312.477z"/> + c-1.107,0-1.909-0.277-2.467-0.817c-0.558-0.521-0.864-1.312-0.855-2.206c0.009-2.02,1.477-3.169,3.466-3.169 + c0.783,0,1.386,0.151,1.684,0.297l-0.288,1.101c-0.333-0.146-0.748-0.263-1.414-0.263c-1.144,0-2.008,0.646-2.008,1.962 + c0,1.254,0.783,1.99,1.909,1.99c0.315,0,0.567-0.036,0.675-0.091v-1.271h-0.937v-1.072h2.26V356.387z"/> @@ -212,15 +212,15 @@ + c-0.594,0-0.882,0.271-0.882,0.586c0,0.387,0.342,0.558,1.125,0.854c1.072,0.396,1.576,0.955,1.576,1.812 + c0,1.019-0.783,1.881-2.449,1.881c-0.693,0-1.377-0.181-1.72-0.369L40.972,311.346z"/> @@ -231,76 +231,77 @@ - - + + - - - - + - - - - - - - - + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res/SLIDERSEQ.svg b/plugins/community/repos/cf/res/SLIDERSEQ.svg index 9e06408f..3b50f3ba 100644 --- a/plugins/community/repos/cf/res/SLIDERSEQ.svg +++ b/plugins/community/repos/cf/res/SLIDERSEQ.svg @@ -7,367 +7,121 @@ viewBox="0 0 135.566 380" enable-background="new 0 0 135.566 380" xml:space="preserve"> - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + - - - - - - - + + + + + + + - + c0.479,0,0.963-0.104,1.278-0.252L111.69,315.384z"/> + - + v1.499H65.09v1.679h2.979L68.068,20.944L68.068,20.944z"/> - + c0-1.379,1.152-2.435,3.062-2.435c0.906,0,1.584,0.192,2.062,0.408l-0.408,1.475c-0.317-0.156-0.896-0.384-1.688-0.384 + c-0.793,0-1.182,0.36-1.182,0.78c0,0.516,0.455,0.743,1.498,1.139c1.434,0.528,2.104,1.271,2.104,2.411 + c0,1.355-1.043,2.507-3.262,2.507c-0.93,0-1.842-0.24-2.291-0.492L76.842,22.479z"/> + - - - - - + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res/VARIABLE.svg b/plugins/community/repos/cf/res/VARIABLE.svg new file mode 100644 index 00000000..f5d96b1e --- /dev/null +++ b/plugins/community/repos/cf/res/VARIABLE.svg @@ -0,0 +1,82 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res/cach.svg b/plugins/community/repos/cf/res/cach.svg new file mode 100644 index 00000000..9eb36a63 --- /dev/null +++ b/plugins/community/repos/cf/res/cach.svg @@ -0,0 +1,19 @@ + + + + + + + + + + diff --git a/plugins/community/repos/cf/res/distocach.svg b/plugins/community/repos/cf/res/distocach.svg new file mode 100644 index 00000000..d308662e --- /dev/null +++ b/plugins/community/repos/cf/res/distocach.svg @@ -0,0 +1,22 @@ + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res/divButton.svg b/plugins/community/repos/cf/res/divButton.svg new file mode 100644 index 00000000..4254c13c --- /dev/null +++ b/plugins/community/repos/cf/res/divButton.svg @@ -0,0 +1,20 @@ + + + + + + + + + + + +/ + diff --git a/plugins/community/repos/cf/res/maxButton.svg b/plugins/community/repos/cf/res/maxButton.svg new file mode 100644 index 00000000..72338b27 --- /dev/null +++ b/plugins/community/repos/cf/res/maxButton.svg @@ -0,0 +1,20 @@ + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res/minButton.svg b/plugins/community/repos/cf/res/minButton.svg new file mode 100644 index 00000000..ef9dbd74 --- /dev/null +++ b/plugins/community/repos/cf/res/minButton.svg @@ -0,0 +1,23 @@ + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res/minusButton.svg b/plugins/community/repos/cf/res/minusButton.svg new file mode 100644 index 00000000..cdc69ff8 --- /dev/null +++ b/plugins/community/repos/cf/res/minusButton.svg @@ -0,0 +1,19 @@ + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res/multButton.svg b/plugins/community/repos/cf/res/multButton.svg new file mode 100644 index 00000000..696072a3 --- /dev/null +++ b/plugins/community/repos/cf/res/multButton.svg @@ -0,0 +1,20 @@ + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res/plusButton.svg b/plugins/community/repos/cf/res/plusButton.svg new file mode 100644 index 00000000..b6ac6e54 --- /dev/null +++ b/plugins/community/repos/cf/res/plusButton.svg @@ -0,0 +1,20 @@ + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/ALGEBRA.svg b/plugins/community/repos/cf/res_b/ALGEBRA.svg new file mode 100644 index 00000000..1b1a483f --- /dev/null +++ b/plugins/community/repos/cf/res_b/ALGEBRA.svg @@ -0,0 +1,57 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/BUFFER.svg b/plugins/community/repos/cf/res_b/BUFFER.svg new file mode 100644 index 00000000..920171cb --- /dev/null +++ b/plugins/community/repos/cf/res_b/BUFFER.svg @@ -0,0 +1,157 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/CHOKE.svg b/plugins/community/repos/cf/res_b/CHOKE.svg new file mode 100644 index 00000000..bb484d1a --- /dev/null +++ b/plugins/community/repos/cf/res_b/CHOKE.svg @@ -0,0 +1,88 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/CUBE.svg b/plugins/community/repos/cf/res_b/CUBE.svg new file mode 100644 index 00000000..fe55d03b --- /dev/null +++ b/plugins/community/repos/cf/res_b/CUBE.svg @@ -0,0 +1,115 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/DAVE.svg b/plugins/community/repos/cf/res_b/DAVE.svg new file mode 100644 index 00000000..243d1d07 --- /dev/null +++ b/plugins/community/repos/cf/res_b/DAVE.svg @@ -0,0 +1,29893 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/DISTO.svg b/plugins/community/repos/cf/res_b/DISTO.svg new file mode 100644 index 00000000..8c60cf28 --- /dev/null +++ b/plugins/community/repos/cf/res_b/DISTO.svg @@ -0,0 +1,135 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/DejaVu-LICENSE.txt b/plugins/community/repos/cf/res_b/DejaVu-LICENSE.txt new file mode 100644 index 00000000..254e2cc4 --- /dev/null +++ b/plugins/community/repos/cf/res_b/DejaVu-LICENSE.txt @@ -0,0 +1,99 @@ +Fonts are (c) Bitstream (see below). DejaVu changes are in public domain. +Glyphs imported from Arev fonts are (c) Tavmjong Bah (see below) + +Bitstream Vera Fonts Copyright +------------------------------ + +Copyright (c) 2003 by Bitstream, Inc. All Rights Reserved. Bitstream Vera is +a trademark of Bitstream, Inc. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of the fonts accompanying this license ("Fonts") and associated +documentation files (the "Font Software"), to reproduce and distribute the +Font Software, including without limitation the rights to use, copy, merge, +publish, distribute, and/or sell copies of the Font Software, and to permit +persons to whom the Font Software is furnished to do so, subject to the +following conditions: + +The above copyright and trademark notices and this permission notice shall +be included in all copies of one or more of the Font Software typefaces. + +The Font Software may be modified, altered, or added to, and in particular +the designs of glyphs or characters in the Fonts may be modified and +additional glyphs or characters may be added to the Fonts, only if the fonts +are renamed to names not containing either the words "Bitstream" or the word +"Vera". + +This License becomes null and void to the extent applicable to Fonts or Font +Software that has been modified and is distributed under the "Bitstream +Vera" names. + +The Font Software may be sold as part of a larger software package but no +copy of one or more of the Font Software typefaces may be sold by itself. + +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, +TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL BITSTREAM OR THE GNOME +FOUNDATION BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING +ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE +FONT SOFTWARE. + +Except as contained in this notice, the names of Gnome, the Gnome +Foundation, and Bitstream Inc., shall not be used in advertising or +otherwise to promote the sale, use or other dealings in this Font Software +without prior written authorization from the Gnome Foundation or Bitstream +Inc., respectively. For further information, contact: fonts at gnome dot +org. + +Arev Fonts Copyright +------------------------------ + +Copyright (c) 2006 by Tavmjong Bah. All Rights Reserved. + +Permission is hereby granted, free of charge, to any person obtaining +a copy of the fonts accompanying this license ("Fonts") and +associated documentation files (the "Font Software"), to reproduce +and distribute the modifications to the Bitstream Vera Font Software, +including without limitation the rights to use, copy, merge, publish, +distribute, and/or sell copies of the Font Software, and to permit +persons to whom the Font Software is furnished to do so, subject to +the following conditions: + +The above copyright and trademark notices and this permission notice +shall be included in all copies of one or more of the Font Software +typefaces. + +The Font Software may be modified, altered, or added to, and in +particular the designs of glyphs or characters in the Fonts may be +modified and additional glyphs or characters may be added to the +Fonts, only if the fonts are renamed to names not containing either +the words "Tavmjong Bah" or the word "Arev". + +This License becomes null and void to the extent applicable to Fonts +or Font Software that has been modified and is distributed under the +"Tavmjong Bah Arev" names. + +The Font Software may be sold as part of a larger software package but +no copy of one or more of the Font Software typefaces may be sold by +itself. + +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL +TAVMJONG BAH BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. + +Except as contained in this notice, the name of Tavmjong Bah shall not +be used in advertising or otherwise to promote the sale, use or other +dealings in this Font Software without prior written authorization +from Tavmjong Bah. For further information, contact: tavmjong @ free +. fr. + +$Id: LICENSE 2133 2007-11-28 02:46:28Z lechimp $ diff --git a/plugins/community/repos/cf/res_b/DejaVuSansMono.ttf b/plugins/community/repos/cf/res_b/DejaVuSansMono.ttf new file mode 100644 index 00000000..f5786022 Binary files /dev/null and b/plugins/community/repos/cf/res_b/DejaVuSansMono.ttf differ diff --git a/plugins/community/repos/cf/res_b/EACH.svg b/plugins/community/repos/cf/res_b/EACH.svg new file mode 100644 index 00000000..82d7a6dd --- /dev/null +++ b/plugins/community/repos/cf/res_b/EACH.svg @@ -0,0 +1,106 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/FOUR.svg b/plugins/community/repos/cf/res_b/FOUR.svg new file mode 100644 index 00000000..cc85d741 --- /dev/null +++ b/plugins/community/repos/cf/res_b/FOUR.svg @@ -0,0 +1,308 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +FOUR + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/L.svg b/plugins/community/repos/cf/res_b/L.svg new file mode 100644 index 00000000..bcffcd3b --- /dev/null +++ b/plugins/community/repos/cf/res_b/L.svg @@ -0,0 +1,9 @@ + + + + + + diff --git a/plugins/community/repos/cf/res_b/L3DS3Q.svg b/plugins/community/repos/cf/res_b/L3DS3Q.svg new file mode 100644 index 00000000..6e1bbea8 --- /dev/null +++ b/plugins/community/repos/cf/res_b/L3DS3Q.svg @@ -0,0 +1,107 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/LEDCalculator.ttf b/plugins/community/repos/cf/res_b/LEDCalculator.ttf new file mode 100644 index 00000000..f5929994 Binary files /dev/null and b/plugins/community/repos/cf/res_b/LEDCalculator.ttf differ diff --git a/plugins/community/repos/cf/res_b/LEDS.svg b/plugins/community/repos/cf/res_b/LEDS.svg new file mode 100644 index 00000000..8391a0d9 --- /dev/null +++ b/plugins/community/repos/cf/res_b/LEDS.svg @@ -0,0 +1,61 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/LEDSEQ.svg b/plugins/community/repos/cf/res_b/LEDSEQ.svg new file mode 100644 index 00000000..ef063e9d --- /dev/null +++ b/plugins/community/repos/cf/res_b/LEDSEQ.svg @@ -0,0 +1,101 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/Ldown.svg b/plugins/community/repos/cf/res_b/Ldown.svg new file mode 100644 index 00000000..ab0e0b4d --- /dev/null +++ b/plugins/community/repos/cf/res_b/Ldown.svg @@ -0,0 +1,9 @@ + + + + + + diff --git a/plugins/community/repos/cf/res_b/MASTER.svg b/plugins/community/repos/cf/res_b/MASTER.svg new file mode 100644 index 00000000..94b2f39b --- /dev/null +++ b/plugins/community/repos/cf/res_b/MASTER.svg @@ -0,0 +1,139 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +PAN +PAN + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/METRO.svg b/plugins/community/repos/cf/res_b/METRO.svg new file mode 100644 index 00000000..6fc0e06d --- /dev/null +++ b/plugins/community/repos/cf/res_b/METRO.svg @@ -0,0 +1,153 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/MONO.svg b/plugins/community/repos/cf/res_b/MONO.svg new file mode 100644 index 00000000..07a02c9e --- /dev/null +++ b/plugins/community/repos/cf/res_b/MONO.svg @@ -0,0 +1,265 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +PAN +PAN + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/PATCH.svg b/plugins/community/repos/cf/res_b/PATCH.svg new file mode 100644 index 00000000..38ac556d --- /dev/null +++ b/plugins/community/repos/cf/res_b/PATCH.svg @@ -0,0 +1,72 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/PEAK.svg b/plugins/community/repos/cf/res_b/PEAK.svg new file mode 100644 index 00000000..7496bf82 --- /dev/null +++ b/plugins/community/repos/cf/res_b/PEAK.svg @@ -0,0 +1,122 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/PLAY.svg b/plugins/community/repos/cf/res_b/PLAY.svg new file mode 100644 index 00000000..36d61148 --- /dev/null +++ b/plugins/community/repos/cf/res_b/PLAY.svg @@ -0,0 +1,48 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/PLAYER.svg b/plugins/community/repos/cf/res_b/PLAYER.svg new file mode 100644 index 00000000..beab44f2 --- /dev/null +++ b/plugins/community/repos/cf/res_b/PLAYER.svg @@ -0,0 +1,258 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/PadButton.svg b/plugins/community/repos/cf/res_b/PadButton.svg new file mode 100644 index 00000000..d24d968d --- /dev/null +++ b/plugins/community/repos/cf/res_b/PadButton.svg @@ -0,0 +1,13 @@ + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/PadButtonDown.svg b/plugins/community/repos/cf/res_b/PadButtonDown.svg new file mode 100644 index 00000000..c3605756 --- /dev/null +++ b/plugins/community/repos/cf/res_b/PadButtonDown.svg @@ -0,0 +1,13 @@ + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/SLIDERSEQ.svg b/plugins/community/repos/cf/res_b/SLIDERSEQ.svg new file mode 100644 index 00000000..7e3d342c --- /dev/null +++ b/plugins/community/repos/cf/res_b/SLIDERSEQ.svg @@ -0,0 +1,135 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/STEPS.svg b/plugins/community/repos/cf/res_b/STEPS.svg new file mode 100644 index 00000000..e6b8d775 --- /dev/null +++ b/plugins/community/repos/cf/res_b/STEPS.svg @@ -0,0 +1,112 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/STEREO.svg b/plugins/community/repos/cf/res_b/STEREO.svg new file mode 100644 index 00000000..659eaeb5 --- /dev/null +++ b/plugins/community/repos/cf/res_b/STEREO.svg @@ -0,0 +1,273 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +PAN +PAN + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/SUB.svg b/plugins/community/repos/cf/res_b/SUB.svg new file mode 100644 index 00000000..2f5042d1 --- /dev/null +++ b/plugins/community/repos/cf/res_b/SUB.svg @@ -0,0 +1,145 @@ + + + + + + + + + + + + + + + + + + + + +PAN +PAN + + + + + + + + + + +PAN + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/Segment7Standard.ttf b/plugins/community/repos/cf/res_b/Segment7Standard.ttf new file mode 100644 index 00000000..bdd6e2af Binary files /dev/null and b/plugins/community/repos/cf/res_b/Segment7Standard.ttf differ diff --git a/plugins/community/repos/cf/res_b/VARIABLE.svg b/plugins/community/repos/cf/res_b/VARIABLE.svg new file mode 100644 index 00000000..53ece729 --- /dev/null +++ b/plugins/community/repos/cf/res_b/VARIABLE.svg @@ -0,0 +1,86 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/cach.svg b/plugins/community/repos/cf/res_b/cach.svg new file mode 100644 index 00000000..e236d95c --- /dev/null +++ b/plugins/community/repos/cf/res_b/cach.svg @@ -0,0 +1,19 @@ + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/distocach.svg b/plugins/community/repos/cf/res_b/distocach.svg new file mode 100644 index 00000000..a14c5797 --- /dev/null +++ b/plugins/community/repos/cf/res_b/distocach.svg @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/divButton.svg b/plugins/community/repos/cf/res_b/divButton.svg new file mode 100644 index 00000000..4254c13c --- /dev/null +++ b/plugins/community/repos/cf/res_b/divButton.svg @@ -0,0 +1,20 @@ + + + + + + + + + + + +/ + diff --git a/plugins/community/repos/cf/res_b/downButton.svg b/plugins/community/repos/cf/res_b/downButton.svg new file mode 100644 index 00000000..640280a6 --- /dev/null +++ b/plugins/community/repos/cf/res_b/downButton.svg @@ -0,0 +1,16 @@ + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/downButtonDown.svg b/plugins/community/repos/cf/res_b/downButtonDown.svg new file mode 100644 index 00000000..f28d358d --- /dev/null +++ b/plugins/community/repos/cf/res_b/downButtonDown.svg @@ -0,0 +1,16 @@ + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/maxButton.svg b/plugins/community/repos/cf/res_b/maxButton.svg new file mode 100644 index 00000000..72338b27 --- /dev/null +++ b/plugins/community/repos/cf/res_b/maxButton.svg @@ -0,0 +1,20 @@ + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/minButton.svg b/plugins/community/repos/cf/res_b/minButton.svg new file mode 100644 index 00000000..ef9dbd74 --- /dev/null +++ b/plugins/community/repos/cf/res_b/minButton.svg @@ -0,0 +1,23 @@ + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/minusButton.svg b/plugins/community/repos/cf/res_b/minusButton.svg new file mode 100644 index 00000000..cdc69ff8 --- /dev/null +++ b/plugins/community/repos/cf/res_b/minusButton.svg @@ -0,0 +1,19 @@ + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/multButton.svg b/plugins/community/repos/cf/res_b/multButton.svg new file mode 100644 index 00000000..696072a3 --- /dev/null +++ b/plugins/community/repos/cf/res_b/multButton.svg @@ -0,0 +1,20 @@ + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/plusButton.svg b/plugins/community/repos/cf/res_b/plusButton.svg new file mode 100644 index 00000000..b6ac6e54 --- /dev/null +++ b/plugins/community/repos/cf/res_b/plusButton.svg @@ -0,0 +1,20 @@ + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/tagada b/plugins/community/repos/cf/res_b/tagada new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/plugins/community/repos/cf/res_b/tagada @@ -0,0 +1 @@ + diff --git a/plugins/community/repos/cf/res_b/trSEQ.svg b/plugins/community/repos/cf/res_b/trSEQ.svg new file mode 100644 index 00000000..3b61c801 --- /dev/null +++ b/plugins/community/repos/cf/res_b/trSEQ.svg @@ -0,0 +1,294 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/upButton.svg b/plugins/community/repos/cf/res_b/upButton.svg new file mode 100644 index 00000000..808ea944 --- /dev/null +++ b/plugins/community/repos/cf/res_b/upButton.svg @@ -0,0 +1,15 @@ + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/res_b/upButtonDown.svg b/plugins/community/repos/cf/res_b/upButtonDown.svg new file mode 100644 index 00000000..f01d39d5 --- /dev/null +++ b/plugins/community/repos/cf/res_b/upButtonDown.svg @@ -0,0 +1,15 @@ + + + + + + + + + + + + diff --git a/plugins/community/repos/cf/screens/cf064.png b/plugins/community/repos/cf/screens/cf064.png new file mode 100644 index 00000000..1572a9ba Binary files /dev/null and b/plugins/community/repos/cf/screens/cf064.png differ diff --git a/plugins/community/repos/cf/screens/cf064b.png b/plugins/community/repos/cf/screens/cf064b.png new file mode 100644 index 00000000..1473606c Binary files /dev/null and b/plugins/community/repos/cf/screens/cf064b.png differ diff --git a/plugins/community/repos/cf/src/ALGEBRA.cpp b/plugins/community/repos/cf/src/ALGEBRA.cpp new file mode 100644 index 00000000..54892a06 --- /dev/null +++ b/plugins/community/repos/cf/src/ALGEBRA.cpp @@ -0,0 +1,170 @@ +#include "cf.hpp" +#include "dsp/digital.hpp" + + +using namespace std; + +namespace rack_plugin_cf { + +struct ALGEBRA : Module { + enum ParamIds { + OP_PARAM, + NUM_PARAMS = OP_PARAM+6 + }; + enum InputIds { + IN1_INPUT, + IN2_INPUT, + NUM_INPUTS + }; + enum OutputIds { + OUT_OUTPUT, + NUM_OUTPUTS + }; + enum LightIds { + LED_LIGHT, + NUM_LIGHTS = LED_LIGHT+6 + }; + + int OP_STATE = 0 ; + SchmittTrigger trTrigger[6]; + +ALGEBRA() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) { } + + void step() override; + +json_t *toJson() override { + json_t *rootJ = json_object(); + + + json_object_set_new(rootJ, "opstate", json_integer(OP_STATE)); + return rootJ; + } + +void fromJson(json_t *rootJ) override { + + + json_t *opstateJ = json_object_get(rootJ, "opstate"); + if (opstateJ) + OP_STATE = json_integer_value(opstateJ); + + } +}; + + + + +void ALGEBRA::step() { + for (int i=0; i<6; i++) { + if (trTrigger[i].process(params[OP_PARAM+i].value)) OP_STATE= i; + if (OP_STATE == i) lights[LED_LIGHT+i].value=1; else lights[LED_LIGHT+i].value=0; + } + if (OP_STATE==0) outputs[OUT_OUTPUT].value = inputs[IN1_INPUT].value + inputs[IN2_INPUT].value; + if (OP_STATE==1) outputs[OUT_OUTPUT].value = inputs[IN1_INPUT].value - inputs[IN2_INPUT].value; + if (OP_STATE==2) outputs[OUT_OUTPUT].value = inputs[IN1_INPUT].value * inputs[IN2_INPUT].value; + if ((OP_STATE==3) & (inputs[IN2_INPUT].value!=0)) outputs[OUT_OUTPUT].value = inputs[IN1_INPUT].value / inputs[IN2_INPUT].value; + if (OP_STATE==4) { + if (inputs[IN1_INPUT].value>=inputs[IN2_INPUT].value) outputs[OUT_OUTPUT].value = inputs[IN1_INPUT].value; + else outputs[OUT_OUTPUT].value = inputs[IN2_INPUT].value; + } + if (OP_STATE==5) { + if (inputs[IN1_INPUT].value<=inputs[IN2_INPUT].value) outputs[OUT_OUTPUT].value = inputs[IN1_INPUT].value; + else outputs[OUT_OUTPUT].value = inputs[IN2_INPUT].value; + } + +} + +struct plusButton : SVGSwitch, MomentarySwitch { + plusButton() { + addFrame(SVG::load(assetPlugin(plugin, "res/plusButton.svg"))); + addFrame(SVG::load(assetPlugin(plugin, "res/plusButton.svg"))); + sw->wrap(); + box.size = sw->box.size; + } +}; +struct minusButton : SVGSwitch, MomentarySwitch { + minusButton() { + addFrame(SVG::load(assetPlugin(plugin, "res/minusButton.svg"))); + addFrame(SVG::load(assetPlugin(plugin, "res/minusButton.svg"))); + sw->wrap(); + box.size = sw->box.size; + } +}; +struct multButton : SVGSwitch, MomentarySwitch { + multButton() { + addFrame(SVG::load(assetPlugin(plugin, "res/multButton.svg"))); + addFrame(SVG::load(assetPlugin(plugin, "res/multButton.svg"))); + sw->wrap(); + box.size = sw->box.size; + } +}; +struct divButton : SVGSwitch, MomentarySwitch { + divButton() { + addFrame(SVG::load(assetPlugin(plugin, "res/divButton.svg"))); + addFrame(SVG::load(assetPlugin(plugin, "res/divButton.svg"))); + sw->wrap(); + box.size = sw->box.size; + } +}; +struct maxButton : SVGSwitch, MomentarySwitch { + maxButton() { + addFrame(SVG::load(assetPlugin(plugin, "res/maxButton.svg"))); + addFrame(SVG::load(assetPlugin(plugin, "res/maxButton.svg"))); + sw->wrap(); + box.size = sw->box.size; + } +}; +struct minButton : SVGSwitch, MomentarySwitch { + minButton() { + addFrame(SVG::load(assetPlugin(plugin, "res/minButton.svg"))); + addFrame(SVG::load(assetPlugin(plugin, "res/minButton.svg"))); + sw->wrap(); + box.size = sw->box.size; + } +}; + +struct ALGEBRAWidget : ModuleWidget { + ALGEBRAWidget(ALGEBRA *module); + //void step() override; + +}; + +ALGEBRAWidget::ALGEBRAWidget(ALGEBRA *module) : ModuleWidget(module) { + setPanel(SVG::load(assetPlugin(plugin, "res/ALGEBRA.svg"))); + + + addChild(Widget::create(Vec(15, 0))); + addChild(Widget::create(Vec(box.size.x-30, 365))); + + + addInput(Port::create(Vec(3, 31), Port::INPUT, module, ALGEBRA::IN1_INPUT)); + addInput(Port::create(Vec(3, 95), Port::INPUT, module, ALGEBRA::IN2_INPUT)); + + int i = 0; + addChild(ModuleLightWidget::create>(Vec(3+4.4, i*24+133+4.4), module, ALGEBRA::LED_LIGHT + i)); + addParam(ParamWidget::create(Vec(6, i*24+136), module, ALGEBRA::OP_PARAM + i, 0.0, 1.0, 0.0)); i=i+1; + addChild(ModuleLightWidget::create>(Vec(3+4.4, i*24+133+4.4), module, ALGEBRA::LED_LIGHT + i)); + addParam(ParamWidget::create(Vec(6, i*24+136), module, ALGEBRA::OP_PARAM + i, 0.0, 1.0, 0.0)); i=i+1; + addChild(ModuleLightWidget::create>(Vec(3+4.4, i*24+133+4.4), module, ALGEBRA::LED_LIGHT + i)); + addParam(ParamWidget::create(Vec(6, i*24+136), module, ALGEBRA::OP_PARAM + i, 0.0, 1.0, 0.0)); i=i+1; + addChild(ModuleLightWidget::create>(Vec(3+4.4, i*24+133+4.4), module, ALGEBRA::LED_LIGHT + i)); + addParam(ParamWidget::create(Vec(6, i*24+136), module, ALGEBRA::OP_PARAM + i, 0.0, 1.0, 0.0)); i=i+1; + addChild(ModuleLightWidget::create>(Vec(3+4.4, i*24+133+4.4), module, ALGEBRA::LED_LIGHT + i)); + addParam(ParamWidget::create(Vec(6, i*24+136), module, ALGEBRA::OP_PARAM + i, 0.0, 1.0, 0.0)); i=i+1; + addChild(ModuleLightWidget::create>(Vec(3+4.4, i*24+133+4.4), module, ALGEBRA::LED_LIGHT + i)); + addParam(ParamWidget::create(Vec(6, i*24+136), module, ALGEBRA::OP_PARAM + i, 0.0, 1.0, 0.0)); + + + + + addOutput(Port::create(Vec(3, 321), Port::OUTPUT, module, ALGEBRA::OUT_OUTPUT)); + +} + +} // namespace rack_plugin_cf + +using namespace rack_plugin_cf; + +RACK_PLUGIN_MODEL_INIT(cf, ALGEBRA) { + Model *modelALGEBRA = Model::create("cf", "ALGEBRA", "Algebra", UTILITY_TAG); + return modelALGEBRA; +} diff --git a/plugins/community/repos/cf/src/AudioFile.cpp b/plugins/community/repos/cf/src/AudioFile.cpp deleted file mode 100644 index cc2db1a5..00000000 --- a/plugins/community/repos/cf/src/AudioFile.cpp +++ /dev/null @@ -1,873 +0,0 @@ -//======================================================================= -/** @file AudioFile.cpp - * @author Adam Stark - * @copyright Copyright (C) 2017 Adam Stark - * - * This file is part of the 'AudioFile' library - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ -//======================================================================= - -#include "AudioFile.h" -#include -#include -#include - -//============================================================= -// Pre-defined 10-byte representations of common sample rates -std::unordered_map > aiffSampleRateTable = { - {8000, {64, 11, 250, 0, 0, 0, 0, 0, 0, 0}}, - {11025, {64, 12, 172, 68, 0, 0, 0, 0, 0, 0}}, - {16000, {64, 12, 250, 0, 0, 0, 0, 0, 0, 0}}, - {22050, {64, 13, 172, 68, 0, 0, 0, 0, 0, 0}}, - {32000, {64, 13, 250, 0, 0, 0, 0, 0, 0, 0}}, - {37800, {64, 14, 147, 168, 0, 0, 0, 0, 0, 0}}, - {44056, {64, 14, 172, 24, 0, 0, 0, 0, 0, 0}}, - {44100, {64, 14, 172, 68, 0, 0, 0, 0, 0, 0}}, - {47250, {64, 14, 184, 146, 0, 0, 0, 0, 0, 0}}, - {48000, {64, 14, 187, 128, 0, 0, 0, 0, 0, 0}}, - {50000, {64, 14, 195, 80, 0, 0, 0, 0, 0, 0}}, - {50400, {64, 14, 196, 224, 0, 0, 0, 0, 0, 0}}, - {88200, {64, 15, 172, 68, 0, 0, 0, 0, 0, 0}}, - {96000, {64, 15, 187, 128, 0, 0, 0, 0, 0, 0}}, - {176400, {64, 16, 172, 68, 0, 0, 0, 0, 0, 0}}, - {192000, {64, 16, 187, 128, 0, 0, 0, 0, 0, 0}}, - {352800, {64, 17, 172, 68, 0, 0, 0, 0, 0, 0}}, - {2822400, {64, 20, 172, 68, 0, 0, 0, 0, 0, 0}}, - {5644800, {64, 21, 172, 68, 0, 0, 0, 0, 0, 0}} -}; - -//============================================================= -template -AudioFile::AudioFile() -{ - bitDepth = 16; - sampleRate = 44100; - samples.resize (1); - samples[0].resize (0); - audioFileFormat = AudioFileFormat::NotLoaded; -} - -//============================================================= -template -uint32_t AudioFile::getSampleRate() const -{ - return sampleRate; -} - -//============================================================= -template -int AudioFile::getNumChannels() const -{ - return (int)samples.size(); -} - -//============================================================= -template -bool AudioFile::isMono() const -{ - return getNumChannels() == 1; -} - -//============================================================= -template -bool AudioFile::isStereo() const -{ - return getNumChannels() == 2; -} - -//============================================================= -template -int AudioFile::getBitDepth() const -{ - return bitDepth; -} - -//============================================================= -template -int AudioFile::getNumSamplesPerChannel() const -{ - if (samples.size() > 0) - return (int) samples[0].size(); - else - return 0; -} - -//============================================================= -template -double AudioFile::getLengthInSeconds() const -{ - return (double)getNumSamplesPerChannel() / (double)sampleRate; -} - -//============================================================= -template -void AudioFile::printSummary() const -{ - std::cout << "|======================================|" << std::endl; - std::cout << "Num Channels: " << getNumChannels() << std::endl; - std::cout << "Num Samples Per Channel: " << getNumSamplesPerChannel() << std::endl; - std::cout << "Sample Rate: " << sampleRate << std::endl; - std::cout << "Bit Depth: " << bitDepth << std::endl; - std::cout << "Length in Seconds: " << getLengthInSeconds() << std::endl; - std::cout << "|======================================|" << std::endl; -} - -//============================================================= -template -bool AudioFile::setAudioBuffer (AudioBuffer& newBuffer) -{ - int numChannels = (int)newBuffer.size(); - - if (numChannels <= 0) - { - assert (false && "The buffer your are trying to use has no channels"); - return false; - } - - int numSamples = (int)newBuffer[0].size(); - - // set the number of channels - samples.resize (newBuffer.size()); - - for (int k = 0; k < getNumChannels(); k++) - { - assert (newBuffer[k].size() == numSamples); - - samples[k].resize (numSamples); - - for (int i = 0; i < numSamples; i++) - { - samples[k][i] = newBuffer[k][i]; - } - } - - return true; -} - -//============================================================= -template -void AudioFile::setAudioBufferSize (int numChannels, int numSamples) -{ - samples.resize (numChannels); - setNumSamplesPerChannel (numSamples); -} - -//============================================================= -template -void AudioFile::setNumSamplesPerChannel (int numSamples) -{ - int originalSize = getNumSamplesPerChannel(); - - for (int i = 0; i < getNumChannels();i++) - { - samples[i].resize (numSamples); - - // set any new samples to zero - if (numSamples > originalSize) - std::fill (samples[i].begin() + originalSize, samples[i].end(), (T)0.); - } -} - -//============================================================= -template -void AudioFile::setNumChannels (int numChannels) -{ - int originalNumChannels = getNumChannels(); - int originalNumSamplesPerChannel = getNumSamplesPerChannel(); - - samples.resize (numChannels); - - // make sure any new channels are set to the right size - // and filled with zeros - if (numChannels > originalNumChannels) - { - for (int i = originalNumChannels; i < numChannels; i++) - { - samples[i].resize (originalNumSamplesPerChannel); - std::fill (samples[i].begin(), samples[i].end(), (T)0.); - } - } -} - -//============================================================= -template -void AudioFile::setBitDepth (int numBitsPerSample) -{ - bitDepth = numBitsPerSample; -} - -//============================================================= -template -void AudioFile::setSampleRate (uint32_t newSampleRate) -{ - sampleRate = newSampleRate; -} - -//============================================================= -template -bool AudioFile::load (std::string filePath) -{ - std::ifstream file (filePath, std::ios::binary); - - // check the file exists - if (! file.good()) - { - std::cout << "ERROR: File doesn't exist or otherwise can't load file" << std::endl; - std::cout << filePath << std::endl; - return false; - } - - file.unsetf (std::ios::skipws); - std::istream_iterator begin (file), end; - std::vector fileData (begin, end); - - // get audio file format - audioFileFormat = determineAudioFileFormat (fileData); - - if (audioFileFormat == AudioFileFormat::Wave) - { - return decodeWaveFile (fileData); - } - else if (audioFileFormat == AudioFileFormat::Aiff) - { - return decodeAiffFile (fileData); - } - else - { - std::cout << "Audio File Type: " << "Error" << std::endl; - return false; - } -} - -//============================================================= -template -bool AudioFile::decodeWaveFile (std::vector& fileData) -{ - // ----------------------------------------------------------- - // HEADER CHUNK - std::string headerChunkID (fileData.begin(), fileData.begin() + 4); - //int32_t fileSizeInBytes = fourBytesToInt (fileData, 4) + 8; - std::string format (fileData.begin() + 8, fileData.begin() + 12); - - // ----------------------------------------------------------- - // try and find the start points of key chunks - int indexOfDataChunk = getIndexOfString (fileData, "data"); - int indexOfFormatChunk = getIndexOfString (fileData, "fmt"); - - // if we can't find the data or format chunks, or the IDs/formats don't seem to be as expected - // then it is unlikely we'll able to read this file, so abort - if (indexOfDataChunk == -1 || indexOfFormatChunk == -1 || headerChunkID != "RIFF" || format != "WAVE") - { - std::cout << "ERROR: this doesn't seem to be a valid .WAV file" << std::endl; - return false; - } - - // ----------------------------------------------------------- - // FORMAT CHUNK - int f = indexOfFormatChunk; - std::string formatChunkID (fileData.begin() + f, fileData.begin() + f + 4); - //int32_t formatChunkSize = fourBytesToInt (fileData, f + 4); - int16_t audioFormat = twoBytesToInt (fileData, f + 8); - int16_t numChannels = twoBytesToInt (fileData, f + 10); - sampleRate = (uint32_t) fourBytesToInt (fileData, f + 12); - int32_t numBytesPerSecond = fourBytesToInt (fileData, f + 16); - int16_t numBytesPerBlock = twoBytesToInt (fileData, f + 20); - bitDepth = (int) twoBytesToInt (fileData, f + 22); - - int numBytesPerSample = bitDepth / 8; - - // check that the audio format is PCM - if (audioFormat != 1) - { - std::cout << "ERROR: this is a compressed .WAV file and this library does not support decoding them at present" << std::endl; - return false; - } - - // check the number of channels is mono or stereo - if (numChannels < 1 ||numChannels > 2) - { - std::cout << "ERROR: this WAV file seems to be neither mono nor stereo (perhaps multi-track, or corrupted?)" << std::endl; - return false; - } - - // check header data is consistent - if ((numBytesPerSecond != (numChannels * sampleRate * bitDepth) / 8) || (numBytesPerBlock != (numChannels * numBytesPerSample))) - { - std::cout << "ERROR: the header data in this WAV file seems to be inconsistent" << std::endl; - return false; - } - - // check bit depth is either 8, 16 or 24 bit - if (bitDepth != 8 && bitDepth != 16 && bitDepth != 24) - { - std::cout << "ERROR: this file has a bit depth that is not 8, 16 or 24 bits" << std::endl; - return false; - } - - // ----------------------------------------------------------- - // DATA CHUNK - int d = indexOfDataChunk; - std::string dataChunkID (fileData.begin() + d, fileData.begin() + d + 4); - int32_t dataChunkSize = fourBytesToInt (fileData, d + 4); - - int numSamples = dataChunkSize / (numChannels * bitDepth / 8); - int samplesStartIndex = indexOfDataChunk + 8; - - clearAudioBuffer(); - samples.resize (numChannels); - - for (int i = 0; i < numSamples; i++) - { - for (int channel = 0; channel < numChannels; channel++) - { - int sampleIndex = samplesStartIndex + (numBytesPerBlock * i) + channel * numBytesPerSample; - - if (bitDepth == 8) - { - int32_t sampleAsInt = (int32_t) fileData[sampleIndex]; - T sample = (T)(sampleAsInt - 128) / (T)128.; - - samples[channel].push_back (sample); - } - else if (bitDepth == 16) - { - int16_t sampleAsInt = twoBytesToInt (fileData, sampleIndex); - T sample = sixteenBitIntToSample (sampleAsInt); - samples[channel].push_back (sample); - } - else if (bitDepth == 24) - { - int32_t sampleAsInt = 0; - sampleAsInt = (fileData[sampleIndex + 2] << 16) | (fileData[sampleIndex + 1] << 8) | fileData[sampleIndex]; - - if (sampleAsInt & 0x800000) // if the 24th bit is set, this is a negative number in 24-bit world - sampleAsInt = sampleAsInt | ~0xFFFFFF; // so make sure sign is extended to the 32 bit float - - T sample = (T)sampleAsInt / (T)8388608.; - samples[channel].push_back (sample); - } - else - { - assert (false); - } - } - } - - return true; -} - -//============================================================= -template -bool AudioFile::decodeAiffFile (std::vector& fileData) -{ - // ----------------------------------------------------------- - // HEADER CHUNK - std::string headerChunkID (fileData.begin(), fileData.begin() + 4); - //int32_t fileSizeInBytes = fourBytesToInt (fileData, 4, Endianness::BigEndian) + 8; - std::string format (fileData.begin() + 8, fileData.begin() + 12); - - // ----------------------------------------------------------- - // try and find the start points of key chunks - int indexOfCommChunk = getIndexOfString (fileData, "COMM"); - int indexOfSoundDataChunk = getIndexOfString (fileData, "SSND"); - - // if we can't find the data or format chunks, or the IDs/formats don't seem to be as expected - // then it is unlikely we'll able to read this file, so abort - if (indexOfSoundDataChunk == -1 || indexOfCommChunk == -1 || headerChunkID != "FORM" || format != "AIFF") - { - std::cout << "ERROR: this doesn't seem to be a valid AIFF file" << std::endl; - return false; - } - - // ----------------------------------------------------------- - // COMM CHUNK - int p = indexOfCommChunk; - std::string commChunkID (fileData.begin() + p, fileData.begin() + p + 4); - //int32_t commChunkSize = fourBytesToInt (fileData, p + 4, Endianness::BigEndian); - int16_t numChannels = twoBytesToInt (fileData, p + 8, Endianness::BigEndian); - int32_t numSamplesPerChannel = fourBytesToInt (fileData, p + 10, Endianness::BigEndian); - bitDepth = (int) twoBytesToInt (fileData, p + 14, Endianness::BigEndian); - sampleRate = getAiffSampleRate (fileData, p + 16); - - // check the sample rate was properly decoded - if (sampleRate == -1) - { - std::cout << "ERROR: this AIFF file has an unsupported sample rate" << std::endl; - return false; - } - - // check the number of channels is mono or stereo - if (numChannels < 1 ||numChannels > 2) - { - std::cout << "ERROR: this AIFF file seems to be neither mono nor stereo (perhaps multi-track, or corrupted?)" << std::endl; - return false; - } - - // check bit depth is either 8, 16 or 24 bit - if (bitDepth != 8 && bitDepth != 16 && bitDepth != 24) - { - std::cout << "ERROR: this file has a bit depth that is not 8, 16 or 24 bits" << std::endl; - return false; - } - - // ----------------------------------------------------------- - // SSND CHUNK - int s = indexOfSoundDataChunk; - std::string soundDataChunkID (fileData.begin() + s, fileData.begin() + s + 4); - int32_t soundDataChunkSize = fourBytesToInt (fileData, s + 4, Endianness::BigEndian); - int32_t offset = fourBytesToInt (fileData, s + 8, Endianness::BigEndian); - //int32_t blockSize = fourBytesToInt (fileData, s + 12, Endianness::BigEndian); - - int numBytesPerSample = bitDepth / 8; - int numBytesPerFrame = numBytesPerSample * numChannels; - int totalNumAudioSampleBytes = numSamplesPerChannel * numBytesPerFrame; - int samplesStartIndex = s + 16 + (int)offset; - - // sanity check the data - if ((soundDataChunkSize - 8) != totalNumAudioSampleBytes || totalNumAudioSampleBytes > (fileData.size() - samplesStartIndex)) - { - std::cout << "ERROR: the metadatafor this file doesn't seem right" << std::endl; - return false; - } - - clearAudioBuffer(); - samples.resize (numChannels); - - for (int i = 0; i < numSamplesPerChannel; i++) - { - for (int channel = 0; channel < numChannels; channel++) - { - int sampleIndex = samplesStartIndex + (numBytesPerFrame * i) + channel * numBytesPerSample; - - if (bitDepth == 8) - { - int8_t sampleAsSigned8Bit = (int8_t)fileData[sampleIndex]; - T sample = (T)sampleAsSigned8Bit / (T)128.; - samples[channel].push_back (sample); - } - else if (bitDepth == 16) - { - int16_t sampleAsInt = twoBytesToInt (fileData, sampleIndex, Endianness::BigEndian); - T sample = sixteenBitIntToSample (sampleAsInt); - samples[channel].push_back (sample); - } - else if (bitDepth == 24) - { - int32_t sampleAsInt = 0; - sampleAsInt = (fileData[sampleIndex] << 16) | (fileData[sampleIndex + 1] << 8) | fileData[sampleIndex + 2]; - - if (sampleAsInt & 0x800000) // if the 24th bit is set, this is a negative number in 24-bit world - sampleAsInt = sampleAsInt | ~0xFFFFFF; // so make sure sign is extended to the 32 bit float - - T sample = (T)sampleAsInt / (T)8388608.; - samples[channel].push_back (sample); - } - else - { - assert (false); - } - } - } - - return true; -} - -//============================================================= -template -uint32_t AudioFile::getAiffSampleRate (std::vector& fileData, int sampleRateStartIndex) -{ - for (auto it : aiffSampleRateTable) - { - if (tenByteMatch (fileData, sampleRateStartIndex, it.second, 0)) - return it.first; - } - - return -1; -} - -//============================================================= -template -bool AudioFile::tenByteMatch (std::vector& v1, int startIndex1, std::vector& v2, int startIndex2) -{ - for (int i = 0; i < 10; i++) - { - if (v1[startIndex1 + i] != v2[startIndex2 + i]) - return false; - } - - return true; -} - -//============================================================= -template -void AudioFile::addSampleRateToAiffData (std::vector& fileData, uint32_t sampleRate) -{ - if (aiffSampleRateTable.count (sampleRate) > 0) - { - for (int i = 0; i < 10; i++) - fileData.push_back (aiffSampleRateTable[sampleRate][i]); - } -} - -//============================================================= -template -bool AudioFile::save (std::string filePath, AudioFileFormat format) -{ - if (format == AudioFileFormat::Wave) - { - return saveToWaveFile (filePath); - } - else if (format == AudioFileFormat::Aiff) - { - return saveToAiffFile (filePath); - } - - return false; -} - -//============================================================= -template -bool AudioFile::saveToWaveFile (std::string filePath) -{ - std::vector fileData; - - int32_t dataChunkSize = getNumSamplesPerChannel() * (getNumChannels() * bitDepth / 8); - - // ----------------------------------------------------------- - // HEADER CHUNK - addStringToFileData (fileData, "RIFF"); - - // The file size in bytes is the header chunk size (4, not counting RIFF and WAVE) + the format - // chunk size (24) + the metadata part of the data chunk plus the actual data chunk size - int32_t fileSizeInBytes = 4 + 24 + 8 + dataChunkSize; - addInt32ToFileData (fileData, fileSizeInBytes); - - addStringToFileData (fileData, "WAVE"); - - // ----------------------------------------------------------- - // FORMAT CHUNK - addStringToFileData (fileData, "fmt "); - addInt32ToFileData (fileData, 16); // format chunk size (16 for PCM) - addInt16ToFileData (fileData, 1); // audio format = 1 - addInt16ToFileData (fileData, (int16_t)getNumChannels()); // num channels - addInt32ToFileData (fileData, (int32_t)sampleRate); // sample rate - - int32_t numBytesPerSecond = (int32_t) ((getNumChannels() * sampleRate * bitDepth) / 8); - addInt32ToFileData (fileData, numBytesPerSecond); - - int16_t numBytesPerBlock = getNumChannels() * (bitDepth / 8); - addInt16ToFileData (fileData, numBytesPerBlock); - - addInt16ToFileData (fileData, (int16_t)bitDepth); - - // ----------------------------------------------------------- - // DATA CHUNK - addStringToFileData (fileData, "data"); - addInt32ToFileData (fileData, dataChunkSize); - - for (int i = 0; i < getNumSamplesPerChannel(); i++) - { - for (int channel = 0; channel < getNumChannels(); channel++) - { - if (bitDepth == 8) - { - int32_t sampleAsInt = ((samples[channel][i] * (T)128.) + 128.); - uint8_t byte = (uint8_t)sampleAsInt; - fileData.push_back (byte); - } - else if (bitDepth == 16) - { - int16_t sampleAsInt = (int16_t) (samples[channel][i] * (T)32768.); - addInt16ToFileData (fileData, sampleAsInt); - } - else if (bitDepth == 24) - { - int32_t sampleAsIntAgain = (int32_t) (samples[channel][i] * (T)8388608.); - - uint8_t bytes[3]; - bytes[2] = (uint8_t) (sampleAsIntAgain >> 16) & 0xFF; - bytes[1] = (uint8_t) (sampleAsIntAgain >> 8) & 0xFF; - bytes[0] = (uint8_t) sampleAsIntAgain & 0xFF; - - fileData.push_back (bytes[0]); - fileData.push_back (bytes[1]); - fileData.push_back (bytes[2]); - } - else - { - assert (false && "Trying to write a file with unsupported bit depth"); - return false; - } - } - } - - // check that the various sizes we put in the metadata are correct - if (fileSizeInBytes != (fileData.size() - 8) || dataChunkSize != (getNumSamplesPerChannel() * getNumChannels() * (bitDepth / 8))) - { - std::cout << "ERROR: couldn't save file to " << filePath << std::endl; - return false; - } - - // try to write the file - return writeDataToFile (fileData, filePath); -} - -//============================================================= -template -bool AudioFile::saveToAiffFile (std::string filePath) -{ - std::vector fileData; - - int32_t numBytesPerSample = bitDepth / 8; - int32_t numBytesPerFrame = numBytesPerSample * getNumChannels(); - int32_t totalNumAudioSampleBytes = getNumSamplesPerChannel() * numBytesPerFrame; - int32_t soundDataChunkSize = totalNumAudioSampleBytes + 8; - - // ----------------------------------------------------------- - // HEADER CHUNK - addStringToFileData (fileData, "FORM"); - - // The file size in bytes is the header chunk size (4, not counting FORM and AIFF) + the COMM - // chunk size (26) + the metadata part of the SSND chunk plus the actual data chunk size - int32_t fileSizeInBytes = 4 + 26 + 16 + totalNumAudioSampleBytes; - addInt32ToFileData (fileData, fileSizeInBytes, Endianness::BigEndian); - - addStringToFileData (fileData, "AIFF"); - - // ----------------------------------------------------------- - // COMM CHUNK - addStringToFileData (fileData, "COMM"); - addInt32ToFileData (fileData, 18, Endianness::BigEndian); // commChunkSize - addInt16ToFileData (fileData, getNumChannels(), Endianness::BigEndian); // num channels - addInt32ToFileData (fileData, getNumSamplesPerChannel(), Endianness::BigEndian); // num samples per channel - addInt16ToFileData (fileData, bitDepth, Endianness::BigEndian); // bit depth - addSampleRateToAiffData (fileData, sampleRate); - - // ----------------------------------------------------------- - // SSND CHUNK - addStringToFileData (fileData, "SSND"); - addInt32ToFileData (fileData, soundDataChunkSize, Endianness::BigEndian); - addInt32ToFileData (fileData, 0, Endianness::BigEndian); // offset - addInt32ToFileData (fileData, 0, Endianness::BigEndian); // block size - - for (int i = 0; i < getNumSamplesPerChannel(); i++) - { - for (int channel = 0; channel < getNumChannels(); channel++) - { - if (bitDepth == 8) - { - int32_t sampleAsInt = (int32_t)(samples[channel][i] * (T)128.); - uint8_t byte = (uint8_t)sampleAsInt; - fileData.push_back (byte); - } - else if (bitDepth == 16) - { - int16_t sampleAsInt = (int16_t) (samples[channel][i] * (T)32768.); - addInt16ToFileData (fileData, sampleAsInt, Endianness::BigEndian); - } - else if (bitDepth == 24) - { - int32_t sampleAsIntAgain = (int32_t) (samples[channel][i] * (T)8388608.); - - uint8_t bytes[3]; - bytes[0] = (uint8_t) (sampleAsIntAgain >> 16) & 0xFF; - bytes[1] = (uint8_t) (sampleAsIntAgain >> 8) & 0xFF; - bytes[2] = (uint8_t) sampleAsIntAgain & 0xFF; - - fileData.push_back (bytes[0]); - fileData.push_back (bytes[1]); - fileData.push_back (bytes[2]); - } - else - { - assert (false && "Trying to write a file with unsupported bit depth"); - return false; - } - } - } - - // check that the various sizes we put in the metadata are correct - if (fileSizeInBytes != (fileData.size() - 8) || soundDataChunkSize != getNumSamplesPerChannel() * numBytesPerFrame + 8) - { - std::cout << "ERROR: couldn't save file to " << filePath << std::endl; - return false; - } - - // try to write the file - return writeDataToFile (fileData, filePath); -} - -//============================================================= -template -bool AudioFile::writeDataToFile (std::vector& fileData, std::string filePath) -{ - std::ofstream outputFile (filePath, std::ios::binary); - - if (outputFile.is_open()) - { - for (int i = 0; i < fileData.size(); i++) - { - char value = (char) fileData[i]; - outputFile.write (&value, sizeof (char)); - } - - outputFile.close(); - - return true; - } - - return false; -} - -//============================================================= -template -void AudioFile::addStringToFileData (std::vector& fileData, std::string s) -{ - for (int i = 0; i < s.length();i++) - fileData.push_back ((uint8_t) s[i]); -} - -//============================================================= -template -void AudioFile::addInt32ToFileData (std::vector& fileData, int32_t i, Endianness endianness) -{ - uint8_t bytes[4]; - - if (endianness == Endianness::LittleEndian) - { - bytes[3] = (i >> 24) & 0xFF; - bytes[2] = (i >> 16) & 0xFF; - bytes[1] = (i >> 8) & 0xFF; - bytes[0] = i & 0xFF; - } - else - { - bytes[0] = (i >> 24) & 0xFF; - bytes[1] = (i >> 16) & 0xFF; - bytes[2] = (i >> 8) & 0xFF; - bytes[3] = i & 0xFF; - } - - for (int i = 0; i < 4; i++) - fileData.push_back (bytes[i]); -} - -//============================================================= -template -void AudioFile::addInt16ToFileData (std::vector& fileData, int16_t i, Endianness endianness) -{ - uint8_t bytes[2]; - - if (endianness == Endianness::LittleEndian) - { - bytes[1] = (i >> 8) & 0xFF; - bytes[0] = i & 0xFF; - } - else - { - bytes[0] = (i >> 8) & 0xFF; - bytes[1] = i & 0xFF; - } - - fileData.push_back (bytes[0]); - fileData.push_back (bytes[1]); -} - -//============================================================= -template -void AudioFile::clearAudioBuffer() -{ - for (int i = 0; i < samples.size();i++) - { - samples[i].clear(); - } - - samples.clear(); -} - -//============================================================= -template -AudioFileFormat AudioFile::determineAudioFileFormat (std::vector& fileData) -{ - std::string header (fileData.begin(), fileData.begin() + 4); - - if (header == "RIFF") - return AudioFileFormat::Wave; - else if (header == "FORM") - return AudioFileFormat::Aiff; - else - return AudioFileFormat::Error; -} - -//============================================================= -template -int32_t AudioFile::fourBytesToInt (std::vector& source, int startIndex, Endianness endianness) -{ - int32_t result; - - if (endianness == Endianness::LittleEndian) - result = (source[startIndex + 3] << 24) | (source[startIndex + 2] << 16) | (source[startIndex + 1] << 8) | source[startIndex]; - else - result = (source[startIndex] << 24) | (source[startIndex + 1] << 16) | (source[startIndex + 2] << 8) | source[startIndex + 3]; - - return result; -} - -//============================================================= -template -int16_t AudioFile::twoBytesToInt (std::vector& source, int startIndex, Endianness endianness) -{ - int16_t result; - - if (endianness == Endianness::LittleEndian) - result = (source[startIndex + 1] << 8) | source[startIndex]; - else - result = (source[startIndex] << 8) | source[startIndex + 1]; - - return result; -} - -//============================================================= -template -int AudioFile::getIndexOfString (std::vector& source, std::string stringToSearchFor) -{ - int index = -1; - int stringLength = (int)stringToSearchFor.length(); - - for (int i = 0; i < source.size() - stringLength;i++) - { - std::string section (source.begin() + i, source.begin() + i + stringLength); - - if (section == stringToSearchFor) - { - index = i; - break; - } - } - - return index; -} - -//============================================================= -template -T AudioFile::sixteenBitIntToSample (int16_t sample) -{ - return (T)sample / (T)32768.; -} - -//=========================================================== -template class AudioFile; -template class AudioFile; diff --git a/plugins/community/repos/cf/src/AudioFile.h b/plugins/community/repos/cf/src/AudioFile.h deleted file mode 100644 index 9f7508b1..00000000 --- a/plugins/community/repos/cf/src/AudioFile.h +++ /dev/null @@ -1,172 +0,0 @@ -//======================================================================= -/** @file AudioFile.h - * @author Adam Stark - * @copyright Copyright (C) 2017 Adam Stark - * - * This file is part of the 'AudioFile' library - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ -//======================================================================= - -#ifndef _AS_AudioFile_h -#define _AS_AudioFile_h - -#include -#include -#include -#include - - -//============================================================= -/** The different types of audio file, plus some other types to - * indicate a failure to load a file, or that one hasn't been - * loaded yet - */ -enum class AudioFileFormat -{ - Error, - NotLoaded, - Wave, - Aiff -}; - -//============================================================= -template -class AudioFile -{ -public: - - //============================================================= - typedef std::vector > AudioBuffer; - - //============================================================= - /** Constructor */ - AudioFile(); - - //============================================================= - /** Loads an audio file from a given file path. - * @Returns true if the file was successfully loaded - */ - bool load (std::string filePath); - - /** Saves an audio file to a given file path. - * @Returns true if the file was successfully saved - */ - bool save (std::string filePath, AudioFileFormat format = AudioFileFormat::Wave); - - //============================================================= - /** @Returns the sample rate */ - uint32_t getSampleRate() const; - - /** @Returns the number of audio channels in the buffer */ - int getNumChannels() const; - - /** @Returns true if the audio file is mono */ - bool isMono() const; - - /** @Returns true if the audio file is stereo */ - bool isStereo() const; - - /** @Returns the bit depth of each sample */ - int getBitDepth() const; - - /** @Returns the number of samples per channel */ - int getNumSamplesPerChannel() const; - - /** @Returns the length in seconds of the audio file based on the number of samples and sample rate */ - double getLengthInSeconds() const; - - /** Prints a summary of the audio file to the console */ - void printSummary() const; - - //============================================================= - - /** Set the audio buffer for this AudioFile by copying samples from another buffer. - * @Returns true if the buffer was copied successfully. - */ - bool setAudioBuffer (AudioBuffer& newBuffer); - - /** Sets the audio buffer to a given number of channels and number of samples per channel. This will try to preserve - * the existing audio, adding zeros to any new channels or new samples in a given channel. - */ - void setAudioBufferSize (int numChannels, int numSamples); - - /** Sets the number of samples per channel in the audio buffer. This will try to preserve - * the existing audio, adding zeros to new samples in a given channel if the number of samples is increased. - */ - void setNumSamplesPerChannel (int numSamples); - - /** Sets the number of channels. New channels will have the correct number of samples and be initialised to zero */ - void setNumChannels (int numChannels); - - /** Sets the bit depth for the audio file. If you use the save() function, this bit depth rate will be used */ - void setBitDepth (int numBitsPerSample); - - /** Sets the sample rate for the audio file. If you use the save() function, this sample rate will be used */ - void setSampleRate (uint32_t newSampleRate); - - //============================================================= - /** A vector of vectors holding the audio samples for the AudioFile. You can - * access the samples by channel and then by sample index, i.e: - * - * samples[channel][sampleIndex] - */ - AudioBuffer samples; - -private: - - //============================================================= - enum class Endianness - { - LittleEndian, - BigEndian - }; - - //============================================================= - AudioFileFormat determineAudioFileFormat (std::vector& fileData); - bool decodeWaveFile (std::vector& fileData); - bool decodeAiffFile (std::vector& fileData); - - //============================================================= - bool saveToWaveFile (std::string filePath); - bool saveToAiffFile (std::string filePath); - - //============================================================= - void clearAudioBuffer(); - - //============================================================= - int32_t fourBytesToInt (std::vector& source, int startIndex, Endianness endianness = Endianness::LittleEndian); - int16_t twoBytesToInt (std::vector& source, int startIndex, Endianness endianness = Endianness::LittleEndian); - int getIndexOfString (std::vector& source, std::string s); - T sixteenBitIntToSample (int16_t sample); - uint32_t getAiffSampleRate (std::vector& fileData, int sampleRateStartIndex); - bool tenByteMatch (std::vector& v1, int startIndex1, std::vector& v2, int startIndex2); - void addSampleRateToAiffData (std::vector& fileData, uint32_t sampleRate); - - //============================================================= - void addStringToFileData (std::vector& fileData, std::string s); - void addInt32ToFileData (std::vector& fileData, int32_t i, Endianness endianness = Endianness::LittleEndian); - void addInt16ToFileData (std::vector& fileData, int16_t i, Endianness endianness = Endianness::LittleEndian); - - //============================================================= - bool writeDataToFile (std::vector& fileData, std::string filePath); - - //============================================================= - AudioFileFormat audioFileFormat; - uint32_t sampleRate; - int bitDepth; -}; - -#endif /* AudioFile_h */ diff --git a/plugins/community/repos/cf/src/BUFFER.cpp b/plugins/community/repos/cf/src/BUFFER.cpp new file mode 100644 index 00000000..8191205c --- /dev/null +++ b/plugins/community/repos/cf/src/BUFFER.cpp @@ -0,0 +1,230 @@ + +#include "cf.hpp" +#include "dsp/digital.hpp" + +namespace rack_plugin_cf { + +struct BUFFER : Module { + enum ParamIds { + MODE_PARAM, + LENGTH_PARAM, + FB_PARAM, + NUM_PARAMS + }; + enum InputIds { + IN_INPUT, + FB_INPUT, + LENGTH_INPUT, + NUM_INPUTS + + }; + enum OutputIds { + X_OUTPUT, + NUM_OUTPUTS + }; + enum LightIds { + MODE_LIGHT, + NUM_LIGHTS + }; + + + float buf[10000] ={}; + float x = 0; + int pos = 0; + int length = 0; + float l_gain ; + int l_affi ; + + bool MODE_STATE = false ; + SchmittTrigger modeTrigger; + + +BUFFER() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {} + void step() override; + +json_t *toJson() override { + json_t *rootJ = json_object(); + + + json_object_set_new(rootJ, "modestate", json_integer(MODE_STATE)); + return rootJ; + } + +void fromJson(json_t *rootJ) override { + + + json_t *modestateJ = json_object_get(rootJ, "modestate"); + if (modestateJ) + MODE_STATE = json_integer_value(modestateJ); + + } + +}; + + + +void BUFFER::step() { + + if (modeTrigger.process(params[MODE_PARAM].value)) + {if (MODE_STATE == 0) MODE_STATE = 1; else MODE_STATE = 0;} + + lights[MODE_LIGHT].value=MODE_STATE; + + if (!inputs[LENGTH_INPUT].active) { + length = int(params[LENGTH_PARAM].value*9998.0f)+1; + l_affi =0; + } + else { + length = clamp(int(inputs[LENGTH_INPUT].value*999.8f),0,9998)+1; + l_gain = clamp(inputs[LENGTH_INPUT].value,0.0f,10.0f); + l_affi = 1; + } + +if (MODE_STATE) length = (int(length/10))+2; + + buf[pos]=(inputs[IN_INPUT].value+inputs[FB_INPUT].value*params[FB_PARAM].value) ; // /(1.0+params[FB_PARAM].value); + + x = float(pos) ; + if (pos<9999) pos=pos+1; else pos=0; + +if (!MODE_STATE) { + if ((pos-length)>0) + outputs[X_OUTPUT].value=clamp(buf[pos-length],-10.0f,10.0f); + else + outputs[X_OUTPUT].value=clamp(buf[9999+pos-length],-10.0f,10.0f); + } else { + float som = 0.0; + for (int i = 1 ; i < length ; i++) { + if ((pos-i)>0) + som=som+buf[pos-i]; + else + som=som+buf[9999+pos-i]; + } + + outputs[X_OUTPUT].value = clamp((inputs[FB_INPUT].value*params[FB_PARAM].value - (som / float(length-1))),-10.0f,10.0f); + } + + +} + + + +struct BUFFERDisplay : TransparentWidget { + + float *xxxx; + int *llll; + float *dbuf[10000] = {}; + + BUFFERDisplay() { + + + } + + void draw(NVGcontext *vg) { + nvgStrokeWidth(vg,1.2); + nvgStrokeColor(vg, nvgRGBA(0x28, 0xb0, 0xf3, 0xff )); + { + nvgBeginPath(vg); + nvgMoveTo(vg, clamp(*dbuf[int(*xxxx)]*4.0f,-45.0f,45.0f),0.0f); + for (int i=1;i<*llll; i++) {if ((*xxxx-i)>0) nvgLineTo(vg, clamp(*dbuf[int(*xxxx)-i]*4.0f,-45.0f,45.0f), -200.0*(i+1)/(*llll)); + else nvgLineTo(vg, clamp(*dbuf[9999+int(*xxxx)-i]*4.0f,-45.0f,45.0f), -200.0*(i+1)/(*llll)); + } + //nvgClosePath(vg); + } + nvgLineCap(vg, NVG_ROUND); + nvgMiterLimit(vg, 20.0f); + nvgGlobalCompositeOperation(vg, NVG_LIGHTER); + nvgStroke(vg); + + } +}; + +struct MOTORPOTDisplay : TransparentWidget { + + float d; + float *gainX ; + int *affich; + + MOTORPOTDisplay() { + + } + + void draw(NVGcontext *vg) { + if (*affich==1) { + float xx = d*sin(-(*gainX*0.17+0.15)*M_PI) ; + float yy = d*cos((*gainX*0.17+0.15)*M_PI) ; + + + nvgBeginPath(vg); + nvgCircle(vg, 0,0, d); + nvgFillColor(vg, nvgRGBA(0x00, 0x00, 0x00, 0xff)); + nvgFill(vg); + + nvgStrokeWidth(vg,1.2); + nvgStrokeColor(vg, nvgRGBA(0xff, 0xff, 0xff, 0xff)); + { + nvgBeginPath(vg); + nvgMoveTo(vg, 0,0); + nvgLineTo(vg, xx,yy); + nvgClosePath(vg); + } + nvgStroke(vg); + } + + } +}; + +struct BUFFERWidget : ModuleWidget { + BUFFERWidget(BUFFER *module); +}; + +BUFFERWidget::BUFFERWidget(BUFFER *module) : ModuleWidget(module) { + setPanel(SVG::load(assetPlugin(plugin, "res/BUFFER.svg"))); + + addChild(Widget::create(Vec(15, 0))); + addChild(Widget::create(Vec(box.size.x-30, 0))); + addChild(Widget::create(Vec(15, 365))); + addChild(Widget::create(Vec(box.size.x-30, 365))); + + { + BUFFERDisplay *bdisplay = new BUFFERDisplay(); + bdisplay->box.pos = Vec(60, 270); + bdisplay->xxxx = &module->x ; + bdisplay->llll = &module->length ; + for (int i=0;i<10000;i++) { + bdisplay->dbuf[i] = &module->buf[i] ; + } + addChild(bdisplay); + } + + + addParam(ParamWidget::create(Vec(19, 35), module, BUFFER::MODE_PARAM, 0.0, 1.0, 0.0)); + addChild(ModuleLightWidget::create>(Vec(23.4, 39.4), module, BUFFER::MODE_LIGHT)); + + addInput(Port::create(Vec(15, 321), Port::INPUT, module, BUFFER::IN_INPUT)); + + addInput(Port::create(Vec(47, 321), Port::INPUT, module, BUFFER::FB_INPUT)); + addParam(ParamWidget::create(Vec(50.4, 284), module, BUFFER::FB_PARAM, 0.0f, 1.0f, 0.5f)); + + addInput(Port::create(Vec(80, 321), Port::INPUT, module, BUFFER::LENGTH_INPUT)); + addParam(ParamWidget::create(Vec(83.4, 284), module, BUFFER::LENGTH_PARAM, 0.0f, 1.0f, 0.5f)); + { + MOTORPOTDisplay *pdisplay = new MOTORPOTDisplay(); + pdisplay->box.pos = Vec(92.8, 293.2); + pdisplay->d = 9.3; + pdisplay->gainX = &module->l_gain; + pdisplay->affich = &module->l_affi; + addChild(pdisplay); + } + addOutput(Port::create(Vec(80, 31), Port::OUTPUT, module, BUFFER::X_OUTPUT)); + +} + +} // namespace rack_plugin_cf + +using namespace rack_plugin_cf; + +RACK_PLUGIN_MODEL_INIT(cf, BUFFER) { + Model *modelBUFFER = Model::create("cf", "BUFFER", "Buffer", DELAY_TAG); + return modelBUFFER; +} diff --git a/plugins/community/repos/cf/src/CHOKE.cpp b/plugins/community/repos/cf/src/CHOKE.cpp new file mode 100644 index 00000000..ca3a183e --- /dev/null +++ b/plugins/community/repos/cf/src/CHOKE.cpp @@ -0,0 +1,104 @@ +#include "cf.hpp" +#include "dsp/digital.hpp" + + +using namespace std; + +namespace rack_plugin_cf { + +struct CHOKE : Module { + enum ParamIds { + TR1_PARAM, + TR2_PARAM, + PAN_PARAM, + NUM_PARAMS + }; + enum InputIds { + TRIG1_INPUT, + TRIG2_INPUT, + IN1_INPUT, + IN2_INPUT, + NUM_INPUTS + }; + enum OutputIds { + OUT_OUTPUT, + NUM_OUTPUTS + }; + enum LightIds { + L2_LIGHT, + NUM_LIGHTS + }; + + bool play = false; + SchmittTrigger tr1Trigger; + SchmittTrigger tr2Trigger; + +CHOKE() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) { } + + void step() override; + + +}; + + + + +void CHOKE::step() { + + if (tr1Trigger.process(inputs[TRIG1_INPUT].value)) + { + play = false ; + + }; + if (tr2Trigger.process(inputs[TRIG2_INPUT].value)) + { + play = true ; + + }; + if (play) + outputs[OUT_OUTPUT].value = inputs[IN2_INPUT].value*(1-clamp(-params[PAN_PARAM].value,0.0f,1.0f)); + else outputs[OUT_OUTPUT].value = inputs[IN1_INPUT].value*(1-clamp(params[PAN_PARAM].value,0.0f,1.0f)); + + +lights[L2_LIGHT].value=play; +} + + + + +struct CHOKEWidget : ModuleWidget { + CHOKEWidget(CHOKE *module); + //void step() override; + +}; + +CHOKEWidget::CHOKEWidget(CHOKE *module) : ModuleWidget(module) { + setPanel(SVG::load(assetPlugin(plugin, "res/CHOKE.svg"))); + + + addChild(Widget::create(Vec(15, 0))); + addChild(Widget::create(Vec(box.size.x-30, 365))); + + addParam(ParamWidget::create(Vec(6, 298), module, CHOKE::PAN_PARAM, -1.0f, 1.0f, 0.0f)); + + addInput(Port::create(Vec(3, 61), Port::INPUT, module, CHOKE::IN1_INPUT)); + addInput(Port::create(Vec(3, 91), Port::INPUT, module, CHOKE::TRIG1_INPUT)); + + addInput(Port::create(Vec(3, 181), Port::INPUT, module, CHOKE::IN2_INPUT)); + addInput(Port::create(Vec(3, 211), Port::INPUT, module, CHOKE::TRIG2_INPUT)); + + addChild(ModuleLightWidget::create>(Vec(8, 276), module, CHOKE::L2_LIGHT)); + + addOutput(Port::create(Vec(3, 321), Port::OUTPUT, module, CHOKE::OUT_OUTPUT)); + +} + +} // namespace rack_plugin_cf + +using namespace rack_plugin_cf; + + +RACK_PLUGIN_MODEL_INIT(cf, CHOKE) { + Model *modelCHOKE = Model::create("cf", "CHOKE", "Choke", UTILITY_TAG); + return modelCHOKE; +} diff --git a/plugins/community/repos/cf/src/CUBE.cpp b/plugins/community/repos/cf/src/CUBE.cpp index 08cc3d3f..48583d05 100644 --- a/plugins/community/repos/cf/src/CUBE.cpp +++ b/plugins/community/repos/cf/src/CUBE.cpp @@ -27,9 +27,9 @@ struct CUBE : Module { float yy[12] = {-1.0,-1.0, 1.0, 1.0,-1.0,-1.0, 1.0, 1.0}; float zz[12] = {-1.0,-1.0,-1.0,-1.0, 1.0, 1.0, 1.0, 1.0}; - float x[12] = {}; - float y[12] = {}; - float z[12] = {}; + float x[8] = {}; + float y[8] = {}; + float z[8] = {}; float d = 0.0; float theta= 0.0 ; @@ -49,7 +49,7 @@ void CUBE::step() { if (inputs[X_INPUT].active) gainX=inputs[X_INPUT].value; if (inputs[Y_INPUT].active) gainY=inputs[Y_INPUT].value; - for(int i=0; i<12; i++) + for(int i=0; i<8; i++) { d = sqrt(yy[i]*yy[i] + zz[i]*zz[i]); theta = atan2(yy[i],zz[i])+frameX; @@ -73,8 +73,8 @@ void CUBE::step() { struct CUBEDisplay : TransparentWidget { - float *xxxx[12] = {}; - float *yyyy[12] = {}; + float *xxxx[8] = {}; + float *yyyy[8] = {}; CUBEDisplay() { @@ -155,7 +155,7 @@ CUBEWidget::CUBEWidget(CUBE *module) : ModuleWidget(module) { { CUBEDisplay *display = new CUBEDisplay(); display->box.pos = Vec(60, 120); - for (int i=0;i<12;i++) { + for (int i=0;i<8;i++) { display->xxxx[i] = &module->x[i] ; display->yyyy[i] = &module->y[i] ; } diff --git a/plugins/community/repos/cf/src/DISTO.cpp b/plugins/community/repos/cf/src/DISTO.cpp new file mode 100644 index 00000000..17e85ff0 --- /dev/null +++ b/plugins/community/repos/cf/src/DISTO.cpp @@ -0,0 +1,191 @@ + +#include "cf.hpp" +#include "dsp/digital.hpp" + +namespace rack_plugin_cf { + +struct DISTO : Module { + enum ParamIds { + FOLD_PARAM, + GAIN_PARAM, + NUM_PARAMS + }; + enum InputIds { + IN_INPUT, + GAIN_INPUT, + FOLD_INPUT, + NUM_INPUTS + + }; + enum OutputIds { + X_OUTPUT, + NUM_OUTPUTS + }; + + + float x = 0; + float y = 0; + int length = 0; + float fold_gain ; + int fold_affi ; + float gain_gain ; + int gain_affi ; + + DISTO() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS) {} + void step() override; + +}; + + + +void DISTO::step() { + + if (inputs[FOLD_INPUT].active) { + fold_affi =true; fold_gain = clamp(inputs[FOLD_INPUT].value,-0.001,10.001) ;} + else {fold_affi =false; fold_gain = params[FOLD_PARAM].value ;} + + if (inputs[GAIN_INPUT].active) { + gain_affi =true; gain_gain = clamp(inputs[GAIN_INPUT].value,-0.001,10.001) ;} + else {gain_affi =false; gain_gain = params[GAIN_PARAM].value ;} + +//////////DISTO + x=inputs[IN_INPUT].value*5.0f*gain_gain; + + if (abs(x)>5) y = clamp((abs(x)-5)/2.2f,0.0f,58.0f); else y=0; + + for (int i =0; i<100; i++) { + if (x<-5.0f) x=-5.0f+(-x-5.0f)*fold_gain/5.0; + if (x>5.0f) x=5.0f-(x-5.0f)*fold_gain/5.0; + if ((x>=-5.0) & (x<=5.0)) i=1000; + if (i==99) x=0; + } + + outputs[X_OUTPUT].value=clamp(x,-5.0f,5.0f); + +} + +struct cachecl : SVGScrew { + cachecl() { + sw->setSVG(SVG::load(assetPlugin(plugin, "res/distocach.svg"))); + box.size = sw->box.size; + } +}; + +struct DISTODisplay : TransparentWidget { + + float *xxxx; + int *llll; + float bu[5] = {}; + int ind = 0; + + DISTODisplay() { + + + } + + void draw(NVGcontext *vg) { + bu[ind] = *xxxx ; + for (int i = 0 ; i<5 ; i++){ + {//nvgStrokeColor(vg, nvgRGBA(0x28, 0xb0, 0xf3, 0xff)); + nvgBeginPath(vg); + nvgCircle(vg, 0,0, bu[i]); + nvgFillColor(vg, nvgRGBA(0x28, 0xb0, 0xf3, 0xff)); + nvgGlobalCompositeOperation(vg, NVG_LIGHTER); + nvgFill(vg); + nvgClosePath(vg); + } + } + //nvgStroke(vg); + if (ind<4) ind = ind +1; else ind = 0; + } +}; + +struct MOTORPOTDisplay : TransparentWidget { + + float d; + float *gainX ; + int *affich; + + MOTORPOTDisplay() { + + } + + void draw(NVGcontext *vg) { + if (*affich==1) { + float xx = d*sin(-(*gainX*0.17+0.15)*M_PI) ; + float yy = d*cos((*gainX*0.17+0.15)*M_PI) ; + + + nvgBeginPath(vg); + nvgCircle(vg, 0,0, d); + nvgFillColor(vg, nvgRGBA(0x00, 0x00, 0x00, 0xff)); + nvgFill(vg); + + nvgStrokeWidth(vg,1.2); + nvgStrokeColor(vg, nvgRGBA(0xff, 0xff, 0xff, 0xff)); + { + nvgBeginPath(vg); + nvgMoveTo(vg, 0,0); + nvgLineTo(vg, xx,yy); + nvgClosePath(vg); + } + nvgStroke(vg); + } + + } +}; + +struct DISTOWidget : ModuleWidget { + DISTOWidget(DISTO *module); +}; + +DISTOWidget::DISTOWidget(DISTO *module) : ModuleWidget(module) { + setPanel(SVG::load(assetPlugin(plugin, "res/DISTO.svg"))); + + addChild(Widget::create(Vec(15, 0))); + addChild(Widget::create(Vec(box.size.x-30, 0))); + addChild(Widget::create(Vec(15, 365))); + addChild(Widget::create(Vec(box.size.x-30, 365))); + + { + DISTODisplay *distdisplay = new DISTODisplay(); + distdisplay->box.pos = Vec(60, 170); + distdisplay->xxxx = &module->y ; + distdisplay->llll = &module->length ; + addChild(distdisplay); + } + + addInput(Port::create(Vec(15, 321), Port::INPUT, module, DISTO::IN_INPUT)); + + addInput(Port::create(Vec(47, 321), Port::INPUT, module, DISTO::GAIN_INPUT)); + addParam(ParamWidget::create(Vec(50.4, 284), module, DISTO::GAIN_PARAM, 0.0f, 10.0f, 0.2f)); + { + MOTORPOTDisplay *gaindisplay = new MOTORPOTDisplay(); + gaindisplay->box.pos = Vec(59.8, 293.2); + gaindisplay->d = 9.3; + gaindisplay->gainX = &module->gain_gain; + gaindisplay->affich = &module->gain_affi; + addChild(gaindisplay); + } + addInput(Port::create(Vec(80, 321), Port::INPUT, module, DISTO::FOLD_INPUT)); + addParam(ParamWidget::create(Vec(83.4, 284), module, DISTO::FOLD_PARAM, 0.0f, 10.0f, 0.0f)); + { + MOTORPOTDisplay *folddisplay = new MOTORPOTDisplay(); + folddisplay->box.pos = Vec(92.8, 293.2); + folddisplay->d = 9.3; + folddisplay->gainX = &module->fold_gain; + folddisplay->affich = &module->fold_affi; + addChild(folddisplay); + } + addOutput(Port::create(Vec(80, 31), Port::OUTPUT, module, DISTO::X_OUTPUT)); + addChild(Widget::create(Vec(0, 0))); +} + +} // namespace rack_plugin_cf + +using namespace rack_plugin_cf; + +RACK_PLUGIN_MODEL_INIT(cf, DISTO) { + Model *modelDISTO = Model::create("cf", "DISTO", "Disto", DISTORTION_TAG); + return modelDISTO; +} diff --git a/plugins/community/repos/cf/src/EACH.cpp b/plugins/community/repos/cf/src/EACH.cpp index 2f0d40c7..e9b5b91b 100644 --- a/plugins/community/repos/cf/src/EACH.cpp +++ b/plugins/community/repos/cf/src/EACH.cpp @@ -50,8 +50,8 @@ void EACH::step() { max_EACH = floor(params[DIV_PARAM].value); or_affi=0; } else { - max_EACH = round(clamp((inputs[DIV_INPUT].value * 1.2)+1,1.0f,12.0f)); - or_gain = round(clamp(inputs[DIV_INPUT].value,0.0f,10.0f)); + max_EACH = round(clamp((inputs[DIV_INPUT].value * 4.8)+1,1.0f,48.0f)); + or_gain = (clamp(inputs[DIV_INPUT].value,0.0f,10.0f)); or_affi=1; } @@ -66,7 +66,7 @@ void EACH::step() { if (inputs[DOUZE_INPUT].active) { if (stepa == max_EACH) { - note = 5; + note = 50; stepa = 0; lum = 2000; } @@ -180,7 +180,7 @@ EACHWidget::EACHWidget(EACH *module) : ModuleWidget(module) { addOutput(Port::create(Vec(54, 321), Port::OUTPUT, module, EACH::DOUZE_OUTPUT)); addOutput(Port::create(Vec(35, 235), Port::OUTPUT, module, EACH::BEAT_OUTPUT)); - addParam(ParamWidget::create(Vec(27, 107), module, EACH::DIV_PARAM, 1.0f, 12.1f, 3.1f)); + addParam(ParamWidget::create(Vec(27, 107), module, EACH::DIV_PARAM, 1.0f, 48.1f, 3.1f)); addInput(Port::create(Vec(11, 141), Port::INPUT, module, EACH::DIV_INPUT)); { MOTORPOTDisplay *display = new MOTORPOTDisplay(); diff --git a/plugins/community/repos/cf/src/L3DS3Q.cpp b/plugins/community/repos/cf/src/L3DS3Q.cpp index f2120e90..a8b85322 100644 --- a/plugins/community/repos/cf/src/L3DS3Q.cpp +++ b/plugins/community/repos/cf/src/L3DS3Q.cpp @@ -25,7 +25,6 @@ struct L3DS3Q : Module { }; -int wait = 0; int pas = 0; bool ledState[80] = {}; int tempState[5] = {}; @@ -33,7 +32,7 @@ bool editState = false ; SchmittTrigger rstTrigger; SchmittTrigger upTrigger; SchmittTrigger editTrigger; - +SchmittTrigger ledTrigger[80] ={}; L3DS3Q() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {} void step() override; @@ -91,7 +90,7 @@ void L3DS3Q::step() { if (upTrigger.process(inputs[UP_INPUT].value)) { for (int i = 0; i < 5; i++) { - if (ledState[(i+pas*5)%80]) tempState [i] = 20; + if (ledState[(i+pas*5)%80]) tempState [i] = 50; } if (pas <15) pas = pas+1; else pas =0; } @@ -105,30 +104,22 @@ void L3DS3Q::step() { { for (int i = 0; i < 80; i++) {lights[LED_LIGHT +i].value=ledState[(i+pas*5)%80];} - if (wait == 0) { for (int i = 0; i < 80; i++) { - if (params[ON_PARAM +i].value) {ledState[(i+pas*5)%80]=!ledState[(i+pas*5)%80]; wait = 20000;} - }} else wait = wait-1; + if (ledTrigger[i].process(params[ON_PARAM +i].value)) {ledState[(i+pas*5)%80]=!ledState[(i+pas*5)%80];} + }; } else { for (int i = 0; i < 80; i++) {lights[LED_LIGHT +i].value=ledState[i];} - if (wait == 0) { + for (int i = 0; i < 80; i++) { - if (params[ON_PARAM +i].value) {ledState[i]=!ledState[i]; wait = 20000;} - }} else wait = wait-1; + if (ledTrigger[i].process(params[ON_PARAM +i].value)) {ledState[i]=!ledState[i];} + }; } for (int i = 0; i < 5; i++) { if (tempState [i]>0) {tempState [i] = tempState [i]-1;outputs[TR_OUTPUT+i].value=10.0f;} else outputs[TR_OUTPUT+i].value=0.0f; } - //if (wait == 0) { - // for (int i = 0; i < 80; i++) { - - // if (params[ON_PARAM +i].value) {ledState[i]=!ledState[i]; wait = 20000;} - // lights[LED_LIGHT +i].value=ledState[i]; - //}} else wait = wait-1; - } diff --git a/plugins/community/repos/cf/src/LEDS.cpp b/plugins/community/repos/cf/src/LEDS.cpp index 82caf5cf..3fa4835a 100644 --- a/plugins/community/repos/cf/src/LEDS.cpp +++ b/plugins/community/repos/cf/src/LEDS.cpp @@ -27,6 +27,7 @@ bool ledState[100] = {}; bool tempState[5] = {}; SchmittTrigger rndTrigger; SchmittTrigger upTrigger; +SchmittTrigger ledTrigger[100]; LEDS() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {} @@ -94,12 +95,12 @@ void LEDS::step() { {ledState[i+95] = tempState[i];} } - if (wait == 0) { + for (int i = 0; i < 100; i++) { - if (params[ON_PARAM +i].value) {ledState[i]=!ledState[i]; wait = 20000;} + if (ledTrigger[i].process(params[ON_PARAM +i].value)) {ledState[i]=!ledState[i];} lights[LED_LIGHT +i].value=ledState[i]; - }} else wait = wait-1; + } } diff --git a/plugins/community/repos/cf/src/LEDSEQ.cpp b/plugins/community/repos/cf/src/LEDSEQ.cpp index 01d3a54f..8887f449 100644 --- a/plugins/community/repos/cf/src/LEDSEQ.cpp +++ b/plugins/community/repos/cf/src/LEDSEQ.cpp @@ -25,7 +25,7 @@ struct LEDSEQ : Module { }; -int wait = 0; + int pas = 0; bool ledState[80] = {}; int tempState[5] = {}; @@ -33,6 +33,7 @@ bool editState = false ; SchmittTrigger rstTrigger; SchmittTrigger upTrigger; SchmittTrigger editTrigger; +SchmittTrigger ledTrigger[80] ={}; LEDSEQ() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {} @@ -91,7 +92,7 @@ void LEDSEQ::step() { if (upTrigger.process(inputs[UP_INPUT].value)) { for (int i = 0; i < 5; i++) { - if (ledState[(i+pas*5)%80]) tempState [i] = 20; + if (ledState[(i+pas*5)%80]) tempState [i] = 50; } if (pas <15) pas = pas+1; else pas =0; } @@ -105,17 +106,17 @@ void LEDSEQ::step() { { for (int i = 0; i < 80; i++) {lights[LED_LIGHT +i].value=ledState[(i+pas*5)%80];} - if (wait == 0) { + for (int i = 0; i < 80; i++) { - if (params[ON_PARAM +i].value) {ledState[(i+pas*5)%80]=!ledState[(i+pas*5)%80]; wait = 20000;} - }} else wait = wait-1; + if (ledTrigger[i].process(params[ON_PARAM +i].value)) {ledState[(i+pas*5)%80]=!ledState[(i+pas*5)%80];} + }; } else { for (int i = 0; i < 80; i++) {lights[LED_LIGHT +i].value=ledState[i];} - if (wait == 0) { + for (int i = 0; i < 80; i++) { - if (params[ON_PARAM +i].value) {ledState[i]=!ledState[i]; wait = 20000;} - }} else wait = wait-1; + if (ledTrigger[i].process(params[ON_PARAM +i].value)) {ledState[i]=!ledState[i];} + }; } for (int i = 0; i < 5; i++) { diff --git a/plugins/community/repos/cf/src/MASTER.cpp b/plugins/community/repos/cf/src/MASTER.cpp index ac0e02ec..cc6e4c8f 100644 --- a/plugins/community/repos/cf/src/MASTER.cpp +++ b/plugins/community/repos/cf/src/MASTER.cpp @@ -131,8 +131,8 @@ MASTERWidget::MASTERWidget(MASTER *module) : ModuleWidget(module) { addOutput(Port::create(Vec(54, 61), Port::OUTPUT, module, MASTER::LEFT_OUTPUT)); addOutput(Port::create(Vec(54, 91), Port::OUTPUT, module, MASTER::RIGHT_OUTPUT)); - addOutput(Port::create(Vec(11, 321), Port::OUTPUT, module, MASTER::LEFT_MAIN_OUTPUT)); - addOutput(Port::create(Vec(54, 321), Port::OUTPUT, module, MASTER::RIGHT_MAIN_OUTPUT)); + addOutput(Port::create(Vec(54, 308), Port::OUTPUT, module, MASTER::LEFT_MAIN_OUTPUT)); + addOutput(Port::create(Vec(54, 334), Port::OUTPUT, module, MASTER::RIGHT_MAIN_OUTPUT)); addInput(Port::create(Vec(11, 61), Port::INPUT, module, MASTER::LEFT_INPUT)); addInput(Port::create(Vec(11, 91), Port::INPUT, module, MASTER::RIGHT_INPUT)); diff --git a/plugins/community/repos/cf/src/MONO.cpp b/plugins/community/repos/cf/src/MONO.cpp index 6e70d609..62047ae4 100644 --- a/plugins/community/repos/cf/src/MONO.cpp +++ b/plugins/community/repos/cf/src/MONO.cpp @@ -6,8 +6,8 @@ namespace rack_plugin_cf { struct MONO : Module { enum ParamIds { PAN_PARAM, - GAIN_PARAM, - SOLO_PARAM, + GAIN_PARAM, + SOLO_PARAM, ON_PARAM, NUM_PARAMS }; @@ -30,7 +30,7 @@ struct MONO : Module { OUT1_OUTPUT, NUM_OUTPUTS }; - enum LightIds { + enum LightIds { SOLO_LIGHT, ON_LIGHT, LEVEL_LIGHTS, @@ -180,6 +180,7 @@ struct MOTORPOTDisplay : TransparentWidget { } }; + struct MONOWidget : ModuleWidget { MONOWidget(MONO *module); }; diff --git a/plugins/community/repos/cf/src/PEAK.cpp b/plugins/community/repos/cf/src/PEAK.cpp index e6750883..90cdcf64 100644 --- a/plugins/community/repos/cf/src/PEAK.cpp +++ b/plugins/community/repos/cf/src/PEAK.cpp @@ -15,10 +15,12 @@ struct PEAK : Module { enum InputIds { LIN1_INPUT, IN1_INPUT, + IN2_INPUT, NUM_INPUTS }; enum OutputIds { OUT1_OUTPUT, + OUT2_OUTPUT, NUM_OUTPUTS }; enum LightIds { @@ -72,6 +74,37 @@ void PEAK::step() { lights[OVER_LIGHT].value = 0.0; } + + + if (inputs[IN2_INPUT].active) + { + + if (inputs[IN2_INPUT].value > params[TRESHOLD_PARAM].value) + { + outputs[OUT2_OUTPUT].value = (max_GAIN/10.0*(params[TRESHOLD_PARAM].value + ((inputs[IN2_INPUT].value-params[TRESHOLD_PARAM].value)/(1+(inputs[IN2_INPUT].value-params[TRESHOLD_PARAM].value))))); + reman_t = sensiv; + } + else if (inputs[IN2_INPUT].value < 0-params[TRESHOLD_PARAM].value) + { + outputs[OUT2_OUTPUT].value = (max_GAIN/10.0*(0-(params[TRESHOLD_PARAM].value - ((inputs[IN2_INPUT].value+params[TRESHOLD_PARAM].value)/(1+(-inputs[IN2_INPUT].value-params[TRESHOLD_PARAM].value)))))); + reman_t = sensiv; + } + else + { + outputs[OUT2_OUTPUT].value =(max_GAIN*inputs[IN2_INPUT].value)/10.0; + } + + if (outputs[OUT2_OUTPUT].value >10) reman_o=sensiv; + + } + else + { + outputs[OUT2_OUTPUT].value = max_GAIN/10; + lights[TRESHOLD_LIGHT].value = 0.0; + lights[OVER_LIGHT].value = 0.0; + } + + if (reman_t >0) { reman_t--; @@ -158,9 +191,13 @@ PEAKWidget::PEAKWidget(PEAK *module) : ModuleWidget(module) { addParam(ParamWidget::create(Vec(27, 227), module, PEAK::TRESHOLD_PARAM, 0.0f, 10.0f, 10.0f)); addChild(ModuleLightWidget::create>(Vec(42.4, 211.4), module, PEAK::TRESHOLD_LIGHT)); - addInput(Port::create(Vec(11, 321), Port::INPUT, module, PEAK::IN1_INPUT)); + addInput(Port::create(Vec(11, 308), Port::INPUT, module, PEAK::IN1_INPUT)); + + addOutput(Port::create(Vec(54, 308), Port::OUTPUT, module, PEAK::OUT1_OUTPUT)); + + addInput(Port::create(Vec(11, 334), Port::INPUT, module, PEAK::IN2_INPUT)); - addOutput(Port::create(Vec(54, 321), Port::OUTPUT, module, PEAK::OUT1_OUTPUT)); + addOutput(Port::create(Vec(54, 334), Port::OUTPUT, module, PEAK::OUT2_OUTPUT)); NumbDisplayWidget *display = new NumbDisplayWidget(); display->box.pos = Vec(20,56); diff --git a/plugins/community/repos/cf/src/PLAY.cpp b/plugins/community/repos/cf/src/PLAY.cpp new file mode 100644 index 00000000..63f536bf --- /dev/null +++ b/plugins/community/repos/cf/src/PLAY.cpp @@ -0,0 +1,321 @@ +#include "cf.hpp" +#include "dsp/digital.hpp" +#include "osdialog.h" +namespace rack_plugin_cf { +// (note) also used in Bidoo module(s) +#include "dr_wav.h" +} +#include +#include "cmath" +#ifdef _MSC_VER +#include "dirent_win32/dirent.h" +#else +#include +#endif +#include //----added by Joakim Lindbom + + +using namespace std; + +namespace rack_plugin_cf { + +struct PLAY : Module { + enum ParamIds { + PREV_PARAM, + NEXT_PARAM, + LSPEED_PARAM, + LOAD_PARAM, + PLAY_PARAM, + NUM_PARAMS + }; + enum InputIds { + TRIG_INPUT, + NUM_INPUTS + }; + enum OutputIds { + OUT_OUTPUT, + NUM_OUTPUTS + }; + enum LightIds { + NUM_LIGHTS + }; + + + unsigned int channels; + unsigned int sampleRate; + drwav_uint64 totalSampleCount; + + vector> playBuffer; + bool loading = false; + + bool run = false; + + string lastPath = ""; + float samplePos = 0; + string fileDesc; + bool fileLoaded = false; + bool reload = false ; + int sampnumber = 0; + vector fichier; + SchmittTrigger loadsampleTrigger; + SchmittTrigger playTrigger; + SchmittTrigger nextTrigger; + SchmittTrigger prevTrigger; + +PLAY() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) { + playBuffer.resize(1); + playBuffer[0].resize(0); } + + void step() override; + + void loadSample(std::string path); + + // persistence + + json_t *toJson() override { + json_t *rootJ = json_object(); + // lastPath + json_object_set_new(rootJ, "lastPath", json_string(lastPath.c_str())); + return rootJ; + } + + void fromJson(json_t *rootJ) override { + // lastPath + json_t *lastPathJ = json_object_get(rootJ, "lastPath"); + if (lastPathJ) { + lastPath = json_string_value(lastPathJ); + reload = true ; + loadSample(lastPath); + + }} + +}; + +void PLAY::loadSample(std::string path) { + + loading = true; + unsigned int c; + unsigned int sr; + drwav_uint64 sc; + float* pSampleData; + pSampleData = drwav_open_and_read_file_f32(path.c_str(), &c, &sr, &sc); + + if (pSampleData != NULL) { + channels = c; + sampleRate = sr; + playBuffer[0].clear(); + for (unsigned int i=0; i < sc; i = i + c) { + playBuffer[0].push_back(pSampleData[i]); + + } + totalSampleCount = playBuffer[0].size(); + drwav_free(pSampleData); +loading = false; + + fileLoaded = true; + + fileDesc = stringFilename(path); + + if (reload) { + DIR* rep = NULL; + struct dirent* dirp = NULL; + std::string dir = path.empty() ? assetLocal("") : stringDirectory(path); + + rep = opendir(dir.c_str()); + int i = 0; + fichier.clear(); + while ((dirp = readdir(rep)) != NULL) { + std::string name = dirp->d_name; + + std::size_t found = name.find(".wav",name.length()-5); + if (found==std::string::npos) found = name.find(".WAV",name.length()-5); + + if (found!=std::string::npos) { + fichier.push_back(name); + if ((dir + "/" + name)==path) {sampnumber = i;} + i=i+1; + } + + } + +//----added by Joakim Lindbom + sort(fichier.begin(), fichier.end()); // Linux needs this to get files in right order + for (int o=0;o 0) sampnumber=sampnumber-1; else sampnumber =int(fichier.size()-1); + loadSample(dir + "/" + fichier[sampnumber]); + } + } else fileDesc = "R.Click to load"; + + + +////////////////////////////////////////////////////////////////// Play + if (inputs[TRIG_INPUT].active) { + if (playTrigger.process(inputs[TRIG_INPUT].value)) + { + run = true; + samplePos = 0; + } + } + + if ((!loading) && (run) && ((abs(floor(samplePos)) < totalSampleCount))) + { if (samplePos>=0) + outputs[OUT_OUTPUT].value = 5 * playBuffer[0][floor(samplePos)]; + else outputs[OUT_OUTPUT].value = 5 * playBuffer[0][floor(totalSampleCount-1+samplePos)]; + samplePos = samplePos+1+(params[LSPEED_PARAM].value) /3; + } + else + { + run = false; + outputs[OUT_OUTPUT].value = 0; + } + +} + +struct upButton : SVGSwitch, MomentarySwitch { + upButton() { + addFrame(SVG::load(assetPlugin(plugin, "res/upButton.svg"))); + addFrame(SVG::load(assetPlugin(plugin, "res/upButtonDown.svg"))); + sw->wrap(); + box.size = sw->box.size; + } +}; +struct downButton : SVGSwitch, MomentarySwitch { + downButton() { + addFrame(SVG::load(assetPlugin(plugin, "res/downButton.svg"))); + addFrame(SVG::load(assetPlugin(plugin, "res/downButtonDown.svg"))); + sw->wrap(); + box.size = sw->box.size; + } +}; + +struct PLAYDisplay : TransparentWidget { + PLAY *module; + + int frame = 0; + shared_ptr font; + + PLAYDisplay() { + font = Font::load(assetPlugin(plugin, "res/LEDCalculator.ttf")); + } + + void draw(NVGcontext *vg) override { + std::string to_display = ""; + for (int i=0; i<14; i++) to_display = to_display + module->fileDesc[i]; + nvgFontSize(vg, 24); + nvgFontFaceId(vg, font->handle); + nvgTextLetterSpacing(vg, 0); + nvgFillColor(vg, nvgRGBA(0x4c, 0xc7, 0xf3, 0xff)); + nvgRotate(vg, -M_PI / 2.0f); + nvgTextBox(vg, 5, 5,350, to_display.c_str(), NULL); + } +}; + + +struct PLAYWidget : ModuleWidget { + PLAYWidget(PLAY *module); +//void step() override; +Menu *createContextMenu() override; +}; + +PLAYWidget::PLAYWidget(PLAY *module) : ModuleWidget(module) { + setPanel(SVG::load(assetPlugin(plugin, "res/PLAY.svg"))); + + + { + PLAYDisplay *gdisplay = new PLAYDisplay(); + gdisplay->module = module; + gdisplay->box.pos = Vec(18, 253); + gdisplay->box.size = Vec(130, 250); + addChild(gdisplay); + } + + addChild(Widget::create(Vec(15, 0))); + addChild(Widget::create(Vec(box.size.x-30, 365))); + + addParam(ParamWidget::create(Vec(6, 298), module, PLAY::LSPEED_PARAM, -5.0f, 5.0f, 0.0f)); + addInput(Port::create(Vec(3, 31), Port::INPUT, module, PLAY::TRIG_INPUT)); + addOutput(Port::create(Vec(3, 321), Port::OUTPUT, module, PLAY::OUT_OUTPUT)); + + addParam(ParamWidget::create(Vec(6, 276), module, PLAY::PREV_PARAM, 0.0f, 1.0f, 0.0f)); + addParam(ParamWidget::create(Vec(6, 256), module, PLAY::NEXT_PARAM, 0.0f, 1.0f, 0.0f)); +} + +struct PLAYItem : MenuItem { + PLAY *play; + void onAction(EventAction &e) override { + + std::string dir = play->lastPath.empty() ? assetLocal("") : stringDirectory(play->lastPath); + char *path = osdialog_file(OSDIALOG_OPEN, dir.c_str(), NULL, NULL); + if (path) { + play->run = false; + play->reload = true; + play->loadSample(path); + + play->samplePos = 0; + play->lastPath = path; + free(path); + } + + } + +}; + +Menu *PLAYWidget::createContextMenu() { + Menu *menu = ModuleWidget::createContextMenu(); + + MenuLabel *spacerLabel = new MenuLabel(); + menu->addChild(spacerLabel); + + PLAY *play = dynamic_cast(module); + assert(play); + + PLAYItem *sampleItem = new PLAYItem(); + sampleItem->text = "Load sample"; + sampleItem->play = play ; + menu->addChild(sampleItem); + + return menu; +} + +} // namespace rack_plugin_cf + +using namespace rack_plugin_cf; + +RACK_PLUGIN_MODEL_INIT(cf, PLAY) { + Model *modelPLAY = Model::create("cf", "PLAY", "Play", SAMPLER_TAG); + return modelPLAY; +} + diff --git a/plugins/community/repos/cf/src/PLAYER.cpp b/plugins/community/repos/cf/src/PLAYER.cpp index 10b8ef40..db0152c9 100644 --- a/plugins/community/repos/cf/src/PLAYER.cpp +++ b/plugins/community/repos/cf/src/PLAYER.cpp @@ -1,7 +1,11 @@ #include "cf.hpp" #include "dsp/digital.hpp" #include "osdialog.h" -#include "AudioFile.h" +namespace rack_plugin_cf { +// (note) also used in Bidoo module(s) +#define DR_WAV_IMPLEMENTATION +#include "dr_wav.h" +} #include #include "cmath" #ifdef _MSC_VER @@ -37,6 +41,7 @@ struct PLAYER : Module { PREV_INPUT, NEXT_INPUT, TRIG_INPUT, + VO_INPUT, NUM_INPUTS }; enum OutputIds { @@ -49,12 +54,22 @@ struct PLAYER : Module { NUM_LIGHTS }; + unsigned int channels; + unsigned int sampleRate; + drwav_uint64 totalSampleCount; + + vector> playBuffer; + bool loading = false; + bool play = false; + string lastPath = ""; - AudioFile audioFile; + + float samplePos = 0; float startPos = 0; vector displayBuff; + string fileDesc; bool fileLoaded = false; @@ -65,6 +80,7 @@ struct PLAYER : Module { SchmittTrigger nextinTrigger; SchmittTrigger previnTrigger; SchmittTrigger oscTrigger; + vector fichier; int sampnumber = 0; @@ -73,7 +89,10 @@ struct PLAYER : Module { bool oscState = false ; - PLAYER() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) { } + PLAYER() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) { + playBuffer.resize(2); + playBuffer[0].resize(0); + playBuffer[1].resize(0); } void step() override; @@ -98,29 +117,47 @@ json_object_set_new(rootJ, "oscstate", json_integer(oscState)); loadSample(lastPath); } - json_t *oscstateJ = json_object_get(rootJ, "oscstate"); - if (oscstateJ) { + json_t *oscstateJ = json_object_get(rootJ, "oscstate"); + if (oscstateJ) oscState = json_integer_value(oscstateJ); - } lights[OSC_LIGHT].value=oscState; + } }; void PLAYER::loadSample(std::string path) { - if (audioFile.load (path.c_str())) { + + loading = true; + unsigned int c; + unsigned int sr; + drwav_uint64 sc; + float* pSampleData; + pSampleData = drwav_open_and_read_file_f32(path.c_str(), &c, &sr, &sc); + + if (pSampleData != NULL) { + channels = c; + sampleRate = sr; + playBuffer[0].clear(); + playBuffer[1].clear(); + for (unsigned int i=0; i < sc; i = i + c) { + playBuffer[0].push_back(pSampleData[i]); + if (channels == 2) + playBuffer[1].push_back((float)pSampleData[i+1]); + + } + totalSampleCount = playBuffer[0].size(); + drwav_free(pSampleData); +loading = false; + + fileLoaded = true; vector().swap(displayBuff); - for (int i=0; i < audioFile.getNumSamplesPerChannel(); i = i + floor(audioFile.getNumSamplesPerChannel()/130)) { - displayBuff.push_back(audioFile.samples[0][i]); + for (int i=0; i < floor(totalSampleCount); i = i + floor(totalSampleCount/130)) { + displayBuff.push_back(playBuffer[0][i]); } fileDesc = stringFilename(path)+ "\n"; - fileDesc += std::to_string(audioFile.getSampleRate())+ " Hz" + " - "; //"\n"; - fileDesc += std::to_string(audioFile.getBitDepth())+ " bits" + " \n"; - // fileDesc += std::to_string(audioFile.getNumSamplesPerChannel())+ " smp" +"\n"; - // fileDesc += std::to_string(audioFile.getLengthInSeconds())+ " s." + "\n"; - fileDesc += std::to_string(audioFile.getNumChannels())+ " channel(s)" + "\n"; - // fileDesc += std::to_string(audioFile.isMono())+ "\n"; - // fileDesc += std::to_string(audioFile.isStereo())+ "\n"; + fileDesc += std::to_string(sampleRate)+ " Hz" + "\n"; + fileDesc += std::to_string(channels)+ " channel(s)" + "\n"; if (reload) { DIR* rep = NULL; @@ -135,26 +172,22 @@ void PLAYER::loadSample(std::string path) { std::size_t found = name.find(".wav",name.length()-5); if (found==std::string::npos) found = name.find(".WAV",name.length()-5); - if (found==std::string::npos) found = name.find(".aif",name.length()-5); - if (found==std::string::npos) found = name.find(".AIF",name.length()-5); - if (found==std::string::npos) found = name.find(".aiff",name.length()-5); - if (found==std::string::npos) found = name.find(".AIFF",name.length()-5); if (found!=std::string::npos) { fichier.push_back(name); if ((dir + "/" + name)==path) {sampnumber = i;} i=i+1; - } + } - } + } //----added by Joakim Lindbom - sort(fichier.begin(), fichier.end()); // Linux needs this to get files in right order - for (int o=0;o 0) sampnumber=sampnumber-1; else sampnumber =int(fichier.size()-1); loadSample(dir + "/" + fichier[sampnumber]); } - } else fileDesc = "right click to load \n .wav or .aif sample \n :)"; + } else fileDesc = "right click to load \n .wav sample \n :)"; if (oscTrigger.process(params[OSC_PARAM].value)) {oscState =!oscState;lights[OSC_LIGHT].value=oscState;} @@ -195,8 +228,8 @@ if (!oscState) { bool gated = inputs[GATE_INPUT].value > 0; if (inputs[POS_INPUT].active) - startPos = clamp((params[LSTART_PARAM].value + inputs[POS_INPUT].value * params[TSTART_PARAM].value),0.0f,10.0f)*audioFile.getNumSamplesPerChannel()/10; - else {startPos = clamp((params[LSTART_PARAM].value),0.0f,10.0f)*audioFile.getNumSamplesPerChannel()/10; + startPos = clamp((params[LSTART_PARAM].value + inputs[POS_INPUT].value * params[TSTART_PARAM].value),0.0f,10.0f)*totalSampleCount/10; + else {startPos = clamp((params[LSTART_PARAM].value),0.0f,10.0f)*totalSampleCount/10; inputs[POS_INPUT].value = 0 ; } @@ -212,18 +245,18 @@ if (!oscState) { } } - if ((play) && ((floor(samplePos) < audioFile.getNumSamplesPerChannel()) && (floor(samplePos) >= 0))) { - if (audioFile.getNumChannels() == 1) { - outputs[OUT_OUTPUT].value = 5 * audioFile.samples[0][floor(samplePos)]; - outputs[OUT2_OUTPUT].value = 5 * audioFile.samples[0][floor(samplePos)];} - else if (audioFile.getNumChannels() ==2) { - outputs[OUT_OUTPUT].value = 5 * audioFile.samples[0][floor(samplePos)]; - outputs[OUT2_OUTPUT].value = 5 * audioFile.samples[1][floor(samplePos)]; + if ((!loading) && (play) && ((floor(samplePos) < totalSampleCount) && (floor(samplePos) >= 0))) { + if (channels == 1) { + outputs[OUT_OUTPUT].value = 5 * playBuffer[0][floor(samplePos)]; + outputs[OUT2_OUTPUT].value = 5 * playBuffer[0][floor(samplePos)];} + else if (channels ==2) { + outputs[OUT_OUTPUT].value = 5 * playBuffer[0][floor(samplePos)]; + outputs[OUT2_OUTPUT].value = 5 * playBuffer[1][floor(samplePos)]; } if (inputs[SPD_INPUT].active) - samplePos = samplePos+1+(params[LSPEED_PARAM].value +inputs[SPD_INPUT].value * params[TSPEED_PARAM].value) /3; + samplePos = samplePos+powf(2.0, inputs[VO_INPUT].value)+(params[LSPEED_PARAM].value +inputs[SPD_INPUT].value * params[TSPEED_PARAM].value) /3; else { - samplePos = samplePos+1+(params[LSPEED_PARAM].value) /3; + samplePos = samplePos+powf(2.0, inputs[VO_INPUT].value)+(params[LSPEED_PARAM].value) /3; inputs[SPD_INPUT].value = 0 ;} } else @@ -234,20 +267,20 @@ if (!oscState) { if (!inputs[TRIG_INPUT].active) {if (gated == false) {play = false; outputs[OUT_OUTPUT].value = 0;outputs[OUT2_OUTPUT].value = 0;}} } else { - if (((floor(samplePos) < audioFile.getNumSamplesPerChannel()) && (floor(samplePos) >= 0))) { + if (((floor(samplePos) < totalSampleCount) && (floor(samplePos) >= 0))) { if (playTrigger.process(inputs[TRIG_INPUT].value)) samplePos = 0; - if (audioFile.getNumChannels() == 1) { - outputs[OUT_OUTPUT].value = 5 * audioFile.samples[0][floor(samplePos)]; - outputs[OUT2_OUTPUT].value = 5 * audioFile.samples[0][floor(samplePos)];} - else if (audioFile.getNumChannels() ==2) { - outputs[OUT_OUTPUT].value = 5 * audioFile.samples[0][floor(samplePos)]; - outputs[OUT2_OUTPUT].value = 5 * audioFile.samples[1][floor(samplePos)]; + if (channels == 1) { + outputs[OUT_OUTPUT].value = 5 * playBuffer[0][floor(samplePos)]; + outputs[OUT2_OUTPUT].value = 5 * playBuffer[0][floor(samplePos)];} + else if (channels ==2) { + outputs[OUT_OUTPUT].value = 5 * playBuffer[0][floor(samplePos)]; + outputs[OUT2_OUTPUT].value = 5 * playBuffer[1][floor(samplePos)]; } if (inputs[SPD_INPUT].active) - samplePos = samplePos+1+(params[LSPEED_PARAM].value +inputs[SPD_INPUT].value * params[TSPEED_PARAM].value) /3; + samplePos = samplePos+powf(2.0, inputs[VO_INPUT].value)+(params[LSPEED_PARAM].value +inputs[SPD_INPUT].value * params[TSPEED_PARAM].value) /3; else { - samplePos = samplePos+1+(params[LSPEED_PARAM].value) /3; + samplePos = samplePos+powf(2.0, inputs[VO_INPUT].value)+(params[LSPEED_PARAM].value) /3; inputs[SPD_INPUT].value = 0 ;} } else @@ -307,8 +340,8 @@ struct PLAYERDisplay : TransparentWidget { nvgStrokeWidth(vg, 0.8); { nvgBeginPath(vg); - nvgMoveTo(vg, floor(module->samplePos * 125 / module->audioFile.getNumSamplesPerChannel()) , 85); - nvgLineTo(vg, floor(module->samplePos * 125 / module->audioFile.getNumSamplesPerChannel()) , 165); + nvgMoveTo(vg, floor(module->samplePos * 125 / module->totalSampleCount) , 85); + nvgLineTo(vg, floor(module->samplePos * 125 / module->totalSampleCount) , 165); nvgClosePath(vg); } nvgStroke(vg); @@ -318,8 +351,8 @@ struct PLAYERDisplay : TransparentWidget { nvgStrokeWidth(vg, 1.5); { nvgBeginPath(vg); - nvgMoveTo(vg, floor(module->startPos * 125 / module->audioFile.getNumSamplesPerChannel()) , 85); - nvgLineTo(vg, floor(module->startPos * 125 / module->audioFile.getNumSamplesPerChannel()) , 165); + nvgMoveTo(vg, floor(module->startPos * 125 / module->totalSampleCount) , 85); + nvgLineTo(vg, floor(module->startPos * 125 / module->totalSampleCount) , 165); nvgClosePath(vg); } nvgStroke(vg); @@ -380,8 +413,8 @@ PLAYERWidget::PLAYERWidget(PLAYER *module) : ModuleWidget(module) { static const float portX0[4] = {10, 40, 70, 100}; - addParam(ParamWidget::create(Vec(23, 230), module, PLAYER::LSTART_PARAM, 0.0f, 10.0f, 0.0f)); - addParam(ParamWidget::create(Vec(73, 230), module, PLAYER::LSPEED_PARAM, -5.0f, 5.0f, 0.0f)); + addParam(ParamWidget::create(Vec(23, 235), module, PLAYER::LSTART_PARAM, 0.0f, 10.0f, 0.0f)); + addParam(ParamWidget::create(Vec(73, 235), module, PLAYER::LSPEED_PARAM, -5.0f, 5.0f, 0.0f)); addParam(ParamWidget::create(Vec(42, 278), module, PLAYER::TSTART_PARAM, -1.0f, 1.0f, 0.0f)); addParam(ParamWidget::create(Vec(73, 278), module, PLAYER::TSPEED_PARAM, -1.0f, 1.0f, 0.0f)); @@ -397,9 +430,9 @@ PLAYERWidget::PLAYERWidget(PLAYER *module) : ModuleWidget(module) { addParam(ParamWidget::create(Vec(43, 95), module, PLAYER::PREV_PARAM, 0.0f, 1.0f, 0.0f)); addParam(ParamWidget::create(Vec(73, 95), module, PLAYER::NEXT_PARAM, 0.0f, 1.0f, 0.0f)); - addParam(ParamWidget::create(Vec(11, 210), module, PLAYER::OSC_PARAM, 0.0, 1.0, 0.0)); - addChild(ModuleLightWidget::create>(Vec(15.4, 214.4), module, PLAYER::OSC_LIGHT)); - + addParam(ParamWidget::create(Vec(104, 212), module, PLAYER::OSC_PARAM, 0.0, 1.0, 0.0)); + addChild(ModuleLightWidget::create>(Vec(108.4, 216.4), module, PLAYER::OSC_LIGHT)); + addInput(Port::create(Vec(portX0[0], 210), Port::INPUT, module, PLAYER::VO_INPUT)); } struct PLAYERItem : MenuItem { diff --git a/plugins/community/repos/cf/src/SLIDERSEQ.cpp b/plugins/community/repos/cf/src/SLIDERSEQ.cpp index 3438bbe6..c2d4d628 100644 --- a/plugins/community/repos/cf/src/SLIDERSEQ.cpp +++ b/plugins/community/repos/cf/src/SLIDERSEQ.cpp @@ -13,6 +13,7 @@ struct SLIDERSEQ : Module { enum InputIds { RST_INPUT, UP_INPUT, +POS_INPUT, NUM_INPUTS }; enum OutputIds { @@ -21,19 +22,19 @@ struct SLIDERSEQ : Module { }; enum LightIds { OFFSET_LIGHT, - LED_LIGHT, - NUM_LIGHTS = LED_LIGHT + 16 + NUM_LIGHTS }; - int pas = 0; bool OFFSET_STATE = false ; SchmittTrigger rstTrigger; SchmittTrigger upTrigger; SchmittTrigger offsetTrigger; - +SchmittTrigger posTrigger; +float sl_pas ; +float sl_value ; SLIDERSEQ() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {} void step() override; @@ -64,31 +65,67 @@ void fromJson(json_t *rootJ) override { void SLIDERSEQ::step() { - +if (!inputs[POS_INPUT].active) { + if (rstTrigger.process(inputs[RST_INPUT].value)) + { + pas = -1; + } if (upTrigger.process(inputs[UP_INPUT].value)) { if (pas <15) pas = pas+1; else pas =0; } - if (rstTrigger.process(inputs[RST_INPUT].value)) - { - pas = 0; - } - for (int i = 0; i < 16; i++) - { - if (i==pas) lights[LED_LIGHT +i].value=1; else lights[LED_LIGHT +i].value= 0; - } +} else { pas = int(inputs[POS_INPUT].value*1.6); + if (pas<0) pas =0; + if (pas>15) pas =15; +}; if (offsetTrigger.process(params[OFFSET_PARAM].value)) {if (OFFSET_STATE == 0) OFFSET_STATE = 1; else OFFSET_STATE = 0;} if (OFFSET_STATE==1) lights[OFFSET_LIGHT].value=true; else lights[OFFSET_LIGHT].value=false; - outputs[TR_OUTPUT].value=params[LVL_PARAM +pas].value*10-OFFSET_STATE*5.0; + +if (pas>-1) { + sl_pas=pas; sl_value = params[LVL_PARAM +pas].value ; + outputs[TR_OUTPUT].value=params[LVL_PARAM +pas].value*10-OFFSET_STATE*5.0;} + else { + sl_pas=0; sl_value = params[LVL_PARAM +0].value ; + outputs[TR_OUTPUT].value=params[LVL_PARAM +0].value*10-OFFSET_STATE*5.0;} } +struct SLDisplay : TransparentWidget { + + float *pp ; + float *vv; + + SLDisplay() { + + } + + void draw(NVGcontext *vg) { + + float xx = (int(*pp)%8) ; + float yy = int(*pp/8)-*vv/2 ; + + + nvgBeginPath(vg); + nvgRect(vg, xx*15,65+yy*125, 4.5,10.5); + nvgFillColor(vg, nvgRGBA(0x4c, 0xc7, 0xf3, 0xff)); + nvgFill(vg); + nvgBeginPath(vg); + nvgRoundedRect(vg, xx*15-3,65+yy*125-3, 10.5,16.5,2.0); + nvgFillColor(vg, nvgRGBA(0x4c, 0xc7, 0xf3, 0x30)); + nvgFill(vg); + nvgBeginPath(vg); + nvgRoundedRect(vg, xx*15-6,65+yy*125-6, 16.5,22.5,4.0); + nvgFillColor(vg, nvgRGBA(0x4c, 0xc7, 0xf3, 0x10)); + nvgFill(vg); + + } +}; struct SLIDERSEQWidget : ModuleWidget { SLIDERSEQWidget(SLIDERSEQ *module); @@ -102,25 +139,33 @@ SLIDERSEQWidget::SLIDERSEQWidget(SLIDERSEQ *module) : ModuleWidget(module) { addChild(Widget::create(Vec(15, 365))); addChild(Widget::create(Vec(box.size.x-30, 365))); - addInput(Port::create(Vec(14, 320), Port::INPUT, module, SLIDERSEQ::RST_INPUT)); - addInput(Port::create(Vec(43, 320), Port::INPUT, module, SLIDERSEQ::UP_INPUT)); - addOutput(Port::create(Vec(96, 320), Port::OUTPUT, module, SLIDERSEQ::TR_OUTPUT)); - + addInput(Port::create(Vec(10, 320), Port::INPUT, module, SLIDERSEQ::RST_INPUT)); + addInput(Port::create(Vec(39, 320), Port::INPUT, module, SLIDERSEQ::UP_INPUT)); + addOutput(Port::create(Vec(100, 320), Port::OUTPUT, module, SLIDERSEQ::TR_OUTPUT)); + //addParam(ParamWidget::create(Vec(74, 322), module, SLIDERSEQ::OFFSET_PARAM, 0.0f, 1.0f, 0.0f)); - addParam(ParamWidget::create(Vec(72, 323), module, SLIDERSEQ::OFFSET_PARAM, 0.0, 1.0, 0.0)); - addChild(ModuleLightWidget::create>(Vec(76.4, 327.4), module, SLIDERSEQ::OFFSET_LIGHT)); + addParam(ParamWidget::create(Vec(84, 288), module, SLIDERSEQ::OFFSET_PARAM, 0.0, 1.0, 0.0)); + addChild(ModuleLightWidget::create>(Vec(88.4, 292.4), module, SLIDERSEQ::OFFSET_LIGHT)); for (int i = 0; i < 8; i++) { - addParam(ParamWidget::create(Vec(4+i*15, 30+ 30), module, SLIDERSEQ::LVL_PARAM+i, 0.0, 1.0, 0.0)); - addChild(ModuleLightWidget::create>(Vec(10+i*15, 30+ 115), module, SLIDERSEQ::LED_LIGHT + i)); + addParam(ParamWidget::create(Vec(4+i*15, 30+ 30), module, SLIDERSEQ::LVL_PARAM+i, 0.0, 1.0, 0.0)); + //addChild(ModuleLightWidget::create>(Vec(10+i*15, 30+ 115), module, SLIDERSEQ::LED_LIGHT + i)); } for (int i = 8; i < 16; i++) { - addParam(ParamWidget::create(Vec(4+(i-8)*15, 30+ 155), module, SLIDERSEQ::LVL_PARAM+i, 0.0, 1.0, 0.0)); - addChild(ModuleLightWidget::create>(Vec(10+(i-8)*15, 30+ 240), module, SLIDERSEQ::LED_LIGHT + i)); + addParam(ParamWidget::create(Vec(4+(i-8)*15, 30+ 155), module, SLIDERSEQ::LVL_PARAM+i, 0.0, 1.0, 0.0)); + //addChild(ModuleLightWidget::create>(Vec(10+(i-8)*15, 30+ 240), module, SLIDERSEQ::LED_LIGHT + i)); } - + + { + SLDisplay *pdisplay = new SLDisplay(); + pdisplay->box.pos = Vec(12, 61); + pdisplay->pp = &module->sl_pas; + pdisplay->vv = &module->sl_value; + addChild(pdisplay); + } + addInput(Port::create(Vec(68, 320), Port::INPUT, module, SLIDERSEQ::POS_INPUT)); } } // namespace rack_plugin_cf diff --git a/plugins/community/repos/cf/src/STEREO.cpp b/plugins/community/repos/cf/src/STEREO.cpp index d6a951fa..813dc2d6 100644 --- a/plugins/community/repos/cf/src/STEREO.cpp +++ b/plugins/community/repos/cf/src/STEREO.cpp @@ -6,8 +6,8 @@ namespace rack_plugin_cf { struct STEREO : Module { enum ParamIds { PAN_PARAM, - GAIN_PARAM, - SOLO_PARAM, + GAIN_PARAM, + SOLO_PARAM, ON_PARAM, NUM_PARAMS }; @@ -40,23 +40,23 @@ struct STEREO : Module { }; - float SIGNAL1 = 0.0 ; - float SIGNAL2 = 0.0 ; - bool ON_STATE = false ; - bool SOLO_STATE = false ; - bool soloed = false; - int lightState[11] = {}; - int cligno =0; - int retard =0; - int retard2 =0; - SchmittTrigger onTrigger; - SchmittTrigger oninTrigger; - SchmittTrigger soloTrigger; - SchmittTrigger soloinTrigger; - float or_gain ; - int or_affi ; - float orp_gain ; - int orp_affi ; +float SIGNAL1 = 0.0 ; +float SIGNAL2 = 0.0 ; +bool ON_STATE = false ; +bool SOLO_STATE = false ; +bool soloed = false; +int lightState[11] = {}; +int cligno =0; +int retard =0; +int retard2 =0; +SchmittTrigger onTrigger; +SchmittTrigger oninTrigger; +SchmittTrigger soloTrigger; +SchmittTrigger soloinTrigger; +float or_gain ; +int or_affi ; +float orp_gain ; +int orp_affi ; STEREO() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {onReset();} void step() override; diff --git a/plugins/community/repos/cf/src/SUB.cpp b/plugins/community/repos/cf/src/SUB.cpp index 0979b41b..10aa1ea0 100644 --- a/plugins/community/repos/cf/src/SUB.cpp +++ b/plugins/community/repos/cf/src/SUB.cpp @@ -6,9 +6,9 @@ namespace rack_plugin_cf { struct SUB : Module { enum ParamIds { - GAIN_PARAM, + GAIN_PARAM, GAIN2_PARAM, - LINK_PARAM, + LINK_PARAM, NUM_PARAMS }; enum InputIds { @@ -33,24 +33,24 @@ struct SUB : Module { }; - float SIGNAL = 0.0 ; - float SIGNAL2 = 0.0 ; - float or_gain ; - float or2_gain ; - int or_affi ; - int or2_affi ; - bool LINK_STATE = false ; - SchmittTrigger linkTrigger; +float SIGNAL = 0.0 ; +float SIGNAL2 = 0.0 ; +float or_gain ; +float or2_gain ; +int or_affi ; +int or2_affi ; +bool LINK_STATE = false ; +SchmittTrigger linkTrigger; SUB() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {reset();} void step() override; - void reset() override { - LINK_STATE = false; - } - - json_t *toJson() override { +void reset() override { + LINK_STATE = false; + } + +json_t *toJson() override { json_t *rootJ = json_object(); // solo json_object_set_new(rootJ, "linkstate", json_integer(LINK_STATE)); @@ -76,26 +76,26 @@ void SUB::step() { {LINK_STATE=!LINK_STATE;} lights[LINK_LIGHT].value=LINK_STATE; - - SIGNAL = inputs[IN1_INPUT].value ; + + SIGNAL = inputs[IN1_INPUT].value ; outputs[OUT1_OUTPUT].value = SIGNAL; - + if (!inputs[GAIN_INPUT].active) - {SIGNAL = SIGNAL * params[GAIN_PARAM].value/10.0 ;or_affi=0;} - else {SIGNAL = SIGNAL * clamp(inputs[GAIN_INPUT].value/10.0f,0.0f,1.0f) ; or_affi=1;or_gain=clamp(inputs[GAIN_INPUT].value,0.0f,10.0f);} + {SIGNAL = SIGNAL * params[GAIN_PARAM].value/10.0 ;or_affi=0;} + else {SIGNAL = SIGNAL * clamp(inputs[GAIN_INPUT].value/10.0f,0.0f,1.0f) ; or_affi=1;or_gain=clamp(inputs[GAIN_INPUT].value,0.0f,10.0f);} outputs[M1_OUTPUT].value = inputs[M1_INPUT].value + SIGNAL; - SIGNAL2 = inputs[IN2_INPUT].value ; - + SIGNAL2 = inputs[IN2_INPUT].value ; + outputs[OUT2_OUTPUT].value = SIGNAL2; - + if (!LINK_STATE) { if (!inputs[GAIN2_INPUT].active) {SIGNAL2 = SIGNAL2 * params[GAIN2_PARAM].value/10.0 ;or2_affi=0;} - else {SIGNAL2 = SIGNAL2 * clamp(inputs[GAIN2_INPUT].value/10.0f,0.0f,1.0f) ; or2_affi=1;or2_gain=clamp(inputs[GAIN2_INPUT].value,0.0f,10.0f);} + else {SIGNAL2 = SIGNAL2 * clamp(inputs[GAIN2_INPUT].value/10.0f,0.0f,1.0f) ; or2_affi=1;or2_gain=clamp(inputs[GAIN2_INPUT].value,0.0f,10.0f);} } else { if (!inputs[GAIN_INPUT].active) {SIGNAL2 = SIGNAL2 * params[GAIN_PARAM].value/10.0 ;or2_affi=1;or2_gain=clamp(params[GAIN_PARAM].value,0.0f,10.0f);} @@ -155,11 +155,11 @@ SUBWidget::SUBWidget(SUB *module) : ModuleWidget(module) { addChild(Widget::create(Vec(15, 365))); addChild(Widget::create(Vec(box.size.x-30, 365))); - addParam(ParamWidget::create(Vec(22, 179), module, SUB::LINK_PARAM, 0.0, 1.0, 0.0)); + addParam(ParamWidget::create(Vec(22, 179), module, SUB::LINK_PARAM, 0.0, 1.0, 0.0)); addChild(ModuleLightWidget::create>(Vec(26.5, 182.5), module, SUB::LINK_LIGHT)); - addParam(ParamWidget::create(Vec(27, 247), module, SUB::GAIN2_PARAM, 0.0, 10.0, 0.0)); + addParam(ParamWidget::create(Vec(27, 247), module, SUB::GAIN2_PARAM, 0.0, 10.0, 0.0)); addInput(Port::create(Vec(11, 281), Port::INPUT, module, SUB::GAIN2_INPUT)); { MOTORPOTDisplay *display2 = new MOTORPOTDisplay(); @@ -183,7 +183,8 @@ SUBWidget::SUBWidget(SUB *module) : ModuleWidget(module) { addInput(Port::create(Vec(11, 61+152), Port::INPUT, module, SUB::M2_INPUT)); - addParam(ParamWidget::create(Vec(27, 247-182), module, SUB::GAIN_PARAM, 0.0, 10.0, 0.0)); + + addParam(ParamWidget::create(Vec(27, 247-182), module, SUB::GAIN_PARAM, 0.0, 10.0, 0.0)); addInput(Port::create(Vec(11, 281-182), Port::INPUT, module, SUB::GAIN_INPUT)); { MOTORPOTDisplay *display = new MOTORPOTDisplay(); @@ -195,13 +196,18 @@ SUBWidget::SUBWidget(SUB *module) : ModuleWidget(module) { } + addInput(Port::create(Vec(11, 321-182), Port::INPUT, module, SUB::IN1_INPUT)); addOutput(Port::create(Vec(54, 321-182), Port::OUTPUT, module, SUB::OUT1_OUTPUT)); + addOutput(Port::create(Vec(54, 31), Port::OUTPUT, module, SUB::M1_OUTPUT)); + addInput(Port::create(Vec(11, 31), Port::INPUT, module, SUB::M1_INPUT)); + + } } // namespace rack_plugin_cf diff --git a/plugins/community/repos/cf/src/VARIABLE.cpp b/plugins/community/repos/cf/src/VARIABLE.cpp new file mode 100644 index 00000000..04525afd --- /dev/null +++ b/plugins/community/repos/cf/src/VARIABLE.cpp @@ -0,0 +1,189 @@ +#include "cf.hpp" +#include "dsp/digital.hpp" +//#include "cmath" + + + + +using namespace std; + +namespace rack_plugin_cf { + +struct VARIABLE : Module { + enum ParamIds { + PREV_PARAM, + NEXT_PARAM, + HOLD_PARAM, + VARIABLE_PARAM, + NUM_PARAMS + }; + enum InputIds { + IN_INPUT, + TRIG_INPUT, + NUM_INPUTS + }; + enum OutputIds { + OUT_OUTPUT, + NUM_OUTPUTS + }; + enum LightIds { + HOLD_LIGHT, + NUM_LIGHTS + }; + + + bool lock = false ; + bool plugged = false ; + float value = 0; + SchmittTrigger trigTrigger; + SchmittTrigger holdTrigger; + SchmittTrigger nextTrigger; + SchmittTrigger prevTrigger; + +VARIABLE() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) { } + + void step() override; + +json_t *toJson() override { + json_t *rootJ = json_object(); + + json_object_set_new(rootJ, "loc", json_integer(lock)); + json_object_set_new(rootJ, "plu", json_integer(plugged)); + json_object_set_new(rootJ, "val", json_real(value)); + return rootJ; + } + +void fromJson(json_t *rootJ) override { + + json_t *locJ = json_object_get(rootJ, "loc"); + if (locJ) + lock = json_integer_value(locJ); + + json_t *pluJ = json_object_get(rootJ, "plu"); + if (pluJ) + plugged = json_integer_value(pluJ); + + json_t *valJ = json_object_get(rootJ, "val"); + if (valJ) + value = json_real_value(valJ); + + } +}; + + + +void VARIABLE::step() { + + if (inputs[IN_INPUT].active & !plugged) {plugged = true; lock = false;} + if (!inputs[IN_INPUT].active) {plugged = false;} + + if (inputs[IN_INPUT].active & !lock) value = inputs[IN_INPUT].value; + + + if ( ( holdTrigger.process(params[HOLD_PARAM].value) || trigTrigger.process(inputs[TRIG_INPUT].value) ) & inputs[IN_INPUT].active) + { + value = inputs[IN_INPUT].value; + lock = true; + } + + + if (nextTrigger.process(params[NEXT_PARAM].value)) + { + if ((value<0)&(value!=int(value))) value = int(value) ; else value = int(value+1); + } + + + if (prevTrigger.process(params[PREV_PARAM].value)) + { + if ((value>=0)&(value!=int(value))) value = int(value) ; else value = int(value-1); + } + + + lights[HOLD_LIGHT].value = lock ; + outputs[OUT_OUTPUT].value = value ; + +} + +struct upButton : SVGSwitch, MomentarySwitch { + upButton() { + addFrame(SVG::load(assetPlugin(plugin, "res/upButton.svg"))); + addFrame(SVG::load(assetPlugin(plugin, "res/upButtonDown.svg"))); + sw->wrap(); + box.size = sw->box.size; + } +}; +struct downButton : SVGSwitch, MomentarySwitch { + downButton() { + addFrame(SVG::load(assetPlugin(plugin, "res/downButton.svg"))); + addFrame(SVG::load(assetPlugin(plugin, "res/downButtonDown.svg"))); + sw->wrap(); + box.size = sw->box.size; + } +}; + +struct VARIABLEDisplay : TransparentWidget { + VARIABLE *module; + + int frame = 0; + shared_ptr font; + + VARIABLEDisplay() { + font = Font::load(assetPlugin(plugin, "res/LEDCalculator.ttf")); + } + + void draw(NVGcontext *vg) override { + std::string to_display = ""; + std::string fileDesc = ""; + if (module->value>=0) + fileDesc = "+" + std::to_string(module->value); else fileDesc = std::to_string(module->value); + for (int i=0; i<9; i++) to_display = to_display + fileDesc[i]; + nvgFontSize(vg, 24); + nvgFontFaceId(vg, font->handle); + nvgTextLetterSpacing(vg, 0); + nvgFillColor(vg, nvgRGBA(0x4c, 0xc7, 0xf3, 0xff)); + nvgRotate(vg, -M_PI / 2.0f); + nvgTextBox(vg, 5, 5,350, to_display.c_str(), NULL); + } +}; + + +struct VARIABLEWidget : ModuleWidget { + VARIABLEWidget(VARIABLE *module); + +}; + +VARIABLEWidget::VARIABLEWidget(VARIABLE *module) : ModuleWidget(module) { + setPanel(SVG::load(assetPlugin(plugin, "res/VARIABLE.svg"))); + + + { + VARIABLEDisplay *gdisplay = new VARIABLEDisplay(); + gdisplay->module = module; + gdisplay->box.pos = Vec(18, 268); + gdisplay->box.size = Vec(130, 250); + addChild(gdisplay); + } + + + addChild(Widget::create(Vec(15, 0))); + addChild(Widget::create(Vec(box.size.x-30, 365))); + + addInput(Port::create(Vec(3, 31), Port::INPUT, module, VARIABLE::IN_INPUT)); + addInput(Port::create(Vec(3, 96), Port::INPUT, module, VARIABLE::TRIG_INPUT)); + addParam(ParamWidget::create(Vec(6, 66+3), module, VARIABLE::HOLD_PARAM, 0.0f, 1.0f, 0.0f)); + addChild(ModuleLightWidget::create>(Vec(6+4.4, 69+4.4), module, VARIABLE::HOLD_LIGHT)); + + addOutput(Port::create(Vec(3, 321), Port::OUTPUT, module, VARIABLE::OUT_OUTPUT)); + + addParam(ParamWidget::create(Vec(6, 296+2), module, VARIABLE::PREV_PARAM, 0.0f, 1.0f, 0.0f)); + addParam(ParamWidget::create(Vec(6, 276+2), module, VARIABLE::NEXT_PARAM, 0.0f, 1.0f, 0.0f)); +} + +} // namespace rack_plugin_cf + +using namespace rack_plugin_cf; + +RACK_PLUGIN_MODEL_INIT(cf, VARIABLE) { + Model *modelVARIABLE = Model::create("cf", "VARIABLE", "Variable", UTILITY_TAG); + return modelVARIABLE; +} diff --git a/plugins/community/repos/cf/src/cf.cpp b/plugins/community/repos/cf/src/cf.cpp index bec0757c..6188a7d9 100644 --- a/plugins/community/repos/cf/src/cf.cpp +++ b/plugins/community/repos/cf/src/cf.cpp @@ -1,46 +1,59 @@ #include "cf.hpp" -RACK_PLUGIN_MODEL_DECLARE(cf, trSEQ); -RACK_PLUGIN_MODEL_DECLARE(cf, LEDSEQ); -RACK_PLUGIN_MODEL_DECLARE(cf, L3DS3Q); -RACK_PLUGIN_MODEL_DECLARE(cf, SLIDERSEQ); -RACK_PLUGIN_MODEL_DECLARE(cf, PLAYER); -RACK_PLUGIN_MODEL_DECLARE(cf, STEPS); -RACK_PLUGIN_MODEL_DECLARE(cf, METRO); +RACK_PLUGIN_MODEL_DECLARE(cf, ALGEBRA); +RACK_PLUGIN_MODEL_DECLARE(cf, BUFFER); +RACK_PLUGIN_MODEL_DECLARE(cf, CHOKE); +RACK_PLUGIN_MODEL_DECLARE(cf, CUBE); +RACK_PLUGIN_MODEL_DECLARE(cf, DAVE); +RACK_PLUGIN_MODEL_DECLARE(cf, DISTO); RACK_PLUGIN_MODEL_DECLARE(cf, EACH); RACK_PLUGIN_MODEL_DECLARE(cf, FOUR); -RACK_PLUGIN_MODEL_DECLARE(cf, PEAK); +RACK_PLUGIN_MODEL_DECLARE(cf, LEDS); +RACK_PLUGIN_MODEL_DECLARE(cf, L3DS3Q); +RACK_PLUGIN_MODEL_DECLARE(cf, LEDSEQ); +RACK_PLUGIN_MODEL_DECLARE(cf, MASTER); +RACK_PLUGIN_MODEL_DECLARE(cf, METRO); RACK_PLUGIN_MODEL_DECLARE(cf, MONO); +RACK_PLUGIN_MODEL_DECLARE(cf, PATCH); +RACK_PLUGIN_MODEL_DECLARE(cf, PEAK); +RACK_PLUGIN_MODEL_DECLARE(cf, PLAY); +RACK_PLUGIN_MODEL_DECLARE(cf, PLAYER); +RACK_PLUGIN_MODEL_DECLARE(cf, SLIDERSEQ); +RACK_PLUGIN_MODEL_DECLARE(cf, STEPS); RACK_PLUGIN_MODEL_DECLARE(cf, STEREO); -RACK_PLUGIN_MODEL_DECLARE(cf, MASTER); RACK_PLUGIN_MODEL_DECLARE(cf, SUB); -RACK_PLUGIN_MODEL_DECLARE(cf, CUBE); -RACK_PLUGIN_MODEL_DECLARE(cf, PATCH); -RACK_PLUGIN_MODEL_DECLARE(cf, LEDS); -RACK_PLUGIN_MODEL_DECLARE(cf, DAVE); +RACK_PLUGIN_MODEL_DECLARE(cf, trSEQ); +RACK_PLUGIN_MODEL_DECLARE(cf, VARIABLE); RACK_PLUGIN_INIT(cf) { RACK_PLUGIN_INIT_ID(); + RACK_PLUGIN_INIT_VERSION("0.6.7"); RACK_PLUGIN_INIT_WEBSITE("https://github.com/cfoulc/cf"); RACK_PLUGIN_INIT_MANUAL("https://github.com/cfoulc/cf/blob/master/README.md"); - RACK_PLUGIN_MODEL_ADD(cf, trSEQ); - RACK_PLUGIN_MODEL_ADD(cf, LEDSEQ); - RACK_PLUGIN_MODEL_ADD(cf, L3DS3Q); - RACK_PLUGIN_MODEL_ADD(cf, SLIDERSEQ); - RACK_PLUGIN_MODEL_ADD(cf, PLAYER); - RACK_PLUGIN_MODEL_ADD(cf, STEPS); - RACK_PLUGIN_MODEL_ADD(cf, METRO); - RACK_PLUGIN_MODEL_ADD(cf, EACH); - RACK_PLUGIN_MODEL_ADD(cf, FOUR); - RACK_PLUGIN_MODEL_ADD(cf, PEAK); - RACK_PLUGIN_MODEL_ADD(cf, MONO); - RACK_PLUGIN_MODEL_ADD(cf, STEREO); - RACK_PLUGIN_MODEL_ADD(cf, MASTER); - RACK_PLUGIN_MODEL_ADD(cf, SUB); - RACK_PLUGIN_MODEL_ADD(cf, CUBE); - RACK_PLUGIN_MODEL_ADD(cf, PATCH); - RACK_PLUGIN_MODEL_ADD(cf, LEDS); - RACK_PLUGIN_MODEL_ADD(cf, DAVE); + RACK_PLUGIN_MODEL_ADD(cf, ALGEBRA); + RACK_PLUGIN_MODEL_ADD(cf, BUFFER); + RACK_PLUGIN_MODEL_ADD(cf, CHOKE); + RACK_PLUGIN_MODEL_ADD(cf, CUBE); + RACK_PLUGIN_MODEL_ADD(cf, DAVE); + RACK_PLUGIN_MODEL_ADD(cf, DISTO); + RACK_PLUGIN_MODEL_ADD(cf, EACH); + RACK_PLUGIN_MODEL_ADD(cf, FOUR); + RACK_PLUGIN_MODEL_ADD(cf, LEDS); + RACK_PLUGIN_MODEL_ADD(cf, L3DS3Q); + RACK_PLUGIN_MODEL_ADD(cf, LEDSEQ); + RACK_PLUGIN_MODEL_ADD(cf, MASTER); + RACK_PLUGIN_MODEL_ADD(cf, METRO); + RACK_PLUGIN_MODEL_ADD(cf, MONO); + RACK_PLUGIN_MODEL_ADD(cf, PATCH); + RACK_PLUGIN_MODEL_ADD(cf, PEAK); + RACK_PLUGIN_MODEL_ADD(cf, PLAY); + RACK_PLUGIN_MODEL_ADD(cf, PLAYER); + RACK_PLUGIN_MODEL_ADD(cf, SLIDERSEQ); + RACK_PLUGIN_MODEL_ADD(cf, STEPS); + RACK_PLUGIN_MODEL_ADD(cf, STEREO); + RACK_PLUGIN_MODEL_ADD(cf, SUB); + RACK_PLUGIN_MODEL_ADD(cf, trSEQ); + RACK_PLUGIN_MODEL_ADD(cf, VARIABLE); } diff --git a/plugins/community/repos/cf/src/dr_wav.h b/plugins/community/repos/cf/src/dr_wav.h new file mode 100644 index 00000000..7b4ae921 --- /dev/null +++ b/plugins/community/repos/cf/src/dr_wav.h @@ -0,0 +1,3724 @@ +// WAV audio loader and writer. Public domain. See "unlicense" statement at the end of this file. +// dr_wav - v0.8.1 - 2018-06-29 +// +// David Reid - mackron@gmail.com + +// USAGE +// +// This is a single-file library. To use it, do something like the following in one .c file. +// #define DR_WAV_IMPLEMENTATION +// #include "dr_wav.h" +// +// You can then #include this file in other parts of the program as you would with any other header file. Do something +// like the following to read audio data: +// +// drwav wav; +// if (!drwav_init_file(&wav, "my_song.wav")) { +// // Error opening WAV file. +// } +// +// drwav_int32* pDecodedInterleavedSamples = malloc(wav.totalSampleCount * sizeof(drwav_int32)); +// size_t numberOfSamplesActuallyDecoded = drwav_read_s32(&wav, wav.totalSampleCount, pDecodedInterleavedSamples); +// +// ... +// +// drwav_uninit(&wav); +// +// You can also use drwav_open() to allocate and initialize the loader for you: +// +// drwav* pWav = drwav_open_file("my_song.wav"); +// if (pWav == NULL) { +// // Error opening WAV file. +// } +// +// ... +// +// drwav_close(pWav); +// +// If you just want to quickly open and read the audio data in a single operation you can do something like this: +// +// unsigned int channels; +// unsigned int sampleRate; +// drwav_uint64 totalSampleCount; +// float* pSampleData = drwav_open_and_read_file_s32("my_song.wav", &channels, &sampleRate, &totalSampleCount); +// if (pSampleData == NULL) { +// // Error opening and reading WAV file. +// } +// +// ... +// +// drwav_free(pSampleData); +// +// The examples above use versions of the API that convert the audio data to a consistent format (32-bit signed PCM, in +// this case), but you can still output the audio data in its internal format (see notes below for supported formats): +// +// size_t samplesRead = drwav_read(&wav, wav.totalSampleCount, pDecodedInterleavedSamples); +// +// You can also read the raw bytes of audio data, which could be useful if dr_wav does not have native support for +// a particular data format: +// +// size_t bytesRead = drwav_read_raw(&wav, bytesToRead, pRawDataBuffer); +// +// +// dr_wav has seamless support the Sony Wave64 format. The decoder will automatically detect it and it should Just Work +// without any manual intervention. +// +// +// dr_wav can also be used to output WAV files. This does not currently support compressed formats. To use this, look at +// drwav_open_write(), drwav_open_file_write(), etc. Use drwav_write() to write samples, or drwav_write_raw() to write +// raw data in the "data" chunk. +// +// drwav_data_format format; +// format.container = drwav_container_riff; // <-- drwav_container_riff = normal WAV files, drwav_container_w64 = Sony Wave64. +// format.format = DR_WAVE_FORMAT_PCM; // <-- Any of the DR_WAVE_FORMAT_* codes. +// format.channels = 2; +// format.sampleRate = 44100; +// format.bitsPerSample = 16; +// drwav* pWav = drwav_open_file_write("data/recording.wav", &format); +// +// ... +// +// drwav_uint64 samplesWritten = drwav_write(pWav, sampleCount, pSamples); +// +// +// +// OPTIONS +// #define these options before including this file. +// +// #define DR_WAV_NO_CONVERSION_API +// Disables conversion APIs such as drwav_read_f32() and drwav_s16_to_f32(). +// +// #define DR_WAV_NO_STDIO +// Disables drwav_open_file(), drwav_open_file_write(), etc. +// +// +// +// QUICK NOTES +// - Samples are always interleaved. +// - The default read function does not do any data conversion. Use drwav_read_f32() to read and convert audio data +// to IEEE 32-bit floating point samples, drwav_read_s32() to read samples as signed 32-bit PCM and drwav_read_s16() +// to read samples as signed 16-bit PCM. Tested and supported internal formats include the following: +// - Unsigned 8-bit PCM +// - Signed 12-bit PCM +// - Signed 16-bit PCM +// - Signed 24-bit PCM +// - Signed 32-bit PCM +// - IEEE 32-bit floating point +// - IEEE 64-bit floating point +// - A-law and u-law +// - Microsoft ADPCM +// - IMA ADPCM (DVI, format code 0x11) +// - dr_wav will try to read the WAV file as best it can, even if it's not strictly conformant to the WAV format. + + +#ifndef dr_wav_h +#define dr_wav_h + +#include + +#if defined(_MSC_VER) && _MSC_VER < 1600 +typedef signed char drwav_int8; +typedef unsigned char drwav_uint8; +typedef signed short drwav_int16; +typedef unsigned short drwav_uint16; +typedef signed int drwav_int32; +typedef unsigned int drwav_uint32; +typedef signed __int64 drwav_int64; +typedef unsigned __int64 drwav_uint64; +#else +#include +typedef int8_t drwav_int8; +typedef uint8_t drwav_uint8; +typedef int16_t drwav_int16; +typedef uint16_t drwav_uint16; +typedef int32_t drwav_int32; +typedef uint32_t drwav_uint32; +typedef int64_t drwav_int64; +typedef uint64_t drwav_uint64; +#endif +typedef drwav_uint8 drwav_bool8; +typedef drwav_uint32 drwav_bool32; +#define DRWAV_TRUE 1 +#define DRWAV_FALSE 0 + +/* #ifdef __cplusplus */ +/* extern "C" { */ +/* #endif */ + +// Common data formats. +#define DR_WAVE_FORMAT_PCM 0x1 +#define DR_WAVE_FORMAT_ADPCM 0x2 +#define DR_WAVE_FORMAT_IEEE_FLOAT 0x3 +#define DR_WAVE_FORMAT_ALAW 0x6 +#define DR_WAVE_FORMAT_MULAW 0x7 +#define DR_WAVE_FORMAT_DVI_ADPCM 0x11 +#define DR_WAVE_FORMAT_EXTENSIBLE 0xFFFE + +typedef enum +{ + drwav_seek_origin_start, + drwav_seek_origin_current +} drwav_seek_origin; + +typedef enum +{ + drwav_container_riff, + drwav_container_w64 +} drwav_container; + +// Callback for when data is read. Return value is the number of bytes actually read. +// +// pUserData [in] The user data that was passed to drwav_init(), drwav_open() and family. +// pBufferOut [out] The output buffer. +// bytesToRead [in] The number of bytes to read. +// +// Returns the number of bytes actually read. +// +// A return value of less than bytesToRead indicates the end of the stream. Do _not_ return from this callback until +// either the entire bytesToRead is filled or you have reached the end of the stream. +typedef size_t (* drwav_read_proc)(void* pUserData, void* pBufferOut, size_t bytesToRead); + +// Callback for when data is written. Returns value is the number of bytes actually written. +// +// pUserData [in] The user data that was passed to drwav_init_write(), drwav_open_write() and family. +// pData [out] A pointer to the data to write. +// bytesToWrite [in] The number of bytes to write. +// +// Returns the number of bytes actually written. +// +// If the return value differs from bytesToWrite, it indicates an error. +typedef size_t (* drwav_write_proc)(void* pUserData, const void* pData, size_t bytesToWrite); + +// Callback for when data needs to be seeked. +// +// pUserData [in] The user data that was passed to drwav_init(), drwav_open() and family. +// offset [in] The number of bytes to move, relative to the origin. Will never be negative. +// origin [in] The origin of the seek - the current position or the start of the stream. +// +// Returns whether or not the seek was successful. +// +// Whether or not it is relative to the beginning or current position is determined by the "origin" parameter which +// will be either drwav_seek_origin_start or drwav_seek_origin_current. +typedef drwav_bool32 (* drwav_seek_proc)(void* pUserData, int offset, drwav_seek_origin origin); + +// Structure for internal use. Only used for loaders opened with drwav_open_memory(). +typedef struct +{ + const drwav_uint8* data; + size_t dataSize; + size_t currentReadPos; +} drwav__memory_stream; + +// Structure for internal use. Only used for writers opened with drwav_open_memory_write(). +typedef struct +{ + void** ppData; + size_t* pDataSize; + size_t dataSize; + size_t dataCapacity; + size_t currentWritePos; +} drwav__memory_stream_write; + +typedef struct +{ + drwav_container container; // RIFF, W64. + drwav_uint32 format; // DR_WAVE_FORMAT_* + drwav_uint32 channels; + drwav_uint32 sampleRate; + drwav_uint32 bitsPerSample; +} drwav_data_format; + +typedef struct +{ + // The format tag exactly as specified in the wave file's "fmt" chunk. This can be used by applications + // that require support for data formats not natively supported by dr_wav. + drwav_uint16 formatTag; + + // The number of channels making up the audio data. When this is set to 1 it is mono, 2 is stereo, etc. + drwav_uint16 channels; + + // The sample rate. Usually set to something like 44100. + drwav_uint32 sampleRate; + + // Average bytes per second. You probably don't need this, but it's left here for informational purposes. + drwav_uint32 avgBytesPerSec; + + // Block align. This is equal to the number of channels * bytes per sample. + drwav_uint16 blockAlign; + + // Bits per sample. + drwav_uint16 bitsPerSample; + + // The size of the extended data. Only used internally for validation, but left here for informational purposes. + drwav_uint16 extendedSize; + + // The number of valid bits per sample. When is equal to WAVE_FORMAT_EXTENSIBLE, + // is always rounded up to the nearest multiple of 8. This variable contains information about exactly how + // many bits a valid per sample. Mainly used for informational purposes. + drwav_uint16 validBitsPerSample; + + // The channel mask. Not used at the moment. + drwav_uint32 channelMask; + + // The sub-format, exactly as specified by the wave file. + drwav_uint8 subFormat[16]; +} drwav_fmt; + +typedef struct +{ + // A pointer to the function to call when more data is needed. + drwav_read_proc onRead; + + // A pointer to the function to call when data needs to be written. Only used when the drwav object is opened in write mode. + drwav_write_proc onWrite; + + // A pointer to the function to call when the wav file needs to be seeked. + drwav_seek_proc onSeek; + + // The user data to pass to callbacks. + void* pUserData; + + + // Whether or not the WAV file is formatted as a standard RIFF file or W64. + drwav_container container; + + + // Structure containing format information exactly as specified by the wav file. + drwav_fmt fmt; + + // The sample rate. Will be set to something like 44100. + drwav_uint32 sampleRate; + + // The number of channels. This will be set to 1 for monaural streams, 2 for stereo, etc. + drwav_uint16 channels; + + // The bits per sample. Will be set to something like 16, 24, etc. + drwav_uint16 bitsPerSample; + + // The number of bytes per sample. + drwav_uint16 bytesPerSample; + + // Equal to fmt.formatTag, or the value specified by fmt.subFormat if fmt.formatTag is equal to 65534 (WAVE_FORMAT_EXTENSIBLE). + drwav_uint16 translatedFormatTag; + + // The total number of samples making up the audio data. Use * to calculate + // the required size of a buffer to hold the entire audio data. + drwav_uint64 totalSampleCount; + + + // The size in bytes of the data chunk. + drwav_uint64 dataChunkDataSize; + + // The position in the stream of the first byte of the data chunk. This is used for seeking. + drwav_uint64 dataChunkDataPos; + + // The number of bytes remaining in the data chunk. + drwav_uint64 bytesRemaining; + + + // Only used in sequential write mode. Keeps track of the desired size of the "data" chunk at the point of initialization time. Always + // set to 0 for non-sequential writes and when the drwav object is opened in read mode. Used for validation. + drwav_uint64 dataChunkDataSizeTargetWrite; + + // Keeps track of whether or not the wav writer was initialized in sequential mode. + drwav_bool32 isSequentialWrite; + + + // A hack to avoid a DRWAV_MALLOC() when opening a decoder with drwav_open_memory(). + drwav__memory_stream memoryStream; + drwav__memory_stream_write memoryStreamWrite; + + // Generic data for compressed formats. This data is shared across all block-compressed formats. + struct + { + drwav_uint64 iCurrentSample; // The index of the next sample that will be read by drwav_read_*(). This is used with "totalSampleCount" to ensure we don't read excess samples at the end of the last block. + } compressed; + + // Microsoft ADPCM specific data. + struct + { + drwav_uint32 bytesRemainingInBlock; + drwav_uint16 predictor[2]; + drwav_int32 delta[2]; + drwav_int32 cachedSamples[4]; // Samples are stored in this cache during decoding. + drwav_uint32 cachedSampleCount; + drwav_int32 prevSamples[2][2]; // The previous 2 samples for each channel (2 channels at most). + } msadpcm; + + // IMA ADPCM specific data. + struct + { + drwav_uint32 bytesRemainingInBlock; + drwav_int32 predictor[2]; + drwav_int32 stepIndex[2]; + drwav_int32 cachedSamples[16]; // Samples are stored in this cache during decoding. + drwav_uint32 cachedSampleCount; + } ima; +} drwav; + + +// Initializes a pre-allocated drwav object. +// +// onRead [in] The function to call when data needs to be read from the client. +// onSeek [in] The function to call when the read position of the client data needs to move. +// pUserData [in, optional] A pointer to application defined data that will be passed to onRead and onSeek. +// +// Returns true if successful; false otherwise. +// +// Close the loader with drwav_uninit(). +// +// This is the lowest level function for initializing a WAV file. You can also use drwav_init_file() and drwav_init_memory() +// to open the stream from a file or from a block of memory respectively. +// +// If you want dr_wav to manage the memory allocation for you, consider using drwav_open() instead. This will allocate +// a drwav object on the heap and return a pointer to it. +// +// See also: drwav_init_file(), drwav_init_memory(), drwav_uninit() +drwav_bool32 drwav_init(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData); + +// Initializes a pre-allocated drwav object for writing. +// +// onWrite [in] The function to call when data needs to be written. +// onSeek [in] The function to call when the write position needs to move. +// pUserData [in, optional] A pointer to application defined data that will be passed to onWrite and onSeek. +// +// Returns true if successful; false otherwise. +// +// Close the writer with drwav_uninit(). +// +// This is the lowest level function for initializing a WAV file. You can also use drwav_init_file() and drwav_init_memory() +// to open the stream from a file or from a block of memory respectively. +// +// If the total sample count is known, you can use drwav_init_write_sequential(). This avoids the need for dr_wav to perform +// a post-processing step for storing the total sample count and the size of the data chunk which requires a backwards seek. +// +// If you want dr_wav to manage the memory allocation for you, consider using drwav_open() instead. This will allocate +// a drwav object on the heap and return a pointer to it. +// +// See also: drwav_init_file_write(), drwav_init_memory_write(), drwav_uninit() +drwav_bool32 drwav_init_write(drwav* pWav, const drwav_data_format* pFormat, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData); +drwav_bool32 drwav_init_write_sequential(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_write_proc onWrite, void* pUserData); + +// Uninitializes the given drwav object. +// +// Use this only for objects initialized with drwav_init(). +void drwav_uninit(drwav* pWav); + + +// Opens a wav file using the given callbacks. +// +// onRead [in] The function to call when data needs to be read from the client. +// onSeek [in] The function to call when the read position of the client data needs to move. +// pUserData [in, optional] A pointer to application defined data that will be passed to onRead and onSeek. +// +// Returns null on error. +// +// Close the loader with drwav_close(). +// +// You can also use drwav_open_file() and drwav_open_memory() to open the stream from a file or from a block of +// memory respectively. +// +// This is different from drwav_init() in that it will allocate the drwav object for you via DRWAV_MALLOC() before +// initializing it. +// +// See also: drwav_open_file(), drwav_open_memory(), drwav_close() +drwav* drwav_open(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData); + +// Opens a wav file for writing using the given callbacks. +// +// onWrite [in] The function to call when data needs to be written. +// onSeek [in] The function to call when the write position needs to move. +// pUserData [in, optional] A pointer to application defined data that will be passed to onWrite and onSeek. +// +// Returns null on error. +// +// Close the loader with drwav_close(). +// +// You can also use drwav_open_file_write() and drwav_open_memory_write() to open the stream from a file or from a block +// of memory respectively. +// +// This is different from drwav_init_write() in that it will allocate the drwav object for you via DRWAV_MALLOC() before +// initializing it. +// +// See also: drwav_open_file_write(), drwav_open_memory_write(), drwav_close() +drwav* drwav_open_write(const drwav_data_format* pFormat, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData); +drwav* drwav_open_write_sequential(const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_write_proc onWrite, void* pUserData); + +// Uninitializes and deletes the the given drwav object. +// +// Use this only for objects created with drwav_open(). +void drwav_close(drwav* pWav); + + +// Reads raw audio data. +// +// This is the lowest level function for reading audio data. It simply reads the given number of +// bytes of the raw internal sample data. +// +// Consider using drwav_read_s16(), drwav_read_s32() or drwav_read_f32() for reading sample data in +// a consistent format. +// +// Returns the number of bytes actually read. +size_t drwav_read_raw(drwav* pWav, size_t bytesToRead, void* pBufferOut); + +// Reads a chunk of audio data in the native internal format. +// +// This is typically the most efficient way to retrieve audio data, but it does not do any format +// conversions which means you'll need to convert the data manually if required. +// +// If the return value is less than it means the end of the file has been reached or +// you have requested more samples than can possibly fit in the output buffer. +// +// This function will only work when sample data is of a fixed size and uncompressed. If you are +// using a compressed format consider using drwav_read_raw() or drwav_read_s16/s32/f32/etc(). +drwav_uint64 drwav_read(drwav* pWav, drwav_uint64 samplesToRead, void* pBufferOut); + +// Seeks to the given sample. +// +// Returns true if successful; false otherwise. +drwav_bool32 drwav_seek_to_sample(drwav* pWav, drwav_uint64 sample); + + +// Writes raw audio data. +// +// Returns the number of bytes actually written. If this differs from bytesToWrite, it indicates an error. +size_t drwav_write_raw(drwav* pWav, size_t bytesToWrite, const void* pData); + +// Writes audio data based on sample counts. +// +// Returns the number of samples written. +drwav_uint64 drwav_write(drwav* pWav, drwav_uint64 samplesToWrite, const void* pData); + + + +//// Conversion Utilities //// +#ifndef DR_WAV_NO_CONVERSION_API + +// Reads a chunk of audio data and converts it to signed 16-bit PCM samples. +// +// Returns the number of samples actually read. +// +// If the return value is less than it means the end of the file has been reached. +drwav_uint64 drwav_read_s16(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut); + +// Low-level function for converting unsigned 8-bit PCM samples to signed 16-bit PCM samples. +void drwav_u8_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount); + +// Low-level function for converting signed 24-bit PCM samples to signed 16-bit PCM samples. +void drwav_s24_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount); + +// Low-level function for converting signed 32-bit PCM samples to signed 16-bit PCM samples. +void drwav_s32_to_s16(drwav_int16* pOut, const drwav_int32* pIn, size_t sampleCount); + +// Low-level function for converting IEEE 32-bit floating point samples to signed 16-bit PCM samples. +void drwav_f32_to_s16(drwav_int16* pOut, const float* pIn, size_t sampleCount); + +// Low-level function for converting IEEE 64-bit floating point samples to signed 16-bit PCM samples. +void drwav_f64_to_s16(drwav_int16* pOut, const double* pIn, size_t sampleCount); + +// Low-level function for converting A-law samples to signed 16-bit PCM samples. +void drwav_alaw_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount); + +// Low-level function for converting u-law samples to signed 16-bit PCM samples. +void drwav_mulaw_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount); + + +// Reads a chunk of audio data and converts it to IEEE 32-bit floating point samples. +// +// Returns the number of samples actually read. +// +// If the return value is less than it means the end of the file has been reached. +drwav_uint64 drwav_read_f32(drwav* pWav, drwav_uint64 samplesToRead, float* pBufferOut); + +// Low-level function for converting unsigned 8-bit PCM samples to IEEE 32-bit floating point samples. +void drwav_u8_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount); + +// Low-level function for converting signed 16-bit PCM samples to IEEE 32-bit floating point samples. +void drwav_s16_to_f32(float* pOut, const drwav_int16* pIn, size_t sampleCount); + +// Low-level function for converting signed 24-bit PCM samples to IEEE 32-bit floating point samples. +void drwav_s24_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount); + +// Low-level function for converting signed 32-bit PCM samples to IEEE 32-bit floating point samples. +void drwav_s32_to_f32(float* pOut, const drwav_int32* pIn, size_t sampleCount); + +// Low-level function for converting IEEE 64-bit floating point samples to IEEE 32-bit floating point samples. +void drwav_f64_to_f32(float* pOut, const double* pIn, size_t sampleCount); + +// Low-level function for converting A-law samples to IEEE 32-bit floating point samples. +void drwav_alaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount); + +// Low-level function for converting u-law samples to IEEE 32-bit floating point samples. +void drwav_mulaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount); + + +// Reads a chunk of audio data and converts it to signed 32-bit PCM samples. +// +// Returns the number of samples actually read. +// +// If the return value is less than it means the end of the file has been reached. +drwav_uint64 drwav_read_s32(drwav* pWav, drwav_uint64 samplesToRead, drwav_int32* pBufferOut); + +// Low-level function for converting unsigned 8-bit PCM samples to signed 32-bit PCM samples. +void drwav_u8_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount); + +// Low-level function for converting signed 16-bit PCM samples to signed 32-bit PCM samples. +void drwav_s16_to_s32(drwav_int32* pOut, const drwav_int16* pIn, size_t sampleCount); + +// Low-level function for converting signed 24-bit PCM samples to signed 32-bit PCM samples. +void drwav_s24_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount); + +// Low-level function for converting IEEE 32-bit floating point samples to signed 32-bit PCM samples. +void drwav_f32_to_s32(drwav_int32* pOut, const float* pIn, size_t sampleCount); + +// Low-level function for converting IEEE 64-bit floating point samples to signed 32-bit PCM samples. +void drwav_f64_to_s32(drwav_int32* pOut, const double* pIn, size_t sampleCount); + +// Low-level function for converting A-law samples to signed 32-bit PCM samples. +void drwav_alaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount); + +// Low-level function for converting u-law samples to signed 32-bit PCM samples. +void drwav_mulaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount); + +#endif //DR_WAV_NO_CONVERSION_API + + +//// High-Level Convenience Helpers //// + +#ifndef DR_WAV_NO_STDIO + +// Helper for initializing a wave file using stdio. +// +// This holds the internal FILE object until drwav_uninit() is called. Keep this in mind if you're caching drwav +// objects because the operating system may restrict the number of file handles an application can have open at +// any given time. +drwav_bool32 drwav_init_file(drwav* pWav, const char* filename); + +// Helper for initializing a wave file for writing using stdio. +// +// This holds the internal FILE object until drwav_uninit() is called. Keep this in mind if you're caching drwav +// objects because the operating system may restrict the number of file handles an application can have open at +// any given time. +drwav_bool32 drwav_init_file_write(drwav* pWav, const char* filename, const drwav_data_format* pFormat); +drwav_bool32 drwav_init_file_write_sequential(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount); + +// Helper for opening a wave file using stdio. +// +// This holds the internal FILE object until drwav_close() is called. Keep this in mind if you're caching drwav +// objects because the operating system may restrict the number of file handles an application can have open at +// any given time. +drwav* drwav_open_file(const char* filename); + +// Helper for opening a wave file for writing using stdio. +// +// This holds the internal FILE object until drwav_close() is called. Keep this in mind if you're caching drwav +// objects because the operating system may restrict the number of file handles an application can have open at +// any given time. +drwav* drwav_open_file_write(const char* filename, const drwav_data_format* pFormat); +drwav* drwav_open_file_write_sequential(const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount); + +#endif //DR_WAV_NO_STDIO + +// Helper for initializing a loader from a pre-allocated memory buffer. +// +// This does not create a copy of the data. It is up to the application to ensure the buffer remains valid for +// the lifetime of the drwav object. +// +// The buffer should contain the contents of the entire wave file, not just the sample data. +drwav_bool32 drwav_init_memory(drwav* pWav, const void* data, size_t dataSize); + +// Helper for initializing a writer which outputs data to a memory buffer. +// +// dr_wav will manage the memory allocations, however it is up to the caller to free the data with drwav_free(). +// +// The buffer will remain allocated even after drwav_uninit() is called. Indeed, the buffer should not be +// considered valid until after drwav_uninit() has been called anyway. +drwav_bool32 drwav_init_memory_write(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat); +drwav_bool32 drwav_init_memory_write_sequential(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount); + +// Helper for opening a loader from a pre-allocated memory buffer. +// +// This does not create a copy of the data. It is up to the application to ensure the buffer remains valid for +// the lifetime of the drwav object. +// +// The buffer should contain the contents of the entire wave file, not just the sample data. +drwav* drwav_open_memory(const void* data, size_t dataSize); + +// Helper for opening a writer which outputs data to a memory buffer. +// +// dr_wav will manage the memory allocations, however it is up to the caller to free the data with drwav_free(). +// +// The buffer will remain allocated even after drwav_close() is called. Indeed, the buffer should not be +// considered valid until after drwav_close() has been called anyway. +drwav* drwav_open_memory_write(void** ppData, size_t* pDataSize, const drwav_data_format* pFormat); +drwav* drwav_open_memory_write_sequential(void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount); + + +#ifndef DR_WAV_NO_CONVERSION_API +// Opens and reads a wav file in a single operation. +drwav_int16* drwav_open_and_read_s16(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount); +float* drwav_open_and_read_f32(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount); +drwav_int32* drwav_open_and_read_s32(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount); +#ifndef DR_WAV_NO_STDIO +// Opens and decodes a wav file in a single operation. +drwav_int16* drwav_open_and_read_file_s16(const char* filename, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount); +float* drwav_open_and_read_file_f32(const char* filename, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount); +drwav_int32* drwav_open_and_read_file_s32(const char* filename, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount); +#endif + +// Opens and decodes a wav file from a block of memory in a single operation. +drwav_int16* drwav_open_and_read_memory_s16(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount); +float* drwav_open_and_read_memory_f32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount); +drwav_int32* drwav_open_and_read_memory_s32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount); +#endif + +// Frees data that was allocated internally by dr_wav. +void drwav_free(void* pDataReturnedByOpenAndRead); + +/* #ifdef __cplusplus */ +/* } */ +/* #endif */ +#endif // dr_wav_h + + +///////////////////////////////////////////////////// +// +// IMPLEMENTATION +// +///////////////////////////////////////////////////// + +#ifdef DR_WAV_IMPLEMENTATION +#include +#include // For memcpy(), memset() +#include // For INT_MAX + +#ifndef DR_WAV_NO_STDIO +#include +#endif + +// Standard library stuff. +#ifndef DRWAV_ASSERT +#include +#define DRWAV_ASSERT(expression) assert(expression) +#endif +#ifndef DRWAV_MALLOC +#define DRWAV_MALLOC(sz) malloc((sz)) +#endif +#ifndef DRWAV_REALLOC +#define DRWAV_REALLOC(p, sz) realloc((p), (sz)) +#endif +#ifndef DRWAV_FREE +#define DRWAV_FREE(p) free((p)) +#endif +#ifndef DRWAV_COPY_MEMORY +#define DRWAV_COPY_MEMORY(dst, src, sz) memcpy((dst), (src), (sz)) +#endif +#ifndef DRWAV_ZERO_MEMORY +#define DRWAV_ZERO_MEMORY(p, sz) memset((p), 0, (sz)) +#endif + +#define drwav_countof(x) (sizeof(x) / sizeof(x[0])) +#define drwav_align(x, a) ((((x) + (a) - 1) / (a)) * (a)) +#define drwav_min(a, b) (((a) < (b)) ? (a) : (b)) +#define drwav_max(a, b) (((a) > (b)) ? (a) : (b)) +#define drwav_clamp(x, lo, hi) (drwav_max((lo), drwav_min((hi), (x)))) + +#define drwav_assert DRWAV_ASSERT +#define drwav_copy_memory DRWAV_COPY_MEMORY +#define drwav_zero_memory DRWAV_ZERO_MEMORY + + +#define DRWAV_MAX_SIMD_VECTOR_SIZE 64 // 64 for AVX-512 in the future. + +#ifdef _MSC_VER +#define DRWAV_INLINE __forceinline +#else +#ifdef __GNUC__ +#define DRWAV_INLINE inline __attribute__((always_inline)) +#else +#define DRWAV_INLINE inline +#endif +#endif + +// I couldn't figure out where SIZE_MAX was defined for VC6. If anybody knows, let me know. +#if defined(_MSC_VER) && _MSC_VER <= 1200 + #if defined(_WIN64) + #define SIZE_MAX ((drwav_uint64)0xFFFFFFFFFFFFFFFF) + #else + #define SIZE_MAX 0xFFFFFFFF + #endif +#endif + +static const drwav_uint8 drwavGUID_W64_RIFF[16] = {0x72,0x69,0x66,0x66, 0x2E,0x91, 0xCF,0x11, 0xA5,0xD6, 0x28,0xDB,0x04,0xC1,0x00,0x00}; // 66666972-912E-11CF-A5D6-28DB04C10000 +static const drwav_uint8 drwavGUID_W64_WAVE[16] = {0x77,0x61,0x76,0x65, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A}; // 65766177-ACF3-11D3-8CD1-00C04F8EDB8A +static const drwav_uint8 drwavGUID_W64_JUNK[16] = {0x6A,0x75,0x6E,0x6B, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A}; // 6B6E756A-ACF3-11D3-8CD1-00C04F8EDB8A +static const drwav_uint8 drwavGUID_W64_FMT [16] = {0x66,0x6D,0x74,0x20, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A}; // 20746D66-ACF3-11D3-8CD1-00C04F8EDB8A +static const drwav_uint8 drwavGUID_W64_FACT[16] = {0x66,0x61,0x63,0x74, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A}; // 74636166-ACF3-11D3-8CD1-00C04F8EDB8A +static const drwav_uint8 drwavGUID_W64_DATA[16] = {0x64,0x61,0x74,0x61, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A}; // 61746164-ACF3-11D3-8CD1-00C04F8EDB8A + +static DRWAV_INLINE drwav_bool32 drwav__guid_equal(const drwav_uint8 a[16], const drwav_uint8 b[16]) +{ + const drwav_uint32* a32 = (const drwav_uint32*)a; + const drwav_uint32* b32 = (const drwav_uint32*)b; + + return + a32[0] == b32[0] && + a32[1] == b32[1] && + a32[2] == b32[2] && + a32[3] == b32[3]; +} + +static DRWAV_INLINE drwav_bool32 drwav__fourcc_equal(const unsigned char* a, const char* b) +{ + return + a[0] == b[0] && + a[1] == b[1] && + a[2] == b[2] && + a[3] == b[3]; +} + + + +static DRWAV_INLINE int drwav__is_little_endian() +{ + int n = 1; + return (*(char*)&n) == 1; +} + +static DRWAV_INLINE unsigned short drwav__bytes_to_u16(const unsigned char* data) +{ + if (drwav__is_little_endian()) { + return (data[0] << 0) | (data[1] << 8); + } else { + return (data[1] << 0) | (data[0] << 8); + } +} + +static DRWAV_INLINE short drwav__bytes_to_s16(const unsigned char* data) +{ + return (short)drwav__bytes_to_u16(data); +} + +static DRWAV_INLINE unsigned int drwav__bytes_to_u32(const unsigned char* data) +{ + if (drwav__is_little_endian()) { + return (data[0] << 0) | (data[1] << 8) | (data[2] << 16) | (data[3] << 24); + } else { + return (data[3] << 0) | (data[2] << 8) | (data[1] << 16) | (data[0] << 24); + } +} + +static DRWAV_INLINE drwav_uint64 drwav__bytes_to_u64(const unsigned char* data) +{ + if (drwav__is_little_endian()) { + return + ((drwav_uint64)data[0] << 0) | ((drwav_uint64)data[1] << 8) | ((drwav_uint64)data[2] << 16) | ((drwav_uint64)data[3] << 24) | + ((drwav_uint64)data[4] << 32) | ((drwav_uint64)data[5] << 40) | ((drwav_uint64)data[6] << 48) | ((drwav_uint64)data[7] << 56); + } else { + return + ((drwav_uint64)data[7] << 0) | ((drwav_uint64)data[6] << 8) | ((drwav_uint64)data[5] << 16) | ((drwav_uint64)data[4] << 24) | + ((drwav_uint64)data[3] << 32) | ((drwav_uint64)data[2] << 40) | ((drwav_uint64)data[1] << 48) | ((drwav_uint64)data[0] << 56); + } +} + +static DRWAV_INLINE void drwav__bytes_to_guid(const unsigned char* data, drwav_uint8* guid) +{ + for (int i = 0; i < 16; ++i) { + guid[i] = data[i]; + } +} + + +static DRWAV_INLINE drwav_bool32 drwav__is_compressed_format_tag(drwav_uint16 formatTag) +{ + return + formatTag == DR_WAVE_FORMAT_ADPCM || + formatTag == DR_WAVE_FORMAT_DVI_ADPCM; +} + + +drwav_uint64 drwav_read_s16__msadpcm(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut); +drwav_uint64 drwav_read_s16__ima(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut); +drwav_bool32 drwav_init_write__internal(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData); +drwav* drwav_open_write__internal(const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData); + +typedef struct +{ + union + { + drwav_uint8 fourcc[4]; + drwav_uint8 guid[16]; + } id; + + // The size in bytes of the chunk. + drwav_uint64 sizeInBytes; + + // RIFF = 2 byte alignment. + // W64 = 8 byte alignment. + unsigned int paddingSize; + +} drwav__chunk_header; + +static drwav_bool32 drwav__read_chunk_header(drwav_read_proc onRead, void* pUserData, drwav_container container, drwav_uint64* pRunningBytesReadOut, drwav__chunk_header* pHeaderOut) +{ + if (container == drwav_container_riff) { + if (onRead(pUserData, pHeaderOut->id.fourcc, 4) != 4) { + return DRWAV_FALSE; + } + + unsigned char sizeInBytes[4]; + if (onRead(pUserData, sizeInBytes, 4) != 4) { + return DRWAV_FALSE; + } + + pHeaderOut->sizeInBytes = drwav__bytes_to_u32(sizeInBytes); + pHeaderOut->paddingSize = (unsigned int)(pHeaderOut->sizeInBytes % 2); + *pRunningBytesReadOut += 8; + } else { + if (onRead(pUserData, pHeaderOut->id.guid, 16) != 16) { + return DRWAV_FALSE; + } + + unsigned char sizeInBytes[8]; + if (onRead(pUserData, sizeInBytes, 8) != 8) { + return DRWAV_FALSE; + } + + pHeaderOut->sizeInBytes = drwav__bytes_to_u64(sizeInBytes) - 24; // <-- Subtract 24 because w64 includes the size of the header. + pHeaderOut->paddingSize = (unsigned int)(pHeaderOut->sizeInBytes % 8); + *pRunningBytesReadOut += 24; + } + + return DRWAV_TRUE; +} + +static drwav_bool32 drwav__seek_forward(drwav_seek_proc onSeek, drwav_uint64 offset, void* pUserData) +{ + drwav_uint64 bytesRemainingToSeek = offset; + while (bytesRemainingToSeek > 0) { + if (bytesRemainingToSeek > 0x7FFFFFFF) { + if (!onSeek(pUserData, 0x7FFFFFFF, drwav_seek_origin_current)) { + return DRWAV_FALSE; + } + bytesRemainingToSeek -= 0x7FFFFFFF; + } else { + if (!onSeek(pUserData, (int)bytesRemainingToSeek, drwav_seek_origin_current)) { + return DRWAV_FALSE; + } + bytesRemainingToSeek = 0; + } + } + + return DRWAV_TRUE; +} + + +static drwav_bool32 drwav__read_fmt(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, drwav_container container, drwav_uint64* pRunningBytesReadOut, drwav_fmt* fmtOut) +{ + drwav__chunk_header header; + if (!drwav__read_chunk_header(onRead, pUserData, container, pRunningBytesReadOut, &header)) { + return DRWAV_FALSE; + } + + + // Skip non-fmt chunks. + if ((container == drwav_container_riff && !drwav__fourcc_equal(header.id.fourcc, "fmt ")) || (container == drwav_container_w64 && !drwav__guid_equal(header.id.guid, drwavGUID_W64_FMT))) { + if (!drwav__seek_forward(onSeek, header.sizeInBytes + header.paddingSize, pUserData)) { + return DRWAV_FALSE; + } + *pRunningBytesReadOut += header.sizeInBytes + header.paddingSize; + + return drwav__read_fmt(onRead, onSeek, pUserData, container, pRunningBytesReadOut, fmtOut); + } + + + // Validation. + if (container == drwav_container_riff) { + if (!drwav__fourcc_equal(header.id.fourcc, "fmt ")) { + return DRWAV_FALSE; + } + } else { + if (!drwav__guid_equal(header.id.guid, drwavGUID_W64_FMT)) { + return DRWAV_FALSE; + } + } + + + unsigned char fmt[16]; + if (onRead(pUserData, fmt, sizeof(fmt)) != sizeof(fmt)) { + return DRWAV_FALSE; + } + *pRunningBytesReadOut += sizeof(fmt); + + fmtOut->formatTag = drwav__bytes_to_u16(fmt + 0); + fmtOut->channels = drwav__bytes_to_u16(fmt + 2); + fmtOut->sampleRate = drwav__bytes_to_u32(fmt + 4); + fmtOut->avgBytesPerSec = drwav__bytes_to_u32(fmt + 8); + fmtOut->blockAlign = drwav__bytes_to_u16(fmt + 12); + fmtOut->bitsPerSample = drwav__bytes_to_u16(fmt + 14); + + fmtOut->extendedSize = 0; + fmtOut->validBitsPerSample = 0; + fmtOut->channelMask = 0; + memset(fmtOut->subFormat, 0, sizeof(fmtOut->subFormat)); + + if (header.sizeInBytes > 16) { + unsigned char fmt_cbSize[2]; + if (onRead(pUserData, fmt_cbSize, sizeof(fmt_cbSize)) != sizeof(fmt_cbSize)) { + return DRWAV_FALSE; // Expecting more data. + } + *pRunningBytesReadOut += sizeof(fmt_cbSize); + + int bytesReadSoFar = 18; + + fmtOut->extendedSize = drwav__bytes_to_u16(fmt_cbSize); + if (fmtOut->extendedSize > 0) { + // Simple validation. + if (fmtOut->formatTag == DR_WAVE_FORMAT_EXTENSIBLE) { + if (fmtOut->extendedSize != 22) { + return DRWAV_FALSE; + } + } + + if (fmtOut->formatTag == DR_WAVE_FORMAT_EXTENSIBLE) { + unsigned char fmtext[22]; + if (onRead(pUserData, fmtext, fmtOut->extendedSize) != fmtOut->extendedSize) { + return DRWAV_FALSE; // Expecting more data. + } + + fmtOut->validBitsPerSample = drwav__bytes_to_u16(fmtext + 0); + fmtOut->channelMask = drwav__bytes_to_u32(fmtext + 2); + drwav__bytes_to_guid(fmtext + 6, fmtOut->subFormat); + } else { + if (!onSeek(pUserData, fmtOut->extendedSize, drwav_seek_origin_current)) { + return DRWAV_FALSE; + } + } + *pRunningBytesReadOut += fmtOut->extendedSize; + + bytesReadSoFar += fmtOut->extendedSize; + } + + // Seek past any leftover bytes. For w64 the leftover will be defined based on the chunk size. + if (!onSeek(pUserData, (int)(header.sizeInBytes - bytesReadSoFar), drwav_seek_origin_current)) { + return DRWAV_FALSE; + } + *pRunningBytesReadOut += (header.sizeInBytes - bytesReadSoFar); + } + + if (header.paddingSize > 0) { + if (!onSeek(pUserData, header.paddingSize, drwav_seek_origin_current)) { + return DRWAV_FALSE; + } + *pRunningBytesReadOut += header.paddingSize; + } + + return DRWAV_TRUE; +} + + +#ifndef DR_WAV_NO_STDIO +FILE* drwav_fopen(const char* filePath, const char* openMode) +{ + FILE* pFile; +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (fopen_s(&pFile, filePath, openMode) != 0) { + return DRWAV_FALSE; + } +#else + pFile = fopen(filePath, openMode); + if (pFile == NULL) { + return DRWAV_FALSE; + } +#endif + + return pFile; +} + +static size_t drwav__on_read_stdio(void* pUserData, void* pBufferOut, size_t bytesToRead) +{ + return fread(pBufferOut, 1, bytesToRead, (FILE*)pUserData); +} + +static size_t drwav__on_write_stdio(void* pUserData, const void* pData, size_t bytesToWrite) +{ + return fwrite(pData, 1, bytesToWrite, (FILE*)pUserData); +} + +static drwav_bool32 drwav__on_seek_stdio(void* pUserData, int offset, drwav_seek_origin origin) +{ + return fseek((FILE*)pUserData, offset, (origin == drwav_seek_origin_current) ? SEEK_CUR : SEEK_SET) == 0; +} + +drwav_bool32 drwav_init_file(drwav* pWav, const char* filename) +{ + FILE* pFile = drwav_fopen(filename, "rb"); + if (pFile == NULL) { + return DRWAV_FALSE; + } + + return drwav_init(pWav, drwav__on_read_stdio, drwav__on_seek_stdio, (void*)pFile); +} + + +drwav_bool32 drwav_init_file_write__internal(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential) +{ + FILE* pFile = drwav_fopen(filename, "wb"); + if (pFile == NULL) { + return DRWAV_FALSE; + } + + return drwav_init_write__internal(pWav, pFormat, totalSampleCount, isSequential, drwav__on_write_stdio, drwav__on_seek_stdio, (void*)pFile); +} + +drwav_bool32 drwav_init_file_write(drwav* pWav, const char* filename, const drwav_data_format* pFormat) +{ + return drwav_init_file_write__internal(pWav, filename, pFormat, 0, DRWAV_FALSE); +} + +drwav_bool32 drwav_init_file_write_sequential(drwav* pWav, const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount) +{ + return drwav_init_file_write__internal(pWav, filename, pFormat, totalSampleCount, DRWAV_TRUE); +} + +drwav* drwav_open_file(const char* filename) +{ + FILE* pFile = drwav_fopen(filename, "rb"); + if (pFile == NULL) { + return DRWAV_FALSE; + } + + drwav* pWav = drwav_open(drwav__on_read_stdio, drwav__on_seek_stdio, (void*)pFile); + if (pWav == NULL) { + fclose(pFile); + return NULL; + } + + return pWav; +} + + +drwav* drwav_open_file_write__internal(const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential) +{ + FILE* pFile = drwav_fopen(filename, "wb"); + if (pFile == NULL) { + return DRWAV_FALSE; + } + + drwav* pWav = drwav_open_write__internal(pFormat, totalSampleCount, isSequential, drwav__on_write_stdio, drwav__on_seek_stdio, (void*)pFile); + if (pWav == NULL) { + fclose(pFile); + return NULL; + } + + return pWav; +} + +drwav* drwav_open_file_write(const char* filename, const drwav_data_format* pFormat) +{ + return drwav_open_file_write__internal(filename, pFormat, 0, DRWAV_FALSE); +} + +drwav* drwav_open_file_write_sequential(const char* filename, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount) +{ + return drwav_open_file_write__internal(filename, pFormat, totalSampleCount, DRWAV_TRUE); +} +#endif //DR_WAV_NO_STDIO + + +static size_t drwav__on_read_memory(void* pUserData, void* pBufferOut, size_t bytesToRead) +{ + drwav__memory_stream* memory = (drwav__memory_stream*)pUserData; + drwav_assert(memory != NULL); + drwav_assert(memory->dataSize >= memory->currentReadPos); + + size_t bytesRemaining = memory->dataSize - memory->currentReadPos; + if (bytesToRead > bytesRemaining) { + bytesToRead = bytesRemaining; + } + + if (bytesToRead > 0) { + DRWAV_COPY_MEMORY(pBufferOut, memory->data + memory->currentReadPos, bytesToRead); + memory->currentReadPos += bytesToRead; + } + + return bytesToRead; +} + +static drwav_bool32 drwav__on_seek_memory(void* pUserData, int offset, drwav_seek_origin origin) +{ + drwav__memory_stream* memory = (drwav__memory_stream*)pUserData; + drwav_assert(memory != NULL); + + if (origin == drwav_seek_origin_current) { + if (offset > 0) { + if (memory->currentReadPos + offset > memory->dataSize) { + offset = (int)(memory->dataSize - memory->currentReadPos); // Trying to seek too far forward. + } + } else { + if (memory->currentReadPos < (size_t)-offset) { + offset = -(int)memory->currentReadPos; // Trying to seek too far backwards. + } + } + + // This will never underflow thanks to the clamps above. + memory->currentReadPos += offset; + } else { + if ((drwav_uint32)offset <= memory->dataSize) { + memory->currentReadPos = offset; + } else { + memory->currentReadPos = memory->dataSize; // Trying to seek too far forward. + } + } + + return DRWAV_TRUE; +} + +static size_t drwav__on_write_memory(void* pUserData, const void* pDataIn, size_t bytesToWrite) +{ + drwav__memory_stream_write* memory = (drwav__memory_stream_write*)pUserData; + drwav_assert(memory != NULL); + drwav_assert(memory->dataCapacity >= memory->currentWritePos); + + size_t bytesRemaining = memory->dataCapacity - memory->currentWritePos; + if (bytesRemaining < bytesToWrite) { + // Need to reallocate. + size_t newDataCapacity = (memory->dataCapacity == 0) ? 256 : memory->dataCapacity * 2; + + // If doubling wasn't enough, just make it the minimum required size to write the data. + if ((newDataCapacity - memory->currentWritePos) < bytesToWrite) { + newDataCapacity = memory->currentWritePos + bytesToWrite; + } + + void* pNewData = DRWAV_REALLOC(*memory->ppData, newDataCapacity); + if (pNewData == NULL) { + return 0; + } + + *memory->ppData = pNewData; + memory->dataCapacity = newDataCapacity; + } + + drwav_uint8* pDataOut = (drwav_uint8*)(*memory->ppData); + DRWAV_COPY_MEMORY(pDataOut + memory->currentWritePos, pDataIn, bytesToWrite); + + memory->currentWritePos += bytesToWrite; + if (memory->dataSize < memory->currentWritePos) { + memory->dataSize = memory->currentWritePos; + } + + *memory->pDataSize = memory->dataSize; + + return bytesToWrite; +} + +static drwav_bool32 drwav__on_seek_memory_write(void* pUserData, int offset, drwav_seek_origin origin) +{ + drwav__memory_stream_write* memory = (drwav__memory_stream_write*)pUserData; + drwav_assert(memory != NULL); + + if (origin == drwav_seek_origin_current) { + if (offset > 0) { + if (memory->currentWritePos + offset > memory->dataSize) { + offset = (int)(memory->dataSize - memory->currentWritePos); // Trying to seek too far forward. + } + } else { + if (memory->currentWritePos < (size_t)-offset) { + offset = -(int)memory->currentWritePos; // Trying to seek too far backwards. + } + } + + // This will never underflow thanks to the clamps above. + memory->currentWritePos += offset; + } else { + if ((drwav_uint32)offset <= memory->dataSize) { + memory->currentWritePos = offset; + } else { + memory->currentWritePos = memory->dataSize; // Trying to seek too far forward. + } + } + + return DRWAV_TRUE; +} + +drwav_bool32 drwav_init_memory(drwav* pWav, const void* data, size_t dataSize) +{ + if (data == NULL || dataSize == 0) { + return DRWAV_FALSE; + } + + drwav__memory_stream memoryStream; + drwav_zero_memory(&memoryStream, sizeof(memoryStream)); + memoryStream.data = (const unsigned char*)data; + memoryStream.dataSize = dataSize; + memoryStream.currentReadPos = 0; + + if (!drwav_init(pWav, drwav__on_read_memory, drwav__on_seek_memory, (void*)&memoryStream)) { + return DRWAV_FALSE; + } + + pWav->memoryStream = memoryStream; + pWav->pUserData = &pWav->memoryStream; + return DRWAV_TRUE; +} + + +drwav_bool32 drwav_init_memory_write__internal(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential) +{ + if (ppData == NULL) { + return DRWAV_FALSE; + } + + *ppData = NULL; // Important because we're using realloc()! + *pDataSize = 0; + + drwav__memory_stream_write memoryStreamWrite; + drwav_zero_memory(&memoryStreamWrite, sizeof(memoryStreamWrite)); + memoryStreamWrite.ppData = ppData; + memoryStreamWrite.pDataSize = pDataSize; + memoryStreamWrite.dataSize = 0; + memoryStreamWrite.dataCapacity = 0; + memoryStreamWrite.currentWritePos = 0; + + if (!drwav_init_write__internal(pWav, pFormat, totalSampleCount, isSequential, drwav__on_write_memory, drwav__on_seek_memory_write, (void*)&memoryStreamWrite)) { + return DRWAV_FALSE; + } + + pWav->memoryStreamWrite = memoryStreamWrite; + pWav->pUserData = &pWav->memoryStreamWrite; + return DRWAV_TRUE; +} + +drwav_bool32 drwav_init_memory_write(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat) +{ + return drwav_init_memory_write__internal(pWav, ppData, pDataSize, pFormat, 0, DRWAV_FALSE); +} + +drwav_bool32 drwav_init_memory_write_sequential(drwav* pWav, void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount) +{ + return drwav_init_memory_write__internal(pWav, ppData, pDataSize, pFormat, totalSampleCount, DRWAV_TRUE); +} + + +drwav* drwav_open_memory(const void* data, size_t dataSize) +{ + if (data == NULL || dataSize == 0) { + return NULL; + } + + drwav__memory_stream memoryStream; + drwav_zero_memory(&memoryStream, sizeof(memoryStream)); + memoryStream.data = (const unsigned char*)data; + memoryStream.dataSize = dataSize; + memoryStream.currentReadPos = 0; + + drwav* pWav = drwav_open(drwav__on_read_memory, drwav__on_seek_memory, (void*)&memoryStream); + if (pWav == NULL) { + return NULL; + } + + pWav->memoryStream = memoryStream; + pWav->pUserData = &pWav->memoryStream; + return pWav; +} + + +drwav* drwav_open_memory_write__internal(void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential) +{ + if (ppData == NULL) { + return NULL; + } + + *ppData = NULL; // Important because we're using realloc()! + *pDataSize = 0; + + drwav__memory_stream_write memoryStreamWrite; + drwav_zero_memory(&memoryStreamWrite, sizeof(memoryStreamWrite)); + memoryStreamWrite.ppData = ppData; + memoryStreamWrite.pDataSize = pDataSize; + memoryStreamWrite.dataSize = 0; + memoryStreamWrite.dataCapacity = 0; + memoryStreamWrite.currentWritePos = 0; + + drwav* pWav = drwav_open_write__internal(pFormat, totalSampleCount, isSequential, drwav__on_write_memory, drwav__on_seek_memory_write, (void*)&memoryStreamWrite); + if (pWav == NULL) { + return NULL; + } + + pWav->memoryStreamWrite = memoryStreamWrite; + pWav->pUserData = &pWav->memoryStreamWrite; + return pWav; +} + +drwav* drwav_open_memory_write(void** ppData, size_t* pDataSize, const drwav_data_format* pFormat) +{ + return drwav_open_memory_write__internal(ppData, pDataSize, pFormat, 0, DRWAV_FALSE); +} + +drwav* drwav_open_memory_write_sequential(void** ppData, size_t* pDataSize, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount) +{ + return drwav_open_memory_write__internal(ppData, pDataSize, pFormat, totalSampleCount, DRWAV_TRUE); +} + + +drwav_bool32 drwav_init(drwav* pWav, drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData) +{ + if (onRead == NULL || onSeek == NULL) { + return DRWAV_FALSE; + } + + drwav_zero_memory(pWav, sizeof(*pWav)); + + + // The first 4 bytes should be the RIFF identifier. + unsigned char riff[4]; + if (onRead(pUserData, riff, sizeof(riff)) != sizeof(riff)) { + return DRWAV_FALSE; // Failed to read data. + } + + // The first 4 bytes can be used to identify the container. For RIFF files it will start with "RIFF" and for + // w64 it will start with "riff". + if (drwav__fourcc_equal(riff, "RIFF")) { + pWav->container = drwav_container_riff; + } else if (drwav__fourcc_equal(riff, "riff")) { + pWav->container = drwav_container_w64; + + // Check the rest of the GUID for validity. + drwav_uint8 riff2[12]; + if (onRead(pUserData, riff2, sizeof(riff2)) != sizeof(riff2)) { + return DRWAV_FALSE; + } + + for (int i = 0; i < 12; ++i) { + if (riff2[i] != drwavGUID_W64_RIFF[i+4]) { + return DRWAV_FALSE; + } + } + } else { + return DRWAV_FALSE; // Unknown or unsupported container. + } + + + if (pWav->container == drwav_container_riff) { + // RIFF/WAVE + unsigned char chunkSizeBytes[4]; + if (onRead(pUserData, chunkSizeBytes, sizeof(chunkSizeBytes)) != sizeof(chunkSizeBytes)) { + return DRWAV_FALSE; + } + + unsigned int chunkSize = drwav__bytes_to_u32(chunkSizeBytes); + if (chunkSize < 36) { + return DRWAV_FALSE; // Chunk size should always be at least 36 bytes. + } + + unsigned char wave[4]; + if (onRead(pUserData, wave, sizeof(wave)) != sizeof(wave)) { + return DRWAV_FALSE; + } + + if (!drwav__fourcc_equal(wave, "WAVE")) { + return DRWAV_FALSE; // Expecting "WAVE". + } + + pWav->dataChunkDataPos = 4 + sizeof(chunkSizeBytes) + sizeof(wave); + } else { + // W64 + unsigned char chunkSize[8]; + if (onRead(pUserData, chunkSize, sizeof(chunkSize)) != sizeof(chunkSize)) { + return DRWAV_FALSE; + } + + if (drwav__bytes_to_u64(chunkSize) < 80) { + return DRWAV_FALSE; + } + + drwav_uint8 wave[16]; + if (onRead(pUserData, wave, sizeof(wave)) != sizeof(wave)) { + return DRWAV_FALSE; + } + + if (!drwav__guid_equal(wave, drwavGUID_W64_WAVE)) { + return DRWAV_FALSE; + } + + pWav->dataChunkDataPos = 16 + sizeof(chunkSize) + sizeof(wave); + } + + + // The next bytes should be the "fmt " chunk. + drwav_fmt fmt; + if (!drwav__read_fmt(onRead, onSeek, pUserData, pWav->container, &pWav->dataChunkDataPos, &fmt)) { + return DRWAV_FALSE; // Failed to read the "fmt " chunk. + } + + // Basic validation. + if (fmt.sampleRate == 0 || fmt.channels == 0 || fmt.bitsPerSample == 0 || fmt.blockAlign == 0) { + return DRWAV_FALSE; // Invalid channel count. Probably an invalid WAV file. + } + + + // Translate the internal format. + unsigned short translatedFormatTag = fmt.formatTag; + if (translatedFormatTag == DR_WAVE_FORMAT_EXTENSIBLE) { + translatedFormatTag = drwav__bytes_to_u16(fmt.subFormat + 0); + } + + + drwav_uint64 sampleCountFromFactChunk = 0; + + // The next chunk we care about is the "data" chunk. This is not necessarily the next chunk so we'll need to loop. + drwav_uint64 dataSize; + for (;;) + { + drwav__chunk_header header; + if (!drwav__read_chunk_header(onRead, pUserData, pWav->container, &pWav->dataChunkDataPos, &header)) { + return DRWAV_FALSE; + } + + dataSize = header.sizeInBytes; + if (pWav->container == drwav_container_riff) { + if (drwav__fourcc_equal(header.id.fourcc, "data")) { + break; + } + } else { + if (drwav__guid_equal(header.id.guid, drwavGUID_W64_DATA)) { + break; + } + } + + // Optional. Get the total sample count from the FACT chunk. This is useful for compressed formats. + if (pWav->container == drwav_container_riff) { + if (drwav__fourcc_equal(header.id.fourcc, "fact")) { + drwav_uint32 sampleCount; + if (onRead(pUserData, &sampleCount, 4) != 4) { + return DRWAV_FALSE; + } + pWav->dataChunkDataPos += 4; + dataSize -= 4; + + // The sample count in the "fact" chunk is either unreliable, or I'm not understanding it properly. For now I am only enabling this + // for Microsoft ADPCM formats. + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) { + sampleCountFromFactChunk = sampleCount; + } else { + sampleCountFromFactChunk = 0; + } + } + } else { + if (drwav__guid_equal(header.id.guid, drwavGUID_W64_FACT)) { + if (onRead(pUserData, &sampleCountFromFactChunk, 8) != 8) { + return DRWAV_FALSE; + } + pWav->dataChunkDataPos += 8; + dataSize -= 8; + } + } + + // If we get here it means we didn't find the "data" chunk. Seek past it. + + // Make sure we seek past the padding. + dataSize += header.paddingSize; + drwav__seek_forward(onSeek, dataSize, pUserData); + pWav->dataChunkDataPos += dataSize; + } + + // At this point we should be sitting on the first byte of the raw audio data. + + pWav->onRead = onRead; + pWav->onSeek = onSeek; + pWav->pUserData = pUserData; + pWav->fmt = fmt; + pWav->sampleRate = fmt.sampleRate; + pWav->channels = fmt.channels; + pWav->bitsPerSample = fmt.bitsPerSample; + pWav->bytesPerSample = fmt.blockAlign / fmt.channels; + pWav->bytesRemaining = dataSize; + pWav->translatedFormatTag = translatedFormatTag; + pWav->dataChunkDataSize = dataSize; + + // The bytes per sample should never be 0 at this point. This would indicate an invalid WAV file. + if (pWav->bytesPerSample == 0) { + return DRWAV_FALSE; + } + + if (sampleCountFromFactChunk != 0) { + pWav->totalSampleCount = sampleCountFromFactChunk * fmt.channels; + } else { + pWav->totalSampleCount = dataSize / pWav->bytesPerSample; + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) { + drwav_uint64 blockCount = dataSize / fmt.blockAlign; + pWav->totalSampleCount = (blockCount * (fmt.blockAlign - (6*pWav->channels))) * 2; // x2 because two samples per byte. + } + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) { + drwav_uint64 blockCount = dataSize / fmt.blockAlign; + pWav->totalSampleCount = ((blockCount * (fmt.blockAlign - (4*pWav->channels))) * 2) + (blockCount * pWav->channels); + } + } + + // The way we calculate the bytes per sample does not make sense for compressed formats so we just set it to 0. + if (drwav__is_compressed_format_tag(pWav->translatedFormatTag)) { + pWav->bytesPerSample = 0; + } + + // Some formats only support a certain number of channels. + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM || pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) { + if (pWav->channels > 2) { + return DRWAV_FALSE; + } + } + +#ifdef DR_WAV_LIBSNDFILE_COMPAT + // I use libsndfile as a benchmark for testing, however in the version I'm using (from the Windows installer on the libsndfile website), + // it appears the total sample count libsndfile uses for MS-ADPCM is incorrect. It would seem they are computing the total sample count + // from the number of blocks, however this results in the inclusion of extra silent samples at the end of the last block. The correct + // way to know the total sample count is to inspect the "fact" chunk, which should always be present for compressed formats, and should + // always include the sample count. This little block of code below is only used to emulate the libsndfile logic so I can properly run my + // correctness tests against libsndfile, and is disabled by default. + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) { + drwav_uint64 blockCount = dataSize / fmt.blockAlign; + pWav->totalSampleCount = (blockCount * (fmt.blockAlign - (6*pWav->channels))) * 2; // x2 because two samples per byte. + } + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) { + drwav_uint64 blockCount = dataSize / fmt.blockAlign; + pWav->totalSampleCount = ((blockCount * (fmt.blockAlign - (4*pWav->channels))) * 2) + (blockCount * pWav->channels); + } +#endif + + return DRWAV_TRUE; +} + + +drwav_uint32 drwav_riff_chunk_size_riff(drwav_uint64 dataChunkSize) +{ + if (dataChunkSize <= (0xFFFFFFFF - 36)) { + return 36 + (drwav_uint32)dataChunkSize; + } else { + return 0xFFFFFFFF; + } +} + +drwav_uint32 drwav_data_chunk_size_riff(drwav_uint64 dataChunkSize) +{ + if (dataChunkSize <= 0xFFFFFFFF) { + return (drwav_uint32)dataChunkSize; + } else { + return 0xFFFFFFFF; + } +} + +drwav_uint64 drwav_riff_chunk_size_w64(drwav_uint64 dataChunkSize) +{ + return 80 + 24 + dataChunkSize; // +24 because W64 includes the size of the GUID and size fields. +} + +drwav_uint64 drwav_data_chunk_size_w64(drwav_uint64 dataChunkSize) +{ + return 24 + dataChunkSize; // +24 because W64 includes the size of the GUID and size fields. +} + + +drwav_bool32 drwav_init_write__internal(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData) +{ + if (pWav == NULL) { + return DRWAV_FALSE; + } + + if (onWrite == NULL) { + return DRWAV_FALSE; + } + + if (!isSequential && onSeek == NULL) { + return DRWAV_FALSE; // <-- onSeek is required when in non-sequential mode. + } + + + // Not currently supporting compressed formats. Will need to add support for the "fact" chunk before we enable this. + if (pFormat->format == DR_WAVE_FORMAT_EXTENSIBLE) { + return DRWAV_FALSE; + } + if (pFormat->format == DR_WAVE_FORMAT_ADPCM || pFormat->format == DR_WAVE_FORMAT_DVI_ADPCM) { + return DRWAV_FALSE; + } + + + drwav_zero_memory(pWav, sizeof(*pWav)); + pWav->onWrite = onWrite; + pWav->onSeek = onSeek; + pWav->pUserData = pUserData; + pWav->fmt.formatTag = (drwav_uint16)pFormat->format; + pWav->fmt.channels = (drwav_uint16)pFormat->channels; + pWav->fmt.sampleRate = pFormat->sampleRate; + pWav->fmt.avgBytesPerSec = (drwav_uint32)((pFormat->bitsPerSample * pFormat->sampleRate * pFormat->channels) / 8); + pWav->fmt.blockAlign = (drwav_uint16)((pFormat->channels * pFormat->bitsPerSample) / 8); + pWav->fmt.bitsPerSample = (drwav_uint16)pFormat->bitsPerSample; + pWav->fmt.extendedSize = 0; + pWav->isSequentialWrite = isSequential; + + + size_t runningPos = 0; + + // The initial values for the "RIFF" and "data" chunks depends on whether or not we are initializing in sequential mode or not. In + // sequential mode we set this to its final values straight away since they can be calculated from the total sample count. In non- + // sequential mode we initialize it all to zero and fill it out in drwav_uninit() using a backwards seek. + drwav_uint64 initialDataChunkSize = 0; + if (isSequential) { + initialDataChunkSize = (totalSampleCount * pWav->fmt.bitsPerSample) / 8; + + // The RIFF container has a limit on the number of samples. drwav is not allowing this. There's no practical limits for Wave64 + // so for the sake of simplicity I'm not doing any validation for that. + if (pFormat->container == drwav_container_riff) { + if (initialDataChunkSize > (0xFFFFFFFF - 36)) { + return DRWAV_FALSE; // Not enough room to store every sample. + } + } + } + + pWav->dataChunkDataSizeTargetWrite = initialDataChunkSize; + + + // "RIFF" chunk. + if (pFormat->container == drwav_container_riff) { + drwav_uint32 chunkSizeRIFF = 36 + (drwav_uint32)initialDataChunkSize; // +36 = "RIFF"+[RIFF Chunk Size]+"WAVE" + [sizeof "fmt " chunk] + runningPos += pWav->onWrite(pUserData, "RIFF", 4); + runningPos += pWav->onWrite(pUserData, &chunkSizeRIFF, 4); + runningPos += pWav->onWrite(pUserData, "WAVE", 4); + } else { + drwav_uint64 chunkSizeRIFF = 80 + 24 + initialDataChunkSize; // +24 because W64 includes the size of the GUID and size fields. + runningPos += pWav->onWrite(pUserData, drwavGUID_W64_RIFF, 16); + runningPos += pWav->onWrite(pUserData, &chunkSizeRIFF, 8); + runningPos += pWav->onWrite(pUserData, drwavGUID_W64_WAVE, 16); + } + + // "fmt " chunk. + drwav_uint64 chunkSizeFMT; + if (pFormat->container == drwav_container_riff) { + chunkSizeFMT = 16; + runningPos += pWav->onWrite(pUserData, "fmt ", 4); + runningPos += pWav->onWrite(pUserData, &chunkSizeFMT, 4); + } else { + chunkSizeFMT = 40; + runningPos += pWav->onWrite(pUserData, drwavGUID_W64_FMT, 16); + runningPos += pWav->onWrite(pUserData, &chunkSizeFMT, 8); + } + + runningPos += pWav->onWrite(pUserData, &pWav->fmt.formatTag, 2); + runningPos += pWav->onWrite(pUserData, &pWav->fmt.channels, 2); + runningPos += pWav->onWrite(pUserData, &pWav->fmt.sampleRate, 4); + runningPos += pWav->onWrite(pUserData, &pWav->fmt.avgBytesPerSec, 4); + runningPos += pWav->onWrite(pUserData, &pWav->fmt.blockAlign, 2); + runningPos += pWav->onWrite(pUserData, &pWav->fmt.bitsPerSample, 2); + + pWav->dataChunkDataPos = runningPos; + + // "data" chunk. + if (pFormat->container == drwav_container_riff) { + drwav_uint32 chunkSizeDATA = (drwav_uint32)initialDataChunkSize; + runningPos += pWav->onWrite(pUserData, "data", 4); + runningPos += pWav->onWrite(pUserData, &chunkSizeDATA, 4); + } else { + drwav_uint64 chunkSizeDATA = 24 + initialDataChunkSize; // +24 because W64 includes the size of the GUID and size fields. + runningPos += pWav->onWrite(pUserData, drwavGUID_W64_DATA, 16); + runningPos += pWav->onWrite(pUserData, &chunkSizeDATA, 8); + } + + + // Simple validation. + if (pFormat->container == drwav_container_riff) { + if (runningPos != 20 + chunkSizeFMT + 8) { + return DRWAV_FALSE; + } + } else { + if (runningPos != 40 + chunkSizeFMT + 24) { + return DRWAV_FALSE; + } + } + + + + // Set some properties for the client's convenience. + pWav->container = pFormat->container; + pWav->channels = (drwav_uint16)pFormat->channels; + pWav->sampleRate = pFormat->sampleRate; + pWav->bitsPerSample = (drwav_uint16)pFormat->bitsPerSample; + pWav->bytesPerSample = (drwav_uint16)(pFormat->bitsPerSample >> 3); + pWav->translatedFormatTag = (drwav_uint16)pFormat->format; + + return DRWAV_TRUE; +} + + +drwav_bool32 drwav_init_write(drwav* pWav, const drwav_data_format* pFormat, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData) +{ + return drwav_init_write__internal(pWav, pFormat, 0, DRWAV_FALSE, onWrite, onSeek, pUserData); // DRWAV_FALSE = Not Sequential +} + +drwav_bool32 drwav_init_write_sequential(drwav* pWav, const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_write_proc onWrite, void* pUserData) +{ + return drwav_init_write__internal(pWav, pFormat, totalSampleCount, DRWAV_TRUE, onWrite, NULL, pUserData); // DRWAV_TRUE = Sequential +} + +void drwav_uninit(drwav* pWav) +{ + if (pWav == NULL) { + return; + } + + // If the drwav object was opened in write mode we'll need to finalize a few things: + // - Make sure the "data" chunk is aligned to 16-bits for RIFF containers, or 64 bits for W64 containers. + // - Set the size of the "data" chunk. + if (pWav->onWrite != NULL) { + // Validation for sequential mode. + if (pWav->isSequentialWrite) { + drwav_assert(pWav->dataChunkDataSize == pWav->dataChunkDataSizeTargetWrite); + } + + // Padding. Do not adjust pWav->dataChunkDataSize - this should not include the padding. + drwav_uint32 paddingSize = 0; + if (pWav->container == drwav_container_riff) { + paddingSize = (drwav_uint32)(pWav->dataChunkDataSize % 2); + } else { + paddingSize = (drwav_uint32)(pWav->dataChunkDataSize % 8); + } + + if (paddingSize > 0) { + drwav_uint64 paddingData = 0; + pWav->onWrite(pWav->pUserData, &paddingData, paddingSize); + } + + + // Chunk sizes. When using sequential mode, these will have been filled in at initialization time. We only need + // to do this when using non-sequential mode. + if (pWav->onSeek && !pWav->isSequentialWrite) { + if (pWav->container == drwav_container_riff) { + // The "RIFF" chunk size. + if (pWav->onSeek(pWav->pUserData, 4, drwav_seek_origin_start)) { + drwav_uint32 riffChunkSize = drwav_riff_chunk_size_riff(pWav->dataChunkDataSize); + pWav->onWrite(pWav->pUserData, &riffChunkSize, 4); + } + + // the "data" chunk size. + if (pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos + 4, drwav_seek_origin_start)) { + drwav_uint32 dataChunkSize = drwav_data_chunk_size_riff(pWav->dataChunkDataSize); + pWav->onWrite(pWav->pUserData, &dataChunkSize, 4); + } + } else { + // The "RIFF" chunk size. + if (pWav->onSeek(pWav->pUserData, 16, drwav_seek_origin_start)) { + drwav_uint64 riffChunkSize = drwav_riff_chunk_size_w64(pWav->dataChunkDataSize); + pWav->onWrite(pWav->pUserData, &riffChunkSize, 8); + } + + // The "data" chunk size. + if (pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos + 16, drwav_seek_origin_start)) { + drwav_uint64 dataChunkSize = drwav_data_chunk_size_w64(pWav->dataChunkDataSize); + pWav->onWrite(pWav->pUserData, &dataChunkSize, 8); + } + } + } + } + +#ifndef DR_WAV_NO_STDIO + // If we opened the file with drwav_open_file() we will want to close the file handle. We can know whether or not drwav_open_file() + // was used by looking at the onRead and onSeek callbacks. + if (pWav->onRead == drwav__on_read_stdio || pWav->onWrite == drwav__on_write_stdio) { + fclose((FILE*)pWav->pUserData); + } +#endif +} + + +drwav* drwav_open(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData) +{ + drwav* pWav = (drwav*)DRWAV_MALLOC(sizeof(*pWav)); + if (pWav == NULL) { + return NULL; + } + + if (!drwav_init(pWav, onRead, onSeek, pUserData)) { + DRWAV_FREE(pWav); + return NULL; + } + + return pWav; +} + + +drwav* drwav_open_write__internal(const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_bool32 isSequential, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData) +{ + drwav* pWav = (drwav*)DRWAV_MALLOC(sizeof(*pWav)); + if (pWav == NULL) { + return NULL; + } + + if (!drwav_init_write__internal(pWav, pFormat, totalSampleCount, isSequential, onWrite, onSeek, pUserData)) { + DRWAV_FREE(pWav); + return NULL; + } + + return pWav; +} + +drwav* drwav_open_write(const drwav_data_format* pFormat, drwav_write_proc onWrite, drwav_seek_proc onSeek, void* pUserData) +{ + return drwav_open_write__internal(pFormat, 0, DRWAV_FALSE, onWrite, onSeek, pUserData); +} + +drwav* drwav_open_write_sequential(const drwav_data_format* pFormat, drwav_uint64 totalSampleCount, drwav_write_proc onWrite, void* pUserData) +{ + return drwav_open_write__internal(pFormat, totalSampleCount, DRWAV_TRUE, onWrite, NULL, pUserData); +} + +void drwav_close(drwav* pWav) +{ + drwav_uninit(pWav); + DRWAV_FREE(pWav); +} + + +size_t drwav_read_raw(drwav* pWav, size_t bytesToRead, void* pBufferOut) +{ + if (pWav == NULL || bytesToRead == 0 || pBufferOut == NULL) { + return 0; + } + + if (bytesToRead > pWav->bytesRemaining) { + bytesToRead = (size_t)pWav->bytesRemaining; + } + + size_t bytesRead = pWav->onRead(pWav->pUserData, pBufferOut, bytesToRead); + + pWav->bytesRemaining -= bytesRead; + return bytesRead; +} + +drwav_uint64 drwav_read(drwav* pWav, drwav_uint64 samplesToRead, void* pBufferOut) +{ + if (pWav == NULL || samplesToRead == 0 || pBufferOut == NULL) { + return 0; + } + + // Cannot use this function for compressed formats. + if (drwav__is_compressed_format_tag(pWav->translatedFormatTag)) { + return 0; + } + + // Don't try to read more samples than can potentially fit in the output buffer. + if (samplesToRead * pWav->bytesPerSample > SIZE_MAX) { + samplesToRead = SIZE_MAX / pWav->bytesPerSample; + } + + size_t bytesRead = drwav_read_raw(pWav, (size_t)(samplesToRead * pWav->bytesPerSample), pBufferOut); + return bytesRead / pWav->bytesPerSample; +} + +drwav_bool32 drwav_seek_to_first_sample(drwav* pWav) +{ + if (pWav->onWrite != NULL) { + return DRWAV_FALSE; // No seeking in write mode. + } + + if (!pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos, drwav_seek_origin_start)) { + return DRWAV_FALSE; + } + + if (drwav__is_compressed_format_tag(pWav->translatedFormatTag)) { + pWav->compressed.iCurrentSample = 0; + } + + pWav->bytesRemaining = pWav->dataChunkDataSize; + return DRWAV_TRUE; +} + +drwav_bool32 drwav_seek_to_sample(drwav* pWav, drwav_uint64 sample) +{ + // Seeking should be compatible with wave files > 2GB. + + if (pWav->onWrite != NULL) { + return DRWAV_FALSE; // No seeking in write mode. + } + + if (pWav == NULL || pWav->onSeek == NULL) { + return DRWAV_FALSE; + } + + // If there are no samples, just return DRWAV_TRUE without doing anything. + if (pWav->totalSampleCount == 0) { + return DRWAV_TRUE; + } + + // Make sure the sample is clamped. + if (sample >= pWav->totalSampleCount) { + sample = pWav->totalSampleCount - 1; + } + + + // For compressed formats we just use a slow generic seek. If we are seeking forward we just seek forward. If we are going backwards we need + // to seek back to the start. + if (drwav__is_compressed_format_tag(pWav->translatedFormatTag)) { + // TODO: This can be optimized. + + // If we're seeking forward it's simple - just keep reading samples until we hit the sample we're requesting. If we're seeking backwards, + // we first need to seek back to the start and then just do the same thing as a forward seek. + if (sample < pWav->compressed.iCurrentSample) { + if (!drwav_seek_to_first_sample(pWav)) { + return DRWAV_FALSE; + } + } + + if (sample > pWav->compressed.iCurrentSample) { + drwav_uint64 offset = sample - pWav->compressed.iCurrentSample; + + drwav_int16 devnull[2048]; + while (offset > 0) { + drwav_uint64 samplesToRead = offset; + if (samplesToRead > 2048) { + samplesToRead = 2048; + } + + drwav_uint64 samplesRead = 0; + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) { + samplesRead = drwav_read_s16__msadpcm(pWav, samplesToRead, devnull); + } else if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) { + samplesRead = drwav_read_s16__ima(pWav, samplesToRead, devnull); + } else { + assert(DRWAV_FALSE); // If this assertion is triggered it means I've implemented a new compressed format but forgot to add a branch for it here. + } + + if (samplesRead != samplesToRead) { + return DRWAV_FALSE; + } + + offset -= samplesRead; + } + } + } else { + drwav_uint64 totalSizeInBytes = pWav->totalSampleCount * pWav->bytesPerSample; + drwav_assert(totalSizeInBytes >= pWav->bytesRemaining); + + drwav_uint64 currentBytePos = totalSizeInBytes - pWav->bytesRemaining; + drwav_uint64 targetBytePos = sample * pWav->bytesPerSample; + + drwav_uint64 offset; + if (currentBytePos < targetBytePos) { + // Offset forwards. + offset = (targetBytePos - currentBytePos); + } else { + // Offset backwards. + if (!drwav_seek_to_first_sample(pWav)) { + return DRWAV_FALSE; + } + offset = targetBytePos; + } + + while (offset > 0) { + int offset32 = ((offset > INT_MAX) ? INT_MAX : (int)offset); + if (!pWav->onSeek(pWav->pUserData, offset32, drwav_seek_origin_current)) { + return DRWAV_FALSE; + } + + pWav->bytesRemaining -= offset32; + offset -= offset32; + } + } + + return DRWAV_TRUE; +} + + +size_t drwav_write_raw(drwav* pWav, size_t bytesToWrite, const void* pData) +{ + if (pWav == NULL || bytesToWrite == 0 || pData == NULL) { + return 0; + } + + size_t bytesWritten = pWav->onWrite(pWav->pUserData, pData, bytesToWrite); + pWav->dataChunkDataSize += bytesWritten; + + return bytesWritten; +} + +drwav_uint64 drwav_write(drwav* pWav, drwav_uint64 samplesToWrite, const void* pData) +{ + if (pWav == NULL || samplesToWrite == 0 || pData == NULL) { + return 0; + } + + drwav_uint64 bytesToWrite = ((samplesToWrite * pWav->bitsPerSample) / 8); + if (bytesToWrite > SIZE_MAX) { + return 0; + } + + drwav_uint64 bytesWritten = 0; + const drwav_uint8* pRunningData = (const drwav_uint8*)pData; + while (bytesToWrite > 0) { + drwav_uint64 bytesToWriteThisIteration = bytesToWrite; + if (bytesToWriteThisIteration > SIZE_MAX) { + bytesToWriteThisIteration = SIZE_MAX; + } + + size_t bytesJustWritten = drwav_write_raw(pWav, (size_t)bytesToWriteThisIteration, pRunningData); + if (bytesJustWritten == 0) { + break; + } + + bytesToWrite -= bytesJustWritten; + bytesWritten += bytesJustWritten; + pRunningData += bytesJustWritten; + } + + return (bytesWritten * 8) / pWav->bitsPerSample; +} + + + +drwav_uint64 drwav_read_s16__msadpcm(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut) +{ + drwav_assert(pWav != NULL); + drwav_assert(samplesToRead > 0); + drwav_assert(pBufferOut != NULL); + + // TODO: Lots of room for optimization here. + + drwav_uint64 totalSamplesRead = 0; + + while (samplesToRead > 0 && pWav->compressed.iCurrentSample < pWav->totalSampleCount) { + // If there are no cached samples we need to load a new block. + if (pWav->msadpcm.cachedSampleCount == 0 && pWav->msadpcm.bytesRemainingInBlock == 0) { + if (pWav->channels == 1) { + // Mono. + drwav_uint8 header[7]; + if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) { + return totalSamplesRead; + } + pWav->msadpcm.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header); + + pWav->msadpcm.predictor[0] = header[0]; + pWav->msadpcm.delta[0] = drwav__bytes_to_s16(header + 1); + pWav->msadpcm.prevSamples[0][1] = (drwav_int32)drwav__bytes_to_s16(header + 3); + pWav->msadpcm.prevSamples[0][0] = (drwav_int32)drwav__bytes_to_s16(header + 5); + pWav->msadpcm.cachedSamples[2] = pWav->msadpcm.prevSamples[0][0]; + pWav->msadpcm.cachedSamples[3] = pWav->msadpcm.prevSamples[0][1]; + pWav->msadpcm.cachedSampleCount = 2; + } else { + // Stereo. + drwav_uint8 header[14]; + if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) { + return totalSamplesRead; + } + pWav->msadpcm.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header); + + pWav->msadpcm.predictor[0] = header[0]; + pWav->msadpcm.predictor[1] = header[1]; + pWav->msadpcm.delta[0] = drwav__bytes_to_s16(header + 2); + pWav->msadpcm.delta[1] = drwav__bytes_to_s16(header + 4); + pWav->msadpcm.prevSamples[0][1] = (drwav_int32)drwav__bytes_to_s16(header + 6); + pWav->msadpcm.prevSamples[1][1] = (drwav_int32)drwav__bytes_to_s16(header + 8); + pWav->msadpcm.prevSamples[0][0] = (drwav_int32)drwav__bytes_to_s16(header + 10); + pWav->msadpcm.prevSamples[1][0] = (drwav_int32)drwav__bytes_to_s16(header + 12); + + pWav->msadpcm.cachedSamples[0] = pWav->msadpcm.prevSamples[0][0]; + pWav->msadpcm.cachedSamples[1] = pWav->msadpcm.prevSamples[1][0]; + pWav->msadpcm.cachedSamples[2] = pWav->msadpcm.prevSamples[0][1]; + pWav->msadpcm.cachedSamples[3] = pWav->msadpcm.prevSamples[1][1]; + pWav->msadpcm.cachedSampleCount = 4; + } + } + + // Output anything that's cached. + while (samplesToRead > 0 && pWav->msadpcm.cachedSampleCount > 0 && pWav->compressed.iCurrentSample < pWav->totalSampleCount) { + pBufferOut[0] = (drwav_int16)pWav->msadpcm.cachedSamples[drwav_countof(pWav->msadpcm.cachedSamples) - pWav->msadpcm.cachedSampleCount]; + pWav->msadpcm.cachedSampleCount -= 1; + + pBufferOut += 1; + samplesToRead -= 1; + totalSamplesRead += 1; + pWav->compressed.iCurrentSample += 1; + } + + if (samplesToRead == 0) { + return totalSamplesRead; + } + + + // If there's nothing left in the cache, just go ahead and load more. If there's nothing left to load in the current block we just continue to the next + // loop iteration which will trigger the loading of a new block. + if (pWav->msadpcm.cachedSampleCount == 0) { + if (pWav->msadpcm.bytesRemainingInBlock == 0) { + continue; + } else { + drwav_uint8 nibbles; + if (pWav->onRead(pWav->pUserData, &nibbles, 1) != 1) { + return totalSamplesRead; + } + pWav->msadpcm.bytesRemainingInBlock -= 1; + + // TODO: Optimize away these if statements. + drwav_int32 nibble0 = ((nibbles & 0xF0) >> 4); if ((nibbles & 0x80)) { nibble0 |= 0xFFFFFFF0UL; } + drwav_int32 nibble1 = ((nibbles & 0x0F) >> 0); if ((nibbles & 0x08)) { nibble1 |= 0xFFFFFFF0UL; } + + static drwav_int32 adaptationTable[] = { + 230, 230, 230, 230, 307, 409, 512, 614, + 768, 614, 512, 409, 307, 230, 230, 230 + }; + static drwav_int32 coeff1Table[] = { 256, 512, 0, 192, 240, 460, 392 }; + static drwav_int32 coeff2Table[] = { 0, -256, 0, 64, 0, -208, -232 }; + + if (pWav->channels == 1) { + // Mono. + drwav_int32 newSample0; + newSample0 = ((pWav->msadpcm.prevSamples[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevSamples[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8; + newSample0 += nibble0 * pWav->msadpcm.delta[0]; + newSample0 = drwav_clamp(newSample0, -32768, 32767); + + pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0xF0) >> 4)] * pWav->msadpcm.delta[0]) >> 8; + if (pWav->msadpcm.delta[0] < 16) { + pWav->msadpcm.delta[0] = 16; + } + + pWav->msadpcm.prevSamples[0][0] = pWav->msadpcm.prevSamples[0][1]; + pWav->msadpcm.prevSamples[0][1] = newSample0; + + + drwav_int32 newSample1; + newSample1 = ((pWav->msadpcm.prevSamples[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevSamples[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8; + newSample1 += nibble1 * pWav->msadpcm.delta[0]; + newSample1 = drwav_clamp(newSample1, -32768, 32767); + + pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0x0F) >> 0)] * pWav->msadpcm.delta[0]) >> 8; + if (pWav->msadpcm.delta[0] < 16) { + pWav->msadpcm.delta[0] = 16; + } + + pWav->msadpcm.prevSamples[0][0] = pWav->msadpcm.prevSamples[0][1]; + pWav->msadpcm.prevSamples[0][1] = newSample1; + + + pWav->msadpcm.cachedSamples[2] = newSample0; + pWav->msadpcm.cachedSamples[3] = newSample1; + pWav->msadpcm.cachedSampleCount = 2; + } else { + // Stereo. + + // Left. + drwav_int32 newSample0; + newSample0 = ((pWav->msadpcm.prevSamples[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevSamples[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8; + newSample0 += nibble0 * pWav->msadpcm.delta[0]; + newSample0 = drwav_clamp(newSample0, -32768, 32767); + + pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0xF0) >> 4)] * pWav->msadpcm.delta[0]) >> 8; + if (pWav->msadpcm.delta[0] < 16) { + pWav->msadpcm.delta[0] = 16; + } + + pWav->msadpcm.prevSamples[0][0] = pWav->msadpcm.prevSamples[0][1]; + pWav->msadpcm.prevSamples[0][1] = newSample0; + + + // Right. + drwav_int32 newSample1; + newSample1 = ((pWav->msadpcm.prevSamples[1][1] * coeff1Table[pWav->msadpcm.predictor[1]]) + (pWav->msadpcm.prevSamples[1][0] * coeff2Table[pWav->msadpcm.predictor[1]])) >> 8; + newSample1 += nibble1 * pWav->msadpcm.delta[1]; + newSample1 = drwav_clamp(newSample1, -32768, 32767); + + pWav->msadpcm.delta[1] = (adaptationTable[((nibbles & 0x0F) >> 0)] * pWav->msadpcm.delta[1]) >> 8; + if (pWav->msadpcm.delta[1] < 16) { + pWav->msadpcm.delta[1] = 16; + } + + pWav->msadpcm.prevSamples[1][0] = pWav->msadpcm.prevSamples[1][1]; + pWav->msadpcm.prevSamples[1][1] = newSample1; + + pWav->msadpcm.cachedSamples[2] = newSample0; + pWav->msadpcm.cachedSamples[3] = newSample1; + pWav->msadpcm.cachedSampleCount = 2; + } + } + } + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_s16__ima(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut) +{ + drwav_assert(pWav != NULL); + drwav_assert(samplesToRead > 0); + drwav_assert(pBufferOut != NULL); + + // TODO: Lots of room for optimization here. + + drwav_uint64 totalSamplesRead = 0; + + while (samplesToRead > 0 && pWav->compressed.iCurrentSample < pWav->totalSampleCount) { + // If there are no cached samples we need to load a new block. + if (pWav->ima.cachedSampleCount == 0 && pWav->ima.bytesRemainingInBlock == 0) { + if (pWav->channels == 1) { + // Mono. + drwav_uint8 header[4]; + if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) { + return totalSamplesRead; + } + pWav->ima.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header); + + pWav->ima.predictor[0] = drwav__bytes_to_s16(header + 0); + pWav->ima.stepIndex[0] = header[2]; + pWav->ima.cachedSamples[drwav_countof(pWav->ima.cachedSamples) - 1] = pWav->ima.predictor[0]; + pWav->ima.cachedSampleCount = 1; + } else { + // Stereo. + drwav_uint8 header[8]; + if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) { + return totalSamplesRead; + } + pWav->ima.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header); + + pWav->ima.predictor[0] = drwav__bytes_to_s16(header + 0); + pWav->ima.stepIndex[0] = header[2]; + pWav->ima.predictor[1] = drwav__bytes_to_s16(header + 4); + pWav->ima.stepIndex[1] = header[6]; + + pWav->ima.cachedSamples[drwav_countof(pWav->ima.cachedSamples) - 2] = pWav->ima.predictor[0]; + pWav->ima.cachedSamples[drwav_countof(pWav->ima.cachedSamples) - 1] = pWav->ima.predictor[1]; + pWav->ima.cachedSampleCount = 2; + } + } + + // Output anything that's cached. + while (samplesToRead > 0 && pWav->ima.cachedSampleCount > 0 && pWav->compressed.iCurrentSample < pWav->totalSampleCount) { + pBufferOut[0] = (drwav_int16)pWav->ima.cachedSamples[drwav_countof(pWav->ima.cachedSamples) - pWav->ima.cachedSampleCount]; + pWav->ima.cachedSampleCount -= 1; + + pBufferOut += 1; + samplesToRead -= 1; + totalSamplesRead += 1; + pWav->compressed.iCurrentSample += 1; + } + + if (samplesToRead == 0) { + return totalSamplesRead; + } + + // If there's nothing left in the cache, just go ahead and load more. If there's nothing left to load in the current block we just continue to the next + // loop iteration which will trigger the loading of a new block. + if (pWav->ima.cachedSampleCount == 0) { + if (pWav->ima.bytesRemainingInBlock == 0) { + continue; + } else { + static drwav_int32 indexTable[16] = { + -1, -1, -1, -1, 2, 4, 6, 8, + -1, -1, -1, -1, 2, 4, 6, 8 + }; + + static drwav_int32 stepTable[89] = { + 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, + 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, + 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, + 130, 143, 157, 173, 190, 209, 230, 253, 279, 307, + 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, + 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, + 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, + 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899, + 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767 + }; + + // From what I can tell with stereo streams, it looks like every 4 bytes (8 samples) is for one channel. So it goes 4 bytes for the + // left channel, 4 bytes for the right channel. + pWav->ima.cachedSampleCount = 8 * pWav->channels; + for (drwav_uint32 iChannel = 0; iChannel < pWav->channels; ++iChannel) { + drwav_uint8 nibbles[4]; + if (pWav->onRead(pWav->pUserData, &nibbles, 4) != 4) { + return totalSamplesRead; + } + pWav->ima.bytesRemainingInBlock -= 4; + + for (drwav_uint32 iByte = 0; iByte < 4; ++iByte) { + drwav_uint8 nibble0 = ((nibbles[iByte] & 0x0F) >> 0); + drwav_uint8 nibble1 = ((nibbles[iByte] & 0xF0) >> 4); + + drwav_int32 step = stepTable[pWav->ima.stepIndex[iChannel]]; + drwav_int32 predictor = pWav->ima.predictor[iChannel]; + + drwav_int32 diff = step >> 3; + if (nibble0 & 1) diff += step >> 2; + if (nibble0 & 2) diff += step >> 1; + if (nibble0 & 4) diff += step; + if (nibble0 & 8) diff = -diff; + + predictor = drwav_clamp(predictor + diff, -32768, 32767); + pWav->ima.predictor[iChannel] = predictor; + pWav->ima.stepIndex[iChannel] = drwav_clamp(pWav->ima.stepIndex[iChannel] + indexTable[nibble0], 0, (drwav_int32)drwav_countof(stepTable)-1); + pWav->ima.cachedSamples[(drwav_countof(pWav->ima.cachedSamples) - pWav->ima.cachedSampleCount) + (iByte*2+0)*pWav->channels + iChannel] = predictor; + + + step = stepTable[pWav->ima.stepIndex[iChannel]]; + predictor = pWav->ima.predictor[iChannel]; + + diff = step >> 3; + if (nibble1 & 1) diff += step >> 2; + if (nibble1 & 2) diff += step >> 1; + if (nibble1 & 4) diff += step; + if (nibble1 & 8) diff = -diff; + + predictor = drwav_clamp(predictor + diff, -32768, 32767); + pWav->ima.predictor[iChannel] = predictor; + pWav->ima.stepIndex[iChannel] = drwav_clamp(pWav->ima.stepIndex[iChannel] + indexTable[nibble1], 0, (drwav_int32)drwav_countof(stepTable)-1); + pWav->ima.cachedSamples[(drwav_countof(pWav->ima.cachedSamples) - pWav->ima.cachedSampleCount) + (iByte*2+1)*pWav->channels + iChannel] = predictor; + } + } + } + } + } + + return totalSamplesRead; +} + + +#ifndef DR_WAV_NO_CONVERSION_API +static unsigned short g_drwavAlawTable[256] = { + 0xEA80, 0xEB80, 0xE880, 0xE980, 0xEE80, 0xEF80, 0xEC80, 0xED80, 0xE280, 0xE380, 0xE080, 0xE180, 0xE680, 0xE780, 0xE480, 0xE580, + 0xF540, 0xF5C0, 0xF440, 0xF4C0, 0xF740, 0xF7C0, 0xF640, 0xF6C0, 0xF140, 0xF1C0, 0xF040, 0xF0C0, 0xF340, 0xF3C0, 0xF240, 0xF2C0, + 0xAA00, 0xAE00, 0xA200, 0xA600, 0xBA00, 0xBE00, 0xB200, 0xB600, 0x8A00, 0x8E00, 0x8200, 0x8600, 0x9A00, 0x9E00, 0x9200, 0x9600, + 0xD500, 0xD700, 0xD100, 0xD300, 0xDD00, 0xDF00, 0xD900, 0xDB00, 0xC500, 0xC700, 0xC100, 0xC300, 0xCD00, 0xCF00, 0xC900, 0xCB00, + 0xFEA8, 0xFEB8, 0xFE88, 0xFE98, 0xFEE8, 0xFEF8, 0xFEC8, 0xFED8, 0xFE28, 0xFE38, 0xFE08, 0xFE18, 0xFE68, 0xFE78, 0xFE48, 0xFE58, + 0xFFA8, 0xFFB8, 0xFF88, 0xFF98, 0xFFE8, 0xFFF8, 0xFFC8, 0xFFD8, 0xFF28, 0xFF38, 0xFF08, 0xFF18, 0xFF68, 0xFF78, 0xFF48, 0xFF58, + 0xFAA0, 0xFAE0, 0xFA20, 0xFA60, 0xFBA0, 0xFBE0, 0xFB20, 0xFB60, 0xF8A0, 0xF8E0, 0xF820, 0xF860, 0xF9A0, 0xF9E0, 0xF920, 0xF960, + 0xFD50, 0xFD70, 0xFD10, 0xFD30, 0xFDD0, 0xFDF0, 0xFD90, 0xFDB0, 0xFC50, 0xFC70, 0xFC10, 0xFC30, 0xFCD0, 0xFCF0, 0xFC90, 0xFCB0, + 0x1580, 0x1480, 0x1780, 0x1680, 0x1180, 0x1080, 0x1380, 0x1280, 0x1D80, 0x1C80, 0x1F80, 0x1E80, 0x1980, 0x1880, 0x1B80, 0x1A80, + 0x0AC0, 0x0A40, 0x0BC0, 0x0B40, 0x08C0, 0x0840, 0x09C0, 0x0940, 0x0EC0, 0x0E40, 0x0FC0, 0x0F40, 0x0CC0, 0x0C40, 0x0DC0, 0x0D40, + 0x5600, 0x5200, 0x5E00, 0x5A00, 0x4600, 0x4200, 0x4E00, 0x4A00, 0x7600, 0x7200, 0x7E00, 0x7A00, 0x6600, 0x6200, 0x6E00, 0x6A00, + 0x2B00, 0x2900, 0x2F00, 0x2D00, 0x2300, 0x2100, 0x2700, 0x2500, 0x3B00, 0x3900, 0x3F00, 0x3D00, 0x3300, 0x3100, 0x3700, 0x3500, + 0x0158, 0x0148, 0x0178, 0x0168, 0x0118, 0x0108, 0x0138, 0x0128, 0x01D8, 0x01C8, 0x01F8, 0x01E8, 0x0198, 0x0188, 0x01B8, 0x01A8, + 0x0058, 0x0048, 0x0078, 0x0068, 0x0018, 0x0008, 0x0038, 0x0028, 0x00D8, 0x00C8, 0x00F8, 0x00E8, 0x0098, 0x0088, 0x00B8, 0x00A8, + 0x0560, 0x0520, 0x05E0, 0x05A0, 0x0460, 0x0420, 0x04E0, 0x04A0, 0x0760, 0x0720, 0x07E0, 0x07A0, 0x0660, 0x0620, 0x06E0, 0x06A0, + 0x02B0, 0x0290, 0x02F0, 0x02D0, 0x0230, 0x0210, 0x0270, 0x0250, 0x03B0, 0x0390, 0x03F0, 0x03D0, 0x0330, 0x0310, 0x0370, 0x0350 +}; + +static unsigned short g_drwavMulawTable[256] = { + 0x8284, 0x8684, 0x8A84, 0x8E84, 0x9284, 0x9684, 0x9A84, 0x9E84, 0xA284, 0xA684, 0xAA84, 0xAE84, 0xB284, 0xB684, 0xBA84, 0xBE84, + 0xC184, 0xC384, 0xC584, 0xC784, 0xC984, 0xCB84, 0xCD84, 0xCF84, 0xD184, 0xD384, 0xD584, 0xD784, 0xD984, 0xDB84, 0xDD84, 0xDF84, + 0xE104, 0xE204, 0xE304, 0xE404, 0xE504, 0xE604, 0xE704, 0xE804, 0xE904, 0xEA04, 0xEB04, 0xEC04, 0xED04, 0xEE04, 0xEF04, 0xF004, + 0xF0C4, 0xF144, 0xF1C4, 0xF244, 0xF2C4, 0xF344, 0xF3C4, 0xF444, 0xF4C4, 0xF544, 0xF5C4, 0xF644, 0xF6C4, 0xF744, 0xF7C4, 0xF844, + 0xF8A4, 0xF8E4, 0xF924, 0xF964, 0xF9A4, 0xF9E4, 0xFA24, 0xFA64, 0xFAA4, 0xFAE4, 0xFB24, 0xFB64, 0xFBA4, 0xFBE4, 0xFC24, 0xFC64, + 0xFC94, 0xFCB4, 0xFCD4, 0xFCF4, 0xFD14, 0xFD34, 0xFD54, 0xFD74, 0xFD94, 0xFDB4, 0xFDD4, 0xFDF4, 0xFE14, 0xFE34, 0xFE54, 0xFE74, + 0xFE8C, 0xFE9C, 0xFEAC, 0xFEBC, 0xFECC, 0xFEDC, 0xFEEC, 0xFEFC, 0xFF0C, 0xFF1C, 0xFF2C, 0xFF3C, 0xFF4C, 0xFF5C, 0xFF6C, 0xFF7C, + 0xFF88, 0xFF90, 0xFF98, 0xFFA0, 0xFFA8, 0xFFB0, 0xFFB8, 0xFFC0, 0xFFC8, 0xFFD0, 0xFFD8, 0xFFE0, 0xFFE8, 0xFFF0, 0xFFF8, 0x0000, + 0x7D7C, 0x797C, 0x757C, 0x717C, 0x6D7C, 0x697C, 0x657C, 0x617C, 0x5D7C, 0x597C, 0x557C, 0x517C, 0x4D7C, 0x497C, 0x457C, 0x417C, + 0x3E7C, 0x3C7C, 0x3A7C, 0x387C, 0x367C, 0x347C, 0x327C, 0x307C, 0x2E7C, 0x2C7C, 0x2A7C, 0x287C, 0x267C, 0x247C, 0x227C, 0x207C, + 0x1EFC, 0x1DFC, 0x1CFC, 0x1BFC, 0x1AFC, 0x19FC, 0x18FC, 0x17FC, 0x16FC, 0x15FC, 0x14FC, 0x13FC, 0x12FC, 0x11FC, 0x10FC, 0x0FFC, + 0x0F3C, 0x0EBC, 0x0E3C, 0x0DBC, 0x0D3C, 0x0CBC, 0x0C3C, 0x0BBC, 0x0B3C, 0x0ABC, 0x0A3C, 0x09BC, 0x093C, 0x08BC, 0x083C, 0x07BC, + 0x075C, 0x071C, 0x06DC, 0x069C, 0x065C, 0x061C, 0x05DC, 0x059C, 0x055C, 0x051C, 0x04DC, 0x049C, 0x045C, 0x041C, 0x03DC, 0x039C, + 0x036C, 0x034C, 0x032C, 0x030C, 0x02EC, 0x02CC, 0x02AC, 0x028C, 0x026C, 0x024C, 0x022C, 0x020C, 0x01EC, 0x01CC, 0x01AC, 0x018C, + 0x0174, 0x0164, 0x0154, 0x0144, 0x0134, 0x0124, 0x0114, 0x0104, 0x00F4, 0x00E4, 0x00D4, 0x00C4, 0x00B4, 0x00A4, 0x0094, 0x0084, + 0x0078, 0x0070, 0x0068, 0x0060, 0x0058, 0x0050, 0x0048, 0x0040, 0x0038, 0x0030, 0x0028, 0x0020, 0x0018, 0x0010, 0x0008, 0x0000 +}; + +static DRWAV_INLINE drwav_int16 drwav__alaw_to_s16(drwav_uint8 sampleIn) +{ + return (short)g_drwavAlawTable[sampleIn]; +} + +static DRWAV_INLINE drwav_int16 drwav__mulaw_to_s16(drwav_uint8 sampleIn) +{ + return (short)g_drwavMulawTable[sampleIn]; +} + + + +static void drwav__pcm_to_s16(drwav_int16* pOut, const unsigned char* pIn, size_t totalSampleCount, unsigned short bytesPerSample) +{ + // Special case for 8-bit sample data because it's treated as unsigned. + if (bytesPerSample == 1) { + drwav_u8_to_s16(pOut, pIn, totalSampleCount); + return; + } + + + // Slightly more optimal implementation for common formats. + if (bytesPerSample == 2) { + for (unsigned int i = 0; i < totalSampleCount; ++i) { + *pOut++ = ((drwav_int16*)pIn)[i]; + } + return; + } + if (bytesPerSample == 3) { + drwav_s24_to_s16(pOut, pIn, totalSampleCount); + return; + } + if (bytesPerSample == 4) { + drwav_s32_to_s16(pOut, (const drwav_int32*)pIn, totalSampleCount); + return; + } + + + // Anything more than 64 bits per sample is not supported. + if (bytesPerSample > 8) { + drwav_zero_memory(pOut, totalSampleCount * sizeof(*pOut)); + return; + } + + + // Generic, slow converter. + for (unsigned int i = 0; i < totalSampleCount; ++i) { + drwav_uint64 sample = 0; + unsigned int shift = (8 - bytesPerSample) * 8; + + unsigned int j; + for (j = 0; j < bytesPerSample && j < 8; j += 1) { + sample |= (drwav_uint64)(pIn[j]) << shift; + shift += 8; + } + + pIn += j; + *pOut++ = (drwav_int16)((drwav_int64)sample >> 48); + } +} + +static void drwav__ieee_to_s16(drwav_int16* pOut, const unsigned char* pIn, size_t totalSampleCount, unsigned short bytesPerSample) +{ + if (bytesPerSample == 4) { + drwav_f32_to_s16(pOut, (float*)pIn, totalSampleCount); + return; + } else if (bytesPerSample == 8) { + drwav_f64_to_s16(pOut, (double*)pIn, totalSampleCount); + return; + } else { + // Only supporting 32- and 64-bit float. Output silence in all other cases. Contributions welcome for 16-bit float. + drwav_zero_memory(pOut, totalSampleCount * sizeof(*pOut)); + return; + } +} + +drwav_uint64 drwav_read_s16__pcm(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut) +{ + // Fast path. + if (pWav->bytesPerSample == 2) { + return drwav_read(pWav, samplesToRead, pBufferOut); + } + + drwav_uint64 totalSamplesRead = 0; + unsigned char sampleData[4096]; + while (samplesToRead > 0) { + drwav_uint64 samplesRead = drwav_read(pWav, drwav_min(samplesToRead, sizeof(sampleData)/pWav->bytesPerSample), sampleData); + if (samplesRead == 0) { + break; + } + + drwav__pcm_to_s16(pBufferOut, sampleData, (size_t)samplesRead, pWav->bytesPerSample); + + pBufferOut += samplesRead; + samplesToRead -= samplesRead; + totalSamplesRead += samplesRead; + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_s16__ieee(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut) +{ + drwav_uint64 totalSamplesRead = 0; + unsigned char sampleData[4096]; + while (samplesToRead > 0) { + drwav_uint64 samplesRead = drwav_read(pWav, drwav_min(samplesToRead, sizeof(sampleData)/pWav->bytesPerSample), sampleData); + if (samplesRead == 0) { + break; + } + + drwav__ieee_to_s16(pBufferOut, sampleData, (size_t)samplesRead, pWav->bytesPerSample); + + pBufferOut += samplesRead; + samplesToRead -= samplesRead; + totalSamplesRead += samplesRead; + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_s16__alaw(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut) +{ + drwav_uint64 totalSamplesRead = 0; + unsigned char sampleData[4096]; + while (samplesToRead > 0) { + drwav_uint64 samplesRead = drwav_read(pWav, drwav_min(samplesToRead, sizeof(sampleData)/pWav->bytesPerSample), sampleData); + if (samplesRead == 0) { + break; + } + + drwav_alaw_to_s16(pBufferOut, sampleData, (size_t)samplesRead); + + pBufferOut += samplesRead; + samplesToRead -= samplesRead; + totalSamplesRead += samplesRead; + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_s16__mulaw(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut) +{ + drwav_uint64 totalSamplesRead = 0; + unsigned char sampleData[4096]; + while (samplesToRead > 0) { + drwav_uint64 samplesRead = drwav_read(pWav, drwav_min(samplesToRead, sizeof(sampleData)/pWav->bytesPerSample), sampleData); + if (samplesRead == 0) { + break; + } + + drwav_mulaw_to_s16(pBufferOut, sampleData, (size_t)samplesRead); + + pBufferOut += samplesRead; + samplesToRead -= samplesRead; + totalSamplesRead += samplesRead; + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_s16(drwav* pWav, drwav_uint64 samplesToRead, drwav_int16* pBufferOut) +{ + if (pWav == NULL || samplesToRead == 0 || pBufferOut == NULL) { + return 0; + } + + // Don't try to read more samples than can potentially fit in the output buffer. + if (samplesToRead * sizeof(drwav_int16) > SIZE_MAX) { + samplesToRead = SIZE_MAX / sizeof(drwav_int16); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_PCM) { + return drwav_read_s16__pcm(pWav, samplesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) { + return drwav_read_s16__msadpcm(pWav, samplesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_IEEE_FLOAT) { + return drwav_read_s16__ieee(pWav, samplesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ALAW) { + return drwav_read_s16__alaw(pWav, samplesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_MULAW) { + return drwav_read_s16__mulaw(pWav, samplesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) { + return drwav_read_s16__ima(pWav, samplesToRead, pBufferOut); + } + + return 0; +} + +void drwav_u8_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + int r; + for (size_t i = 0; i < sampleCount; ++i) { + int x = pIn[i]; + r = x - 128; + r = r << 8; + pOut[i] = (short)r; + } +} + +void drwav_s24_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + int r; + for (size_t i = 0; i < sampleCount; ++i) { + int x = ((int)(((unsigned int)(((unsigned char*)pIn)[i*3+0]) << 8) | ((unsigned int)(((unsigned char*)pIn)[i*3+1]) << 16) | ((unsigned int)(((unsigned char*)pIn)[i*3+2])) << 24)) >> 8; + r = x >> 8; + pOut[i] = (short)r; + } +} + +void drwav_s32_to_s16(drwav_int16* pOut, const drwav_int32* pIn, size_t sampleCount) +{ + int r; + for (size_t i = 0; i < sampleCount; ++i) { + int x = pIn[i]; + r = x >> 16; + pOut[i] = (short)r; + } +} + +void drwav_f32_to_s16(drwav_int16* pOut, const float* pIn, size_t sampleCount) +{ + int r; + for (size_t i = 0; i < sampleCount; ++i) { + float x = pIn[i]; + float c; + c = ((x < -1) ? -1 : ((x > 1) ? 1 : x)); + c = c + 1; + r = (int)(c * 32767.5f); + r = r - 32768; + pOut[i] = (short)r; + } +} + +void drwav_f64_to_s16(drwav_int16* pOut, const double* pIn, size_t sampleCount) +{ + int r; + for (size_t i = 0; i < sampleCount; ++i) { + double x = pIn[i]; + double c; + c = ((x < -1) ? -1 : ((x > 1) ? 1 : x)); + c = c + 1; + r = (int)(c * 32767.5); + r = r - 32768; + pOut[i] = (short)r; + } +} + +void drwav_alaw_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + for (size_t i = 0; i < sampleCount; ++i) { + pOut[i] = drwav__alaw_to_s16(pIn[i]); + } +} + +void drwav_mulaw_to_s16(drwav_int16* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + for (size_t i = 0; i < sampleCount; ++i) { + pOut[i] = drwav__mulaw_to_s16(pIn[i]); + } +} + + + +static void drwav__pcm_to_f32(float* pOut, const unsigned char* pIn, size_t sampleCount, unsigned short bytesPerSample) +{ + // Special case for 8-bit sample data because it's treated as unsigned. + if (bytesPerSample == 1) { + drwav_u8_to_f32(pOut, pIn, sampleCount); + return; + } + + // Slightly more optimal implementation for common formats. + if (bytesPerSample == 2) { + drwav_s16_to_f32(pOut, (const drwav_int16*)pIn, sampleCount); + return; + } + if (bytesPerSample == 3) { + drwav_s24_to_f32(pOut, pIn, sampleCount); + return; + } + if (bytesPerSample == 4) { + drwav_s32_to_f32(pOut, (const drwav_int32*)pIn, sampleCount); + return; + } + + + // Anything more than 64 bits per sample is not supported. + if (bytesPerSample > 8) { + drwav_zero_memory(pOut, sampleCount * sizeof(*pOut)); + return; + } + + + // Generic, slow converter. + for (unsigned int i = 0; i < sampleCount; ++i) { + drwav_uint64 sample = 0; + unsigned int shift = (8 - bytesPerSample) * 8; + + unsigned int j; + for (j = 0; j < bytesPerSample && j < 8; j += 1) { + sample |= (drwav_uint64)(pIn[j]) << shift; + shift += 8; + } + + pIn += j; + *pOut++ = (float)((drwav_int64)sample / 9223372036854775807.0); + } +} + +static void drwav__ieee_to_f32(float* pOut, const unsigned char* pIn, size_t sampleCount, unsigned short bytesPerSample) +{ + if (bytesPerSample == 4) { + for (unsigned int i = 0; i < sampleCount; ++i) { + *pOut++ = ((float*)pIn)[i]; + } + return; + } else if (bytesPerSample == 8) { + drwav_f64_to_f32(pOut, (double*)pIn, sampleCount); + return; + } else { + // Only supporting 32- and 64-bit float. Output silence in all other cases. Contributions welcome for 16-bit float. + drwav_zero_memory(pOut, sampleCount * sizeof(*pOut)); + return; + } +} + + +drwav_uint64 drwav_read_f32__pcm(drwav* pWav, drwav_uint64 samplesToRead, float* pBufferOut) +{ + if (pWav->bytesPerSample == 0) { + return 0; + } + + drwav_uint64 totalSamplesRead = 0; + unsigned char sampleData[4096]; + while (samplesToRead > 0) { + drwav_uint64 samplesRead = drwav_read(pWav, drwav_min(samplesToRead, sizeof(sampleData)/pWav->bytesPerSample), sampleData); + if (samplesRead == 0) { + break; + } + + drwav__pcm_to_f32(pBufferOut, sampleData, (size_t)samplesRead, pWav->bytesPerSample); + pBufferOut += samplesRead; + + samplesToRead -= samplesRead; + totalSamplesRead += samplesRead; + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_f32__msadpcm(drwav* pWav, drwav_uint64 samplesToRead, float* pBufferOut) +{ + // We're just going to borrow the implementation from the drwav_read_s16() since ADPCM is a little bit more complicated than other formats and I don't + // want to duplicate that code. + drwav_uint64 totalSamplesRead = 0; + drwav_int16 samples16[2048]; + while (samplesToRead > 0) { + drwav_uint64 samplesRead = drwav_read_s16(pWav, drwav_min(samplesToRead, 2048), samples16); + if (samplesRead == 0) { + break; + } + + drwav_s16_to_f32(pBufferOut, samples16, (size_t)samplesRead); // <-- Safe cast because we're clamping to 2048. + + pBufferOut += samplesRead; + samplesToRead -= samplesRead; + totalSamplesRead += samplesRead; + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_f32__ima(drwav* pWav, drwav_uint64 samplesToRead, float* pBufferOut) +{ + // We're just going to borrow the implementation from the drwav_read_s16() since IMA-ADPCM is a little bit more complicated than other formats and I don't + // want to duplicate that code. + drwav_uint64 totalSamplesRead = 0; + drwav_int16 samples16[2048]; + while (samplesToRead > 0) { + drwav_uint64 samplesRead = drwav_read_s16(pWav, drwav_min(samplesToRead, 2048), samples16); + if (samplesRead == 0) { + break; + } + + drwav_s16_to_f32(pBufferOut, samples16, (size_t)samplesRead); // <-- Safe cast because we're clamping to 2048. + + pBufferOut += samplesRead; + samplesToRead -= samplesRead; + totalSamplesRead += samplesRead; + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_f32__ieee(drwav* pWav, drwav_uint64 samplesToRead, float* pBufferOut) +{ + // Fast path. + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_IEEE_FLOAT && pWav->bytesPerSample == 4) { + return drwav_read(pWav, samplesToRead, pBufferOut); + } + + if (pWav->bytesPerSample == 0) { + return 0; + } + + drwav_uint64 totalSamplesRead = 0; + unsigned char sampleData[4096]; + while (samplesToRead > 0) { + drwav_uint64 samplesRead = drwav_read(pWav, drwav_min(samplesToRead, sizeof(sampleData)/pWav->bytesPerSample), sampleData); + if (samplesRead == 0) { + break; + } + + drwav__ieee_to_f32(pBufferOut, sampleData, (size_t)samplesRead, pWav->bytesPerSample); + + pBufferOut += samplesRead; + samplesToRead -= samplesRead; + totalSamplesRead += samplesRead; + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_f32__alaw(drwav* pWav, drwav_uint64 samplesToRead, float* pBufferOut) +{ + if (pWav->bytesPerSample == 0) { + return 0; + } + + drwav_uint64 totalSamplesRead = 0; + unsigned char sampleData[4096]; + while (samplesToRead > 0) { + drwav_uint64 samplesRead = drwav_read(pWav, drwav_min(samplesToRead, sizeof(sampleData)/pWav->bytesPerSample), sampleData); + if (samplesRead == 0) { + break; + } + + drwav_alaw_to_f32(pBufferOut, sampleData, (size_t)samplesRead); + + pBufferOut += samplesRead; + samplesToRead -= samplesRead; + totalSamplesRead += samplesRead; + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_f32__mulaw(drwav* pWav, drwav_uint64 samplesToRead, float* pBufferOut) +{ + if (pWav->bytesPerSample == 0) { + return 0; + } + + drwav_uint64 totalSamplesRead = 0; + unsigned char sampleData[4096]; + while (samplesToRead > 0) { + drwav_uint64 samplesRead = drwav_read(pWav, drwav_min(samplesToRead, sizeof(sampleData)/pWav->bytesPerSample), sampleData); + if (samplesRead == 0) { + break; + } + + drwav_mulaw_to_f32(pBufferOut, sampleData, (size_t)samplesRead); + + pBufferOut += samplesRead; + samplesToRead -= samplesRead; + totalSamplesRead += samplesRead; + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_f32(drwav* pWav, drwav_uint64 samplesToRead, float* pBufferOut) +{ + if (pWav == NULL || samplesToRead == 0 || pBufferOut == NULL) { + return 0; + } + + // Don't try to read more samples than can potentially fit in the output buffer. + if (samplesToRead * sizeof(float) > SIZE_MAX) { + samplesToRead = SIZE_MAX / sizeof(float); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_PCM) { + return drwav_read_f32__pcm(pWav, samplesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) { + return drwav_read_f32__msadpcm(pWav, samplesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_IEEE_FLOAT) { + return drwav_read_f32__ieee(pWav, samplesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ALAW) { + return drwav_read_f32__alaw(pWav, samplesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_MULAW) { + return drwav_read_f32__mulaw(pWav, samplesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) { + return drwav_read_f32__ima(pWav, samplesToRead, pBufferOut); + } + + return 0; +} + +void drwav_u8_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + if (pOut == NULL || pIn == NULL) { + return; + } + +#ifdef DR_WAV_LIBSNDFILE_COMPAT + // It appears libsndfile uses slightly different logic for the u8 -> f32 conversion to dr_wav, which in my opinion is incorrect. It appears + // libsndfile performs the conversion something like "f32 = (u8 / 256) * 2 - 1", however I think it should be "f32 = (u8 / 255) * 2 - 1" (note + // the divisor of 256 vs 255). I use libsndfile as a benchmark for testing, so I'm therefore leaving this block here just for my automated + // correctness testing. This is disabled by default. + for (size_t i = 0; i < sampleCount; ++i) { + *pOut++ = (pIn[i] / 256.0f) * 2 - 1; + } +#else + for (size_t i = 0; i < sampleCount; ++i) { + *pOut++ = (pIn[i] / 255.0f) * 2 - 1; + } +#endif +} + +void drwav_s16_to_f32(float* pOut, const drwav_int16* pIn, size_t sampleCount) +{ + if (pOut == NULL || pIn == NULL) { + return; + } + + for (size_t i = 0; i < sampleCount; ++i) { + *pOut++ = pIn[i] / 32768.0f; + } +} + +void drwav_s24_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + if (pOut == NULL || pIn == NULL) { + return; + } + + for (size_t i = 0; i < sampleCount; ++i) { + unsigned int s0 = pIn[i*3 + 0]; + unsigned int s1 = pIn[i*3 + 1]; + unsigned int s2 = pIn[i*3 + 2]; + + int sample32 = (int)((s0 << 8) | (s1 << 16) | (s2 << 24)); + *pOut++ = (float)(sample32 / 2147483648.0); + } +} + +void drwav_s32_to_f32(float* pOut, const drwav_int32* pIn, size_t sampleCount) +{ + if (pOut == NULL || pIn == NULL) { + return; + } + + for (size_t i = 0; i < sampleCount; ++i) { + *pOut++ = (float)(pIn[i] / 2147483648.0); + } +} + +void drwav_f64_to_f32(float* pOut, const double* pIn, size_t sampleCount) +{ + if (pOut == NULL || pIn == NULL) { + return; + } + + for (size_t i = 0; i < sampleCount; ++i) { + *pOut++ = (float)pIn[i]; + } +} + +void drwav_alaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + if (pOut == NULL || pIn == NULL) { + return; + } + + for (size_t i = 0; i < sampleCount; ++i) { + *pOut++ = drwav__alaw_to_s16(pIn[i]) / 32768.0f; + } +} + +void drwav_mulaw_to_f32(float* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + if (pOut == NULL || pIn == NULL) { + return; + } + + for (size_t i = 0; i < sampleCount; ++i) { + *pOut++ = drwav__mulaw_to_s16(pIn[i]) / 32768.0f; + } +} + + + +static void drwav__pcm_to_s32(drwav_int32* pOut, const unsigned char* pIn, size_t totalSampleCount, unsigned short bytesPerSample) +{ + // Special case for 8-bit sample data because it's treated as unsigned. + if (bytesPerSample == 1) { + drwav_u8_to_s32(pOut, pIn, totalSampleCount); + return; + } + + // Slightly more optimal implementation for common formats. + if (bytesPerSample == 2) { + drwav_s16_to_s32(pOut, (const drwav_int16*)pIn, totalSampleCount); + return; + } + if (bytesPerSample == 3) { + drwav_s24_to_s32(pOut, pIn, totalSampleCount); + return; + } + if (bytesPerSample == 4) { + for (unsigned int i = 0; i < totalSampleCount; ++i) { + *pOut++ = ((drwav_int32*)pIn)[i]; + } + return; + } + + + // Anything more than 64 bits per sample is not supported. + if (bytesPerSample > 8) { + drwav_zero_memory(pOut, totalSampleCount * sizeof(*pOut)); + return; + } + + + // Generic, slow converter. + for (unsigned int i = 0; i < totalSampleCount; ++i) { + drwav_uint64 sample = 0; + unsigned int shift = (8 - bytesPerSample) * 8; + + unsigned int j; + for (j = 0; j < bytesPerSample && j < 8; j += 1) { + sample |= (drwav_uint64)(pIn[j]) << shift; + shift += 8; + } + + pIn += j; + *pOut++ = (drwav_int32)((drwav_int64)sample >> 32); + } +} + +static void drwav__ieee_to_s32(drwav_int32* pOut, const unsigned char* pIn, size_t totalSampleCount, unsigned short bytesPerSample) +{ + if (bytesPerSample == 4) { + drwav_f32_to_s32(pOut, (float*)pIn, totalSampleCount); + return; + } else if (bytesPerSample == 8) { + drwav_f64_to_s32(pOut, (double*)pIn, totalSampleCount); + return; + } else { + // Only supporting 32- and 64-bit float. Output silence in all other cases. Contributions welcome for 16-bit float. + drwav_zero_memory(pOut, totalSampleCount * sizeof(*pOut)); + return; + } +} + + +drwav_uint64 drwav_read_s32__pcm(drwav* pWav, drwav_uint64 samplesToRead, drwav_int32* pBufferOut) +{ + // Fast path. + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_PCM && pWav->bytesPerSample == 4) { + return drwav_read(pWav, samplesToRead, pBufferOut); + } + + if (pWav->bytesPerSample == 0) { + return 0; + } + + drwav_uint64 totalSamplesRead = 0; + unsigned char sampleData[4096]; + while (samplesToRead > 0) { + drwav_uint64 samplesRead = drwav_read(pWav, drwav_min(samplesToRead, sizeof(sampleData)/pWav->bytesPerSample), sampleData); + if (samplesRead == 0) { + break; + } + + drwav__pcm_to_s32(pBufferOut, sampleData, (size_t)samplesRead, pWav->bytesPerSample); + + pBufferOut += samplesRead; + samplesToRead -= samplesRead; + totalSamplesRead += samplesRead; + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_s32__msadpcm(drwav* pWav, drwav_uint64 samplesToRead, drwav_int32* pBufferOut) +{ + // We're just going to borrow the implementation from the drwav_read_s16() since ADPCM is a little bit more complicated than other formats and I don't + // want to duplicate that code. + drwav_uint64 totalSamplesRead = 0; + drwav_int16 samples16[2048]; + while (samplesToRead > 0) { + drwav_uint64 samplesRead = drwav_read_s16(pWav, drwav_min(samplesToRead, 2048), samples16); + if (samplesRead == 0) { + break; + } + + drwav_s16_to_s32(pBufferOut, samples16, (size_t)samplesRead); // <-- Safe cast because we're clamping to 2048. + + pBufferOut += samplesRead; + samplesToRead -= samplesRead; + totalSamplesRead += samplesRead; + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_s32__ima(drwav* pWav, drwav_uint64 samplesToRead, drwav_int32* pBufferOut) +{ + // We're just going to borrow the implementation from the drwav_read_s16() since IMA-ADPCM is a little bit more complicated than other formats and I don't + // want to duplicate that code. + drwav_uint64 totalSamplesRead = 0; + drwav_int16 samples16[2048]; + while (samplesToRead > 0) { + drwav_uint64 samplesRead = drwav_read_s16(pWav, drwav_min(samplesToRead, 2048), samples16); + if (samplesRead == 0) { + break; + } + + drwav_s16_to_s32(pBufferOut, samples16, (size_t)samplesRead); // <-- Safe cast because we're clamping to 2048. + + pBufferOut += samplesRead; + samplesToRead -= samplesRead; + totalSamplesRead += samplesRead; + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_s32__ieee(drwav* pWav, drwav_uint64 samplesToRead, drwav_int32* pBufferOut) +{ + if (pWav->bytesPerSample == 0) { + return 0; + } + + drwav_uint64 totalSamplesRead = 0; + unsigned char sampleData[4096]; + while (samplesToRead > 0) { + drwav_uint64 samplesRead = drwav_read(pWav, drwav_min(samplesToRead, sizeof(sampleData)/pWav->bytesPerSample), sampleData); + if (samplesRead == 0) { + break; + } + + drwav__ieee_to_s32(pBufferOut, sampleData, (size_t)samplesRead, pWav->bytesPerSample); + + pBufferOut += samplesRead; + samplesToRead -= samplesRead; + totalSamplesRead += samplesRead; + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_s32__alaw(drwav* pWav, drwav_uint64 samplesToRead, drwav_int32* pBufferOut) +{ + if (pWav->bytesPerSample == 0) { + return 0; + } + + drwav_uint64 totalSamplesRead = 0; + unsigned char sampleData[4096]; + while (samplesToRead > 0) { + drwav_uint64 samplesRead = drwav_read(pWav, drwav_min(samplesToRead, sizeof(sampleData)/pWav->bytesPerSample), sampleData); + if (samplesRead == 0) { + break; + } + + drwav_alaw_to_s32(pBufferOut, sampleData, (size_t)samplesRead); + + pBufferOut += samplesRead; + samplesToRead -= samplesRead; + totalSamplesRead += samplesRead; + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_s32__mulaw(drwav* pWav, drwav_uint64 samplesToRead, drwav_int32* pBufferOut) +{ + if (pWav->bytesPerSample == 0) { + return 0; + } + + drwav_uint64 totalSamplesRead = 0; + unsigned char sampleData[4096]; + while (samplesToRead > 0) { + drwav_uint64 samplesRead = drwav_read(pWav, drwav_min(samplesToRead, sizeof(sampleData)/pWav->bytesPerSample), sampleData); + if (samplesRead == 0) { + break; + } + + drwav_mulaw_to_s32(pBufferOut, sampleData, (size_t)samplesRead); + + pBufferOut += samplesRead; + samplesToRead -= samplesRead; + totalSamplesRead += samplesRead; + } + + return totalSamplesRead; +} + +drwav_uint64 drwav_read_s32(drwav* pWav, drwav_uint64 samplesToRead, drwav_int32* pBufferOut) +{ + if (pWav == NULL || samplesToRead == 0 || pBufferOut == NULL) { + return 0; + } + + // Don't try to read more samples than can potentially fit in the output buffer. + if (samplesToRead * sizeof(drwav_int32) > SIZE_MAX) { + samplesToRead = SIZE_MAX / sizeof(drwav_int32); + } + + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_PCM) { + return drwav_read_s32__pcm(pWav, samplesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ADPCM) { + return drwav_read_s32__msadpcm(pWav, samplesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_IEEE_FLOAT) { + return drwav_read_s32__ieee(pWav, samplesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_ALAW) { + return drwav_read_s32__alaw(pWav, samplesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_MULAW) { + return drwav_read_s32__mulaw(pWav, samplesToRead, pBufferOut); + } + + if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) { + return drwav_read_s32__ima(pWav, samplesToRead, pBufferOut); + } + + return 0; +} + +void drwav_u8_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + if (pOut == NULL || pIn == NULL) { + return; + } + + for (size_t i = 0; i < sampleCount; ++i) { + *pOut++ = ((int)pIn[i] - 128) << 24; + } +} + +void drwav_s16_to_s32(drwav_int32* pOut, const drwav_int16* pIn, size_t sampleCount) +{ + if (pOut == NULL || pIn == NULL) { + return; + } + + for (size_t i = 0; i < sampleCount; ++i) { + *pOut++ = pIn[i] << 16; + } +} + +void drwav_s24_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + if (pOut == NULL || pIn == NULL) { + return; + } + + for (size_t i = 0; i < sampleCount; ++i) { + unsigned int s0 = pIn[i*3 + 0]; + unsigned int s1 = pIn[i*3 + 1]; + unsigned int s2 = pIn[i*3 + 2]; + + drwav_int32 sample32 = (drwav_int32)((s0 << 8) | (s1 << 16) | (s2 << 24)); + *pOut++ = sample32; + } +} + +void drwav_f32_to_s32(drwav_int32* pOut, const float* pIn, size_t sampleCount) +{ + if (pOut == NULL || pIn == NULL) { + return; + } + + for (size_t i = 0; i < sampleCount; ++i) { + *pOut++ = (drwav_int32)(2147483648.0 * pIn[i]); + } +} + +void drwav_f64_to_s32(drwav_int32* pOut, const double* pIn, size_t sampleCount) +{ + if (pOut == NULL || pIn == NULL) { + return; + } + + for (size_t i = 0; i < sampleCount; ++i) { + *pOut++ = (drwav_int32)(2147483648.0 * pIn[i]); + } +} + +void drwav_alaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + if (pOut == NULL || pIn == NULL) { + return; + } + + for (size_t i = 0; i < sampleCount; ++i) { + *pOut++ = ((drwav_int32)drwav__alaw_to_s16(pIn[i])) << 16; + } +} + +void drwav_mulaw_to_s32(drwav_int32* pOut, const drwav_uint8* pIn, size_t sampleCount) +{ + if (pOut == NULL || pIn == NULL) { + return; + } + + for (size_t i= 0; i < sampleCount; ++i) { + *pOut++ = ((drwav_int32)drwav__mulaw_to_s16(pIn[i])) << 16; + } +} + + + +drwav_int16* drwav__read_and_close_s16(drwav* pWav, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount) +{ + drwav_assert(pWav != NULL); + + drwav_uint64 sampleDataSize = pWav->totalSampleCount * sizeof(drwav_int16); + if (sampleDataSize > SIZE_MAX) { + drwav_uninit(pWav); + return NULL; // File's too big. + } + + drwav_int16* pSampleData = (drwav_int16*)DRWAV_MALLOC((size_t)sampleDataSize); // <-- Safe cast due to the check above. + if (pSampleData == NULL) { + drwav_uninit(pWav); + return NULL; // Failed to allocate memory. + } + + drwav_uint64 samplesRead = drwav_read_s16(pWav, (size_t)pWav->totalSampleCount, pSampleData); + if (samplesRead != pWav->totalSampleCount) { + DRWAV_FREE(pSampleData); + drwav_uninit(pWav); + return NULL; // There was an error reading the samples. + } + + drwav_uninit(pWav); + + if (sampleRate) *sampleRate = pWav->sampleRate; + if (channels) *channels = pWav->channels; + if (totalSampleCount) *totalSampleCount = pWav->totalSampleCount; + return pSampleData; +} + +float* drwav__read_and_close_f32(drwav* pWav, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount) +{ + drwav_assert(pWav != NULL); + + drwav_uint64 sampleDataSize = pWav->totalSampleCount * sizeof(float); + if (sampleDataSize > SIZE_MAX) { + drwav_uninit(pWav); + return NULL; // File's too big. + } + + float* pSampleData = (float*)DRWAV_MALLOC((size_t)sampleDataSize); // <-- Safe cast due to the check above. + if (pSampleData == NULL) { + drwav_uninit(pWav); + return NULL; // Failed to allocate memory. + } + + drwav_uint64 samplesRead = drwav_read_f32(pWav, (size_t)pWav->totalSampleCount, pSampleData); + if (samplesRead != pWav->totalSampleCount) { + DRWAV_FREE(pSampleData); + drwav_uninit(pWav); + return NULL; // There was an error reading the samples. + } + + drwav_uninit(pWav); + + if (sampleRate) *sampleRate = pWav->sampleRate; + if (channels) *channels = pWav->channels; + if (totalSampleCount) *totalSampleCount = pWav->totalSampleCount; + return pSampleData; +} + +drwav_int32* drwav__read_and_close_s32(drwav* pWav, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount) +{ + drwav_assert(pWav != NULL); + + drwav_uint64 sampleDataSize = pWav->totalSampleCount * sizeof(drwav_int32); + if (sampleDataSize > SIZE_MAX) { + drwav_uninit(pWav); + return NULL; // File's too big. + } + + drwav_int32* pSampleData = (drwav_int32*)DRWAV_MALLOC((size_t)sampleDataSize); // <-- Safe cast due to the check above. + if (pSampleData == NULL) { + drwav_uninit(pWav); + return NULL; // Failed to allocate memory. + } + + drwav_uint64 samplesRead = drwav_read_s32(pWav, (size_t)pWav->totalSampleCount, pSampleData); + if (samplesRead != pWav->totalSampleCount) { + DRWAV_FREE(pSampleData); + drwav_uninit(pWav); + return NULL; // There was an error reading the samples. + } + + drwav_uninit(pWav); + + if (sampleRate) *sampleRate = pWav->sampleRate; + if (channels) *channels = pWav->channels; + if (totalSampleCount) *totalSampleCount = pWav->totalSampleCount; + return pSampleData; +} + + +drwav_int16* drwav_open_and_read_s16(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount) +{ + if (sampleRate) *sampleRate = 0; + if (channels) *channels = 0; + if (totalSampleCount) *totalSampleCount = 0; + + drwav wav; + if (!drwav_init(&wav, onRead, onSeek, pUserData)) { + return NULL; + } + + return drwav__read_and_close_s16(&wav, channels, sampleRate, totalSampleCount); +} + +float* drwav_open_and_read_f32(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount) +{ + if (sampleRate) *sampleRate = 0; + if (channels) *channels = 0; + if (totalSampleCount) *totalSampleCount = 0; + + drwav wav; + if (!drwav_init(&wav, onRead, onSeek, pUserData)) { + return NULL; + } + + return drwav__read_and_close_f32(&wav, channels, sampleRate, totalSampleCount); +} + +drwav_int32* drwav_open_and_read_s32(drwav_read_proc onRead, drwav_seek_proc onSeek, void* pUserData, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount) +{ + if (sampleRate) *sampleRate = 0; + if (channels) *channels = 0; + if (totalSampleCount) *totalSampleCount = 0; + + drwav wav; + if (!drwav_init(&wav, onRead, onSeek, pUserData)) { + return NULL; + } + + return drwav__read_and_close_s32(&wav, channels, sampleRate, totalSampleCount); +} + +#ifndef DR_WAV_NO_STDIO +drwav_int16* drwav_open_and_read_file_s16(const char* filename, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount) +{ + if (sampleRate) *sampleRate = 0; + if (channels) *channels = 0; + if (totalSampleCount) *totalSampleCount = 0; + + drwav wav; + if (!drwav_init_file(&wav, filename)) { + return NULL; + } + + return drwav__read_and_close_s16(&wav, channels, sampleRate, totalSampleCount); +} + +float* drwav_open_and_read_file_f32(const char* filename, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount) +{ + if (sampleRate) *sampleRate = 0; + if (channels) *channels = 0; + if (totalSampleCount) *totalSampleCount = 0; + + drwav wav; + if (!drwav_init_file(&wav, filename)) { + return NULL; + } + + return drwav__read_and_close_f32(&wav, channels, sampleRate, totalSampleCount); +} + +drwav_int32* drwav_open_and_read_file_s32(const char* filename, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount) +{ + if (sampleRate) *sampleRate = 0; + if (channels) *channels = 0; + if (totalSampleCount) *totalSampleCount = 0; + + drwav wav; + if (!drwav_init_file(&wav, filename)) { + return NULL; + } + + return drwav__read_and_close_s32(&wav, channels, sampleRate, totalSampleCount); +} +#endif + +drwav_int16* drwav_open_and_read_memory_s16(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount) +{ + if (sampleRate) *sampleRate = 0; + if (channels) *channels = 0; + if (totalSampleCount) *totalSampleCount = 0; + + drwav wav; + if (!drwav_init_memory(&wav, data, dataSize)) { + return NULL; + } + + return drwav__read_and_close_s16(&wav, channels, sampleRate, totalSampleCount); +} + +float* drwav_open_and_read_memory_f32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount) +{ + if (sampleRate) *sampleRate = 0; + if (channels) *channels = 0; + if (totalSampleCount) *totalSampleCount = 0; + + drwav wav; + if (!drwav_init_memory(&wav, data, dataSize)) { + return NULL; + } + + return drwav__read_and_close_f32(&wav, channels, sampleRate, totalSampleCount); +} + +drwav_int32* drwav_open_and_read_memory_s32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, drwav_uint64* totalSampleCount) +{ + if (sampleRate) *sampleRate = 0; + if (channels) *channels = 0; + if (totalSampleCount) *totalSampleCount = 0; + + drwav wav; + if (!drwav_init_memory(&wav, data, dataSize)) { + return NULL; + } + + return drwav__read_and_close_s32(&wav, channels, sampleRate, totalSampleCount); +} +#endif //DR_WAV_NO_CONVERSION_API + + +void drwav_free(void* pDataReturnedByOpenAndRead) +{ + DRWAV_FREE(pDataReturnedByOpenAndRead); +} + +#endif //DR_WAV_IMPLEMENTATION + + +// REVISION HISTORY +// +// v0.8.1 - 2018-06-29 +// - Add support for sequential writing APIs. +// - Disable seeking in write mode. +// - Fix bugs with Wave64. +// - Fix typos. +// +// v0.8 - 2018-04-27 +// - Bug fix. +// - Start using major.minor.revision versioning. +// +// v0.7f - 2018-02-05 +// - Restrict ADPCM formats to a maximum of 2 channels. +// +// v0.7e - 2018-02-02 +// - Fix a crash. +// +// v0.7d - 2018-02-01 +// - Fix a crash. +// +// v0.7c - 2018-02-01 +// - Set drwav.bytesPerSample to 0 for all compressed formats. +// - Fix a crash when reading 16-bit floating point WAV files. In this case dr_wav will output silence for +// all format conversion reading APIs (*_s16, *_s32, *_f32 APIs). +// - Fix some divide-by-zero errors. +// +// v0.7b - 2018-01-22 +// - Fix errors with seeking of compressed formats. +// - Fix compilation error when DR_WAV_NO_CONVERSION_API +// +// v0.7a - 2017-11-17 +// - Fix some GCC warnings. +// +// v0.7 - 2017-11-04 +// - Add writing APIs. +// +// v0.6 - 2017-08-16 +// - API CHANGE: Rename dr_* types to drwav_*. +// - Add support for custom implementations of malloc(), realloc(), etc. +// - Add support for Microsoft ADPCM. +// - Add support for IMA ADPCM (DVI, format code 0x11). +// - Optimizations to drwav_read_s16(). +// - Bug fixes. +// +// v0.5g - 2017-07-16 +// - Change underlying type for booleans to unsigned. +// +// v0.5f - 2017-04-04 +// - Fix a minor bug with drwav_open_and_read_s16() and family. +// +// v0.5e - 2016-12-29 +// - Added support for reading samples as signed 16-bit integers. Use the _s16() family of APIs for this. +// - Minor fixes to documentation. +// +// v0.5d - 2016-12-28 +// - Use drwav_int*/drwav_uint* sized types to improve compiler support. +// +// v0.5c - 2016-11-11 +// - Properly handle JUNK chunks that come before the FMT chunk. +// +// v0.5b - 2016-10-23 +// - A minor change to drwav_bool8 and drwav_bool32 types. +// +// v0.5a - 2016-10-11 +// - Fixed a bug with drwav_open_and_read() and family due to incorrect argument ordering. +// - Improve A-law and mu-law efficiency. +// +// v0.5 - 2016-09-29 +// - API CHANGE. Swap the order of "channels" and "sampleRate" parameters in drwav_open_and_read*(). Rationale for this is to +// keep it consistent with dr_audio and dr_flac. +// +// v0.4b - 2016-09-18 +// - Fixed a typo in documentation. +// +// v0.4a - 2016-09-18 +// - Fixed a typo. +// - Change date format to ISO 8601 (YYYY-MM-DD) +// +// v0.4 - 2016-07-13 +// - API CHANGE. Make onSeek consistent with dr_flac. +// - API CHANGE. Rename drwav_seek() to drwav_seek_to_sample() for clarity and consistency with dr_flac. +// - Added support for Sony Wave64. +// +// v0.3a - 2016-05-28 +// - API CHANGE. Return drwav_bool32 instead of int in onSeek callback. +// - Fixed a memory leak. +// +// v0.3 - 2016-05-22 +// - Lots of API changes for consistency. +// +// v0.2a - 2016-05-16 +// - Fixed Linux/GCC build. +// +// v0.2 - 2016-05-11 +// - Added support for reading data as signed 32-bit PCM for consistency with dr_flac. +// +// v0.1a - 2016-05-07 +// - Fixed a bug in drwav_open_file() where the file handle would not be closed if the loader failed to initialize. +// +// v0.1 - 2016-05-04 +// - Initial versioned release. + + +/* +This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or +distribute this software, either in source code form or as a compiled +binary, for any purpose, commercial or non-commercial, and by any +means. + +In jurisdictions that recognize copyright laws, the author or authors +of this software dedicate any and all copyright interest in the +software to the public domain. We make this dedication for the benefit +of the public at large and to the detriment of our heirs and +successors. We intend this dedication to be an overt act of +relinquishment in perpetuity of all present and future rights to this +software under copyright law. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +For more information, please refer to +*/ diff --git a/vst2_bin/CHANGELOG_VST.txt b/vst2_bin/CHANGELOG_VST.txt index d9a811cf..4e00a97a 100644 --- a/vst2_bin/CHANGELOG_VST.txt +++ b/vst2_bin/CHANGELOG_VST.txt @@ -1,4 +1,14 @@ +** November ??, 2018 +- update cf modules to v0.6.7 +- add module cf.ALGEBRA +- add module cf.BUFFER +- add module cf.CHOKE +- add module cf.DISTO +- add module cf.PLAY +- add module cf.VARIABLE + + ** October 31st, 2018 - add Linux port - thanks to Github user "cameronleger" for porting LGLW ! diff --git a/vst2_bin/log.txt b/vst2_bin/log.txt index a469520c..503d4ed8 100644 --- a/vst2_bin/log.txt +++ b/vst2_bin/log.txt @@ -3,19 +3,19 @@ [0.000 info src/main.cpp:71] Local directory: f:\git\VeeSeeVSTRack\vst2_bin\/ [0.000 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin 21kHz 0.6.1 [0.000 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin AmalgamatedHarmonics 0.6.1 -[0.000 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Alikins 0.6.1 -[0.000 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin alto777_LFSR 0.6.1 +[0.001 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Alikins 0.6.1 +[0.001 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin alto777_LFSR 0.6.1 [0.001 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin AS 0.6.9 [0.001 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin AudibleInstruments 0.6.3 [0.001 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Autodafe 0.6.1 [0.001 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin BaconMusic 0.6.1 [0.002 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Befaco 0.6.1 [0.002 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Bidoo 0.6.1 -[0.002 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Bogaudio 0.6.7 -[0.002 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin CastleRocktronics 0.6.1 -[0.002 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin cf 0.6.1 -[0.002 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin com-soundchasing-stochasm 0.6.1 -[0.002 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin computerscare 0.6.1 +[0.003 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Bogaudio 0.6.7 +[0.003 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin CastleRocktronics 0.6.1 +[0.003 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin cf 0.6.7 +[0.003 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin com-soundchasing-stochasm 0.6.1 +[0.003 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin computerscare 0.6.1 [0.003 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin DHE-Modules 0.6.1 [0.003 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin DrumKit 0.6.1 [0.003 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin ErraticInstruments 0.6.1 @@ -23,21 +23,21 @@ [0.003 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin FrankBussFormula 0.6.1 [0.003 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin FrozenWasteland 0.6.1 [0.003 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Fundamental 0.6.1 -[0.003 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Geodesics 0.6.1 -[0.003 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Gratrix 0.6.1 -[0.003 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin HetrickCV 0.6.1 -[0.003 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin huaba 0.6.1 -[0.003 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin ImpromptuModular 0.6.11 +[0.004 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Geodesics 0.6.1 +[0.004 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Gratrix 0.6.1 +[0.004 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin HetrickCV 0.6.1 +[0.004 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin huaba 0.6.1 +[0.004 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin ImpromptuModular 0.6.11 [0.004 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin JE 0.6.1 [0.004 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin JW-Modules 0.6.1 [0.004 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Koralfx-Modules 0.6.1 [0.004 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin LindenbergResearch 0.6.2b [0.004 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin LOGinstruments 0.6.1 [0.004 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin mental 0.6.1 -[0.004 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin ML_modules 0.6.1 -[0.004 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin moDllz 0.6.1 -[0.004 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin modular80 0.6.1 -[0.004 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin mscHack 0.6.1 +[0.005 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin ML_modules 0.6.1 +[0.005 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin moDllz 0.6.1 +[0.005 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin modular80 0.6.1 +[0.005 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin mscHack 0.6.1 [0.005 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin mtsch-plugins 0.6.1 [0.005 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin NauModular 0.6.1 [0.005 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Nohmad 0.6.1 @@ -45,142 +45,89 @@ [0.005 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin PG-Instruments 0.6.1 [0.005 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin PvC 0.6.1 [0.005 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Qwelk 0.6.1 -[0.005 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin RJModules 0.6.1 -[0.005 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin SerialRacker 0.6.1 -[0.005 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin SonusModular 0.6.1 -[0.005 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Southpole 0.6.1 +[0.006 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin RJModules 0.6.1 +[0.006 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin SerialRacker 0.6.1 +[0.006 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin SonusModular 0.6.1 +[0.006 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Southpole 0.6.1 [0.006 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Southpole-parasites 0.6.1 [0.006 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin squinkylabs-plug1 0.6.9 [0.006 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin SubmarineFree 0.6.8 [0.006 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin SynthKit 0.6.1 [0.006 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Template 0.6.1 -[0.006 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin TheXOR 0.6.1 -[0.006 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin trowaSoft 0.6.1 -[0.006 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin unless_modules 0.6.1 -[0.006 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Valley 0.6.1 +[0.007 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin TheXOR 0.6.1 +[0.007 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin trowaSoft 0.6.1 +[0.007 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin unless_modules 0.6.1 +[0.007 info src/plugin_static.cpp:140] vcvrack: Loaded static plugin Valley 0.6.1 [0.007 info src/plugin.cpp:90] trying to load shared plugin file f:\git\VeeSeeVSTRack\vst2_bin\/plugins/bsp/plugin.dll.instr [0.008 info src/plugin.cpp:160] Loaded plugin bsp 0.6.1 from f:\git\VeeSeeVSTRack\vst2_bin\/plugins/bsp/plugin.dll.instr [0.008 info src/plugin.cpp:90] trying to load shared plugin file f:\git\VeeSeeVSTRack\vst2_bin\/plugins/dBiz/plugin.dll.instr [0.009 info src/plugin.cpp:160] Loaded plugin dBiz 0.6.1 from f:\git\VeeSeeVSTRack\vst2_bin\/plugins/dBiz/plugin.dll.instr -[0.009 info src/plugin.cpp:90] trying to load shared plugin file f:\git\VeeSeeVSTRack\vst2_bin\/plugins/Template_shared/plugin.dll.instr -[0.010 info src/plugin.cpp:160] Loaded plugin Template_shared 0.6.1 from f:\git\VeeSeeVSTRack\vst2_bin\/plugins/Template_shared/plugin.dll.instr +[0.010 info src/plugin.cpp:90] trying to load shared plugin file f:\git\VeeSeeVSTRack\vst2_bin\/plugins/Template_shared/plugin.dll.instr +[0.011 info src/plugin.cpp:160] Loaded plugin Template_shared 0.6.1 from f:\git\VeeSeeVSTRack\vst2_bin\/plugins/Template_shared/plugin.dll.instr [0.011 info src/settings.cpp:462] Loading settings f:\git\VeeSeeVSTRack\vst2_bin\/settings.json [0.020 info src/window.cpp:725] Loaded font f:\git\VeeSeeVSTRack\vst2_bin\/res/fonts/DejaVuSans.ttf -[0.020 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/noun_146097_cc.svg +[0.021 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/noun_146097_cc.svg [0.021 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/noun_31859_cc.svg -[0.021 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/noun_1343816_cc.svg -[0.021 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/noun_1343811_cc.svg -[0.021 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/noun_1084369_cc.svg -[0.021 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/noun_1745061_cc.svg +[0.022 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/noun_1343816_cc.svg +[0.022 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/noun_1343811_cc.svg +[0.022 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/noun_1084369_cc.svg +[0.022 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/noun_1745061_cc.svg [0.022 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/noun_1240789_cc.svg -[0.022 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/noun_305536_cc.svg -[0.022 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/noun_468341_cc.svg -[0.022 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/idle_mode_icon_cc.svg -[0.022 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/settings_icon_cc.svg -[0.022 info src/settings.cpp:462] Loading settings f:\git\VeeSeeVSTRack\vst2_bin\/settings.json -[0.030 info src/app/RackWidget.cpp:216] Loading patch from string -[0.031 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/Core/AudioInterface.svg -[0.032 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/ScrewSilver.svg -[0.032 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/PJ301M.svg -[0.032 info src/window.cpp:725] Loaded font f:\git\VeeSeeVSTRack\vst2_bin\/res/fonts/ShareTechMono-Regular.ttf -[0.033 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/Core/MIDIToCVInterface.svg -[0.036 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/XCO.svg -[0.036 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/knob_68px.svg -[0.036 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/knob_16px.svg -[0.036 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/button_9px_0.svg -[0.036 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/button_9px_1.svg -[0.037 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/knob_38px.svg -[0.037 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/slider_switch_2_14px_0.svg -[0.037 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/slider_switch_2_14px_1.svg -[0.037 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/port.svg -[0.038 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Fundamental/res/VCA.svg -[0.038 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/RoundLargeBlackKnob.svg -[0.040 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/AS/res/ADSR.svg -[0.040 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/AS/res/as-hexscrew.svg -[0.040 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/AS/res/as-SlidePot.svg -[0.040 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/AS/res/as-SlidePotHandle.svg -[0.041 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/AS/res/as-PJ301M.svg -[0.044 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/21kHz/res/Panels/D_Inf.svg -[0.044 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/21kHz/res/Components/kHzScrew.svg -[0.045 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/21kHz/res/Components/kHzKnobSmall.svg -[0.045 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/21kHz/res/Components/kHzButton_0.svg -[0.045 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/21kHz/res/Components/kHzButton_1.svg -[0.045 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/21kHz/res/Components/kHzPort.svg -[0.046 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Autodafe/res/Multiple18.svg -[0.046 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/PJ3410.svg -[5.288 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/AudibleInstruments/res/Rings.svg -[5.288 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/TL1105_0.svg -[5.288 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/TL1105_1.svg -[5.289 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/Rogan3PSWhite.svg -[5.289 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/Rogan1PSWhite.svg -[5.289 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/Trimpot.svg -[8.429 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/AudibleInstruments/res/Plaits.svg -[12.083 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/AudibleInstruments/res/Stages.svg -[12.083 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/LEDSlider.svg -[12.083 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/LEDSliderGreenHandle.svg -[37.782 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/DexterPanelDark.svg -[37.788 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/DexterPanelLight.svg -[37.789 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/ScrewBlack.svg -[37.789 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo0.svg -[37.789 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo1.svg -[37.790 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo2.svg -[37.790 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo3.svg -[37.790 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo4.svg -[37.791 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo5.svg -[37.791 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo6.svg -[37.791 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo7.svg -[37.792 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo8.svg -[37.792 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo9.svg -[37.792 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo10.svg -[37.792 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo11.svg -[37.793 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo12.svg -[37.793 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo13.svg -[37.793 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo14.svg -[37.793 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo15.svg -[37.794 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo16.svg -[37.794 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo17.svg -[37.794 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo18.svg -[37.795 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo19.svg -[37.795 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo20.svg -[37.795 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo21.svg -[37.795 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo22.svg -[37.796 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo0Dark.svg -[37.796 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo1Dark.svg -[37.796 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo2Dark.svg -[37.797 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo3Dark.svg -[37.797 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo4Dark.svg -[37.797 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo5Dark.svg -[37.798 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo6Dark.svg -[37.799 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo7Dark.svg -[37.799 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo8Dark.svg -[37.799 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo9Dark.svg -[37.799 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo10Dark.svg -[37.800 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo11Dark.svg -[37.800 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo12Dark.svg -[37.800 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo13Dark.svg -[37.801 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo14Dark.svg -[37.801 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo15Dark.svg -[37.801 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo16Dark.svg -[37.802 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo17Dark.svg -[37.802 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo18Dark.svg -[37.803 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo19Dark.svg -[37.803 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo20Dark.svg -[37.803 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo21Dark.svg -[37.803 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/algo22Dark.svg -[37.804 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/Rogan1PSBlueMed.svg -[37.804 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/Rogan1PSBlueMedSmall.svg -[37.804 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/Rogan1PSGreenMed.svg -[37.805 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/Rogan1PSRedMed.svg -[37.805 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/Rogan1PSOrangeMed.svg -[37.805 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/Rogan1PSBlueSmall.svg -[37.805 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/Rogan1PSOrangeSmall.svg -[37.805 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/Rogan1PSGreenSmall.svg -[37.806 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/Rogan1PSRedSmall.svg -[37.806 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/LightLEDButton80.svg -[37.806 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/PJ301MDarkSmallOut.svg -[37.806 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/PJ301MDarkSmall.svg -[37.808 info src/window.cpp:725] Loaded font f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/din1451alt.ttf -[37.809 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/Rogan1PSPurpleMed.svg -[37.809 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/Rogan1PSMustardSmall.svg -[37.809 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Valley/res/Rogan1PSPurpleSmall.svg -[44.640 info src/app/RackWidget.cpp:178] Saving patch to string +[0.023 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/noun_305536_cc.svg +[0.023 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/noun_468341_cc.svg +[0.023 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/idle_mode_icon_cc.svg +[0.023 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/icons/settings_icon_cc.svg +[0.023 info src/settings.cpp:462] Loading settings f:\git\VeeSeeVSTRack\vst2_bin\/settings.json +[0.031 info src/app/RackWidget.cpp:216] Loading patch from string +[0.038 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/Core/AudioInterface.svg +[0.038 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/ScrewSilver.svg +[0.038 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/PJ301M.svg +[0.043 info src/window.cpp:725] Loaded font f:\git\VeeSeeVSTRack\vst2_bin\/res/fonts/ShareTechMono-Regular.ttf +[0.049 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/Core/MIDIToCVInterface.svg +[0.057 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/XCO.svg +[0.061 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/knob_68px.svg +[0.064 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/knob_16px.svg +[0.068 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/button_9px_0.svg +[0.072 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/button_9px_1.svg +[0.075 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/knob_38px.svg +[0.079 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/slider_switch_2_14px_0.svg +[0.083 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/slider_switch_2_14px_1.svg +[0.086 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Bogaudio/res/port.svg +[0.091 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Fundamental/res/VCA.svg +[0.092 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/RoundLargeBlackKnob.svg +[0.097 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/AS/res/ADSR.svg +[0.101 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/AS/res/as-hexscrew.svg +[0.105 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/AS/res/as-SlidePot.svg +[0.108 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/AS/res/as-SlidePotHandle.svg +[0.112 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/AS/res/as-PJ301M.svg +[0.134 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/21kHz/res/Panels/D_Inf.svg +[0.137 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/21kHz/res/Components/kHzScrew.svg +[0.140 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/21kHz/res/Components/kHzKnobSmall.svg +[0.143 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/21kHz/res/Components/kHzButton_0.svg +[0.146 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/21kHz/res/Components/kHzButton_1.svg +[0.149 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/21kHz/res/Components/kHzPort.svg +[0.154 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/Autodafe/res/Multiple18.svg +[0.158 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/PJ3410.svg +[6.585 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/ALGEBRA.svg +[6.585 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/plusButton.svg +[6.586 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/minusButton.svg +[6.586 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/multButton.svg +[6.586 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/divButton.svg +[6.586 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/maxButton.svg +[6.586 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/minButton.svg +[10.154 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/BUFFER.svg +[10.154 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/LEDButton.svg +[10.154 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\/res/ComponentLibrary/Trimpot.svg +[12.538 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/CHOKE.svg +[15.921 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/DISTO.svg +[15.921 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/distocach.svg +[47.876 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/PLAY.svg +[47.877 info src/window.cpp:725] Loaded font f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/LEDCalculator.ttf +[47.877 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/upButton.svg +[47.877 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/upButtonDown.svg +[47.877 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/downButton.svg +[47.878 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/downButtonDown.svg +[101.841 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/PLAYER.svg +[101.841 info src/window.cpp:725] Loaded font f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/DejaVuSansMono.ttf +[151.731 info src/window.cpp:780] Loaded SVG f:\git\VeeSeeVSTRack\vst2_bin\plugins/cf/res/VARIABLE.svg +[174.493 info src/app/RackWidget.cpp:178] Saving patch to string diff --git a/vst2_bin/plugins/cf/README.md b/vst2_bin/plugins/cf/README.md index 80845481..5bdf15cc 100644 --- a/vst2_bin/plugins/cf/README.md +++ b/vst2_bin/plugins/cf/README.md @@ -1,7 +1,7 @@ -![alt text](/cf060.png) - +![alt text](/screens/cf064.png) +![alt text](/screens/cf064b.png) **trSEQ : tr style 16 steps SEQ with trig input per step** diff --git a/vst2_bin/plugins/cf/cf060.png b/vst2_bin/plugins/cf/cf060.png deleted file mode 100644 index 33684990..00000000 Binary files a/vst2_bin/plugins/cf/cf060.png and /dev/null differ diff --git a/vst2_bin/plugins/cf/playeroscs/noisepink.wav b/vst2_bin/plugins/cf/playeroscs/noisepink.wav new file mode 100644 index 00000000..84c43374 Binary files /dev/null and b/vst2_bin/plugins/cf/playeroscs/noisepink.wav differ diff --git a/vst2_bin/plugins/cf/playeroscs/noisewhite.wav b/vst2_bin/plugins/cf/playeroscs/noisewhite.wav new file mode 100644 index 00000000..1096433c Binary files /dev/null and b/vst2_bin/plugins/cf/playeroscs/noisewhite.wav differ diff --git a/vst2_bin/plugins/cf/playeroscs/osc1.wav b/vst2_bin/plugins/cf/playeroscs/osc1.wav new file mode 100644 index 00000000..9fdd80bd Binary files /dev/null and b/vst2_bin/plugins/cf/playeroscs/osc1.wav differ diff --git a/vst2_bin/plugins/cf/playeroscs/osc2.wav b/vst2_bin/plugins/cf/playeroscs/osc2.wav new file mode 100644 index 00000000..52c16ebc Binary files /dev/null and b/vst2_bin/plugins/cf/playeroscs/osc2.wav differ diff --git a/vst2_bin/plugins/cf/playeroscs/osc3.wav b/vst2_bin/plugins/cf/playeroscs/osc3.wav new file mode 100644 index 00000000..835f3fc1 Binary files /dev/null and b/vst2_bin/plugins/cf/playeroscs/osc3.wav differ diff --git a/vst2_bin/plugins/cf/playeroscs/osc4.wav b/vst2_bin/plugins/cf/playeroscs/osc4.wav new file mode 100644 index 00000000..94eea669 Binary files /dev/null and b/vst2_bin/plugins/cf/playeroscs/osc4.wav differ diff --git a/vst2_bin/plugins/cf/playeroscs/osc5.wav b/vst2_bin/plugins/cf/playeroscs/osc5.wav new file mode 100644 index 00000000..43a42efe Binary files /dev/null and b/vst2_bin/plugins/cf/playeroscs/osc5.wav differ diff --git a/vst2_bin/plugins/cf/playeroscs/osc6.wav b/vst2_bin/plugins/cf/playeroscs/osc6.wav new file mode 100644 index 00000000..0f21b898 Binary files /dev/null and b/vst2_bin/plugins/cf/playeroscs/osc6.wav differ diff --git a/vst2_bin/plugins/cf/playeroscs/osc7.wav b/vst2_bin/plugins/cf/playeroscs/osc7.wav new file mode 100644 index 00000000..822bbb49 Binary files /dev/null and b/vst2_bin/plugins/cf/playeroscs/osc7.wav differ diff --git a/vst2_bin/plugins/cf/playeroscs/osc8.wav b/vst2_bin/plugins/cf/playeroscs/osc8.wav new file mode 100644 index 00000000..3ff4f0ed Binary files /dev/null and b/vst2_bin/plugins/cf/playeroscs/osc8.wav differ diff --git a/vst2_bin/plugins/cf/playeroscs/saw.wav b/vst2_bin/plugins/cf/playeroscs/saw.wav new file mode 100644 index 00000000..0a2fcd88 Binary files /dev/null and b/vst2_bin/plugins/cf/playeroscs/saw.wav differ diff --git a/vst2_bin/plugins/cf/res/ALGEBRA.svg b/vst2_bin/plugins/cf/res/ALGEBRA.svg new file mode 100644 index 00000000..3d61f812 --- /dev/null +++ b/vst2_bin/plugins/cf/res/ALGEBRA.svg @@ -0,0 +1,55 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/res/BUFFER.svg b/vst2_bin/plugins/cf/res/BUFFER.svg new file mode 100644 index 00000000..bb0f2aa8 --- /dev/null +++ b/vst2_bin/plugins/cf/res/BUFFER.svg @@ -0,0 +1,153 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/res/CHOKE.svg b/vst2_bin/plugins/cf/res/CHOKE.svg new file mode 100644 index 00000000..03fb4aab --- /dev/null +++ b/vst2_bin/plugins/cf/res/CHOKE.svg @@ -0,0 +1,79 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/res/DAVE.svg b/vst2_bin/plugins/cf/res/DAVE.svg index 243d1d07..d80046d5 100644 --- a/vst2_bin/plugins/cf/res/DAVE.svg +++ b/vst2_bin/plugins/cf/res/DAVE.svg @@ -1,29893 +1,1073 @@ - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +image/svg+xml \ No newline at end of file diff --git a/vst2_bin/plugins/cf/res/DISTO.svg b/vst2_bin/plugins/cf/res/DISTO.svg new file mode 100644 index 00000000..ced7101e --- /dev/null +++ b/vst2_bin/plugins/cf/res/DISTO.svg @@ -0,0 +1,131 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/res/L3DS3Q.svg b/vst2_bin/plugins/cf/res/L3DS3Q.svg index b37bef67..f089fd95 100644 --- a/vst2_bin/plugins/cf/res/L3DS3Q.svg +++ b/vst2_bin/plugins/cf/res/L3DS3Q.svg @@ -2,11 +2,11 @@ - + - - - - - - - - - + + + + + + + + + + c1.125,0,1.928,0.262,2.457,0.758c0.541,0.494,0.854,1.196,0.854,2.179c0,0.989-0.308,1.801-0.874,2.358 + c-0.564,0.566-1.503,0.873-2.683,0.873c-0.56,0-1.026-0.027-1.425-0.072v-5.969H71.194z M71.978,58.711 + c0.197,0.036,0.485,0.045,0.793,0.045c1.674,0,2.584-0.937,2.584-2.574c0.011-1.432-0.803-2.34-2.459-2.34 + c-0.402,0-0.711,0.034-0.918,0.08V58.711z"/> - + - - + + - - + - + @@ -82,22 +85,23 @@ c0,1.379-1.212,2.387-3.19,2.387c-1.008,0-1.859-0.264-2.315-0.552L30.583,23.328z"/> + c-0.852,0.708-2.146,1.043-3.73,1.043c-0.947,0-1.619-0.06-2.074-0.12L37.207,17.14L37.207,17.14z M39.042,23.736 + c0.155,0.036,0.407,0.036,0.636,0.036c1.655,0.012,2.734-0.899,2.734-2.831c0.012-1.679-0.972-2.566-2.543-2.566 + c-0.407,0-0.672,0.036-0.827,0.072V23.736L39.042,23.736z"/> - - + diff --git a/vst2_bin/plugins/cf/res/LEDCalculator.ttf b/vst2_bin/plugins/cf/res/LEDCalculator.ttf new file mode 100644 index 00000000..f5929994 Binary files /dev/null and b/vst2_bin/plugins/cf/res/LEDCalculator.ttf differ diff --git a/vst2_bin/plugins/cf/res/LEDSEQ.svg b/vst2_bin/plugins/cf/res/LEDSEQ.svg index 101795cb..c2d76410 100644 --- a/vst2_bin/plugins/cf/res/LEDSEQ.svg +++ b/vst2_bin/plugins/cf/res/LEDSEQ.svg @@ -2,11 +2,11 @@ - + - + @@ -31,29 +31,30 @@ - - + + c0.803,0,1.271-0.422,1.271-1.032c0-0.565-0.324-0.894-1.144-1.206c-0.99-0.354-1.604-0.864-1.604-1.723 + c0-0.942,0.784-1.646,1.963-1.646c0.621,0,1.071,0.146,1.343,0.297l-0.217,0.642c-0.197-0.107-0.604-0.289-1.15-0.289 + c-0.83,0-1.146,0.496-1.146,0.91c0,0.565,0.369,0.848,1.206,1.17c1.025,0.396,1.549,0.893,1.549,1.783 + c0,0.937-0.691,1.744-2.125,1.744c-0.585,0-1.225-0.171-1.549-0.387L64.658,335.548z"/> - @@ -62,14 +63,14 @@ c0.468,0.162,0.748,0.595,0.892,1.226c0.198,0.847,0.342,1.431,0.468,1.665h-0.81c-0.099-0.171-0.234-0.693-0.405-1.449 c-0.18-0.838-0.504-1.152-1.215-1.18H7.513v2.629H6.73V330.516z M7.513,333.279h0.801c0.837,0,1.369-0.459,1.369-1.152 c0-0.783-0.567-1.126-1.396-1.135c-0.378,0-0.648,0.035-0.774,0.072V333.279z"/> - - + @@ -83,15 +84,15 @@ c1.655,0.012,2.734-0.899,2.734-2.831c0.012-1.679-0.971-2.566-2.542-2.566c-0.408,0-0.672,0.036-0.828,0.072V23.736L39.042,23.736 z"/> diff --git a/vst2_bin/plugins/cf/res/MASTER.svg b/vst2_bin/plugins/cf/res/MASTER.svg index 5dcb6634..5cbe1566 100644 --- a/vst2_bin/plugins/cf/res/MASTER.svg +++ b/vst2_bin/plugins/cf/res/MASTER.svg @@ -6,9 +6,9 @@ xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="90.135px" height="380px" viewBox="0 0 90.135 380" enable-background="new 0 0 90.135 380" xml:space="preserve"> - - - + + + @@ -19,55 +19,55 @@ + c-0.575-0.015-1.065-0.125-1.275-0.229l0.294-1.479c0.21,0.084,0.434,0.104,0.659,0.104c0.7-0.021,0.938-0.396,1.139-1.981 + l0.229-1.969H45.94v-1.479H45.937L45.937,362.066L45.937,362.066z"/> + c0.63,0,0.963-0.262,0.963-0.646c0-0.378-0.288-0.604-1.018-0.854c-1.009-0.354-1.666-0.904-1.666-1.791 + c0-1.032,0.864-1.825,2.296-1.825c0.684,0,1.188,0.146,1.548,0.312l-0.306,1.104c-0.243-0.115-0.676-0.289-1.27-0.289 + c-0.604,0-0.892,0.271-0.892,0.587c0,0.393,0.351,0.562,1.125,0.854c1.067,0.396,1.575,0.951,1.575,1.812 + c0,1.021-0.782,1.886-2.448,1.886c-0.688,0-1.377-0.184-1.724-0.366L131.11,283.479z"/> - - - + + c-0.354-0.646-0.756-1.438-1.053-2.146l-0.027,0.009c0.037,0.806,0.062,1.657,0.062,2.646v1.826h-1.27V295.146L51.276,295.146z"/> @@ -97,7 +97,7 @@ c-0.11,0.44-0.22,1.001-0.341,1.431l-0.44,1.573H39.676z"/> - - - - - - - - - - + + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/res/PEAK.svg b/vst2_bin/plugins/cf/res/PEAK.svg index 249ca57d..e69d4de4 100644 --- a/vst2_bin/plugins/cf/res/PEAK.svg +++ b/vst2_bin/plugins/cf/res/PEAK.svg @@ -2,41 +2,13 @@ - + - - - - - - - - - - - - - - - - - - + l0.229-1.962H45.94v-1.485H45.937L45.937,362.066z"/> + c-0.469,0.441-1.159,0.639-1.971,0.639c-0.184,0-0.345-0.009-0.472-0.027v2.169H60.94V161.408z M62.3,164.163 + c0.117,0.027,0.262,0.036,0.46,0.036c0.729,0,1.179-0.369,1.179-0.99c0-0.559-0.387-0.892-1.067-0.892 + c-0.279,0-0.472,0.027-0.565,0.054L62.3,164.163L62.3,164.163z"/> - @@ -94,10 +66,10 @@ C53.783,279.814,53.243,280.697,53.243,281.876z"/> + c1.148,0,1.896,0.207,2.48,0.646c0.63,0.47,1.023,1.218,1.023,2.287c0,1.16-0.424,1.962-1.01,2.457 + c-0.639,0.531-1.607,0.783-2.799,0.783c-0.712,0-1.216-0.046-1.559-0.093V278.9h0.004v0.004H63.124z M64.502,283.857 + c0.117,0.022,0.306,0.022,0.478,0.022c1.242,0.013,2.056-0.675,2.056-2.124c0.01-1.261-0.729-1.928-1.908-1.928 + c-0.31,0-0.504,0.023-0.621,0.055L64.502,283.857L64.502,283.857z"/> @@ -107,13 +79,33 @@ c-0.624,0.588-1.547,0.852-2.626,0.852c-0.24,0-0.456-0.012-0.624-0.036v2.891h-1.811V16.467z M34.336,20.137 c0.156,0.036,0.348,0.048,0.612,0.048c0.971,0,1.571-0.492,1.571-1.319c0-0.743-0.516-1.187-1.427-1.187 c-0.372,0-0.624,0.036-0.756,0.072V20.137z"/> - - + - + + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/res/PLAY.svg b/vst2_bin/plugins/cf/res/PLAY.svg new file mode 100644 index 00000000..c11d1e51 --- /dev/null +++ b/vst2_bin/plugins/cf/res/PLAY.svg @@ -0,0 +1,52 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/res/PLAYER.svg b/vst2_bin/plugins/cf/res/PLAYER.svg index c38e185e..8bbc3734 100644 --- a/vst2_bin/plugins/cf/res/PLAYER.svg +++ b/vst2_bin/plugins/cf/res/PLAYER.svg @@ -85,10 +85,10 @@ c-1.801,0-2.854-1.358-2.854-3.088c0-1.818,1.162-3.188,2.953-3.188C108.337,387.3,109.354,388.695,109.354,390.37z M104.971,390.451c0,1.188,0.559,2.025,1.479,2.025c0.927,0,1.458-0.896,1.458-2.062c0-1.09-0.521-2.025-1.471-2.025 C105.512,388.391,104.971,389.271,104.971,390.451z"/> - - @@ -120,7 +120,7 @@ c0.369,0.188,0.938,0.379,1.521,0.379c0.631,0,0.963-0.262,0.963-0.646c0-0.378-0.287-0.604-1.021-0.854 c-1.008-0.354-1.666-0.899-1.666-1.789c0-1.029,0.864-1.82,2.301-1.82c0.688,0,1.188,0.146,1.547,0.312l-0.31,1.104 c-0.239-0.107-0.675-0.285-1.271-0.285c-0.594,0-0.881,0.271-0.881,0.588c0,0.396,0.342,0.562,1.125,0.854 - c1.062,0.396,1.562,0.952,1.562,1.812c0,1.021-0.771,1.887-2.438,1.887c-0.688,0-1.377-0.188-1.729-0.363L69.666,392.15z"/> + c1.062,0.396,1.562,0.952,1.562,1.812c0,1.021-0.771,1.887-2.438,1.887c-0.688,0-1.377-0.188-1.729-0.362L69.666,392.15z"/> @@ -141,12 +141,12 @@ c0.369,0.188,0.937,0.379,1.521,0.379c0.63,0,0.963-0.262,0.963-0.646c0-0.378-0.288-0.604-1.018-0.854 c-1.008-0.354-1.666-0.899-1.666-1.789c0-1.029,0.864-1.82,2.296-1.82c0.684,0,1.188,0.146,1.548,0.312l-0.306,1.104 c-0.243-0.107-0.675-0.285-1.269-0.285c-0.594,0-0.882,0.271-0.882,0.588c0,0.396,0.342,0.562,1.125,0.854 - c1.071,0.396,1.575,0.952,1.575,1.812c0,1.021-0.783,1.887-2.449,1.887c-0.693,0-1.377-0.188-1.719-0.363L39.647,392.15z"/> + c1.071,0.396,1.575,0.952,1.575,1.812c0,1.021-0.783,1.887-2.449,1.887c-0.693,0-1.377-0.188-1.719-0.362L39.647,392.15z"/> + c-0.09,0.355-0.18,0.814-0.279,1.17l-0.36,1.287H51.7z"/> + l2.071,6.066h-0.837l-0.648-1.907H19.221z M21.211,391.053l-0.594-1.746c-0.135-0.396-0.225-0.757-0.315-1.104h-0.018 + c-0.09,0.356-0.189,0.729-0.306,1.104l-0.594,1.758L21.211,391.053L21.211,391.053z"/> - + c-1.107,0-1.909-0.277-2.467-0.817c-0.558-0.521-0.864-1.312-0.855-2.206c0.009-2.02,1.477-3.169,3.466-3.169 + c0.783,0,1.386,0.151,1.684,0.297l-0.288,1.101c-0.333-0.146-0.748-0.262-1.414-0.262c-1.144,0-2.008,0.646-2.008,1.963 + c0,1.252,0.783,1.988,1.909,1.988c0.315,0,0.567-0.035,0.675-0.091v-1.271h-0.937v-1.07h2.26V312.477z"/> + c-1.107,0-1.909-0.277-2.467-0.817c-0.558-0.521-0.864-1.312-0.855-2.206c0.009-2.02,1.477-3.169,3.466-3.169 + c0.783,0,1.386,0.151,1.684,0.297l-0.288,1.101c-0.333-0.146-0.748-0.263-1.414-0.263c-1.144,0-2.008,0.646-2.008,1.962 + c0,1.254,0.783,1.99,1.909,1.99c0.315,0,0.567-0.036,0.675-0.091v-1.271h-0.937v-1.072h2.26V356.387z"/> @@ -212,15 +212,15 @@ + c-0.594,0-0.882,0.271-0.882,0.586c0,0.387,0.342,0.558,1.125,0.854c1.072,0.396,1.576,0.955,1.576,1.812 + c0,1.019-0.783,1.881-2.449,1.881c-0.693,0-1.377-0.181-1.72-0.369L40.972,311.346z"/> @@ -231,76 +231,77 @@ - - + + - - - - + - - - - - - - - + + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/res/SLIDERSEQ.svg b/vst2_bin/plugins/cf/res/SLIDERSEQ.svg index 9e06408f..3b50f3ba 100644 --- a/vst2_bin/plugins/cf/res/SLIDERSEQ.svg +++ b/vst2_bin/plugins/cf/res/SLIDERSEQ.svg @@ -7,367 +7,121 @@ viewBox="0 0 135.566 380" enable-background="new 0 0 135.566 380" xml:space="preserve"> - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + - - - - - - - + + + + + + + - + c0.479,0,0.963-0.104,1.278-0.252L111.69,315.384z"/> + - + v1.499H65.09v1.679h2.979L68.068,20.944L68.068,20.944z"/> - + c0-1.379,1.152-2.435,3.062-2.435c0.906,0,1.584,0.192,2.062,0.408l-0.408,1.475c-0.317-0.156-0.896-0.384-1.688-0.384 + c-0.793,0-1.182,0.36-1.182,0.78c0,0.516,0.455,0.743,1.498,1.139c1.434,0.528,2.104,1.271,2.104,2.411 + c0,1.355-1.043,2.507-3.262,2.507c-0.93,0-1.842-0.24-2.291-0.492L76.842,22.479z"/> + - - - - - + + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/res/VARIABLE.svg b/vst2_bin/plugins/cf/res/VARIABLE.svg new file mode 100644 index 00000000..f5d96b1e --- /dev/null +++ b/vst2_bin/plugins/cf/res/VARIABLE.svg @@ -0,0 +1,82 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/res/cach.svg b/vst2_bin/plugins/cf/res/cach.svg new file mode 100644 index 00000000..9eb36a63 --- /dev/null +++ b/vst2_bin/plugins/cf/res/cach.svg @@ -0,0 +1,19 @@ + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/res/distocach.svg b/vst2_bin/plugins/cf/res/distocach.svg new file mode 100644 index 00000000..d308662e --- /dev/null +++ b/vst2_bin/plugins/cf/res/distocach.svg @@ -0,0 +1,22 @@ + + + + + + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/res/divButton.svg b/vst2_bin/plugins/cf/res/divButton.svg new file mode 100644 index 00000000..4254c13c --- /dev/null +++ b/vst2_bin/plugins/cf/res/divButton.svg @@ -0,0 +1,20 @@ + + + + + + + + + + + +/ + diff --git a/vst2_bin/plugins/cf/res/maxButton.svg b/vst2_bin/plugins/cf/res/maxButton.svg new file mode 100644 index 00000000..72338b27 --- /dev/null +++ b/vst2_bin/plugins/cf/res/maxButton.svg @@ -0,0 +1,20 @@ + + + + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/res/minButton.svg b/vst2_bin/plugins/cf/res/minButton.svg new file mode 100644 index 00000000..ef9dbd74 --- /dev/null +++ b/vst2_bin/plugins/cf/res/minButton.svg @@ -0,0 +1,23 @@ + + + + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/res/minusButton.svg b/vst2_bin/plugins/cf/res/minusButton.svg new file mode 100644 index 00000000..cdc69ff8 --- /dev/null +++ b/vst2_bin/plugins/cf/res/minusButton.svg @@ -0,0 +1,19 @@ + + + + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/res/multButton.svg b/vst2_bin/plugins/cf/res/multButton.svg new file mode 100644 index 00000000..696072a3 --- /dev/null +++ b/vst2_bin/plugins/cf/res/multButton.svg @@ -0,0 +1,20 @@ + + + + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/res/plusButton.svg b/vst2_bin/plugins/cf/res/plusButton.svg new file mode 100644 index 00000000..b6ac6e54 --- /dev/null +++ b/vst2_bin/plugins/cf/res/plusButton.svg @@ -0,0 +1,20 @@ + + + + + + + + + + + + + diff --git a/vst2_bin/plugins/cf/screens/cf064.png b/vst2_bin/plugins/cf/screens/cf064.png new file mode 100644 index 00000000..1572a9ba Binary files /dev/null and b/vst2_bin/plugins/cf/screens/cf064.png differ diff --git a/vst2_bin/plugins/cf/screens/cf064b.png b/vst2_bin/plugins/cf/screens/cf064b.png new file mode 100644 index 00000000..1473606c Binary files /dev/null and b/vst2_bin/plugins/cf/screens/cf064b.png differ diff --git a/vst2_bin/plugins/cf/screens/clock.png b/vst2_bin/plugins/cf/screens/clock.png new file mode 100644 index 00000000..3870858b Binary files /dev/null and b/vst2_bin/plugins/cf/screens/clock.png differ diff --git a/vst2_bin/plugins/cf/screens/cube1.png b/vst2_bin/plugins/cf/screens/cube1.png new file mode 100644 index 00000000..05357e81 Binary files /dev/null and b/vst2_bin/plugins/cf/screens/cube1.png differ diff --git a/vst2_bin/plugins/cf/screens/four1.png b/vst2_bin/plugins/cf/screens/four1.png new file mode 100644 index 00000000..a05ef5d9 Binary files /dev/null and b/vst2_bin/plugins/cf/screens/four1.png differ diff --git a/vst2_bin/plugins/cf/screens/four2.png b/vst2_bin/plugins/cf/screens/four2.png new file mode 100644 index 00000000..21a87ca4 Binary files /dev/null and b/vst2_bin/plugins/cf/screens/four2.png differ diff --git a/vst2_bin/plugins/cf/screens/four3.png b/vst2_bin/plugins/cf/screens/four3.png new file mode 100644 index 00000000..7b6d072d Binary files /dev/null and b/vst2_bin/plugins/cf/screens/four3.png differ diff --git a/vst2_bin/plugins/cf/screens/mixer.png b/vst2_bin/plugins/cf/screens/mixer.png new file mode 100644 index 00000000..0291bfc0 Binary files /dev/null and b/vst2_bin/plugins/cf/screens/mixer.png differ diff --git a/vst2_bin/plugins/cf/screens/peak1.png b/vst2_bin/plugins/cf/screens/peak1.png new file mode 100644 index 00000000..10ded322 Binary files /dev/null and b/vst2_bin/plugins/cf/screens/peak1.png differ diff --git a/vst2_bin/plugins/cf/screens/peak2.png b/vst2_bin/plugins/cf/screens/peak2.png new file mode 100644 index 00000000..62c3232d Binary files /dev/null and b/vst2_bin/plugins/cf/screens/peak2.png differ diff --git a/vst2_bin/plugins/cf/screens/player1.png b/vst2_bin/plugins/cf/screens/player1.png new file mode 100644 index 00000000..9017889d Binary files /dev/null and b/vst2_bin/plugins/cf/screens/player1.png differ diff --git a/vst2_bin/plugins/cf/screens/player2.png b/vst2_bin/plugins/cf/screens/player2.png new file mode 100644 index 00000000..b7785d7c Binary files /dev/null and b/vst2_bin/plugins/cf/screens/player2.png differ diff --git a/vst2_bin/plugins/cf/screens/steps1.png b/vst2_bin/plugins/cf/screens/steps1.png new file mode 100644 index 00000000..c9ad6039 Binary files /dev/null and b/vst2_bin/plugins/cf/screens/steps1.png differ diff --git a/vst2_bin/plugins/cf/screens/steps2.png b/vst2_bin/plugins/cf/screens/steps2.png new file mode 100644 index 00000000..b707605b Binary files /dev/null and b/vst2_bin/plugins/cf/screens/steps2.png differ diff --git a/vst2_bin/plugins/cf/screens/trseq1.png b/vst2_bin/plugins/cf/screens/trseq1.png new file mode 100644 index 00000000..f36c6b44 Binary files /dev/null and b/vst2_bin/plugins/cf/screens/trseq1.png differ diff --git a/vst2_bin/plugins/cf/screens/trseq2.png b/vst2_bin/plugins/cf/screens/trseq2.png new file mode 100644 index 00000000..586fcc36 Binary files /dev/null and b/vst2_bin/plugins/cf/screens/trseq2.png differ diff --git a/vst2_bin/plugins/cf/screens/trseq3.png b/vst2_bin/plugins/cf/screens/trseq3.png new file mode 100644 index 00000000..f9b57d27 Binary files /dev/null and b/vst2_bin/plugins/cf/screens/trseq3.png differ