Move STFX stuff (aside from stfx-library.h) into separate repo
This commit is contained in:
Geraint
parent
16b2ba955c
commit
e8103a1013
@ -1,95 +0,0 @@
|
||||
cmake_minimum_required(VERSION 3.28)
|
||||
|
||||
set(CMAKE_CXX_VISIBILITY_PRESET hidden)
|
||||
set(CMAKE_C_VISIBILITY_PRESET hidden)
|
||||
set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
|
||||
|
||||
project(plugins VERSION 1.0.0)
|
||||
|
||||
################ boilerplate config
|
||||
|
||||
set(CMAKE_CXX_STANDARD 17) # for string_view
|
||||
|
||||
if (APPLE)
|
||||
set(CMAKE_OSX_DEPLOYMENT_TARGET 10.13)
|
||||
set(CMAKE_OSX_ARCHITECTURES "x86_64;arm64")
|
||||
enable_language(OBJCXX)
|
||||
endif ()
|
||||
|
||||
include(FetchContent)
|
||||
FetchContent_Declare(
|
||||
clap
|
||||
GIT_REPOSITORY https://github.com/geraintluff/clap.git # https://github.com/free-audio/clap
|
||||
GIT_TAG 2df92fe17911f15436176b9c37faec370166d14f # draft/web
|
||||
GIT_SHALLOW OFF
|
||||
)
|
||||
FetchContent_MakeAvailable(clap)
|
||||
|
||||
################ CLAP wrapper stuff
|
||||
|
||||
if(NOT DEFINED VST3_SDK_ROOT)
|
||||
if(EMSCRIPTEN)
|
||||
# don't download the VST3 SDK
|
||||
set(VST3_SDK_ROOT "./dummy/vst3sdk/path")
|
||||
else()
|
||||
set(CLAP_WRAPPER_DOWNLOAD_DEPENDENCIES TRUE)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
set(CLAP_WRAPPER_OUTPUT_NAME clap-wrapper-target)
|
||||
set(CLAP_WRAPPER_DONT_ADD_TARGETS TRUE)
|
||||
|
||||
include(FetchContent)
|
||||
FetchContent_Declare(
|
||||
clap-wrapper
|
||||
GIT_REPOSITORY https://github.com/geraintluff/clap-wrapper.git
|
||||
GIT_TAG cd666f7d2291d47f810d9c8f123886026a631576
|
||||
GIT_SHALLOW ON
|
||||
)
|
||||
FetchContent_MakeAvailable(clap-wrapper)
|
||||
|
||||
################ Helpers
|
||||
|
||||
FetchContent_Declare(
|
||||
clap-helpers
|
||||
GIT_REPOSITORY https://github.com/free-audio/clap-helpers
|
||||
GIT_TAG 58ab81b1dc8219e859529c1306f364bb3aedf7d5
|
||||
GIT_SHALLOW OFF
|
||||
)
|
||||
FetchContent_MakeAvailable(clap-helpers)
|
||||
|
||||
################ The actual plugin(s)
|
||||
|
||||
add_subdirectory(../ signalsmith-basics/) # need explicit path since it's not a subdir
|
||||
|
||||
set(NAME basics)
|
||||
add_library(${NAME}_static STATIC)
|
||||
target_link_libraries(${NAME}_static PUBLIC
|
||||
clap
|
||||
signalsmith-basics
|
||||
)
|
||||
target_sources(${NAME}_static PRIVATE
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/source/basics.cpp
|
||||
)
|
||||
|
||||
make_clapfirst_plugins(
|
||||
TARGET_NAME ${NAME}
|
||||
IMPL_TARGET ${NAME}_static
|
||||
|
||||
RESOURCE_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/resources"
|
||||
|
||||
OUTPUT_NAME "${NAME}"
|
||||
ENTRY_SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/source/clap_entry.cpp
|
||||
|
||||
BUNDLE_IDENTIFIER "uk.co.signalsmith-audio.plugins.${NAME}"
|
||||
BUNDLE_VERSION "1.0.0"
|
||||
WINDOWS_FOLDER_VST3 TRUE
|
||||
|
||||
PLUGIN_FORMATS CLAP VST3 WCLAP # AUV2
|
||||
COPY_AFTER_BUILD FALSE
|
||||
|
||||
AUV2_MANUFACTURER_NAME "Signalsmith Audio"
|
||||
AUV2_MANUFACTURER_CODE "SigA"
|
||||
AUV2_SUBTYPE_CODE "BdDt"
|
||||
AUV2_INSTRUMENT_TYPE "aufx"
|
||||
)
|
||||
@ -1,52 +0,0 @@
|
||||
.PHONY: build build-emscripten emsdk
|
||||
PROJECT := plugins
|
||||
PLUGIN := basics
|
||||
|
||||
CMAKE_PARAMS := -DCMAKE_LIBRARY_OUTPUT_DIRECTORY=.. -G Xcode # -DCMAKE_BUILD_TYPE=Release
|
||||
|
||||
mac-installer: mac-installer-$(PLUGIN)
|
||||
|
||||
clean:
|
||||
rm -rf out
|
||||
|
||||
build:
|
||||
cmake . -B out/build $(CMAKE_PARAMS)
|
||||
|
||||
release-%: build
|
||||
cmake --build out/build --target $* --config Release
|
||||
|
||||
mac-installer-%: release-%_vst3 release-%_clap emscripten-%_wclap
|
||||
../stfx/front-end/clap/mac/make-pkg-installer.sh out/$*.pkg $* uk.co.signalsmith.installer.stfx.$* out/Release/$*
|
||||
|
||||
####### Emscripten #######
|
||||
# based on https://stunlock.gg/posts/emscripten_with_cmake/
|
||||
|
||||
CURRENT_DIR := $(shell pwd)
|
||||
EMSDK ?= $(CURRENT_DIR)/emsdk
|
||||
EMSDK_ENV = unset CMAKE_TOOLCHAIN_FILE; EMSDK_QUIET=1 . "$(EMSDK)/emsdk_env.sh";
|
||||
|
||||
emsdk:
|
||||
@ if ! test -d "$(EMSDK)" ;\
|
||||
then \
|
||||
echo "SDK not found - cloning from Github" ;\
|
||||
git clone https://github.com/emscripten-core/emsdk.git "$(EMSDK)" ;\
|
||||
cd "$(EMSDK)" && git pull && ./emsdk install latest && ./emsdk activate latest ;\
|
||||
$(EMSDK_ENV) emcc --check && python3 --version && cmake --version ;\
|
||||
fi
|
||||
|
||||
build-emscripten: emsdk
|
||||
$(EMSDK_ENV) emcmake cmake . -B out/build-emscripten -DCMAKE_RUNTIME_OUTPUT_DIRECTORY=../Release -DCMAKE_BUILD_TYPE=Release
|
||||
|
||||
emscripten-%: build-emscripten
|
||||
$(EMSDK_ENV) cmake --build out/build-emscripten --target $* --config Release
|
||||
|
||||
####### Dev stuff #######
|
||||
|
||||
format:
|
||||
find source -iname \*.cpp -o -iname \*.h | xargs clang-format -i
|
||||
|
||||
dev: release-$(PLUGIN)_clap
|
||||
/Applications/REAPER.app/Contents/MacOS/REAPER REAPER/$(PLUGIN)/$(PLUGIN).RPP
|
||||
|
||||
wclap: emscripten-$(PLUGIN)_wclap
|
||||
./wclap-tar.sh out/Release/$(PLUGIN).wclap out/
|
||||
@ -1,159 +0,0 @@
|
||||
<REAPER_PROJECT 0.1 "7.24/OSX64-clang" 1750919608
|
||||
<NOTES 0 2
|
||||
>
|
||||
RIPPLE 0
|
||||
GROUPOVERRIDE 0 0 0
|
||||
AUTOXFADE 129
|
||||
ENVATTACH 3
|
||||
POOLEDENVATTACH 0
|
||||
MIXERUIFLAGS 11 48
|
||||
ENVFADESZ10 40
|
||||
PEAKGAIN 1
|
||||
FEEDBACK 0
|
||||
PANLAW 1
|
||||
PROJOFFS 0 0 0
|
||||
MAXPROJLEN 0 0
|
||||
GRID 3199 8 1 8 1 0 0 0
|
||||
TIMEMODE 1 5 -1 30 0 0 -1
|
||||
VIDEO_CONFIG 0 0 256
|
||||
PANMODE 3
|
||||
PANLAWFLAGS 3
|
||||
CURSOR 0
|
||||
ZOOM 100 0 0
|
||||
VZOOMEX 6 0
|
||||
USE_REC_CFG 0
|
||||
RECMODE 1
|
||||
SMPTESYNC 0 30 100 40 1000 300 0 0 1 0 0
|
||||
LOOP 0
|
||||
LOOPGRAN 0 4
|
||||
RECORD_PATH "Media" ""
|
||||
<RECORD_CFG
|
||||
ZXZhdxgAAQ==
|
||||
>
|
||||
<APPLYFX_CFG
|
||||
>
|
||||
RENDER_FILE ""
|
||||
RENDER_PATTERN ""
|
||||
RENDER_FMT 0 2 0
|
||||
RENDER_1X 0
|
||||
RENDER_RANGE 1 0 0 18 1000
|
||||
RENDER_RESAMPLE 3 0 1
|
||||
RENDER_ADDTOPROJ 0
|
||||
RENDER_STEMS 0
|
||||
RENDER_DITHER 0
|
||||
TIMELOCKMODE 1
|
||||
TEMPOENVLOCKMODE 1
|
||||
ITEMMIX 1
|
||||
DEFPITCHMODE 589824 0
|
||||
TAKELANE 1
|
||||
SAMPLERATE 44100 0 0
|
||||
<RENDER_CFG
|
||||
ZXZhdxgAAQ==
|
||||
>
|
||||
LOCK 1
|
||||
<METRONOME 6 2
|
||||
VOL 0.25 0.125
|
||||
BEATLEN 4
|
||||
FREQ 1760 880 1
|
||||
SAMPLES "" ""
|
||||
SPLIGNORE 0 0
|
||||
SPLDEF 2 660 "" 0
|
||||
SPLDEF 3 440 "" 0
|
||||
PATTERN 0 169
|
||||
PATTERNSTR ABBB
|
||||
MULT 1
|
||||
>
|
||||
GLOBAL_AUTO -1
|
||||
TEMPO 120 4 4
|
||||
PLAYRATE 1 0 0.25 4
|
||||
SELECTION 0 0
|
||||
SELECTION2 0 0
|
||||
MASTERAUTOMODE 0
|
||||
MASTERTRACKHEIGHT 0 0
|
||||
MASTERPEAKCOL 16576
|
||||
MASTERMUTESOLO 0
|
||||
MASTERTRACKVIEW 1 0.6667 0.5 0.5 0 0 0 0 0 0 0 0 0 0
|
||||
MASTERHWOUT 0 0 1 0 0 0 0 -1
|
||||
MASTER_NCH 4 2
|
||||
MASTER_VOLUME 1 0 -1 -1 1
|
||||
MASTER_PANMODE 3
|
||||
MASTER_PANLAWFLAGS 3
|
||||
MASTER_FX 1
|
||||
MASTER_SEL 0
|
||||
<MASTERFXLIST
|
||||
WNDRECT 848 592 601 240
|
||||
SHOW 0
|
||||
LASTSEL 1
|
||||
DOCKED 0
|
||||
BYPASS 0 0 0
|
||||
<VST "VST3: [Basics] Limiter (Signalsmith Audio)" Signalsmith-Audio-signalsmith-basics.vst3 0 "" 767935365{85C8AB4F80EBAD2FB1B22206AC3BB024} ""
|
||||
hcPFLe5e7f4EAAAAAQAAAAAAAAACAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAEAAAAAQAAAAAAAAACAAAAAAAAAAQAAAAAAAAACAAAAAAAAABqAAAAAQAAAP//EAA=
|
||||
QQAAAAEAAAAAAAAAAAAAEEAAAAAAAADwP5CkT2MBlO0/6sSBcQw8H0CDkljf3IUjQBaXn5dXrjlAAAAAAAAA8D8AAAAAAADgPxkAAAAAAAAAAAAAAAAAAAAAAAAAAACA
|
||||
gUAAAAAAAEBlQA==
|
||||
AAAQAAAA
|
||||
>
|
||||
FLOATPOS 0 0 0 0
|
||||
FXID {81F27681-ACFE-1D40-9AAE-F8C9A0035B1F}
|
||||
WAK 0 0
|
||||
BYPASS 0 0 0
|
||||
<VST "VST: ReaStream (Cockos) (8ch)" reastream.vst.dylib 0 "" 1920169074<5653547273747272656173747265616D> ""
|
||||
cnRzcu5e7f4IAAAAAQAAAAAAAAACAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAgAAAABAAAAAAAAAAIAAAAAAAAA
|
||||
BAAAAAAAAAAIAAAAAAAAABAAAAAAAAAAIAAAAAAAAABAAAAAAAAAAIAAAAAAAAAArAAAAAEAAAAAABAA
|
||||
AQAAAAIAAAABAAAAZGVmYXVsdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxMjcuMC4wLjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
||||
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==
|
||||
AFByb2dyYW0gMQAQAAAA
|
||||
>
|
||||
FLOATPOS 0 0 0 0
|
||||
FXID {11A0D811-6420-CB40-95D6-F9D12E45C862}
|
||||
WAK 0 0
|
||||
>
|
||||
<MASTERPLAYSPEEDENV
|
||||
EGUID {590DCF42-C4B4-1D40-9C66-B99188BD30ED}
|
||||
ACT 0 -1
|
||||
VIS 0 1 1
|
||||
LANEHEIGHT 0 0
|
||||
ARM 0
|
||||
DEFSHAPE 0 -1 -1
|
||||
>
|
||||
<TEMPOENVEX
|
||||
EGUID {9E65AFD8-F464-FB46-AC60-C5553CE5E330}
|
||||
ACT 0 -1
|
||||
VIS 1 0 1
|
||||
LANEHEIGHT 0 0
|
||||
ARM 0
|
||||
DEFSHAPE 1 -1 -1
|
||||
>
|
||||
<PROJBAY
|
||||
>
|
||||
<TRACK {93E699D9-F890-234E-A113-7E0053A85B78}
|
||||
NAME ""
|
||||
PEAKCOL 16576
|
||||
BEAT -1
|
||||
AUTOMODE 0
|
||||
PANLAWFLAGS 3
|
||||
VOLPAN 1 0 -1 -1 1
|
||||
MUTESOLO 0 0 0
|
||||
IPHASE 0
|
||||
PLAYOFFS 0 1
|
||||
ISBUS 0 0
|
||||
BUSCOMP 0 0 0 0 0
|
||||
SHOWINMIX 1 0.6667 0.5 1 0.5 0 0 0
|
||||
FIXEDLANES 9 0 0 0 0
|
||||
SEL 1
|
||||
REC 0 5088 1 7 0 0 0 0
|
||||
VU 2
|
||||
TRACKHEIGHT 0 0 0 0 0 0 0
|
||||
INQ 0 0 0 0.5 100 0 0 100
|
||||
NCHAN 2
|
||||
FX 1
|
||||
TRACKID {93E699D9-F890-234E-A113-7E0053A85B78}
|
||||
PERF 0
|
||||
MIDIOUT -1
|
||||
MAINSEND 1 0
|
||||
<FXCHAIN
|
||||
SHOW 0
|
||||
LASTSEL 0
|
||||
DOCKED 0
|
||||
>
|
||||
>
|
||||
>
|
||||
@ -1,7 +0,0 @@
|
||||
<!DOCTYPE html>
|
||||
<html><head><title></title><meta name="viewport" content="width=device-width,initial-scale=1"><style>body{display: flex;flex-direction:column;justify-content:stretch;align-items:center;min-height:100vh;justify-content:center;font:12pt sans-serif;color:#FFF;background:#222;margin:0;padding:0}img,video{max-width:100vw;max-height:100vh;flex-shrink:1}a{color:#8AF;text-decoration:none;margin-top:1em}iframe{background:#FFF;width:100%;flex-grow:0.8}</style>
|
||||
</head><body><form onsubmit="return false"><input id="p" type="password" autofocus><input type="submit" value="go" onclick="d(document.querySelector('#p').value).catch(e=>document.body.textContent='failed')"></form><script>
|
||||
let balloonOptions={"rounds":5,"buffers":32768},s64="Ho9CMRCSYNw84y+8VRdnwVrm5eZBlEWlC8LK0oP2AlM=",e64="xGiUxaRUjqura2lejNiFdvZs6SQB1P3wY9COVVzbHk6X5Z84KO_YaoeUq0hathjnPiVsUNHBvnsEmrP8q06pElSZeo8brf2bZWxSf6NxG3TL2Ghh_2Rw1Gl7qSpeJZ6vr3jnd-fL5hzC5nAbD2Hnx6mgH0sW3DMarGYnBItq3O8TE9LzvWSWceBGhD518fyjDKThWJEzvkTG5f04mcixVMdOQQj09zgO0Msd0CG-S65WFRqGzfPmnuPFCzyknhCdjHy8At1GtssIib3h-pBeWwyCnezZX5iprn8gnPhxgSHZgMVp082L18XqcaVAiiry8XGi3B-QGmRW5V2xuJGz3s-1GMJxl1-4Od7X-9yRwsmA2LplZtATa5zpF50pUspSXGGn1ZDWpTft34SW3Tf-cIEJ_PfitsV-w7k1OGMKgst6X5XxITQwhGYiO6GiO6T189ZDgswexN9jb-AZTFrLI_9U_53kJj-wjar2a8a1wSaBXmNivtPGDmALAFyS-zSj9Y_yllulg1h482G8MhTE4mOp3uIxOw";
|
||||
let cryptoUtils=(function r(){let n={factory:r};var e=[];for(let t=2;e.length<64;++t)e.some(r=>!(t%r))||e.push(t);let g=4294967296,p=e.slice(0,8).map(r=>Math.sqrt(r)*g|0),D=e.map(r=>Math.cbrt(r)*g|0),h=new Int32Array(64),d=new Int32Array(32),x=n.sha256=function(r,t){"string"==typeof r&&(r=(new TextEncoder).encode(r));var e="hex"==t,n=(t=(t=e?null:t)||new Uint8Array(32),r.length),a=16*Math.ceil((n+1+8)/64),i=32==a?d.fill(0):new Int32Array(a),o=new Uint8Array(i.buffer),y=(o.set(r),o[n]=128,new DataView(i.buffer));for(let r=0;r<a;++r)i[r]=y.getInt32(4*r);i[a-1]=8*n|0,i[a-2]=8*n/g|0;var f=new Int32Array(t.buffer);for(let r=0;r<8;++r)f[r]=p[r];var l=f.slice(0,8);for(let t=0;t<a;t+=16){for(let r=0;r<16;++r)h[r]=i[t+r];for(let r=16;r<64;++r){var w=h[r-15],c=h[r-2];h[r]=h[r-16]+h[r-7]+((w>>>7|w<<25)^(w>>>18|w<<14)^w>>>3)+((c>>>17|c<<15)^(c>>>19|c<<13)^c>>>10)|0}for(let r=0;r<64;r++){var A=l[0],u=l[4],v=l[7]+((u>>>6|u<<26)^(u>>>11|u<<21)^(u>>>25|u<<7))+(u&l[5]^~u&l[6])+D[r]+h[r],s=(A&l[1]^A&l[2]^l[1]&l[2])+((A>>>2|A<<30)^(A>>>13|A<<19)^(A>>>22|A<<10));l[7]=l[6],l[6]=l[5],l[5]=u,l[4]=l[3]+v|0,l[3]=l[2],l[2]=l[1],l[1]=A,l[0]=v+s|0}for(let r=0;r<8;r++)f[r]=l[r]=f[r]+l[r]|0}var U=new DataView(t.buffer);for(let r=0;r<8;r++)U.setInt32(4*r,f[r]);return e?Array.from(t,r=>(r>>>4).toString(16)+(15&r).toString(16)).join(""):t};return n.balloon=async function(n,r,t={}){var e=new TextEncoder,a=("string"==typeof n&&(n=x(e.encode(n))),"string"==typeof r&&(text=x(e.encode(r))),t.buffers=t.buffers||32768),i=t.rounds=t.rounds||4,o=t.delta=t.delta||3,y=[],f=t.workPeriod||100;let l=f*(1/(t.workRatio||1)-1);var w=t.progress||(r=>r);32!=n.length&&(n=x(n)),32!=r.length&&(r=x(r));let c=new Uint8Array(68),A=new DataView(c.buffer);var u=a*(1+i*(1+2*o));let v=0;function s(t,e){A.setUint32(0,v++,!0);for(let r=0;r<32;++r)c[4+r]=t[r];for(let r=0;r<32;++r)c[36+r]=e[r];return x(c)}y[0]=s(r,n);for(let r=1;r<a;++r)y[r]=s(y[r-1],n);let U=Date.now()+f;var g=new Uint8Array(32),p=new DataView(g.buffer);for(let e=0;e<i;++e)for(let t=0;t<a;++t){Date.now()>U&&(w(v,u),e=await new Promise((t,r)=>{setTimeout(r=>t(e),l)}),U=Date.now()+f);var D=0==t?y[a-1]:y[t-1];y[t]=s(D,y[t]);for(let r=0;r<o;++r){p.setUint32(0,e,!0),p.setUint32(4,t,!0),p.setUint32(8,r,!0);var h=s(n,g),h=new DataView(h.buffer).getUint32(0,!0);y[t]=s(y[t],y[h%a])}}return w(v,u),y[a-1]},n.aesPair=async function(r){return"string"==typeof r&&(r=Uint8Array.fromBase64(r)),crypto.subtle.importKey("raw",r,"AES-GCM",!1,["encrypt","decrypt"]).then(a=>({key:a,encrypt:(r,e)=>{"string"==typeof r&&(r=(new TextEncoder).encode(r));let n=new Uint8Array(12);return self.crypto.getRandomValues(n),crypto.subtle.encrypt({name:"AES-GCM",iv:n,tagLength:128},a,r).then(r=>{r=new Uint8Array(r);var t=new Uint8Array(12+r.length);return t.set(n),t.set(r,12),e?t.toBase64(!0):t})},decrypt:(r,t)=>{var e=(r="string"==typeof r?Uint8Array.fromBase64(r):r).subarray(0,12),r=r.subarray(12);return crypto.subtle.decrypt({name:"AES-GCM",iv:e,tagLength:128},a,r).then(r=>t?new TextDecoder("utf-8",{fatal:!0}).decode(r):r)}}))},n.balloonPair=async function(r,t,e={}){return n.balloon(r,t,e).then(n.aesPair)},Uint8Array.prototype.toBase64=function(r){let t="";return this.forEach(r=>t+=String.fromCharCode(r)),t=btoa(t),t=r?t.replace(/\+/g,"-").replace(/\//g,"_").replace(/=+/,""):t},Uint8Array.fromBase64=r=>Uint8Array.from(atob(r.replace(/_/g,"/").replace(/-/g,"+")),r=>r.charCodeAt(0)),Uint8Array.prototype.toHex=function(){return Array.from(this,r=>(r>>>4).toString(16)+(15&r).toString(16)).join("")},Uint8Array.fromHex=t=>{var e=t.length/2,n=new Uint8Array(e);for(let r=0;r<e;++r)n[r]=parseInt(t.slice(2*r,2*r+2),16)||0;return n},n})();
|
||||
async function d(t){let e=document.body;balloonOptions.progress=((t,n)=>e.textContent=Math.round(100*t/n)+"%");let n=await cryptoUtils.balloonPair(Uint8Array.fromBase64(s64),t,balloonOptions),a=await n.decrypt(e64);e.textContent="";let o=new DataView(a),r=new Uint8Array(a),i=0;function l(t){let e=4294967296*o.getUint32(i)+o.getUint32(i+4);i+=8;let n=r.subarray(i,i+e);return i+=e,t?new TextDecoder("utf-8",{fatal:!0}).decode(n):n}let d={image:"img",audio:"audio",video:"video",text:"iframe"};for(;i<r.length;){let t=l(1),n=l(1),a=document.createElement("a");a.href=URL.createObjectURL(new File([l()],t,{type:n})),a.setAttribute("download",a.textContent=t),e.append(a);let o=n.split("/")[0];if(d[o]){let t=document.createElement(d[o]);t.src=t.data=a.href,t.controls=!0,e.append(t)}}}
|
||||
</script></body></html>
|
||||
@ -1,114 +0,0 @@
|
||||
#ifndef LOG_EXPR
|
||||
# include <iostream>
|
||||
# define LOG_EXPR(expr) std::cout << #expr " = " << (expr) << std::endl;
|
||||
#endif
|
||||
|
||||
#include "signalsmith-basics/analyser.h"
|
||||
#include "signalsmith-basics/chorus.h"
|
||||
#include "signalsmith-basics/crunch.h"
|
||||
#include "signalsmith-basics/freq-shifter.h"
|
||||
#include "signalsmith-basics/limiter.h"
|
||||
#include "signalsmith-basics/reverb.h"
|
||||
|
||||
#include "../../stfx/clap/stfx-clap.h"
|
||||
|
||||
template<class Effect>
|
||||
struct AnalyserSTFX : public signalsmith::basics::AnalyserSTFX<Effect> {
|
||||
AnalyserSTFX() {
|
||||
this->webPage += "?compact&columns";
|
||||
}
|
||||
};
|
||||
|
||||
static stfx::clap::Plugins plugins;
|
||||
bool clap_init(const char *path) {
|
||||
plugins.add<AnalyserSTFX>({
|
||||
.clap_version = CLAP_VERSION,
|
||||
.id = "uk.co.signalsmith.basics.analyser",
|
||||
.name = "[Basics] Analyser",
|
||||
.vendor = "Signalsmith Audio",
|
||||
.url = "",
|
||||
.manual_url = "",
|
||||
.support_url = "",
|
||||
.version = "1.0.0"
|
||||
}, {
|
||||
CLAP_PLUGIN_FEATURE_ANALYZER,
|
||||
});
|
||||
|
||||
plugins.add<signalsmith::basics::ChorusSTFX>({
|
||||
.clap_version = CLAP_VERSION,
|
||||
.id = "uk.co.signalsmith.basics.chorus",
|
||||
.name = "[Basics] Chorus",
|
||||
.vendor = "Signalsmith Audio",
|
||||
.url = "",
|
||||
.manual_url = "",
|
||||
.support_url = "",
|
||||
.version = "1.0.0"
|
||||
}, {
|
||||
CLAP_PLUGIN_FEATURE_AUDIO_EFFECT,
|
||||
CLAP_PLUGIN_FEATURE_CHORUS,
|
||||
});
|
||||
|
||||
plugins.add<signalsmith::basics::CrunchSTFX>({
|
||||
.clap_version = CLAP_VERSION,
|
||||
.id = "uk.co.signalsmith.basics.crunch",
|
||||
.name = "[Basics] Crunch",
|
||||
.vendor = "Signalsmith Audio",
|
||||
.url = "",
|
||||
.manual_url = "",
|
||||
.support_url = "",
|
||||
.version = "1.0.0"
|
||||
}, {
|
||||
CLAP_PLUGIN_FEATURE_AUDIO_EFFECT,
|
||||
CLAP_PLUGIN_FEATURE_DISTORTION,
|
||||
});
|
||||
|
||||
plugins.add<signalsmith::basics::FreqShifterSTFX>({
|
||||
.clap_version = CLAP_VERSION,
|
||||
.id = "uk.co.signalsmith.basics.freq-shifter",
|
||||
.name = "[Basics] Frequency Shifter",
|
||||
.vendor = "Signalsmith Audio",
|
||||
.url = "",
|
||||
.manual_url = "",
|
||||
.support_url = "",
|
||||
.version = "1.0.0"
|
||||
}, {
|
||||
CLAP_PLUGIN_FEATURE_AUDIO_EFFECT,
|
||||
CLAP_PLUGIN_FEATURE_FREQUENCY_SHIFTER,
|
||||
});
|
||||
|
||||
plugins.add<signalsmith::basics::LimiterSTFX>({
|
||||
.clap_version = CLAP_VERSION,
|
||||
.id = "uk.co.signalsmith.basics.limiter",
|
||||
.name = "[Basics] Limiter",
|
||||
.vendor = "Signalsmith Audio",
|
||||
.url = "",
|
||||
.manual_url = "",
|
||||
.support_url = "",
|
||||
.version = "1.0.0"
|
||||
}, {
|
||||
CLAP_PLUGIN_FEATURE_AUDIO_EFFECT,
|
||||
CLAP_PLUGIN_FEATURE_LIMITER,
|
||||
});
|
||||
|
||||
plugins.add<signalsmith::basics::ReverbSTFX>({
|
||||
.clap_version = CLAP_VERSION,
|
||||
.id = "uk.co.signalsmith.basics.reverb",
|
||||
.name = "[Basics] Reverb",
|
||||
.vendor = "Signalsmith Audio",
|
||||
.url = "",
|
||||
.manual_url = "",
|
||||
.support_url = "",
|
||||
.version = "1.0.0"
|
||||
}, {
|
||||
CLAP_PLUGIN_FEATURE_AUDIO_EFFECT,
|
||||
CLAP_PLUGIN_FEATURE_REVERB,
|
||||
});
|
||||
|
||||
return plugins.clap_init(path);
|
||||
}
|
||||
void clap_deinit() {
|
||||
plugins.clap_deinit();
|
||||
}
|
||||
const void * clap_get_factory(const char *id) {
|
||||
return plugins.clap_get_factory(id);
|
||||
}
|
||||
@ -1,40 +0,0 @@
|
||||
#include "clap/entry.h"
|
||||
/*
|
||||
#include "../../stfx/clap/stfx-clap.h"
|
||||
|
||||
stfx::clap::Plugins stfxPlugins;
|
||||
extern void addAnalyser();
|
||||
extern void addCrunch();
|
||||
extern void addLimiter();
|
||||
extern void addReverb();
|
||||
|
||||
bool clap_init(const char *path) {
|
||||
static bool added = false;
|
||||
if (!added) {
|
||||
addAnalyser();
|
||||
addCrunch();
|
||||
addLimiter();
|
||||
addReverb();
|
||||
}
|
||||
return added = stfxPlugins.clap_init(path);
|
||||
}
|
||||
void clap_deinit() {
|
||||
stfxPlugins.clap_deinit();
|
||||
}
|
||||
const void * clap_get_factory(const char *id) {
|
||||
return stfxPlugins.clap_get_factory(id);
|
||||
}
|
||||
*/
|
||||
|
||||
extern bool clap_init(const char *path);
|
||||
extern void clap_deinit();
|
||||
extern const void * clap_get_factory(const char *id);
|
||||
|
||||
extern "C" {
|
||||
const CLAP_EXPORT clap_plugin_entry clap_entry{
|
||||
.clap_version = CLAP_VERSION,
|
||||
.init = clap_init,
|
||||
.deinit = clap_deinit,
|
||||
.get_factory = clap_get_factory
|
||||
};
|
||||
}
|
||||
@ -1,14 +0,0 @@
|
||||
#!/usr/bin/env sh
|
||||
|
||||
name="$(basename $1)"
|
||||
|
||||
outDir="${2:-..}"
|
||||
pushd "${outDir}"
|
||||
outDir=`pwd`
|
||||
popd
|
||||
|
||||
echo $name
|
||||
|
||||
cd $1
|
||||
rm -f "${outDir}/${name}.tar.gz"
|
||||
tar --exclude=".*" -vczf "${outDir}/${name}.tar.gz" *
|
||||
@ -1,656 +0,0 @@
|
||||
#include "clap/clap.h"
|
||||
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <functional>
|
||||
#include <initializer_list>
|
||||
#include <cstdio>
|
||||
#include <optional>
|
||||
|
||||
#include "../param-info.h"
|
||||
#include "../storage/stfx-storage.h"
|
||||
#include "../ui/web-ui.h"
|
||||
|
||||
namespace stfx { namespace clap {
|
||||
|
||||
// A CLAP plugin made from an STFX template
|
||||
template<template<class> class EffectSTFX>
|
||||
struct Plugin;
|
||||
|
||||
// A helper to make a CLAP plugin factory from STFX templates
|
||||
struct Plugins {
|
||||
template<template<class> class EffectSTFX, class ...Args>
|
||||
size_t add(clap_plugin_descriptor desc, std::initializer_list<const char *> features, Args ...args) {
|
||||
size_t index = featureLists.size();
|
||||
|
||||
featureLists.emplace_back(features);
|
||||
featureLists[index].push_back(nullptr);
|
||||
desc.features = featureLists[index].data();
|
||||
descriptors.push_back(desc);
|
||||
|
||||
creates.push_back([=](const clap_host *host){
|
||||
return new Plugin<EffectSTFX>(*this, &descriptors[index], host, args...);
|
||||
});
|
||||
return index;
|
||||
}
|
||||
|
||||
bool clap_init(const char *path) {
|
||||
modulePath = path;
|
||||
return true;
|
||||
}
|
||||
|
||||
void clap_deinit() {}
|
||||
|
||||
const void * clap_get_factory(const char *id) {
|
||||
if (!std::strcmp(id, CLAP_PLUGIN_FACTORY_ID)) {
|
||||
// static variables like this are thread-safe (since C++11)
|
||||
// https://en.cppreference.com/w/cpp/language/storage_duration.html#Static_block_variables
|
||||
static PluginFactory factory{*this};
|
||||
return &factory;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
std::string modulePath;
|
||||
private:
|
||||
std::vector<std::vector<const char *>> featureLists;
|
||||
std::vector<clap_plugin_descriptor> descriptors;
|
||||
std::vector<std::function<const clap_plugin_t *(const clap_host *)>> creates;
|
||||
|
||||
struct PluginFactory : public clap_plugin_factory {
|
||||
Plugins &plugins;
|
||||
|
||||
PluginFactory(Plugins &plugins) : plugins(plugins) {
|
||||
get_plugin_count = static_get_plugin_count;
|
||||
get_plugin_descriptor = static_get_plugin_descriptor;
|
||||
create_plugin = static_create_plugin;
|
||||
}
|
||||
|
||||
static uint32_t static_get_plugin_count(const clap_plugin_factory *factory) {
|
||||
const auto &plugins = ((PluginFactory *)factory)->plugins;
|
||||
return uint32_t(plugins.creates.size());
|
||||
}
|
||||
|
||||
static const clap_plugin_descriptor * static_get_plugin_descriptor(const clap_plugin_factory *factory, uint32_t index) {
|
||||
const auto &plugins = ((PluginFactory *)factory)->plugins;
|
||||
if (index >= plugins.descriptors.size()) return nullptr;
|
||||
return &plugins.descriptors[index];
|
||||
}
|
||||
|
||||
static const clap_plugin * static_create_plugin(const clap_plugin_factory *factory, const clap_host *host, const char *pluginId) {
|
||||
const auto &plugins = ((PluginFactory *)factory)->plugins;
|
||||
for (size_t index = 0; index < plugins.descriptors.size(); ++index) {
|
||||
auto &desc = plugins.descriptors[index];
|
||||
if (!std::strcmp(pluginId, desc.id)) {
|
||||
return plugins.creates[index](host);
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
struct Crc32 {
|
||||
void add(uint8_t byte) {
|
||||
uint32_t val = (crc^byte)&0xFF;
|
||||
for (int i = 0; i < 8; ++i) {
|
||||
val = (val&1) ? (val>>1)^0xEDB88320 : (val>>1);
|
||||
}
|
||||
crc = val^(crc>>8);
|
||||
}
|
||||
|
||||
Crc32 & addString(const char *str, bool includeNull=true) {
|
||||
while (*str) {
|
||||
add(uint8_t(*str));
|
||||
++str;
|
||||
}
|
||||
if (includeNull) add(0);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Crc32 copy() {
|
||||
return {*this};
|
||||
}
|
||||
|
||||
uint32_t done() const {
|
||||
return crc^0xFFFFFFFFu;
|
||||
}
|
||||
private:
|
||||
uint32_t crc = 0xFFFFFFFFu;
|
||||
};
|
||||
|
||||
// Just include the proposed draft structs here
|
||||
static constexpr const char *CLAP_EXT_WEBVIEW1 = "clap.webview/1";
|
||||
struct clap_plugin_webview1 {
|
||||
bool(CLAP_ABI *provide_starting_uri)(const clap_plugin_t *plugin, char *out_buffer, uint32_t out_buffer_capacity);
|
||||
bool(CLAP_ABI *receive)(const clap_plugin_t *plugin, const void *buffer, uint32_t size);
|
||||
};
|
||||
struct clap_host_webview1 {
|
||||
bool(CLAP_ABI *is_open)(const clap_host_t *host);
|
||||
bool(CLAP_ABI *send)(const clap_host_t *host, const void *buffer, uint32_t size);
|
||||
};
|
||||
|
||||
template<template<class> class EffectSTFX>
|
||||
struct Plugin : public clap_plugin {
|
||||
const Plugins &plugins;
|
||||
const clap_host *host;
|
||||
const clap_host_params *hostParams = nullptr;
|
||||
const clap_host_webview1 *hostWebview1 = nullptr;
|
||||
using Effect = stfx::web::WebUILibraryEffect<float, EffectSTFX>;
|
||||
Effect effect;
|
||||
|
||||
template<class ...Args>
|
||||
Plugin(const Plugins &plugins, const clap_plugin_descriptor *desc, const clap_host *host, Args ...args) : plugins(plugins), host(host), effect(args...) {
|
||||
this->desc = desc;
|
||||
this->plugin_data = nullptr;
|
||||
this->init = plugin_init;
|
||||
this->destroy = plugin_destroy;
|
||||
this->activate = plugin_activate;
|
||||
this->deactivate = plugin_deactivate;
|
||||
this->start_processing = plugin_start_processing;
|
||||
this->stop_processing = plugin_stop_processing;
|
||||
this->reset = plugin_reset;
|
||||
this->process = plugin_process;
|
||||
this->get_extension = plugin_get_extension;
|
||||
this->on_main_thread = plugin_on_main_thread;
|
||||
|
||||
scanParams();
|
||||
}
|
||||
|
||||
// plugin state
|
||||
bool isConfigured = false;
|
||||
// for library STFX, all inputs/outputs (main and aux) get concatenated together
|
||||
std::vector<const float *> inputBuffers;
|
||||
std::vector<float *> outputBuffers;
|
||||
|
||||
void processEvent(const clap_event_header *header) {
|
||||
if (header->space_id != CLAP_CORE_EVENT_SPACE_ID) return; // only core events supported atm
|
||||
if (header->type == CLAP_EVENT_PARAM_VALUE) {
|
||||
auto *event = (clap_event_param_value *)header;
|
||||
auto *param = (Param *)event->cookie;
|
||||
if (!param) {
|
||||
auto paramId = event->param_id;
|
||||
for (auto &p : params) {
|
||||
if (p.id == paramId) {
|
||||
param = &p;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!param) return; // invalid parameter
|
||||
} else if (param->id != event->param_id) {
|
||||
return; // inconsistent ID / cookie
|
||||
}
|
||||
if (param->rangeParam) {
|
||||
*param->rangeParam = param->rangeInfo->fromUnit(event->value);
|
||||
} else {
|
||||
*param->steppedParam = int(std::round(event->value));
|
||||
}
|
||||
} else {
|
||||
LOG_EXPR(header->size);
|
||||
LOG_EXPR(header->time);
|
||||
LOG_EXPR(header->space_id);
|
||||
LOG_EXPR(header->type);
|
||||
LOG_EXPR(header->flags);
|
||||
}
|
||||
}
|
||||
|
||||
// CLAP plugin methods
|
||||
static bool plugin_init(const clap_plugin *obj) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
#define STFX_GET_EXT(field, extId) \
|
||||
plugin.field = (decltype(plugin.field))plugin.host->get_extension(plugin.host, extId);
|
||||
STFX_GET_EXT(hostParams, CLAP_EXT_PARAMS)
|
||||
STFX_GET_EXT(hostWebview1, CLAP_EXT_WEBVIEW1)
|
||||
#undef STFX_GET_EXT
|
||||
return true;
|
||||
}
|
||||
static void plugin_destroy(const clap_plugin *obj) {
|
||||
delete (Plugin *)obj;
|
||||
}
|
||||
static bool plugin_activate(const clap_plugin *obj, double sampleRate, uint32_t minFrames, uint32_t maxFrames) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
auto &config = plugin.effect.config;
|
||||
if (!plugin.isConfigured || sampleRate != plugin.effect.config.sampleRate) {
|
||||
auto prevConfig = config;
|
||||
plugin.isConfigured = plugin.effect.configure();
|
||||
if (!plugin.isConfigured) {
|
||||
// Can't change config (e.g. sample-rate/ports/etc.) here, return to previous
|
||||
config = prevConfig;
|
||||
}
|
||||
}
|
||||
size_t inputChannels = config.inputChannels;
|
||||
for (auto &a : config.auxInputs) inputChannels += a;
|
||||
plugin.inputBuffers.reserve(inputChannels);
|
||||
size_t outputChannels = config.outputChannels;
|
||||
for (auto &a : config.auxOutputs) a += outputChannels;
|
||||
plugin.outputBuffers.reserve(outputChannels);
|
||||
return plugin.isConfigured;
|
||||
}
|
||||
static void plugin_deactivate(const clap_plugin *obj) {}
|
||||
static bool plugin_start_processing(const clap_plugin *obj) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
return plugin.isConfigured;
|
||||
}
|
||||
static void plugin_stop_processing(const clap_plugin *obj) {}
|
||||
static void plugin_reset(const clap_plugin *obj) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
if (plugin.isConfigured) plugin.effect.reset();
|
||||
}
|
||||
static const void * plugin_get_extension(const clap_plugin *obj, const char *extId) {
|
||||
if (!std::strcmp(extId, CLAP_EXT_PARAMS)) {
|
||||
static struct clap_plugin_params ext{
|
||||
params_count,
|
||||
params_get_info,
|
||||
params_get_value,
|
||||
params_value_to_text,
|
||||
params_text_to_value,
|
||||
params_flush
|
||||
};
|
||||
return &ext;
|
||||
} else if (!std::strcmp(extId, CLAP_EXT_AUDIO_PORTS)) {
|
||||
static struct clap_plugin_audio_ports ext{
|
||||
audio_ports_count,
|
||||
audio_ports_get
|
||||
};
|
||||
return &ext;
|
||||
} else if (!std::strcmp(extId, CLAP_EXT_STATE)) {
|
||||
static struct clap_plugin_state ext{
|
||||
state_save,
|
||||
state_load
|
||||
};
|
||||
return &ext;
|
||||
} else if (!std::strcmp(extId, CLAP_EXT_WEBVIEW1)) {
|
||||
static struct clap_plugin_webview1 ext{
|
||||
webview1_provide_starting_uri,
|
||||
webview1_receive
|
||||
};
|
||||
return &ext;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
static clap_process_status plugin_process(const clap_plugin *obj, const clap_process *process) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
auto &inputBuffers = plugin.inputBuffers;
|
||||
for (uint32_t i = 0; i < process->audio_inputs_count; ++i) {
|
||||
auto &buffer = process->audio_inputs[i];
|
||||
for (uint32_t c = 0; c < buffer.channel_count; ++c) {
|
||||
inputBuffers.push_back(buffer.data32[c]);
|
||||
}
|
||||
}
|
||||
auto &outputBuffers = plugin.outputBuffers;
|
||||
for (uint32_t i = 0; i < process->audio_outputs_count; ++i) {
|
||||
auto &buffer = process->audio_outputs[i];
|
||||
for (uint32_t c = 0; c < buffer.channel_count; ++c) {
|
||||
outputBuffers.push_back(buffer.data32[c]);
|
||||
}
|
||||
}
|
||||
|
||||
size_t length = process->frames_count;
|
||||
auto inputEventCount = process->in_events->size(process->in_events);
|
||||
size_t offset = 0, nextEventIndex = 0;
|
||||
while (offset < length) {
|
||||
size_t nextEventOffset = length;
|
||||
const clap_event_header *event = nullptr;
|
||||
if (nextEventIndex < inputEventCount) {
|
||||
event = process->in_events->get(process->in_events, nextEventIndex);
|
||||
nextEventOffset = std::max<size_t>(offset, event->time);
|
||||
}
|
||||
|
||||
// process up until the next event (or end)
|
||||
if (nextEventOffset > offset) {
|
||||
auto delta = nextEventOffset - offset;
|
||||
plugin.effect.process(inputBuffers.data(), outputBuffers.data(), delta);
|
||||
offset = nextEventOffset;
|
||||
for (auto &p : inputBuffers) p += delta;
|
||||
for (auto &p : outputBuffers) p += delta;
|
||||
}
|
||||
if (event) {
|
||||
plugin.processEvent(event);
|
||||
++nextEventIndex;
|
||||
}
|
||||
}
|
||||
inputBuffers.resize(0);
|
||||
outputBuffers.resize(0);
|
||||
|
||||
if (plugin.effect.hasPendingWebMessage()) {
|
||||
plugin.host->request_callback(plugin.host);
|
||||
}
|
||||
plugin.sendParamEvents(process->out_events);
|
||||
return CLAP_PROCESS_CONTINUE;
|
||||
}
|
||||
static void plugin_on_main_thread(const clap_plugin *obj) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
plugin.sendWebMessages();
|
||||
}
|
||||
|
||||
// parameters
|
||||
struct Param : public clap_param_info {
|
||||
typename Effect::ParamRange *rangeParam = nullptr;
|
||||
std::optional<RangeParamInfo> rangeInfo;
|
||||
typename Effect::ParamStepped *steppedParam = nullptr;
|
||||
std::optional<SteppedParamInfo> steppedInfo;
|
||||
|
||||
std::atomic_flag hostValueSent = ATOMIC_FLAG_INIT;
|
||||
std::atomic_flag hostStartGestureSent = ATOMIC_FLAG_INIT;
|
||||
std::atomic_flag hostStopGestureSent = ATOMIC_FLAG_INIT;
|
||||
|
||||
Param() {}
|
||||
Param(Param &&other) : clap_param_info(other), rangeParam(other.rangeParam), rangeInfo(std::move(other.rangeInfo)), steppedParam(other.steppedParam), steppedInfo(std::move(other.steppedInfo)) {}
|
||||
|
||||
void setClapInfo() {
|
||||
flags |= CLAP_PARAM_IS_AUTOMATABLE;
|
||||
cookie = this;
|
||||
if (rangeParam) {
|
||||
std::strncpy(name, rangeInfo->name.c_str(), CLAP_NAME_SIZE);
|
||||
// STFX range params are mapped to [0, 1] so we can give them a nonlinear shape
|
||||
min_value = 0;
|
||||
max_value = 1;
|
||||
default_value = rangeInfo->toUnit(rangeInfo->defaultValue);
|
||||
} else {
|
||||
std::strncpy(name, steppedInfo->name.c_str(), CLAP_NAME_SIZE);
|
||||
flags |= CLAP_PARAM_IS_STEPPED;
|
||||
min_value = steppedInfo->low;
|
||||
max_value = steppedInfo->high;
|
||||
default_value = steppedInfo->defaultValue;
|
||||
}
|
||||
|
||||
hostValueSent.test_and_set();
|
||||
hostStartGestureSent.test_and_set();
|
||||
hostStopGestureSent.test_and_set();
|
||||
}
|
||||
};
|
||||
std::vector<Param> params;
|
||||
struct ParamScanner : public storage::STFXStorageScanner<ParamScanner> {
|
||||
std::vector<Param> ¶ms;
|
||||
Crc32 crc;
|
||||
|
||||
ParamScanner(std::vector<Param> ¶ms) : params(params) {}
|
||||
|
||||
template<class PR>
|
||||
RangeParamInfo & range(const char *key, PR ¶m) {
|
||||
param.context.index = params.size(); // so we can find it in the listeners below
|
||||
params.emplace_back();
|
||||
auto &entry = params.back();
|
||||
entry.id = crc.copy().addString(key, true).done();
|
||||
entry.rangeParam = ¶m;
|
||||
return entry.rangeInfo.emplace(param);
|
||||
}
|
||||
template<class PS>
|
||||
SteppedParamInfo & stepped(const char *key, PS ¶m) {
|
||||
param.context.index = params.size(); // so we can find it in the listeners below
|
||||
|
||||
params.emplace_back();
|
||||
auto &entry = params.back();
|
||||
entry.id = crc.copy().addString(key, true).done();
|
||||
entry.steppedParam = ¶m;
|
||||
return entry.steppedInfo.emplace(param);
|
||||
}
|
||||
};
|
||||
void scanParams() {
|
||||
params.clear();
|
||||
ParamScanner scanner{params};
|
||||
effect.state(scanner);
|
||||
for (auto &entry : params) entry.setClapInfo();
|
||||
|
||||
// Listen for changes from the effect UI
|
||||
effect.paramListenerRange = [&](stfx::web::ParamContext context, double value){
|
||||
params[context.index].hostValueSent.clear();
|
||||
if (hostParams) hostParams->request_flush(host);
|
||||
};
|
||||
effect.paramListenerGesture = [&](stfx::web::ParamContext context, bool gesture){
|
||||
if (gesture) {
|
||||
params[context.index].hostStartGestureSent.clear();
|
||||
} else {
|
||||
params[context.index].hostStopGestureSent.clear();
|
||||
}
|
||||
if (hostParams) hostParams->request_flush(host);
|
||||
};
|
||||
effect.paramListenerStepped = [&](stfx::web::ParamContext context, int value){
|
||||
params[context.index].hostValueSent.clear();
|
||||
if (hostParams) hostParams->request_flush(host);
|
||||
};
|
||||
}
|
||||
void sendParamEvents(const clap_output_events *events) {
|
||||
for (auto ¶m : params) {
|
||||
auto sendGesture = [&](uint16_t eventType){
|
||||
clap_event_param_gesture event{
|
||||
.header={
|
||||
.size=sizeof(event),
|
||||
.time=0,
|
||||
.space_id=CLAP_CORE_EVENT_SPACE_ID,
|
||||
.type=eventType
|
||||
},
|
||||
.param_id=param.id,
|
||||
};
|
||||
// Not *super* bothered if this fails
|
||||
events->try_push(events, &event.header);
|
||||
};
|
||||
|
||||
if (!param.hostStartGestureSent.test_and_set()) {
|
||||
sendGesture(CLAP_EVENT_PARAM_GESTURE_BEGIN);
|
||||
}
|
||||
if (!param.hostValueSent.test_and_set()) {
|
||||
clap_event_param_value event{
|
||||
.header={
|
||||
.size=sizeof(event),
|
||||
.time=0,
|
||||
.space_id=CLAP_CORE_EVENT_SPACE_ID,
|
||||
.type=CLAP_EVENT_PARAM_VALUE
|
||||
},
|
||||
.param_id=param.id,
|
||||
.cookie=param.cookie,
|
||||
.note_id=-1,
|
||||
.port_index=-1,
|
||||
.channel=-1,
|
||||
.key=-1
|
||||
};
|
||||
if (param.rangeParam) {
|
||||
event.value = param.rangeInfo->toUnit((double)*param.rangeParam);
|
||||
} else {
|
||||
event.value = (int)*param.steppedParam;
|
||||
}
|
||||
if (!events->try_push(events, &event.header)) {
|
||||
// failed, try again later
|
||||
param.hostValueSent.clear();
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (!param.hostStopGestureSent.test_and_set()) {
|
||||
sendGesture(CLAP_EVENT_PARAM_GESTURE_END);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// CLAP parameter methods
|
||||
static uint32_t params_count(const clap_plugin *obj) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
return plugin.params.size();
|
||||
}
|
||||
static bool params_get_info(const clap_plugin *obj, uint32_t index, clap_param_info *info) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
if (index >= plugin.params.size()) return false;
|
||||
*info = plugin.params[index];
|
||||
return true;
|
||||
}
|
||||
static bool params_get_value(const clap_plugin *obj, clap_id paramId, double *value) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
for (auto ¶m : plugin.params) {
|
||||
if (param.id == paramId) {
|
||||
if (param.rangeParam) {
|
||||
*value = param.rangeInfo->toUnit((double)*param.rangeParam);
|
||||
} else {
|
||||
*value = (int)*param.steppedParam;
|
||||
}
|
||||
param.hostValueSent.test_and_set();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
static bool params_value_to_text(const clap_plugin *obj, clap_id paramId, double value, char *text, uint32_t textCapacity) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
for (auto ¶m : plugin.params) {
|
||||
if (param.id == paramId) {
|
||||
if (param.rangeParam) {
|
||||
auto str = param.rangeInfo->toString(param.rangeInfo->fromUnit(value));
|
||||
std::strncpy(text, str.c_str(), textCapacity);
|
||||
} else {
|
||||
auto str = param.steppedInfo->toString(int(std::round(value)));
|
||||
std::strncpy(text, str.c_str(), textCapacity);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
static bool params_text_to_value(const clap_plugin *obj, clap_id paramId, const char *text, double *value) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
for (auto ¶m : plugin.params) {
|
||||
if (param.id == paramId) {
|
||||
std::string str = text;
|
||||
if (param.rangeParam) {
|
||||
*value = param.rangeInfo->toUnit(param.rangeInfo->fromString(str));
|
||||
} else {
|
||||
*value = param.steppedInfo->fromString(str);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
static void params_flush(const clap_plugin *obj, const clap_input_events *inEvents, const clap_output_events *outEvents) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
auto count = inEvents->size(inEvents);
|
||||
for (uint32_t i = 0; i < count; ++i) {
|
||||
auto *header = inEvents->get(inEvents, i);
|
||||
plugin.processEvent(header);
|
||||
}
|
||||
plugin.sendParamEvents(outEvents);
|
||||
}
|
||||
|
||||
// CLAP audio port methods
|
||||
static uint32_t audio_ports_count(const clap_plugin *obj, bool inputPorts) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
if (!plugin.isConfigured) {
|
||||
plugin.isConfigured = plugin.effect.configurePersistent();
|
||||
if (!plugin.isConfigured) return 0;
|
||||
}
|
||||
auto &config = plugin.effect.config;
|
||||
if (inputPorts) {
|
||||
return config.auxInputs.size() + (config.inputChannels > 0);
|
||||
} else {
|
||||
return config.auxOutputs.size() + (config.outputChannels > 0);
|
||||
}
|
||||
}
|
||||
static bool audio_ports_get(const clap_plugin *obj, uint32_t index, bool inputPorts, clap_audio_port_info *info) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
if (!plugin.isConfigured) return false;
|
||||
auto &config = plugin.effect.config;
|
||||
|
||||
clap_id portIdBase = (inputPorts ? 0x1000000 : 0x2000000);
|
||||
auto main = uint32_t(inputPorts ? config.inputChannels : config.outputChannels);
|
||||
auto &aux = (inputPorts ? config.auxInputs : config.auxOutputs);
|
||||
auto auxIndex = index;
|
||||
if (main) {
|
||||
if (index == 0) {
|
||||
*info = {
|
||||
.id=portIdBase,
|
||||
.name={'m', 'a', 'i', 'n'},
|
||||
.flags=CLAP_AUDIO_PORT_IS_MAIN,
|
||||
.channel_count=main,
|
||||
.port_type=nullptr,
|
||||
.in_place_pair=CLAP_INVALID_ID
|
||||
};
|
||||
return true;
|
||||
}
|
||||
--auxIndex;
|
||||
}
|
||||
if (auxIndex < aux.size()) {
|
||||
*info = {
|
||||
.id=portIdBase + index,
|
||||
.name={'a', 'u', 'x'},
|
||||
.flags=CLAP_AUDIO_PORT_IS_MAIN,
|
||||
.channel_count=main,
|
||||
.port_type=nullptr,
|
||||
.in_place_pair=CLAP_INVALID_ID
|
||||
};
|
||||
if (aux.size() > 1) {
|
||||
info->name[3] = '1' + auxIndex;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool writeToStream(const unsigned char *bytes, size_t length, const clap_ostream *stream) {
|
||||
size_t index = 0;
|
||||
while (index < length) {
|
||||
size_t remaining = length - index;
|
||||
auto written = stream->write(stream, bytes + index, remaining);
|
||||
if (written <= 0) return false;
|
||||
index += written;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
static bool fillFromStream(const clap_istream *stream, std::vector<unsigned char> &buffer) {
|
||||
buffer.resize(0);
|
||||
size_t chunkSize = 1024;
|
||||
size_t length = 0;
|
||||
while (1) {
|
||||
buffer.resize(length + chunkSize);
|
||||
auto read = stream->read(stream, buffer.data() + length, chunkSize);
|
||||
length += read;
|
||||
if (read < 0) {
|
||||
buffer.resize(0);
|
||||
return false;
|
||||
} else if (read == 0) {
|
||||
buffer.resize(length);
|
||||
return true;
|
||||
}
|
||||
chunkSize = buffer.size();
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<unsigned char> stateBuffer;
|
||||
static bool state_save(const clap_plugin *obj, const clap_ostream *stream) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
auto &buffer = plugin.stateBuffer;
|
||||
plugin.effect.saveState(buffer);
|
||||
return writeToStream(buffer.data(), buffer.size(), stream);
|
||||
}
|
||||
static bool state_load(const clap_plugin *obj, const clap_istream *stream) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
auto &buffer = plugin.stateBuffer;
|
||||
if (!fillFromStream(stream, buffer)) return false;
|
||||
plugin.effect.loadState(buffer);
|
||||
plugin.sendWebMessages(); // should already be on the main thread
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool webview1_provide_starting_uri(const clap_plugin_t *obj, char *startingUri, uint32_t capacity) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
if (!plugin.hostWebview1) return false;
|
||||
if (!plugin.effect.webPage.size() + 1 > capacity) return false;
|
||||
std::strcpy(startingUri, plugin.effect.webPage.c_str());
|
||||
return true;
|
||||
}
|
||||
static bool webview1_receive(const clap_plugin_t *obj, const void *buffer, uint32_t size) {
|
||||
auto &plugin = *(Plugin *)obj;
|
||||
plugin.effect.webReceive(buffer, size);
|
||||
// TODO: *double* check we're on the main thread, for safety
|
||||
plugin.sendWebMessages();
|
||||
return true;
|
||||
}
|
||||
|
||||
void sendWebMessages() {
|
||||
if (!hostWebview1) return;
|
||||
while (auto *m = effect.getPendingWebMessage()) {
|
||||
hostWebview1->send(host, m->bytes.data(), m->bytes.size());
|
||||
m->sent();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
}} // namespace
|
||||
|
||||
extern stfx::clap::Plugins stfxPlugins;
|
||||
@ -1,336 +0,0 @@
|
||||
#ifndef SIGNALSMITH_STFX_STFX2_PARAM_INFO_H
|
||||
#define SIGNALSMITH_STFX_STFX2_PARAM_INFO_H
|
||||
|
||||
#include <vector>
|
||||
#include <cmath>
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
#include <iomanip>
|
||||
#include <map>
|
||||
|
||||
namespace stfx {
|
||||
class UnitRangeMap {
|
||||
double a, b, d;
|
||||
public:
|
||||
UnitRangeMap() : a(0), b(1), d(0) {} // identity
|
||||
UnitRangeMap(double min, double mid, double max) {
|
||||
double k = (mid - min)/(max - mid);
|
||||
a = min;
|
||||
b = max*k - min;
|
||||
d = k - 1;
|
||||
}
|
||||
|
||||
double toUnit(double value) const {
|
||||
return (value - a)/(b - value*d);
|
||||
}
|
||||
double fromUnit(double unit) const {
|
||||
return (a + unit*b)/(1 + unit*d);
|
||||
}
|
||||
};
|
||||
|
||||
struct RangeParamInfo {
|
||||
double defaultValue;
|
||||
double low, mid, high;
|
||||
std::string name, description;
|
||||
|
||||
RangeParamInfo(double defaultValue) : defaultValue(defaultValue), low(defaultValue), mid(defaultValue), high(defaultValue) {}
|
||||
RangeParamInfo(const RangeParamInfo &other) = delete;
|
||||
RangeParamInfo(RangeParamInfo &&other) = default;
|
||||
|
||||
RangeParamInfo & info(std::string pName, std::string pDescription) {
|
||||
name = pName;
|
||||
description = pDescription;
|
||||
return *this;
|
||||
}
|
||||
RangeParamInfo & range(double pLow, double pHigh) {
|
||||
return range(pLow, pHigh, (pLow + pHigh)*0.5);
|
||||
}
|
||||
RangeParamInfo & range(double pLow, double pMid, double pHigh) {
|
||||
low = pLow;
|
||||
mid = pMid;
|
||||
high = pHigh;
|
||||
// sanity check in case we mix the argument order up
|
||||
if ((mid < high) != (low < high)) std::swap(mid, high); // middle crosses the high
|
||||
if ((low < mid) != (low < high)) std::swap(low, mid); // middle crosses the low
|
||||
rangeMap = {low, mid, high};
|
||||
return *this;
|
||||
}
|
||||
|
||||
typedef double((*DoubleMap)(double));
|
||||
RangeParamInfo & unit(std::string suffix, int precision=2, DoubleMap fromDisplay=identityMap, DoubleMap toDisplay=identityMap, double validLow=doubleLowest, double validHigh=doubleMax) {
|
||||
unitOptions.emplace_back(suffix, fromDisplay, toDisplay, validLow, validHigh, precision);
|
||||
return *this;
|
||||
}
|
||||
RangeParamInfo & unit(std::string suffix, DoubleMap fromDisplay, DoubleMap toDisplay, double validLow=doubleLowest, double validHigh=doubleMax) {
|
||||
return unit(suffix, 2, fromDisplay, toDisplay, validLow, validHigh);
|
||||
}
|
||||
RangeParamInfo & unit(std::string suffix, int precision, double validLow, double validHigh) {
|
||||
return unit(suffix, precision, identityMap, identityMap, validLow, validHigh);
|
||||
}
|
||||
RangeParamInfo & unit(std::string suffix, double validLow, double validHigh) {
|
||||
return unit(suffix, identityMap, identityMap, validLow, validHigh);
|
||||
}
|
||||
|
||||
RangeParamInfo & exact(double v, std::string valueName) {
|
||||
exactOptions.push_back({v, valueName});
|
||||
return *this;
|
||||
}
|
||||
|
||||
std::string toString(double value) const {
|
||||
for (auto &option : exactOptions) {
|
||||
if (value == option.value) return option.name;
|
||||
}
|
||||
for (const auto &unit : unitOptions) {
|
||||
if (unit.valid(value)) return unit.toString(value);
|
||||
}
|
||||
if (unitOptions.empty()) return std::to_string(value);
|
||||
return unitOptions[0].toString(value);
|
||||
}
|
||||
void toString(double value, std::string &valueString, std::string &unitString) const {
|
||||
for (auto &option : exactOptions) {
|
||||
if (value == option.value) {
|
||||
valueString = option.name;
|
||||
unitString = "";
|
||||
return;
|
||||
}
|
||||
}
|
||||
for (const auto &unit : unitOptions) {
|
||||
if (unit.valid(value)) return unit.toString(value, valueString, unitString);
|
||||
}
|
||||
if (unitOptions.empty()) {
|
||||
valueString = std::to_string(value);
|
||||
unitString = "";
|
||||
}
|
||||
unitOptions[0].toString(value, valueString, unitString);
|
||||
}
|
||||
double fromString(const std::string &str) const {
|
||||
bool hasDecimal = false, hasDigit = false;;
|
||||
{ // check for a parseable number
|
||||
size_t pos = 0;
|
||||
while (str[pos] == '\t' || str[pos] == ' ') ++pos; // strip leading whitespace
|
||||
if (str[pos] == '-') ++pos;
|
||||
while (pos < str.length()) {
|
||||
if (!hasDecimal && (str[pos] == '.' || str[pos] == ',')) {
|
||||
hasDecimal = true;
|
||||
} else if (str[pos] >= '0' && str[pos] <= '9') {
|
||||
hasDigit = true;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
++pos;
|
||||
}
|
||||
}
|
||||
// It's not a number - look for an exact match
|
||||
if (!hasDigit) {
|
||||
int longestMatch = -1;
|
||||
double result = defaultValue;
|
||||
for (auto &option : exactOptions) {
|
||||
for (size_t i = 0; i < option.name.size() && i < str.size(); ++i) {
|
||||
if (option.name[i] == str[i]) {
|
||||
if (int(i) > longestMatch) {
|
||||
longestMatch = i;
|
||||
result = option.value;
|
||||
}
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
size_t pos = 0;
|
||||
double result = std::stod(str, 0);
|
||||
// Skip whitespace after the number
|
||||
while (pos < str.length() && (str[pos] == ' ' || str[pos] == '\t')) ++pos;
|
||||
size_t end = str.length(); // and at the end
|
||||
while (end > pos && end > 0 && (str[end - 1] == ' ' || str[end - 1] == '\t')) --end;
|
||||
std::string unit = str.substr(pos, end - pos);
|
||||
|
||||
for (const auto &u : unitOptions) {
|
||||
if (u.unit == unit) {
|
||||
return u.fromDisplay(result);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
std::vector<std::string> getUnits() const {
|
||||
std::vector<std::string> result;
|
||||
for (size_t i = 0; i < unitOptions.size(); ++i) {
|
||||
bool duplicate = false;
|
||||
for (size_t j = 0; j < i; ++j) {
|
||||
if (unitOptions[i].unit == unitOptions[j].unit) {
|
||||
duplicate = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!duplicate) result.push_back(unitOptions[i].unit);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
double toUnit(double value) const {
|
||||
return rangeMap.toUnit(value);
|
||||
}
|
||||
double fromUnit(double unit) const {
|
||||
return rangeMap.fromUnit(unit);
|
||||
}
|
||||
|
||||
private:
|
||||
static constexpr double doubleLowest = std::numeric_limits<double>::lowest();
|
||||
static constexpr double doubleMax = std::numeric_limits<double>::max();
|
||||
static double identityMap(double v) {
|
||||
return v;
|
||||
}
|
||||
|
||||
// A map from [0, 1] to another range with specified midpoint, based on a 1/x curve
|
||||
UnitRangeMap rangeMap;
|
||||
|
||||
protected:
|
||||
struct ExactEntry {
|
||||
double value;
|
||||
std::string name;
|
||||
};
|
||||
std::vector<ExactEntry> exactOptions;
|
||||
struct UnitEntry {
|
||||
std::string fixedDisplay = "";
|
||||
std::string unit;
|
||||
bool addSpace = false, useFixed = false, keepZeros = false;
|
||||
DoubleMap fromDisplay, toDisplay;
|
||||
double validLow, validHigh;
|
||||
int precision;
|
||||
double precisionOffset = 0;
|
||||
|
||||
UnitEntry(std::string unit, DoubleMap fromDisplay, DoubleMap toDisplay, double validLow, double validHigh, int precision=2) : unit(unit), fromDisplay(fromDisplay), toDisplay(toDisplay), validLow(validLow), validHigh(validHigh), precision(precision) {
|
||||
if (validLow > validHigh) {
|
||||
std::swap(validLow, validHigh);
|
||||
keepZeros = true;
|
||||
}
|
||||
if (unit[0] == ' ') {
|
||||
addSpace = true;
|
||||
this->unit = unit.substr(1, unit.size() - 1);
|
||||
}
|
||||
precisionOffset = 0.4999*std::pow(10, -precision);
|
||||
}
|
||||
|
||||
bool valid(double value) const {
|
||||
return value >= validLow && value <= validHigh;
|
||||
}
|
||||
|
||||
void toString(double value, std::string &valueString, std::string &unitString) const {
|
||||
std::ostringstream oss;
|
||||
oss.precision(precision);
|
||||
oss << std::fixed;
|
||||
double offset = 0;
|
||||
if (precision > 0) {
|
||||
oss << toDisplay(value) + offset;
|
||||
} else {
|
||||
oss << (int)(toDisplay(value) + offset);
|
||||
}
|
||||
valueString = oss.str();
|
||||
// Strip trailing zeroes
|
||||
if (!keepZeros) for (int i = 0; i < (int)valueString.size(); ++i) {
|
||||
if (valueString[i] == '.') {
|
||||
int zeros = valueString.size();
|
||||
while (zeros > i && valueString[zeros - 1] == '0') --zeros;
|
||||
if (zeros == i + 1) --zeros;
|
||||
valueString = valueString.substr(0, zeros);
|
||||
break;
|
||||
}
|
||||
}
|
||||
unitString = unit;
|
||||
}
|
||||
std::string toString(double value) const {
|
||||
std::string valueString, unitString;
|
||||
toString(value, valueString, unitString);
|
||||
return valueString + (addSpace ? " " : "") + unitString;
|
||||
}
|
||||
};
|
||||
std::vector<UnitEntry> unitOptions;
|
||||
};
|
||||
|
||||
struct SteppedParamInfo {
|
||||
int defaultValue;
|
||||
int low, high;
|
||||
std::string name, description;
|
||||
|
||||
SteppedParamInfo(int defaultValue) : defaultValue(defaultValue), low(defaultValue), high(defaultValue), nameIndex(defaultValue) {}
|
||||
SteppedParamInfo(const SteppedParamInfo &other) = delete;
|
||||
SteppedParamInfo(SteppedParamInfo &&other) = default;
|
||||
|
||||
SteppedParamInfo & info(std::string pName, std::string pDescription) {
|
||||
name = pName;
|
||||
description = pDescription;
|
||||
return *this;
|
||||
}
|
||||
SteppedParamInfo & range(int pLow, int pHigh) {
|
||||
low = pLow;
|
||||
high = pHigh;
|
||||
return *this;
|
||||
}
|
||||
|
||||
SteppedParamInfo & label(const char *n) {
|
||||
if (nameIndex > high && high >= low) high = nameIndex;
|
||||
if (nameIndex > low && low > high) low = nameIndex;
|
||||
nameMap[nameIndex] = n;
|
||||
valueMap[n] = nameIndex;
|
||||
return *this;
|
||||
}
|
||||
bool fullyLabelled() const {
|
||||
return int(nameMap.size()) == (high - low + 1);
|
||||
}
|
||||
|
||||
template<class ...Args>
|
||||
SteppedParamInfo & label(const char *first, Args... others) {
|
||||
label(first);
|
||||
++nameIndex;
|
||||
return label(others...);
|
||||
}
|
||||
|
||||
template<class ...Args>
|
||||
SteppedParamInfo & label(int start, const char *first, Args... others) {
|
||||
nameIndex = start;
|
||||
return label(first, others...);
|
||||
}
|
||||
|
||||
const std::string * getLabel(int value) const {
|
||||
auto pair = nameMap.find(value);
|
||||
if (pair != nameMap.end()) {
|
||||
return &pair->second;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
std::string toString(int value) const {
|
||||
const std::string *maybeLabel = getLabel(value);
|
||||
if (maybeLabel) return *maybeLabel;
|
||||
return std::to_string(value);
|
||||
}
|
||||
int fromString(const std::string &str) const {
|
||||
auto pair = valueMap.find(str);
|
||||
if (pair != valueMap.end()) return pair->second;
|
||||
|
||||
size_t pos = 0;
|
||||
if (str[0] == '-') ++pos;
|
||||
while (pos < str.length() && str[pos] >= '0' && str[pos] <= '9') ++pos;
|
||||
if (pos >= str.length() || pos == 0 || (pos == 1 && str[0] == '-')) {
|
||||
return defaultValue;
|
||||
}
|
||||
int result = std::stoi(str, &pos);
|
||||
if (high >= low) {
|
||||
return std::max<int>(std::min<int>(high, result), low);
|
||||
} else {
|
||||
return std::max<int>(std::min<int>(low, result), high);
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
int nameIndex;
|
||||
protected:
|
||||
std::map<int, std::string> nameMap;
|
||||
std::map<std::string, int> valueMap;
|
||||
};
|
||||
|
||||
} // namespace
|
||||
#endif // include guard
|
||||
@ -1,990 +0,0 @@
|
||||
#ifndef SIGNALSMITH_CBOR_WALKER_H
|
||||
#define SIGNALSMITH_CBOR_WALKER_H
|
||||
|
||||
#include <cstdint>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#ifndef UINT64_MAX
|
||||
# define UINT64_MAX 0xFFFFFFFFFFFFFFFFull;
|
||||
#endif
|
||||
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#if __cplusplus >= 201703L
|
||||
# define CBOR_WALKER_USE_STRING_VIEW
|
||||
# include <string_view>
|
||||
#endif
|
||||
#if __cplusplus >= 202002L
|
||||
# define CBOR_WALKER_USE_BIT_CAST
|
||||
# include <bit>
|
||||
#endif
|
||||
|
||||
namespace signalsmith { namespace cbor {
|
||||
|
||||
struct CborWalker {
|
||||
CborWalker(uint64_t errorCode=ERROR_NOT_INITIALISED) : CborWalker(nullptr, nullptr, errorCode) {}
|
||||
CborWalker(const std::vector<unsigned char> &vector) : CborWalker(vector.data(), vector.data() + vector.size()) {}
|
||||
CborWalker(const unsigned char *data, const unsigned char *dataEnd) : data(data), dataEnd(dataEnd) {
|
||||
if (data >= dataEnd) {
|
||||
typeCode = TypeCode::error;
|
||||
additional = ERROR_END_OF_DATA;
|
||||
return;
|
||||
}
|
||||
unsigned char head = *data;
|
||||
typeCode = (TypeCode)(head>>5);
|
||||
unsigned char remainder = head&0x1F;
|
||||
switch (remainder) {
|
||||
case 24:
|
||||
additional = data[1];
|
||||
dataNext = data + 2;
|
||||
break;
|
||||
case 25:
|
||||
if (typeCode == TypeCode::simple) {
|
||||
#ifdef CBOR_WALKER_HALF_PRECISION_FLOAT
|
||||
// Translated from RFC 8949 Appendix D
|
||||
uint16_t half = ((uint16_t)data[1]<<8) + data[2];
|
||||
uint16_t exponent = (half>>10)&0x001F;
|
||||
uint16_t mantissa = half&0x03FF;
|
||||
double value;
|
||||
if (exponent == 0) {
|
||||
value = std::ldexpf(mantissa, -24);
|
||||
} else if (exponent == 31) {
|
||||
value = (mantissa == 0) ? INFINITY : NAN;
|
||||
} else {
|
||||
value = std::ldexpf(mantissa + 1024, exponent - 25);
|
||||
}
|
||||
typeCode = TypeCode::float32;
|
||||
float32 = (half&0x8000) ? -value : value;
|
||||
#else
|
||||
float32 = 0;
|
||||
#endif
|
||||
} else {
|
||||
additional = (uint64_t(data[1])<<8)|uint64_t(data[2]);
|
||||
}
|
||||
dataNext = data + 3;
|
||||
break;
|
||||
case 26:
|
||||
if (typeCode == TypeCode::simple) {
|
||||
typeCode = TypeCode::float32;
|
||||
}
|
||||
additional = (uint64_t(data[1])<<24)|(uint64_t(data[2])<<16)|(uint64_t(data[3])<<8)|uint64_t(data[4]);
|
||||
dataNext = data + 5;
|
||||
break;
|
||||
case 27:
|
||||
if (typeCode == TypeCode::simple) {
|
||||
typeCode = TypeCode::float64;
|
||||
}
|
||||
additional = (uint64_t(data[1])<<56)|(uint64_t(data[2])<<48)|(uint64_t(data[3])<<40)|(uint64_t(data[4])<<32)|(uint64_t(data[5])<<24)|(uint64_t(data[6])<<16)|(uint64_t(data[7])<<8)|uint64_t(data[8]);
|
||||
dataNext = data + 9;
|
||||
break;
|
||||
case 28:
|
||||
case 29:
|
||||
case 30:
|
||||
typeCode = TypeCode::error;
|
||||
additional = ERROR_INVALID_ADDITIONAL;
|
||||
dataNext = data;
|
||||
case 31:
|
||||
additional = 0; // returns 0 length for indefinite values
|
||||
switch (typeCode) {
|
||||
case TypeCode::integerP:
|
||||
case TypeCode::integerN:
|
||||
case TypeCode::tag:
|
||||
typeCode = TypeCode::error;
|
||||
additional = ERROR_INVALID_ADDITIONAL;
|
||||
break;
|
||||
case TypeCode::bytes:
|
||||
typeCode = TypeCode::indefiniteBytes;
|
||||
break;
|
||||
case TypeCode::utf8:
|
||||
typeCode = TypeCode::indefiniteUtf8;
|
||||
break;
|
||||
case TypeCode::array:
|
||||
typeCode = TypeCode::indefiniteArray;
|
||||
break;
|
||||
case TypeCode::map:
|
||||
typeCode = TypeCode::indefiniteMap;
|
||||
break;
|
||||
case TypeCode::simple:
|
||||
typeCode = TypeCode::indefiniteBreak;
|
||||
break;
|
||||
default:
|
||||
typeCode = TypeCode::error;
|
||||
additional = ERROR_SHOULD_BE_IMPOSSIBLE;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
additional = remainder;
|
||||
dataNext = data + 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// All error codes are non-zero, so can be checked with `.error()`
|
||||
static constexpr uint64_t ERROR_END_OF_DATA = 1;
|
||||
static constexpr uint64_t ERROR_INVALID_ADDITIONAL = 2;
|
||||
static constexpr uint64_t ERROR_INVALID_VALUE = 3;
|
||||
static constexpr uint64_t ERROR_INCONSISTENT_INDEFINITE = 4;
|
||||
static constexpr uint64_t ERROR_NOT_INITIALISED = 5;
|
||||
static constexpr uint64_t ERROR_METHOD_TYPE_MISMATCH = 6;
|
||||
static constexpr uint64_t ERROR_SHOULD_BE_IMPOSSIBLE = 7;
|
||||
|
||||
CborWalker next(size_t count) const {
|
||||
CborWalker result = *this;
|
||||
for (size_t i = 0; i < count; ++i) {
|
||||
++result;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
CborWalker next() const {
|
||||
switch (typeCode) {
|
||||
case TypeCode::integerP:
|
||||
case TypeCode::integerN:
|
||||
case TypeCode::simple:
|
||||
case TypeCode::float32:
|
||||
case TypeCode::float64:
|
||||
case TypeCode::indefiniteBreak:
|
||||
return nextBasic();
|
||||
case TypeCode::bytes:
|
||||
case TypeCode::utf8:
|
||||
return {dataNext + additional, dataEnd};
|
||||
return {dataNext + additional, dataEnd};
|
||||
case TypeCode::array: {
|
||||
auto result = nextBasic();
|
||||
auto length = additional;
|
||||
for (uint64_t i = 0; i < length; ++i) {
|
||||
++result;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
case TypeCode::map: {
|
||||
auto result = nextBasic();
|
||||
auto length = additional;
|
||||
for (uint64_t i = 0; i < length; ++i) {
|
||||
++result;
|
||||
++result;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
case TypeCode::indefiniteBytes: {
|
||||
auto result = nextBasic();
|
||||
while (!result.error() && result.typeCode != TypeCode::indefiniteBreak) {
|
||||
if (result.typeCode != TypeCode::bytes) {
|
||||
return {data, dataEnd, ERROR_INCONSISTENT_INDEFINITE};
|
||||
}
|
||||
++result;
|
||||
}
|
||||
return result.nextBasic();
|
||||
}
|
||||
case TypeCode::indefiniteUtf8: {
|
||||
auto result = nextBasic();
|
||||
while (!result.error() && result.typeCode != TypeCode::indefiniteBreak) {
|
||||
if (result.typeCode != TypeCode::utf8) {
|
||||
return {data, dataEnd, ERROR_INCONSISTENT_INDEFINITE};
|
||||
}
|
||||
++result;
|
||||
}
|
||||
return result.nextBasic();
|
||||
}
|
||||
case TypeCode::indefiniteArray: {
|
||||
auto result = nextBasic();
|
||||
while (!result.error() && result.typeCode != TypeCode::indefiniteBreak) {
|
||||
result = result.next();
|
||||
}
|
||||
return result.nextBasic();
|
||||
}
|
||||
case TypeCode::indefiniteMap: {
|
||||
auto result = nextBasic();
|
||||
while (!result.error() && result.typeCode != TypeCode::indefiniteBreak) {
|
||||
++result;
|
||||
++result;
|
||||
}
|
||||
return result.nextBasic();
|
||||
}
|
||||
case TypeCode::tag: {
|
||||
// Skip all the tags first
|
||||
auto result = nextBasic();
|
||||
while (result.isTagged()) result = nextBasic();
|
||||
return result.next();
|
||||
}
|
||||
case TypeCode::error:
|
||||
return *this;
|
||||
}
|
||||
}
|
||||
|
||||
// ++Prefix increments the position, and returns itself
|
||||
CborWalker & operator++() {
|
||||
*this = next();
|
||||
return *this;
|
||||
}
|
||||
|
||||
// Postfix++ increments the position, but returns the old position
|
||||
CborWalker operator++(int) {
|
||||
CborWalker result = *this;
|
||||
*this = next();
|
||||
return result;
|
||||
}
|
||||
|
||||
CborWalker enter() const {
|
||||
switch (typeCode) {
|
||||
case TypeCode::integerP:
|
||||
case TypeCode::integerN:
|
||||
case TypeCode::simple:
|
||||
case TypeCode::float32:
|
||||
case TypeCode::float64:
|
||||
case TypeCode::indefiniteBreak:
|
||||
case TypeCode::bytes:
|
||||
case TypeCode::utf8:
|
||||
return next();
|
||||
case TypeCode::tag:
|
||||
case TypeCode::array:
|
||||
case TypeCode::map:
|
||||
case TypeCode::indefiniteBytes:
|
||||
case TypeCode::indefiniteUtf8:
|
||||
case TypeCode::indefiniteArray:
|
||||
case TypeCode::indefiniteMap:
|
||||
return nextBasic();
|
||||
case TypeCode::error:
|
||||
return *this;
|
||||
}
|
||||
}
|
||||
|
||||
CborWalker nextExit() const {
|
||||
CborWalker result = *this;
|
||||
while (!result.error() && !result.isExit()) {
|
||||
++result;
|
||||
}
|
||||
return result.nextBasic();
|
||||
}
|
||||
|
||||
uint64_t error() const {
|
||||
return typeCode == TypeCode::error ? additional : 0;
|
||||
}
|
||||
|
||||
bool isSimple() const {
|
||||
return typeCode == TypeCode::simple;
|
||||
}
|
||||
bool isBool() const {
|
||||
if (typeCode != TypeCode::simple) return false;
|
||||
return (additional == 20 || additional == 21);
|
||||
}
|
||||
explicit operator bool() const {
|
||||
return (additional == 21);
|
||||
}
|
||||
|
||||
bool isNull() const {
|
||||
return typeCode == TypeCode::simple && additional == 22;
|
||||
}
|
||||
|
||||
bool isUndefined() const {
|
||||
return typeCode == TypeCode::simple && additional == 23;
|
||||
}
|
||||
|
||||
bool isExit() const {
|
||||
return typeCode == TypeCode::indefiniteBreak;
|
||||
}
|
||||
|
||||
bool atEnd() const {
|
||||
return typeCode == TypeCode::error && additional == ERROR_END_OF_DATA;
|
||||
}
|
||||
|
||||
bool isNumber() const {
|
||||
return isFloat() || isInt();
|
||||
}
|
||||
|
||||
bool isInt() const {
|
||||
return typeCode == TypeCode::integerP || typeCode == TypeCode::integerN;
|
||||
}
|
||||
operator uint64_t() const {
|
||||
switch (typeCode) {
|
||||
case TypeCode::integerP:
|
||||
case TypeCode::bytes:
|
||||
case TypeCode::utf8:
|
||||
case TypeCode::array:
|
||||
case TypeCode::map:
|
||||
case TypeCode::tag:
|
||||
case TypeCode::simple:
|
||||
case TypeCode::error:
|
||||
return (int64_t)additional;
|
||||
case TypeCode::integerN:
|
||||
return (uint64_t)-1 - (uint64_t)additional;
|
||||
return additional;
|
||||
case TypeCode::float32:
|
||||
return (uint64_t)float32;
|
||||
case TypeCode::float64:
|
||||
return (uint64_t)float64;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
operator int64_t() const {
|
||||
switch (typeCode) {
|
||||
case TypeCode::integerP:
|
||||
case TypeCode::bytes:
|
||||
case TypeCode::utf8:
|
||||
case TypeCode::array:
|
||||
case TypeCode::map:
|
||||
case TypeCode::tag:
|
||||
case TypeCode::simple:
|
||||
case TypeCode::error:
|
||||
return (int64_t)additional;
|
||||
case TypeCode::integerN:
|
||||
return -1 - (int64_t)additional;
|
||||
case TypeCode::float32:
|
||||
return (uint64_t)float32;
|
||||
case TypeCode::float64:
|
||||
return (uint64_t)float64;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
operator uint32_t() const {
|
||||
return (uint32_t)(uint64_t)(*this);
|
||||
}
|
||||
operator uint16_t() const {
|
||||
return (uint16_t)(uint64_t)(*this);
|
||||
}
|
||||
operator uint8_t() const {
|
||||
return (uint32_t)(uint64_t)(*this);
|
||||
}
|
||||
operator size_t() const {
|
||||
return (size_t)(uint64_t)(*this);
|
||||
}
|
||||
// For the signed ones, we cast from the signed 64-bit
|
||||
operator int32_t() const {
|
||||
return (int32_t)(int64_t)(*this);
|
||||
}
|
||||
operator int16_t() const {
|
||||
return (int16_t)(int64_t)(*this);
|
||||
}
|
||||
operator int8_t() const {
|
||||
return (int8_t)(int64_t)(*this);
|
||||
}
|
||||
|
||||
bool isFloat() const {
|
||||
return typeCode == TypeCode::float32 || typeCode == TypeCode::float64;
|
||||
}
|
||||
operator double() const {
|
||||
switch (typeCode) {
|
||||
case TypeCode::float32:
|
||||
return float32;
|
||||
case TypeCode::float64:
|
||||
return float64;
|
||||
case TypeCode::integerP:
|
||||
return (uint64_t)(*this);
|
||||
case TypeCode::integerN:
|
||||
return (int64_t)(*this);
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
operator float() const {
|
||||
return (float)(double)(*this);
|
||||
}
|
||||
|
||||
bool isBytes() const {
|
||||
return typeCode == TypeCode::bytes || typeCode == TypeCode::indefiniteBytes;
|
||||
}
|
||||
bool isUtf8() const {
|
||||
return typeCode == TypeCode::utf8 || typeCode == TypeCode::indefiniteUtf8;
|
||||
}
|
||||
bool hasLength() const {
|
||||
return typeCode != TypeCode::indefiniteBytes && typeCode != TypeCode::indefiniteUtf8 && typeCode != TypeCode::indefiniteArray && typeCode != TypeCode::indefiniteMap;
|
||||
}
|
||||
size_t length() const {
|
||||
return (size_t)(*this);
|
||||
}
|
||||
|
||||
const unsigned char * bytes() const {
|
||||
return dataNext;
|
||||
}
|
||||
|
||||
std::string utf8() const {
|
||||
if (typeCode != TypeCode::utf8) return "";
|
||||
return {(const char *)dataNext, length()};
|
||||
}
|
||||
#ifdef CBOR_WALKER_USE_STRING_VIEW
|
||||
std::string_view utf8View() const {
|
||||
if (typeCode != TypeCode::utf8) return {nullptr, 0};
|
||||
return {(const char *)dataNext, length()};
|
||||
}
|
||||
#endif
|
||||
|
||||
bool isArray() const {
|
||||
return typeCode == TypeCode::array || typeCode == TypeCode::indefiniteArray;
|
||||
}
|
||||
template<class Fn>
|
||||
CborWalker forEach(Fn &&fn, bool mapValues=true) const {
|
||||
if (typeCode == TypeCode::array) {
|
||||
size_t count = length();
|
||||
CborWalker item = enter();
|
||||
for (size_t i = 0; i < count; ++i) {
|
||||
if (item.error()) return item;
|
||||
CborWalker value = item++;
|
||||
fn(value, i);
|
||||
}
|
||||
return item;
|
||||
} else if (typeCode == TypeCode::indefiniteArray) {
|
||||
CborWalker item = enter();
|
||||
size_t i = 0;
|
||||
while (!item.error() && !item.isExit()) {
|
||||
fn(item++, i++);
|
||||
}
|
||||
return item.next(); // move past the exit
|
||||
} else if (typeCode == TypeCode::indefiniteBytes) {
|
||||
CborWalker item = enter();
|
||||
size_t i = 0;
|
||||
while (!item.error() && !item.isExit()) {
|
||||
if (item.typeCode != TypeCode::bytes) return {data, dataEnd, ERROR_INVALID_VALUE};
|
||||
fn(item++, i++);
|
||||
}
|
||||
return item.next(); // move past the exit
|
||||
} else if (typeCode == TypeCode::indefiniteUtf8) {
|
||||
CborWalker item = enter();
|
||||
size_t i = 0;
|
||||
while (!item.error() && !item.isExit()) {
|
||||
if (item.typeCode != TypeCode::utf8) return {data, dataEnd, ERROR_INVALID_VALUE};
|
||||
fn(item++, i++);
|
||||
}
|
||||
return item.next(); // move past the exit
|
||||
} else if (typeCode == TypeCode::map) {
|
||||
size_t count = length();
|
||||
CborWalker item = enter();
|
||||
for (size_t i = 0; i < count; ++i) {
|
||||
if (item.error()) return item;
|
||||
CborWalker key = item++;
|
||||
if (item.error()) return item;
|
||||
CborWalker value = item++;
|
||||
fn(mapValues ? value : key, i);
|
||||
}
|
||||
return item;
|
||||
} else if (typeCode == TypeCode::indefiniteMap) {
|
||||
CborWalker item = enter();
|
||||
size_t i = 0;
|
||||
while (!item.error() && !item.isExit()) {
|
||||
CborWalker key = item++;
|
||||
if (item.error()) return item;
|
||||
if (item.isExit()) return {item.data, item.dataEnd, ERROR_INVALID_VALUE};
|
||||
CborWalker value = item++;
|
||||
fn(mapValues ? value : key, i);
|
||||
++i;
|
||||
}
|
||||
return item.next(); // move past the exit
|
||||
}
|
||||
return {data, dataEnd, ERROR_METHOD_TYPE_MISMATCH};
|
||||
}
|
||||
|
||||
bool isMap() const {
|
||||
return typeCode == TypeCode::map || typeCode == TypeCode::indefiniteMap;
|
||||
}
|
||||
|
||||
template<class Fn>
|
||||
CborWalker forEachPair(Fn &&fn) const {
|
||||
if (typeCode == TypeCode::map) {
|
||||
size_t count = length();
|
||||
CborWalker item = enter();
|
||||
for (size_t i = 0; i < count; ++i) {
|
||||
auto key = item++;
|
||||
if (key.error() || item.error()) return item;
|
||||
auto value = item++;
|
||||
fn(key, value);
|
||||
}
|
||||
return item;
|
||||
} else if (typeCode == TypeCode::indefiniteMap) {
|
||||
CborWalker item = enter();
|
||||
while (!item.error() && !item.isExit()) {
|
||||
auto key = item++;
|
||||
if (key.error() || item.error()) return item;
|
||||
if (item.isExit()) return {item.data, item.dataEnd, ERROR_INVALID_VALUE};
|
||||
auto value = item++;
|
||||
fn(CborWalker(key), CborWalker(value));
|
||||
}
|
||||
return item.next(); // move past the exit
|
||||
}
|
||||
return {data, dataEnd, ERROR_METHOD_TYPE_MISMATCH};
|
||||
}
|
||||
|
||||
bool isEnd() const {
|
||||
return typeCode == TypeCode::array || typeCode == TypeCode::indefiniteArray;
|
||||
}
|
||||
|
||||
bool isTagged() const {
|
||||
return typeCode == TypeCode::tag;
|
||||
}
|
||||
|
||||
protected:
|
||||
CborWalker(const unsigned char *data, const unsigned char *dataEnd, uint64_t errorCode) : data(data), dataEnd(dataEnd), dataNext(nullptr), typeCode(TypeCode::error), additional(errorCode) {}
|
||||
|
||||
// The next *core* value - but doesn't check whether the current value is the header for a string/array/etc.
|
||||
CborWalker nextBasic() const {
|
||||
return {dataNext, dataEnd};
|
||||
}
|
||||
|
||||
const unsigned char *data, *dataEnd, *dataNext;
|
||||
enum class TypeCode {
|
||||
integerP, integerN, bytes, utf8, array, map, tag, simple, float32, float64,
|
||||
error, indefiniteBreak, indefiniteBytes, indefiniteUtf8, indefiniteArray, indefiniteMap
|
||||
};
|
||||
TypeCode typeCode;
|
||||
union {
|
||||
uint64_t additional;
|
||||
float float32;
|
||||
double float64;
|
||||
unsigned char additionalBytes[8];
|
||||
};
|
||||
};
|
||||
|
||||
// Automatically skips over tags, but still lets you query them
|
||||
struct TaggedCborWalker : public CborWalker {
|
||||
TaggedCborWalker() {}
|
||||
TaggedCborWalker(const CborWalker& basic) : CborWalker(basic), tagStart(data) {
|
||||
consumeTags();
|
||||
}
|
||||
TaggedCborWalker(const unsigned char *dataStart, const unsigned char *dataEnd) : CborWalker(dataStart, dataEnd), tagStart(dataStart) {
|
||||
consumeTags();
|
||||
}
|
||||
|
||||
TaggedCborWalker next(size_t i=1) const {
|
||||
return CborWalker::next(i);
|
||||
}
|
||||
TaggedCborWalker & operator++() {
|
||||
CborWalker::operator++();
|
||||
return *this;
|
||||
}
|
||||
TaggedCborWalker operator++(int _) {
|
||||
return CborWalker::operator++(_);
|
||||
}
|
||||
TaggedCborWalker enter() const {
|
||||
return CborWalker::enter();
|
||||
}
|
||||
TaggedCborWalker nextExit() const {
|
||||
return CborWalker::nextExit();
|
||||
}
|
||||
template<class Fn>
|
||||
TaggedCborWalker forEach(Fn &&fn) const {
|
||||
return CborWalker::forEach([&](const CborWalker &item, size_t i){
|
||||
fn(TaggedCborWalker{item}, i);
|
||||
});
|
||||
}
|
||||
template<class Fn>
|
||||
TaggedCborWalker forEachPair(Fn &&fn) const {
|
||||
return CborWalker::forEachPair([&](const CborWalker &key, const CborWalker &value){
|
||||
fn(TaggedCborWalker{key}, TaggedCborWalker{value});
|
||||
});
|
||||
}
|
||||
|
||||
size_t tagCount() const {
|
||||
return nTags;
|
||||
}
|
||||
|
||||
uint64_t tag(size_t tagIndex) const {
|
||||
CborWalker tagWalker(tagStart, dataEnd);
|
||||
for (size_t i = 0; i < tagIndex; ++i) {
|
||||
tagWalker = tagWalker.enter();
|
||||
}
|
||||
return tagWalker;
|
||||
}
|
||||
|
||||
bool isTypedArray() const {
|
||||
return isBytes() && typedArrayTag;
|
||||
}
|
||||
|
||||
size_t typedArrayLength() const {
|
||||
uint8_t widthLog2 = typedArrayTag&0x03;
|
||||
uint8_t elementType = (typedArrayTag&0x18)>>3; // unsigned, signed, float
|
||||
widthLog2 += (elementType == 2); // int sizes are 8-64 bits, float sizes are 16-128
|
||||
size_t stride = 1<<widthLog2;
|
||||
return length()/stride;
|
||||
}
|
||||
|
||||
template<class Array>
|
||||
size_t readTypedArray(Array &&array) const {
|
||||
return readTypedArray(array, 0, typedArrayLength());
|
||||
}
|
||||
|
||||
template<class Array>
|
||||
size_t readTypedArray(Array &&array, size_t offset, size_t maxCount) const {
|
||||
size_t byteLength = length();
|
||||
|
||||
bool bigEndian = !(typedArrayTag&0x04);
|
||||
|
||||
switch (typedArrayTag&0xFB) { // without endian flag
|
||||
// unsigned int
|
||||
case 64: {
|
||||
size_t count = std::min(maxCount, byteLength);
|
||||
const uint8_t *bytes = dataNext + offset;
|
||||
for (size_t i = 0; i < count; ++i) {
|
||||
array[i] = bytes[i];
|
||||
}
|
||||
return count;
|
||||
}
|
||||
case 65:
|
||||
return typedArrayReadInner<Array, uint16_t, uint16_t>(array, offset, maxCount, bigEndian);
|
||||
case 66:
|
||||
return typedArrayReadInner<Array, uint32_t, uint32_t>(array, offset, maxCount, bigEndian);
|
||||
case 67:
|
||||
return typedArrayReadInner<Array, uint64_t, uint64_t>(array, offset, maxCount, bigEndian);
|
||||
// signed int
|
||||
case 72: {
|
||||
size_t count = std::min(maxCount, byteLength);
|
||||
const uint8_t *bytes = dataNext + offset;
|
||||
for (size_t i = 0; i < count; ++i) {
|
||||
array[i] = (int8_t)bytes[i]; // cast to signed here first, to make sure negatives behave correctly
|
||||
}
|
||||
return count;
|
||||
}
|
||||
case 73:
|
||||
return typedArrayReadInner<Array, uint16_t, int16_t>(array, offset, maxCount, bigEndian);
|
||||
case 74:
|
||||
return typedArrayReadInner<Array, uint32_t, int32_t>(array, offset, maxCount, bigEndian);
|
||||
case 75:
|
||||
return typedArrayReadInner<Array, uint64_t, int64_t>(array, offset, maxCount, bigEndian);
|
||||
// floating-point
|
||||
case 80:
|
||||
// TODO: half-precision float support
|
||||
return 0;
|
||||
case 81:
|
||||
return typedArrayReadInner<Array, uint32_t, float, true>(array, offset, maxCount, bigEndian);
|
||||
case 82:
|
||||
return typedArrayReadInner<Array, uint64_t, double, true>(array, offset, maxCount, bigEndian);
|
||||
case 83:
|
||||
// TODO: quad-precision float support
|
||||
return 0;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
size_t nTags = 0;
|
||||
const unsigned char *tagStart;
|
||||
|
||||
uint8_t typedArrayTag = 0;
|
||||
|
||||
void consumeTags() {
|
||||
while (isTagged() && data < dataEnd) {
|
||||
++nTags;
|
||||
uint64_t tag = (*this);
|
||||
if (tag >= 64 && tag < 87) { // RFC-8746 range
|
||||
typedArrayTag = tag;
|
||||
}
|
||||
// Move "into" the tag
|
||||
CborWalker::operator=(enter());
|
||||
}
|
||||
}
|
||||
|
||||
template<class Array, typename UIntType, typename ResultT, bool bitcast=false>
|
||||
size_t typedArrayReadInner(Array &&array, size_t offset, size_t maxCount, bool bigEndian) const {
|
||||
constexpr size_t B = sizeof(UIntType);
|
||||
if (offset*B > length()) return 0;
|
||||
const uint8_t *bytes = dataNext + offset*B;
|
||||
size_t count = std::min(maxCount, length()/B - offset);
|
||||
if (bigEndian) {
|
||||
for (size_t i = 0; i < count; ++i) {
|
||||
UIntType v = 0;
|
||||
for (size_t b = 0; b < B; ++b) {
|
||||
UIntType bv = bytes[i*B + b];
|
||||
v += bv<<((B - 1 - b)*8);
|
||||
}
|
||||
if (bitcast) {
|
||||
#ifdef CBOR_WALKER_USE_BIT_CAST
|
||||
array[i] = std::bit_cast<ResultT>(v);
|
||||
#else
|
||||
ResultT r;
|
||||
std::memcpy(&r, &v, B);
|
||||
array[i] = r;
|
||||
#endif
|
||||
} else {
|
||||
array[i] = (ResultT)v;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (size_t i = 0; i < count; ++i) {
|
||||
UIntType v = 0;
|
||||
for (size_t b = 0; b < B; ++b) {
|
||||
UIntType bv = bytes[i*B + b];
|
||||
v += bv<<(b*8);
|
||||
}
|
||||
if (bitcast) {
|
||||
#ifdef CBOR_WALKER_USE_BIT_CAST
|
||||
array[i] = std::bit_cast<ResultT>(v);
|
||||
#else
|
||||
ResultT r;
|
||||
std::memcpy(&r, &v, B);
|
||||
array[i] = r;
|
||||
#endif
|
||||
} else {
|
||||
array[i] = (ResultT)v;
|
||||
}
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
};
|
||||
|
||||
struct CborWriter {
|
||||
CborWriter(std::vector<unsigned char> &bytes) : bytes(bytes) {}
|
||||
|
||||
CborWriter & addUInt(uint64_t u) {
|
||||
writeHead(0, u);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addInt(int64_t u) {
|
||||
if (u >= 0) {
|
||||
writeHead(0, u);
|
||||
} else {
|
||||
writeHead(1, -1 - u);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addTag(uint64_t u) {
|
||||
writeHead(6, u);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addBool(bool b) {
|
||||
writeHead(7, 20 + b);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & openArray() {
|
||||
bytes.push_back(0x9F);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & openArray(size_t items) {
|
||||
writeHead(4, items);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & openMap() {
|
||||
bytes.push_back(0xBF);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & openMap(size_t pairs) {
|
||||
writeHead(5, pairs);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & close() {
|
||||
bytes.push_back(0xFF);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addBytes(const void *ptr, size_t length) {
|
||||
addBytes((const unsigned char *)ptr, length);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addBytes(const unsigned char *ptr, size_t length) {
|
||||
writeHead(2, length);
|
||||
bytes.insert(bytes.end(), ptr, ptr + length);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & openBytes() {
|
||||
bytes.push_back(0x5F);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addUtf8(const char *ptr, size_t length) {
|
||||
writeHead(3, length);
|
||||
bytes.insert(bytes.end(), ptr, ptr + length);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addUtf8(const char *str) {
|
||||
addUtf8(str, std::strlen(str));
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addUtf8(const std::string &str) {
|
||||
addUtf8(str.c_str());
|
||||
return *this;
|
||||
}
|
||||
#ifdef CBOR_WALKER_USE_STRING_VIEW
|
||||
CborWriter & addUtf8(const std::string_view &str) {
|
||||
addUtf8(str.data(), str.size());
|
||||
return *this;
|
||||
}
|
||||
#endif
|
||||
CborWriter & openUtf8() {
|
||||
bytes.push_back(0x7F);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addNull() {
|
||||
bytes.push_back(0xF6);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addUndefined() {
|
||||
bytes.push_back(0xF7);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addSimple(unsigned char k) {
|
||||
writeHead(7, k);
|
||||
return *this;
|
||||
}
|
||||
|
||||
CborWriter & addFloat(float v) {
|
||||
bytes.push_back(0xFA);
|
||||
#ifdef CBOR_WALKER_USE_BIT_CAST
|
||||
uint32_t vi = std::bit_cast<uint32_t>(v);
|
||||
#else
|
||||
uint32_t vi;
|
||||
std::memcpy(&vi, &v, 4);
|
||||
#endif
|
||||
for (size_t i = 0; i < 4; ++i) {
|
||||
auto shift = (3 - i)*8;
|
||||
bytes.push_back((vi>>shift)&0xFF);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addFloat(double v) {
|
||||
bytes.push_back(0xFB);
|
||||
#ifdef CBOR_WALKER_USE_BIT_CAST
|
||||
uint64_t vi = std::bit_cast<uint64_t>(v);
|
||||
#else
|
||||
uint64_t vi;
|
||||
std::memcpy(&vi, &v, 8);
|
||||
#endif
|
||||
for (size_t i = 0; i < 8; ++i) {
|
||||
auto shift = (7 - i)*8;
|
||||
bytes.push_back((vi>>shift)&0xFF);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
// RFC-8746 tags for typed arrays
|
||||
// bits: [1, 0] = log2(elementBytes), [2] = isLittleEndian, [3, 4] = [unsigned, signed, float]
|
||||
CborWriter & addTypedArray(const uint8_t *arr, size_t length) {
|
||||
addTag(64);
|
||||
addBytes((const void *)arr, length);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addTypedArray(const int8_t *arr, size_t length) {
|
||||
addTag(72);
|
||||
addBytes((const void *)arr, length);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addTypedArray(const uint16_t *arr, size_t length, bool bigEndian=false) {
|
||||
addTag(bigEndian ? 65 : 69);
|
||||
writeTypedBlock<uint16_t>(arr, length, bigEndian);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addTypedArray(const uint32_t *arr, size_t length, bool bigEndian=false) {
|
||||
addTag(bigEndian ? 66 : 70);
|
||||
writeTypedBlock<uint32_t>(arr, length, bigEndian);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addTypedArray(const uint64_t *arr, size_t length, bool bigEndian=false) {
|
||||
addTag(bigEndian ? 67 : 71);
|
||||
writeTypedBlock<uint64_t>(arr, length, bigEndian);
|
||||
return *this;
|
||||
}
|
||||
// For signed ints, we make a proxy struct which casts them on-the-fly
|
||||
CborWriter & addTypedArray(const int16_t *arr, size_t length, bool bigEndian=false) {
|
||||
addTag(bigEndian ? 73 : 77);
|
||||
struct {
|
||||
const int16_t *arr;
|
||||
uint16_t operator[](size_t i) const {
|
||||
return (uint16_t)(arr[i]);
|
||||
}
|
||||
} unsignedArray{arr};
|
||||
writeTypedBlock<uint16_t>(unsignedArray, length, bigEndian);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addTypedArray(const int32_t *arr, size_t length, bool bigEndian=false) {
|
||||
addTag(bigEndian ? 74 : 78);
|
||||
struct {
|
||||
const int32_t *arr;
|
||||
uint32_t operator[](size_t i) const {
|
||||
return (uint32_t)(arr[i]);
|
||||
}
|
||||
} unsignedArray{arr};
|
||||
writeTypedBlock<uint32_t>(unsignedArray, length, bigEndian);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addTypedArray(const int64_t *arr, size_t length, bool bigEndian=false) {
|
||||
addTag(bigEndian ? 75 : 79);
|
||||
struct {
|
||||
const int64_t *arr;
|
||||
uint64_t operator[](size_t i) const {
|
||||
return (uint64_t)(arr[i]);
|
||||
}
|
||||
} unsignedArray{arr};
|
||||
writeTypedBlock<uint64_t>(unsignedArray, length, bigEndian);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addTypedArray(const float *arr, size_t length, bool bigEndian=false) {
|
||||
addTag(bigEndian ? 81 : 85);
|
||||
struct {
|
||||
const float *arr;
|
||||
uint32_t operator[](size_t i) const {
|
||||
#ifdef CBOR_WALKER_USE_BIT_CAST
|
||||
return std::bit_cast<uint32_t>(arr[i]);
|
||||
#else
|
||||
float v = arr[i];
|
||||
uint32_t vi;
|
||||
std::memcpy(&vi, &v, 4);
|
||||
return vi;
|
||||
#endif
|
||||
}
|
||||
} unsignedArray{arr};
|
||||
writeTypedBlock<uint32_t>(unsignedArray, length, bigEndian);
|
||||
return *this;
|
||||
}
|
||||
CborWriter & addTypedArray(const double *arr, size_t length, bool bigEndian=false) {
|
||||
addTag(bigEndian ? 82 : 86);
|
||||
struct {
|
||||
const double *arr;
|
||||
uint64_t operator[](size_t i) const {
|
||||
#ifdef CBOR_WALKER_USE_BIT_CAST
|
||||
return std::bit_cast<uint64_t>(arr[i]);
|
||||
#else
|
||||
double v = arr[i];
|
||||
uint64_t vi;
|
||||
std::memcpy(&vi, &v, 8);
|
||||
return vi;
|
||||
#endif
|
||||
}
|
||||
} unsignedArray{arr};
|
||||
writeTypedBlock<uint64_t>(unsignedArray, length, bigEndian);
|
||||
return *this;
|
||||
}
|
||||
|
||||
private:
|
||||
void writeHead(unsigned char type, uint64_t argument) {
|
||||
type <<= 5;
|
||||
if (argument >= 4294967296ul) {
|
||||
bytes.push_back(type|27);
|
||||
for (size_t i = 0; i < 8; ++i) {
|
||||
bytes.push_back(argument>>(56 - i*8));
|
||||
}
|
||||
} else if (argument >= 65536) {
|
||||
bytes.push_back(type|26);
|
||||
for (size_t i = 0; i < 4; ++i) {
|
||||
bytes.push_back(argument>>(24 - i*8));
|
||||
}
|
||||
} else if (argument >= 256) {
|
||||
bytes.push_back(type|25);
|
||||
bytes.push_back(argument>>8);
|
||||
bytes.push_back(argument);
|
||||
} else if (argument >= 24) {
|
||||
bytes.push_back(type|24);
|
||||
bytes.push_back(argument);
|
||||
} else {
|
||||
bytes.push_back(type|argument);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename UIntType, class Array>
|
||||
void writeTypedBlock(Array &&array, size_t length, bool bigEndian) {
|
||||
constexpr size_t B = sizeof(UIntType);
|
||||
writeHead(2, length*B);
|
||||
if (bigEndian) {
|
||||
for (size_t i = 0; i < length; ++i) {
|
||||
UIntType v = array[i];
|
||||
for (size_t b = 0; b < B; ++b) bytes.push_back((v>>((B-1-b)*8))&0xFF);
|
||||
}
|
||||
} else {
|
||||
for (size_t i = 0; i < length; ++i) {
|
||||
UIntType v = array[i];
|
||||
for (size_t b = 0; b < B; ++b) bytes.push_back((v>>(b*8))&0xFF);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<unsigned char> &bytes;
|
||||
};
|
||||
|
||||
}} // namespace
|
||||
|
||||
#endif // include guard
|
||||
@ -1,136 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "./storage.h"
|
||||
#include "../stfx-library.h" // for the ...ParamIgnore classes
|
||||
|
||||
namespace stfx { namespace storage {
|
||||
|
||||
template<class SubClassCRTP>
|
||||
struct STFXStorageScanner : public signalsmith::storage::StorageScanner<SubClassCRTP> {
|
||||
void info(const char *, const char *) {}
|
||||
int version(int v) {
|
||||
return v;
|
||||
}
|
||||
|
||||
template<class V>
|
||||
bool changed(const char *key, V &v) {
|
||||
auto &sub = *(SubClassCRTP *)this;
|
||||
sub(key, v);
|
||||
return false;
|
||||
}
|
||||
void invalidate(const char *) {}
|
||||
|
||||
bool extra() {
|
||||
return false;
|
||||
}
|
||||
template<class V>
|
||||
void extra(const char *, V) {}
|
||||
|
||||
template<class PR>
|
||||
RangeParamIgnore range(const char *key, PR ¶m) {
|
||||
return {};
|
||||
}
|
||||
template<class PS>
|
||||
SteppedParamIgnore stepped(const char *key, PS ¶m) {
|
||||
return {};
|
||||
}
|
||||
};
|
||||
|
||||
template<class SubClassCRTP=void>
|
||||
struct STFXStorageWriter : public signalsmith::storage::StorageCborWriter<SubClassCRTP> {
|
||||
using signalsmith::storage::StorageCborWriter<SubClassCRTP>::StorageCborWriter;
|
||||
|
||||
void info(const char *name, const char *desc) {
|
||||
sub().extra("name", name);
|
||||
sub().extra("desc", desc);
|
||||
}
|
||||
|
||||
template<class V>
|
||||
bool changed(const char *key, V &v) {
|
||||
sub()(key, v);
|
||||
return false;
|
||||
}
|
||||
void invalidate(const char *) {}
|
||||
|
||||
int version(int v) {
|
||||
sub()("version", v);
|
||||
return v;
|
||||
}
|
||||
bool extra() {
|
||||
return false;
|
||||
}
|
||||
template<class V>
|
||||
void extra(const char *key, V v) {}
|
||||
|
||||
template<class PR>
|
||||
RangeParamIgnore range(const char *key, PR ¶m) {
|
||||
sub()(key, param);
|
||||
return {};
|
||||
}
|
||||
template<class PS>
|
||||
SteppedParamIgnore stepped(const char *key, PS ¶m) {
|
||||
sub()(key, param);
|
||||
return {};
|
||||
}
|
||||
|
||||
private:
|
||||
SubClassCRTP & sub() {
|
||||
return *(SubClassCRTP *)this;
|
||||
}
|
||||
};
|
||||
|
||||
template<class SubClassCRTP=void>
|
||||
struct STFXStorageReader : public signalsmith::storage::StorageCborReader<SubClassCRTP> {
|
||||
using signalsmith::storage::StorageCborReader<SubClassCRTP>::StorageCborReader;
|
||||
|
||||
// This is supplemental
|
||||
void info(const char *, const char *) {}
|
||||
|
||||
int version(int v) {
|
||||
sub()("version", v);
|
||||
return v;
|
||||
}
|
||||
bool extra() {
|
||||
return false;
|
||||
}
|
||||
template<class V>
|
||||
void extra(const char *key, V v) {}
|
||||
|
||||
template<class V>
|
||||
bool changed(const char *key, V &v) {
|
||||
V prev = v;
|
||||
sub()(key, v);
|
||||
return v != prev;
|
||||
}
|
||||
void invalidate(const char *invalidatedKey) {
|
||||
//LOG_EXPR(invalidatedKey);
|
||||
}
|
||||
|
||||
template<class PR>
|
||||
RangeParamIgnore range(const char *key, PR ¶m) {
|
||||
sub()(key, param);
|
||||
return {};
|
||||
}
|
||||
template<class PS>
|
||||
SteppedParamIgnore stepped(const char *key, PS ¶m) {
|
||||
sub()(key, param);
|
||||
return {};
|
||||
}
|
||||
|
||||
private:
|
||||
SubClassCRTP & sub() {
|
||||
return *(SubClassCRTP *)this;
|
||||
}
|
||||
};
|
||||
|
||||
// If void, use itself for CRTP
|
||||
template<>
|
||||
struct STFXStorageWriter<void> : public STFXStorageWriter<STFXStorageWriter<void>> {
|
||||
using STFXStorageWriter<STFXStorageWriter<void>>::STFXStorageWriter;
|
||||
};
|
||||
template<>
|
||||
struct STFXStorageReader<void> : public STFXStorageReader<STFXStorageReader<void>> {
|
||||
using STFXStorageReader<STFXStorageReader<void>>::STFXStorageReader;
|
||||
};
|
||||
|
||||
}} // namespace
|
||||
@ -1,264 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "./cbor-walker.h"
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace signalsmith { namespace storage {
|
||||
|
||||
struct StorageDummy {
|
||||
template<class V>
|
||||
void operator()(const char *, V &) {}
|
||||
};
|
||||
|
||||
template<class SubClassCRTP>
|
||||
struct StorageScanner {
|
||||
template<class V>
|
||||
void operator()(const char */*key*/, V &v) {
|
||||
value(v);
|
||||
}
|
||||
|
||||
private:
|
||||
void value(int64_t &v) {};
|
||||
void value(uint64_t &v) {};
|
||||
void value(int32_t &v) {};
|
||||
void value(uint32_t &v) {};
|
||||
void value(int16_t &v) {};
|
||||
void value(uint16_t &v) {};
|
||||
void value(int8_t &v) {};
|
||||
void value(uint8_t &v) {};
|
||||
void value(float &v) {};
|
||||
void value(double &v) {};
|
||||
void value(bool &v) {};
|
||||
void value(std::string &str) {};
|
||||
|
||||
template<class Item>
|
||||
void value(std::vector<Item> &array) {
|
||||
for (auto &item : array) {
|
||||
value(item);
|
||||
}
|
||||
}
|
||||
|
||||
template<class V>
|
||||
void value(V &v) {
|
||||
v.state(*(SubClassCRTP *)this);
|
||||
}
|
||||
};
|
||||
|
||||
template<class SubClassCRTP=void>
|
||||
struct StorageCborWriter {
|
||||
StorageCborWriter(const signalsmith::cbor::CborWriter &writer, std::vector<unsigned char> *buffer=nullptr) : cbor(writer) {
|
||||
if (buffer) buffer->resize(0);
|
||||
|
||||
cbor.openMap();
|
||||
}
|
||||
StorageCborWriter(std::vector<unsigned char> &cborBuffer) : StorageCborWriter(signalsmith::cbor::CborWriter(cborBuffer), &cborBuffer) {}
|
||||
~StorageCborWriter() {
|
||||
cbor.close();
|
||||
}
|
||||
|
||||
template<class V>
|
||||
void operator()(const char *key, V &value) {
|
||||
cbor.addUtf8(key);
|
||||
writeValue(value);
|
||||
}
|
||||
|
||||
private:
|
||||
signalsmith::cbor::CborWriter cbor;
|
||||
|
||||
#define STORAGE_BASIC_INT(V) \
|
||||
void writeValue(V &value) { \
|
||||
cbor.addInt(value); \
|
||||
}
|
||||
STORAGE_BASIC_INT(int64_t)
|
||||
STORAGE_BASIC_INT(uint64_t)
|
||||
STORAGE_BASIC_INT(int32_t)
|
||||
STORAGE_BASIC_INT(uint32_t)
|
||||
STORAGE_BASIC_INT(int16_t)
|
||||
STORAGE_BASIC_INT(uint16_t)
|
||||
STORAGE_BASIC_INT(int8_t)
|
||||
STORAGE_BASIC_INT(uint8_t)
|
||||
#undef STORAGE_BASIC_INT
|
||||
|
||||
void writeValue(float &value) {
|
||||
cbor.addFloat(value);
|
||||
}
|
||||
void writeValue(double &value) {
|
||||
cbor.addFloat(value);
|
||||
}
|
||||
void writeValue(bool &value) {
|
||||
cbor.addBool(value);
|
||||
}
|
||||
|
||||
// Support writing C strings (but not reading them), so inherited writers can add supplemental hints/info without allocating
|
||||
void writeValue(const char *cStr) {
|
||||
cbor.addUtf8(cStr);
|
||||
}
|
||||
|
||||
void writeValue(std::string &str) {
|
||||
writeValue(str.c_str());
|
||||
}
|
||||
|
||||
template<class Item>
|
||||
void writeValue(std::vector<Item> &array) {
|
||||
cbor.openArray(array.size());
|
||||
for (auto &item : array) {
|
||||
writeValue(item);
|
||||
}
|
||||
}
|
||||
#define STORAGE_TYPED_ARRAY(T) \
|
||||
void writeValue(std::vector<T> &array) { \
|
||||
cbor.addTypedArray(array.data(), array.size()); \
|
||||
}
|
||||
STORAGE_TYPED_ARRAY(uint8_t)
|
||||
STORAGE_TYPED_ARRAY(int8_t)
|
||||
STORAGE_TYPED_ARRAY(uint16_t)
|
||||
STORAGE_TYPED_ARRAY(int16_t)
|
||||
STORAGE_TYPED_ARRAY(uint32_t)
|
||||
STORAGE_TYPED_ARRAY(int32_t)
|
||||
STORAGE_TYPED_ARRAY(uint64_t)
|
||||
STORAGE_TYPED_ARRAY(int64_t)
|
||||
STORAGE_TYPED_ARRAY(float)
|
||||
STORAGE_TYPED_ARRAY(double)
|
||||
#undef STORAGE_TYPED_ARRAY
|
||||
|
||||
template<class Obj>
|
||||
void writeValue(Obj &obj) {
|
||||
cbor.openMap();
|
||||
obj.state(*(SubClassCRTP *)this);
|
||||
cbor.close();
|
||||
}
|
||||
};
|
||||
|
||||
template<class SubClassCRTP=void>
|
||||
struct StorageCborReader {
|
||||
using Cbor = signalsmith::cbor::TaggedCborWalker;
|
||||
|
||||
StorageCborReader(Cbor c) : cbor(c) {
|
||||
if (cbor.isMap()) cbor = cbor.enter();
|
||||
}
|
||||
StorageCborReader(const std::vector<unsigned char> &v) : StorageCborReader(Cbor(v)) {}
|
||||
|
||||
template<class V>
|
||||
void operator()(const char *key, V &v) {
|
||||
if (filterKeyBytes != nullptr) {
|
||||
if (!keyMatch(key, filterKeyBytes, filterKeyLength)) return;
|
||||
}
|
||||
if (!cbor.isUtf8()) return; // We expect a string key
|
||||
// If we have a filter, we *should* be just in front of the appropriate key, but check anyway
|
||||
if (!keyMatch(key, (const char *)cbor.bytes(), cbor.length())) {
|
||||
return; // key doesn't match
|
||||
}
|
||||
cbor++;
|
||||
readValue(v);
|
||||
}
|
||||
|
||||
private:
|
||||
Cbor cbor;
|
||||
const char *filterKeyBytes = nullptr;
|
||||
size_t filterKeyLength = 0;
|
||||
|
||||
template<class Obj>
|
||||
void readValue(Obj &obj) {
|
||||
if (!cbor.isMap()) return;
|
||||
|
||||
cbor = cbor.forEachPair([&](Cbor key, Cbor value){
|
||||
if (!key.isUtf8()) return;
|
||||
|
||||
const char *fkb = filterKeyBytes;
|
||||
size_t fkl = filterKeyLength;
|
||||
|
||||
// Temporarily set key, and scan the object for that property
|
||||
filterKeyBytes = (const char *)key.bytes();
|
||||
filterKeyLength = key.length();
|
||||
cbor = key;
|
||||
obj.state(*(SubClassCRTP *)this);
|
||||
|
||||
filterKeyBytes = fkb;
|
||||
filterKeyLength = fkl;
|
||||
});
|
||||
}
|
||||
|
||||
#define STORAGE_BASIC_TYPE(V) \
|
||||
void readValue(V &v) { \
|
||||
v = V(cbor++); \
|
||||
}
|
||||
STORAGE_BASIC_TYPE(int64_t)
|
||||
STORAGE_BASIC_TYPE(uint64_t)
|
||||
STORAGE_BASIC_TYPE(int32_t)
|
||||
STORAGE_BASIC_TYPE(uint32_t)
|
||||
STORAGE_BASIC_TYPE(int16_t)
|
||||
STORAGE_BASIC_TYPE(uint16_t)
|
||||
STORAGE_BASIC_TYPE(int8_t)
|
||||
STORAGE_BASIC_TYPE(uint8_t)
|
||||
STORAGE_BASIC_TYPE(float)
|
||||
STORAGE_BASIC_TYPE(double)
|
||||
STORAGE_BASIC_TYPE(bool)
|
||||
#undef STORAGE_BASIC_TYPE
|
||||
|
||||
void readValue(std::string &v) {
|
||||
if (!cbor.isUtf8()) v.clear();
|
||||
v.assign((const char *)cbor.bytes(), cbor.length());
|
||||
++cbor;
|
||||
}
|
||||
|
||||
template<class Item>
|
||||
void readVector(std::vector<Item> &array) {
|
||||
if (!cbor.isArray()) return;
|
||||
size_t length = 0;
|
||||
cbor = cbor.forEach([&](Cbor item, size_t index){
|
||||
length = index + 1;
|
||||
if (array.size() < length) array.resize(length);
|
||||
|
||||
cbor = item;
|
||||
readValue(array[index]);
|
||||
});
|
||||
array.resize(length);
|
||||
}
|
||||
|
||||
template<class Item>
|
||||
void readValue(std::vector<Item> &array) {
|
||||
readVector(array);
|
||||
}
|
||||
|
||||
#define STORAGE_TYPED_ARRAY(T) \
|
||||
void readValue(std::vector<T> &array) { \
|
||||
if (cbor.isTypedArray()) { \
|
||||
array.resize(cbor.typedArrayLength()); \
|
||||
cbor.readTypedArray(array); \
|
||||
} else { \
|
||||
readVector<T>(array); \
|
||||
} \
|
||||
}
|
||||
STORAGE_TYPED_ARRAY(uint8_t)
|
||||
STORAGE_TYPED_ARRAY(int8_t)
|
||||
STORAGE_TYPED_ARRAY(uint16_t)
|
||||
STORAGE_TYPED_ARRAY(int16_t)
|
||||
STORAGE_TYPED_ARRAY(uint32_t)
|
||||
STORAGE_TYPED_ARRAY(int32_t)
|
||||
STORAGE_TYPED_ARRAY(uint64_t)
|
||||
STORAGE_TYPED_ARRAY(int64_t)
|
||||
STORAGE_TYPED_ARRAY(float)
|
||||
STORAGE_TYPED_ARRAY(double)
|
||||
#undef STORAGE_TYPED_ARRAY
|
||||
|
||||
static bool keyMatch(const char *key, const char *filterKeyBytes, size_t filterKeyLength) {
|
||||
for (size_t i = 0; i < filterKeyLength; ++i) {
|
||||
if (key[i] != filterKeyBytes[i]) return false;
|
||||
}
|
||||
return key[filterKeyLength] == 0;
|
||||
}
|
||||
};
|
||||
|
||||
// If void, use itself for CRTP
|
||||
template<>
|
||||
struct StorageCborWriter<void> : public StorageCborWriter<StorageCborWriter<void>> {
|
||||
using StorageCborWriter<StorageCborWriter<void>>::StorageCborWriter;
|
||||
};
|
||||
template<>
|
||||
struct StorageCborReader<void> : public StorageCborReader<StorageCborReader<void>> {
|
||||
using StorageCborReader<StorageCborReader<void>>::StorageCborReader;
|
||||
};
|
||||
|
||||
}} // namespace
|
||||
1
stfx/ui/html/cbor.min.js
vendored
1
stfx/ui/html/cbor.min.js
vendored
File diff suppressed because one or more lines are too long
@ -1,383 +0,0 @@
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<title>Generic STFX UI</title>
|
||||
<style>
|
||||
:root {
|
||||
font-size:12pt;
|
||||
}
|
||||
* {
|
||||
box-sizing: border-box;
|
||||
}
|
||||
body {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
width: 100vw;
|
||||
max-width: 100vw;
|
||||
height: 100vh;
|
||||
min-height: 100vh;
|
||||
max-height: 100vh;
|
||||
overflow: hidden;
|
||||
|
||||
background: linear-gradient(#FFF, #EEE, #CCC);
|
||||
color: #000;
|
||||
|
||||
text-align: center;
|
||||
word-wrap: break-word;
|
||||
font-family: Bahnschrift, 'DIN Alternate', 'Alte DIN 1451 Mittelschrift', 'D-DIN', 'OpenDin', 'Clear Sans', 'Barlow', 'Abel', 'Franklin Gothic Medium', system-ui, sans-serif;
|
||||
|
||||
/* no text selectable by default */
|
||||
user-select: none;
|
||||
}
|
||||
output {
|
||||
font-family: ui-monospace, 'Cascadia Code', 'Source Code Pro', Menlo, Consolas, 'DejaVu Sans Mono', monospace;
|
||||
font-weight: normal;
|
||||
color: #000;
|
||||
}
|
||||
|
||||
#header {
|
||||
grid-area: header;
|
||||
display: flex;
|
||||
justify-content: center;
|
||||
margin: 0.5rem;
|
||||
|
||||
font-weight: normal;
|
||||
letter-spacing: 0.1ex;
|
||||
transform: scale(0.95, 1);
|
||||
}
|
||||
#params {
|
||||
flex-grow: 1;
|
||||
display: flex;
|
||||
align-content: space-around;
|
||||
justify-content: space-evenly;
|
||||
flex-wrap: wrap;
|
||||
|
||||
padding: 1rem;
|
||||
gap: 1rem;
|
||||
}
|
||||
|
||||
.param-range {
|
||||
display: grid;
|
||||
width: 3.5rem;
|
||||
grid-template-areas: "dial" "name";
|
||||
grid-template-rows: 3.5rem 1fr;
|
||||
}
|
||||
.param-range-value {
|
||||
position: relative;
|
||||
grid-area: dial;
|
||||
|
||||
width: 3.5rem;
|
||||
height: 3.5rem;
|
||||
}
|
||||
.param-range-dial {
|
||||
position: absolute;
|
||||
top: 0;
|
||||
left: 0;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
z-index: -1;
|
||||
}
|
||||
.param-range-text {
|
||||
position: absolute;
|
||||
top: 30%;
|
||||
left: 0;
|
||||
width: 100%;
|
||||
letter-spacing: -0.1ex;
|
||||
}
|
||||
.param-range-units {
|
||||
position: absolute;
|
||||
top: 60%;
|
||||
left: 0;
|
||||
width: 100%;
|
||||
|
||||
color: #666;
|
||||
font-size: 0.85rem;
|
||||
}
|
||||
.param-range-name {
|
||||
grid-area: name;
|
||||
}
|
||||
|
||||
#plots {
|
||||
display: flex;
|
||||
flex-grow: 10;
|
||||
|
||||
}
|
||||
.plot {
|
||||
display: block;
|
||||
width: 100%;
|
||||
flex-grow: 100;
|
||||
|
||||
position: relative;
|
||||
background: linear-gradient(#222, #000 2rem);
|
||||
}
|
||||
.plot canvas {
|
||||
position: absolute;
|
||||
left: 0;
|
||||
top: 0;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
}
|
||||
|
||||
/* Alternative layouts */
|
||||
/* compact: more compact, */
|
||||
:root.compact {
|
||||
font-size: 9pt;
|
||||
}
|
||||
:root.compact #params {
|
||||
padding: 0.5rem;
|
||||
}
|
||||
/* columns: horizontal layout, not vertical */
|
||||
:root.columns body {
|
||||
flex-direction: row;
|
||||
}
|
||||
:root.columns #params {
|
||||
flex-direction: column;
|
||||
}
|
||||
:root.columns #header {
|
||||
display: none;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<h1 id="header">{name}</h1>
|
||||
<section id="params">
|
||||
<template @foreach>
|
||||
<label class="param-range" @if="${d => d.$type == 'ParamRange'}">
|
||||
<div class="param-range-name">{name}</div>
|
||||
<script>
|
||||
let gestureUnit = Symbol(), scrollTimeout = Symbol();
|
||||
function move(data, dx, dy, element) {
|
||||
let prev = data.gesture ? data[gestureUnit] : data.rangeUnit;
|
||||
data[gestureUnit] = data.rangeUnit = Math.min(1, Math.max(0, prev - dy/250));
|
||||
}
|
||||
function scroll(data, dx, dy, element) {
|
||||
let prev = data.gesture ? data[gestureUnit] : data.rangeUnit;
|
||||
|
||||
clearTimeout(element[scrollTimeout]);
|
||||
data.gesture = true;
|
||||
element[scrollTimeout] = setTimeout(_ => data.gesture = false, 500);
|
||||
|
||||
data[gestureUnit] = data.rangeUnit = Math.min(1, Math.max(0, prev + dy/250));
|
||||
}
|
||||
function press(data, count, event, element) {
|
||||
clearTimeout(element[scrollTimeout]);
|
||||
data.gesture = true;
|
||||
data[gestureUnit] = data.rangeUnit;
|
||||
if (count == 2) {
|
||||
data.value = data.defaultValue;
|
||||
data.gesture = false;
|
||||
}
|
||||
}
|
||||
function unpress(data) {
|
||||
data.gesture = false;
|
||||
}
|
||||
|
||||
function drawDial(data, canvas) {
|
||||
let scale = window.devicePixelRatio;
|
||||
let pixels = canvas.offsetWidth*scale;
|
||||
if (canvas.width != pixels) canvas.width = pixels;
|
||||
if (canvas.height != pixels) canvas.height = pixels;
|
||||
|
||||
let context = canvas.getContext('2d');
|
||||
context.resetTransform();
|
||||
context.clearRect(0, 0, pixels, pixels);
|
||||
|
||||
context.scale(pixels/2, pixels/2);
|
||||
context.translate(1, 1);
|
||||
|
||||
context.beginPath();
|
||||
context.ellipse(0, 0, 0.8, 0.8, 0, 0, Math.PI*2);
|
||||
context.fillStyle = '#FFF';
|
||||
context.fill();
|
||||
|
||||
context.lineWidth = 0.2;
|
||||
context.lineCap = 'round';
|
||||
context.beginPath();
|
||||
context.ellipse(0, 0, 0.9, 0.9, 0, Math.PI*-1.25, Math.PI*0.25);
|
||||
context.strokeStyle = '#0001';
|
||||
context.stroke();
|
||||
|
||||
let rangeUnit = data.rangeUnit;
|
||||
if (data.gesture) rangeUnit = data[gestureUnit];
|
||||
|
||||
context.beginPath();
|
||||
context.ellipse(0, 0, 0.9, 0.9, 0, Math.PI*-1.25, Math.PI*(-1.249 + rangeUnit*1.499));
|
||||
context.strokeStyle = '#000';
|
||||
context.stroke();
|
||||
}
|
||||
</script>
|
||||
<div class="param-range-value" $move="${move}" $scroll="${scroll}" $press="${press}" $unpress="${unpress}">
|
||||
<canvas class="param-range-dial" $update="${drawDial}"></canvas>
|
||||
<output class="param-range-text">{text}</output><br>
|
||||
<div class="param-range-units">{textUnits}</div>
|
||||
</div>
|
||||
</label>
|
||||
</template>
|
||||
</section>
|
||||
<template @foreach>
|
||||
<div class="plot" @if="${d => d.$type == 'Spectrum'}" $fullscreentoggle='foo'>
|
||||
<canvas class="plot-grid" $update="${drawSpectrum}" $resize="${drawSpectrum}"></canvas>
|
||||
<canvas class="plot-data" $update="${drawSpectrum}" $resize="${drawSpectrum}"></canvas>
|
||||
<canvas class="plot-labels" $update="${drawSpectrum}" $resize="${drawSpectrum}"></canvas>
|
||||
</div>
|
||||
</template>
|
||||
<script>
|
||||
// Query keys set CSS class on the root
|
||||
new URL(location).searchParams.forEach((value, key) => {
|
||||
document.body.parentNode.classList.add(key);
|
||||
});
|
||||
|
||||
let plotColours = ['#8CF', '#FC8', '#8D8', '#F9B'];
|
||||
function freqScale(width, lowHz, highHz) {
|
||||
// let a = -289.614, b = 1176.76, c = 15.3385, d = -0.552833; // Bark
|
||||
let low = lowHz/(1500 + lowHz);
|
||||
let high = highHz/(1500 + highHz);
|
||||
|
||||
let scale = width/(high - low);
|
||||
return hz => {
|
||||
let v = hz/(1500 + hz);
|
||||
return scale*(v - low);
|
||||
};
|
||||
}
|
||||
function drawSpectrum(data, canvas) {
|
||||
let context = canvas.getContext('2d');
|
||||
let width = canvas.offsetWidth, height = canvas.offsetHeight;
|
||||
{
|
||||
let pixelWidth = Math.round(width*window.devicePixelRatio);
|
||||
let pixelHeight = Math.round(height*devicePixelRatio);
|
||||
if (canvas.width != pixelWidth) canvas.width = pixelWidth;
|
||||
if (canvas.height != pixelHeight) canvas.height = pixelHeight;
|
||||
|
||||
context.resetTransform();
|
||||
context.clearRect(0, 0, pixelWidth, pixelHeight);
|
||||
context.scale(window.devicePixelRatio, window.devicePixelRatio);
|
||||
}
|
||||
|
||||
let baseHz = 100, maxHz = data.hz[data.hz.length - 1];
|
||||
let xScale = freqScale(width, data.hz[0], maxHz);
|
||||
let yScale = e => height*Math.log10(e + 1e-30)*10/-105;
|
||||
yScale = e => {
|
||||
e = Math.pow(e, 0.12);
|
||||
e = e*0.6/(1 - 0.6 - e + 2*e*0.6);
|
||||
return height*(1 - e);
|
||||
};
|
||||
|
||||
if (canvas.classList.contains('plot-grid')) {
|
||||
context.beginPath();
|
||||
context.lineWidth = 1;
|
||||
context.strokeStyle = '#555';
|
||||
for (let baseHz = 100; baseHz < maxHz; baseHz *= 10) {
|
||||
for (let i = 1; i < 10; ++i) {
|
||||
let hz = baseHz*i;
|
||||
let x = xScale(hz);
|
||||
context.moveTo(x, 0);
|
||||
context.lineTo(x, height);
|
||||
}
|
||||
}
|
||||
for (let db = 0; db >= -240; db -= 12) {
|
||||
let e = Math.pow(10, db/10);
|
||||
let y = yScale(e);
|
||||
context.moveTo(0, y);
|
||||
context.lineTo(width, y);
|
||||
}
|
||||
context.stroke();
|
||||
} else if (canvas.classList.contains('plot-data')) {
|
||||
context.lineWidth = 1.5;
|
||||
context.lineCap = 'round';
|
||||
context.lineJoin = 'round';
|
||||
|
||||
let xMapped = Matsui.getRaw(data.hz).map(xScale);
|
||||
data.energy.forEach((line, index) => {
|
||||
context.strokeStyle = plotColours[index%plotColours.length];
|
||||
context.globalAlpha = 6/(6 + index);
|
||||
context.beginPath();
|
||||
for (let i = 0; i < xMapped.length; ++i) {
|
||||
let e = line[i];
|
||||
let y = yScale(e);
|
||||
context.lineTo(xMapped[i], y);
|
||||
}
|
||||
context.stroke();
|
||||
if (1) {
|
||||
context.fillStyle = plotColours[index%plotColours.length];
|
||||
context.lineTo(width, height);
|
||||
context.lineTo(0, height);
|
||||
context.globalAlpha = 2/(10 + index);
|
||||
context.fill();
|
||||
}
|
||||
});
|
||||
} else {
|
||||
context.globalAlpha = 1;
|
||||
context.lineWidth = 2;
|
||||
context.strokeStyle = '#0006';
|
||||
context.fillStyle = '#DDD';
|
||||
for (let baseHz = 100; baseHz < maxHz; baseHz *= 10) {
|
||||
let text = (baseHz < 1000) ? baseHz + "Hz" : baseHz/1000 + "kHz";
|
||||
context.strokeText(text, xScale(baseHz) + 2, height - 2);
|
||||
context.fillText(text, xScale(baseHz) + 2, height - 2);
|
||||
}
|
||||
for (let db = 0; db > -105; db -= (db <= -48 ? 24 : 12)) {
|
||||
let e = Math.pow(10, db/10);
|
||||
let y = yScale(e);
|
||||
context.strokeText(db + "dB", 2, y + 4 + 4*(db == 0));
|
||||
context.fillText(db + "dB", 2, y + 4 + 4*(db == 0));
|
||||
}
|
||||
}
|
||||
}
|
||||
</script>
|
||||
|
||||
<script src="cbor.min.js"></script>
|
||||
<script src="matsui-bundle.min.js"></script>
|
||||
<script>
|
||||
Matsui.global.attributes.fullscreentoggle = (element) => {
|
||||
Matsui.global.attributes.press(element, count => {
|
||||
if (count == 2) {
|
||||
if (document.fullscreenElement == element) {
|
||||
document.exitFullscreen();
|
||||
} else {
|
||||
element.requestFullscreen();
|
||||
}
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
let state = Matsui.replace(document.body, {name: "..."});
|
||||
state.trackMerges(merge => {
|
||||
console.log(JSON.stringify(merge));
|
||||
window.parent.postMessage(CBOR.encode(merge), '*');
|
||||
});
|
||||
let pendingMerge = null;
|
||||
addEventListener('message', e => {
|
||||
let merge = CBOR.decode(e.data);
|
||||
if (pendingMerge !== null) {
|
||||
Matsui.merge.apply(pendingMerge, merge);
|
||||
} else {
|
||||
pendingMerge = merge;
|
||||
requestAnimationFrame(_ => {
|
||||
pendingMerge = null;
|
||||
state.merge(merge);
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
if (window.parent !== window) window.parent.postMessage(CBOR.encode("ready"), '*');
|
||||
|
||||
// Monitor framerate and send every 200ms
|
||||
let frameMs = 100, prevFrame = Date.now(), prevSent = 100;
|
||||
requestAnimationFrame(function nextFrame() {
|
||||
let now = Date.now(), delta = now - prevFrame;
|
||||
frameMs += (delta - frameMs)*frameMs/1000;
|
||||
prevFrame = now;
|
||||
|
||||
prevSent += delta;
|
||||
if (prevSent > 200) {
|
||||
window.parent.postMessage(CBOR.encode(["meters", frameMs/1000, 0.3]));
|
||||
prevSent = 0;
|
||||
}
|
||||
requestAnimationFrame(nextFrame);
|
||||
});
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
2
stfx/ui/html/matsui-bundle.min.js
vendored
2
stfx/ui/html/matsui-bundle.min.js
vendored
File diff suppressed because one or more lines are too long
460
stfx/ui/web-ui.h
460
stfx/ui/web-ui.h
@ -1,460 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "../storage/cbor-walker.h"
|
||||
#include "../storage/stfx-storage.h"
|
||||
#include "../param-info.h"
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <functional>
|
||||
#include <atomic>
|
||||
#include <memory>
|
||||
#include <iostream> // we log to stderr if our queue gets full
|
||||
|
||||
namespace stfx { namespace web {
|
||||
|
||||
struct ParamContext {
|
||||
union {
|
||||
void *pointer;
|
||||
size_t index;
|
||||
};
|
||||
|
||||
ParamContext() : index(0) {}
|
||||
};
|
||||
|
||||
struct WebStateWriter : public storage::STFXStorageWriter<WebStateWriter> {
|
||||
using Super = storage::STFXStorageWriter<WebStateWriter>;
|
||||
|
||||
using Super::Super;
|
||||
|
||||
// There should never be a version mismatch, ignore this
|
||||
int version(int v) {return v;}
|
||||
|
||||
// Include extra info
|
||||
bool extra() {
|
||||
return true;
|
||||
}
|
||||
template<class V>
|
||||
void extra(const char *key, V v) {
|
||||
(*this)(key, v);
|
||||
}
|
||||
};
|
||||
|
||||
struct WebStateReader : public storage::STFXStorageReader<WebStateReader> {
|
||||
using Super = storage::STFXStorageReader<WebStateReader>;
|
||||
|
||||
using Super::Super;
|
||||
|
||||
// There should never be a version mismatch, ignore this
|
||||
int version(int v) {return v;}
|
||||
|
||||
// We're interested in an extended set of values being sent back
|
||||
bool extra() {
|
||||
return true;
|
||||
}
|
||||
// But anything read-only gets skipped
|
||||
template<class V>
|
||||
void extra(const char *key, V v) {}
|
||||
|
||||
void invalidate(const char *invalidatedKey) {
|
||||
// TODO: right now this is hacked together, by the params re-sending themselves whenever they would otherwise invalidate.
|
||||
// Instead, this would let us reply with only the keys which changed
|
||||
}
|
||||
};
|
||||
|
||||
template<class S>
|
||||
constexpr bool storageIsWeb() {return false;}
|
||||
template<>
|
||||
constexpr bool storageIsWeb<WebStateWriter>() {return true;}
|
||||
template<>
|
||||
constexpr bool storageIsWeb<WebStateReader>() {return true;}
|
||||
|
||||
/* Given an STFX template which (when insantiated) has inheritance like:
|
||||
|
||||
EffectSTFX : Effect
|
||||
|
||||
This produces a template with inheritance like:
|
||||
|
||||
WebSTFX : EffectSTFX : WebBase : Effect
|
||||
|
||||
The WebBase template replaces the ParamRange/ParamStepped classes, so that the UI can be updated when they change. The outer WebSTFX class adds methods for forwarding messages between the effect and its webview.
|
||||
*/
|
||||
|
||||
template<template<class, class...> class EffectSTFX, class SubClass>
|
||||
struct WebUIHelper {
|
||||
|
||||
template<class Effect>
|
||||
class WebBase : public Effect {
|
||||
using SuperRange = typename Effect::ParamRange;
|
||||
using SuperStepped = typename Effect::ParamStepped;
|
||||
|
||||
protected:
|
||||
struct WebParamScanner : public storage::STFXStorageScanner<WebParamScanner>{
|
||||
SubClass *effect;
|
||||
std::vector<std::string> scope;
|
||||
|
||||
WebParamScanner(SubClass *effect) : effect(effect) {}
|
||||
|
||||
// Extra methods we add for STFX storage
|
||||
void info(const char *, const char *) {}
|
||||
int version(int v) {
|
||||
return v;
|
||||
}
|
||||
template<class PR>
|
||||
RangeParamInfo & range(const char *key, PR ¶m) {
|
||||
param.effect = effect;
|
||||
param.scope = scope;
|
||||
param.scope.emplace_back(key);
|
||||
param.info = std::unique_ptr<RangeParamInfo>{
|
||||
new RangeParamInfo(param)
|
||||
};
|
||||
return *param.info;
|
||||
}
|
||||
template<class PS>
|
||||
SteppedParamInfo & stepped(const char *key, PS ¶m) {
|
||||
param.effect = effect;
|
||||
param.scope = scope;
|
||||
param.scope.emplace_back(key);
|
||||
param.info = std::unique_ptr<SteppedParamInfo>{
|
||||
new SteppedParamInfo(param)
|
||||
};
|
||||
return *param.info;
|
||||
}
|
||||
template<class V>
|
||||
bool changed(const char *key, V &v) {
|
||||
(*this)(key, v);
|
||||
return false;
|
||||
}
|
||||
void invalidate(const char *) {}
|
||||
};
|
||||
|
||||
public:
|
||||
using Effect::Effect;
|
||||
|
||||
std::string webPage = "html/generic.html";
|
||||
int webWidth = 640, webHeight = 480;
|
||||
|
||||
struct ParamRange : public SuperRange {
|
||||
using SuperRange::SuperRange;
|
||||
|
||||
ParamContext context;
|
||||
|
||||
ParamRange & operator=(double v) {
|
||||
bool changed = (v != *this);
|
||||
SuperRange::operator=(v);
|
||||
if (changed) sendUpdateMessage();
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class Storage>
|
||||
void state(Storage &storage) {
|
||||
double prevV = *this;
|
||||
bool prevGesture = gesture;
|
||||
SuperRange::state(storage);
|
||||
|
||||
constexpr bool isWeb = storageIsWeb<Storage>();
|
||||
if (isWeb) { // a bunch of extra state
|
||||
storage.extra("$type", "ParamRange");
|
||||
storage.extra("name", info->name);
|
||||
storage.extra("defaultValue", info->defaultValue);
|
||||
std::string text, units;
|
||||
info->toString((double)*this, text, units);
|
||||
storage.extra("text", text);
|
||||
storage.extra("textUnits", units);
|
||||
storage("gesture", gesture);
|
||||
|
||||
double unit = info->toUnit(*this);
|
||||
if (storage.changed("rangeUnit", unit)) {
|
||||
SuperRange::operator=(info->fromUnit(unit));
|
||||
storage.invalidate("value");
|
||||
}
|
||||
}
|
||||
|
||||
if (prevV != *this) {
|
||||
storage.invalidate("rangeUnit");
|
||||
storage.invalidate("text");
|
||||
storage.invalidate("textUnits");
|
||||
if (isWeb) {
|
||||
if (effect->paramListenerRange) {
|
||||
effect->paramListenerRange(context, *this);
|
||||
}
|
||||
sendUpdateMessage(); // TODO: shouldn't be necessary once we have `.invalidate()` working
|
||||
} else {
|
||||
sendUpdateMessage();
|
||||
}
|
||||
}
|
||||
if (gesture != prevGesture) {
|
||||
if (isWeb && effect->paramListenerGesture) {
|
||||
effect->paramListenerGesture(context, gesture);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
friend struct WebParamScanner;
|
||||
SubClass *effect = nullptr;
|
||||
std::vector<std::string> scope;
|
||||
std::unique_ptr<RangeParamInfo> info;
|
||||
bool gesture = false;
|
||||
|
||||
void sendUpdateMessage() {
|
||||
if (auto *m = effect->getEmptyMessage()) {
|
||||
signalsmith::cbor::CborWriter cbor{m->bytes};
|
||||
for (auto &key : scope) {
|
||||
cbor.openMap(1);
|
||||
cbor.addUtf8(key);
|
||||
}
|
||||
WebStateWriter storage{cbor};
|
||||
state(storage);
|
||||
m->markReady();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
struct ParamStepped : public SuperStepped {
|
||||
using SuperStepped::SuperStepped;
|
||||
|
||||
ParamContext context;
|
||||
|
||||
ParamStepped & operator=(int v) {
|
||||
bool changed = (v != *this);
|
||||
SuperStepped::operator=(v);
|
||||
if (changed) sendUpdateMessage();
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class Storage>
|
||||
void state(Storage &storage) {
|
||||
int prevV = *this;
|
||||
SuperStepped::state(storage);
|
||||
|
||||
constexpr bool isWeb = storageIsWeb<Storage>();
|
||||
if (isWeb) {
|
||||
storage.extra("$type", "ParamStepped");
|
||||
storage.extra("low", info->low);
|
||||
storage.extra("high", info->high);
|
||||
storage.extra("name", info->name);
|
||||
std::string text = info->toString((int)*this);
|
||||
storage.extra("text", text);
|
||||
}
|
||||
|
||||
if (prevV != *this) {
|
||||
storage.invalidate("text");
|
||||
if (isWeb) {
|
||||
if (effect->paramListenerStepped) {
|
||||
effect->paramListenerStepped(context, *this);
|
||||
}
|
||||
sendUpdateMessage(); // TODO: shouldn't be necessary once we have `.invalidate()` working
|
||||
} else {
|
||||
sendUpdateMessage();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
friend struct WebParamScanner;
|
||||
SubClass *effect = nullptr;
|
||||
std::vector<std::string> scope;
|
||||
std::unique_ptr<SteppedParamInfo> info;
|
||||
|
||||
void sendUpdateMessage() {
|
||||
if (auto *m = effect->getEmptyMessage()) {
|
||||
signalsmith::cbor::CborWriter cbor{m->bytes};
|
||||
for (auto &key : scope) {
|
||||
cbor.openMap(1);
|
||||
cbor.addUtf8(key);
|
||||
}
|
||||
WebStateWriter storage{cbor};
|
||||
state(storage);
|
||||
m->markReady();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template<class Storage>
|
||||
void meterState(Storage &storage) {}
|
||||
};
|
||||
|
||||
template<class Effect, class... ExtraArgs>
|
||||
struct WebSTFX : public EffectSTFX<WebBase<Effect>, ExtraArgs...> {
|
||||
using Super = EffectSTFX<WebBase<Effect>, ExtraArgs...>;
|
||||
};
|
||||
};
|
||||
|
||||
// Use this instead of a plain LibraryEffect
|
||||
template<typename Sample, template<class, class...> class EffectSTFX, class... ExtraArgs>
|
||||
struct WebUILibraryEffect : public LibraryEffect<Sample, WebUIHelper<EffectSTFX, WebUILibraryEffect<Sample, EffectSTFX, ExtraArgs...>>::template WebSTFX, ExtraArgs...> {
|
||||
using Super = LibraryEffect<Sample, WebUIHelper<EffectSTFX, WebUILibraryEffect<Sample, EffectSTFX, ExtraArgs...>>::template WebSTFX, ExtraArgs...>;
|
||||
|
||||
template<class... Args>
|
||||
WebUILibraryEffect(Args... args) : Super(args...) {
|
||||
typename Super::WebParamScanner scanner{this};
|
||||
this->state(scanner);
|
||||
// The web-message queue starts in a reset state
|
||||
requestEntireState();
|
||||
};
|
||||
|
||||
// These are called when the parameter is changed from the web UI
|
||||
std::function<void(ParamContext, double)> paramListenerRange;
|
||||
std::function<void(ParamContext, bool)> paramListenerGesture;
|
||||
std::function<void(ParamContext, int)> paramListenerStepped;
|
||||
|
||||
// This state includes all the parameters
|
||||
void saveState(std::vector<unsigned char> &bytes) {
|
||||
stfx::storage::STFXStorageWriter<> storage(bytes);
|
||||
this->state(storage);
|
||||
}
|
||||
void loadState(const std::vector<unsigned char> &bytes) {
|
||||
stfx::storage::STFXStorageReader<> storage(bytes);
|
||||
this->state(storage);
|
||||
requestEntireState();
|
||||
}
|
||||
|
||||
struct WebMessage {
|
||||
std::vector<unsigned char> bytes;
|
||||
|
||||
WebMessage() {
|
||||
bytes.reserve(256);
|
||||
}
|
||||
|
||||
void sent() {
|
||||
readyToSend.clear();
|
||||
}
|
||||
|
||||
private:
|
||||
friend class WebUILibraryEffect;
|
||||
friend struct Super::ParamRange;
|
||||
friend struct Super::ParamStepped;
|
||||
std::atomic_flag readyToSend = ATOMIC_FLAG_INIT;
|
||||
|
||||
void markReady() {
|
||||
readyToSend.test_and_set();
|
||||
}
|
||||
};
|
||||
|
||||
bool hasPendingWebMessage() const {
|
||||
auto &message = queue[readIndex];
|
||||
return message.readyToSend.test();
|
||||
}
|
||||
|
||||
// Poll on the main thread (and directly after any `.webReceive()`), calling `.sent()` after you've sent it, repeat until you get `nullptr`
|
||||
WebMessage * getPendingWebMessage() {
|
||||
auto &message = queue[readIndex];
|
||||
if (!message.readyToSend.test()) return nullptr;
|
||||
if (++readIndex == queue.size()) readIndex = 0;
|
||||
|
||||
if (resetQueue.test()) {
|
||||
// Clear ("send") every message aside from this one
|
||||
for (auto &m : queue) {
|
||||
if (&m == &message) continue;
|
||||
m.sent();
|
||||
}
|
||||
// Ready to start sending messages again, starting from the next index
|
||||
writeIndex.store(readIndex);
|
||||
resetQueue.clear();
|
||||
// any messages (state updates) sent after this won't assume a *newer* state than what we serialise below
|
||||
|
||||
// Replace this one's message with the complete plugin state
|
||||
WebStateWriter storage(message.bytes);
|
||||
this->state(storage);
|
||||
}
|
||||
return &message;
|
||||
}
|
||||
|
||||
// Call when the webview posts any message back
|
||||
void webReceive(const void *message, size_t size) {
|
||||
auto *bytes = (const unsigned char *)message;
|
||||
signalsmith::cbor::TaggedCborWalker cbor(bytes, bytes + size);
|
||||
|
||||
if (cbor.isUtf8()) {
|
||||
if (cbor.utf8View() == "ready") {
|
||||
requestEntireState();
|
||||
return;
|
||||
}
|
||||
} else if (cbor.isArray()) {
|
||||
size_t length = cbor.length();
|
||||
cbor = cbor.enter();
|
||||
if (cbor.utf8View() == "meters" && length == 3) {
|
||||
double interval = ++cbor;
|
||||
double duration = ++cbor;
|
||||
metersInterval.store(interval*this->config.sampleRate);
|
||||
metersDuration.store(duration*this->config.sampleRate);
|
||||
}
|
||||
} else if (cbor.isMap()) {
|
||||
// Apply it as a merge
|
||||
WebStateReader reader(cbor);
|
||||
this->state(reader);
|
||||
}
|
||||
}
|
||||
|
||||
void webClosed() {
|
||||
// stops new messages from being queued up until the reset message is sent
|
||||
requestEntireState();
|
||||
}
|
||||
|
||||
// Replace `.process()` to add meter messages if they exist
|
||||
template<class Buffers>
|
||||
void process(Buffers &&buffers, int blockLength) {
|
||||
process(buffers, buffers, blockLength);
|
||||
}
|
||||
|
||||
template<class Inputs, class Outputs>
|
||||
void process(Inputs &&inputs, Outputs &&outputs, int blockLength) {
|
||||
Super::process(inputs, outputs, blockLength);
|
||||
|
||||
if (this->hasMeters()) {
|
||||
auto *m = getEmptyMessage();
|
||||
if (m) {
|
||||
signalsmith::cbor::CborWriter cbor{m->bytes};
|
||||
WebStateWriter storage{cbor};
|
||||
this->meterState(storage);
|
||||
m->markReady();
|
||||
}
|
||||
this->wantsMeters(false);
|
||||
}
|
||||
|
||||
if (metersDuration.load() > 0) {
|
||||
metersDuration -= blockLength;
|
||||
samplesSinceMeters += blockLength;
|
||||
if (samplesSinceMeters > metersInterval.load()) {
|
||||
this->wantsMeters();
|
||||
samplesSinceMeters = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
friend struct Super::ParamRange;
|
||||
friend struct Super::ParamStepped;
|
||||
|
||||
std::atomic<int> metersInterval = 0, metersDuration = 0;
|
||||
int samplesSinceMeters = 0; // only used from `.process()`
|
||||
|
||||
std::vector<WebMessage> queue = std::vector<WebMessage>(64); // power of 2 so that overflow doesn't mess with the modulo
|
||||
size_t readIndex = 0;
|
||||
std::atomic_flag resetQueue = ATOMIC_FLAG_INIT;
|
||||
|
||||
// Atomic because multiple threads might write
|
||||
std::atomic<size_t> writeIndex = 0;
|
||||
WebMessage * getEmptyMessage() {
|
||||
if (resetQueue.test()) return nullptr;
|
||||
auto reservedIndex = writeIndex.fetch_add(1);
|
||||
auto &message = queue[reservedIndex%queue.size()];
|
||||
if (message.readyToSend.test()) {
|
||||
std::cerr << "Web message queue full - sending entire state instead\n";
|
||||
// When our queue is full, we drop the entire thing and re-send the entire state
|
||||
resetQueue.test_and_set();
|
||||
return nullptr;
|
||||
}
|
||||
message.bytes.resize(0);
|
||||
return &message;
|
||||
}
|
||||
|
||||
void requestEntireState() {
|
||||
if (auto *m = getEmptyMessage()) {
|
||||
resetQueue.test_and_set();
|
||||
m->markReady();
|
||||
} // if this fails, then the queue is full and we're doing a reset anyway
|
||||
}};
|
||||
|
||||
}} // namespace
|
||||
Loading…
x
Reference in New Issue
Block a user