├── Makefile
├── Notes.md
├── README.md
├── audio
    ├── loop.mp3
    └── twang.m4a
├── audioworkletnode-clap.mjs
├── audioworkletprocessor-clap.mjs
├── clap-host
    ├── clap-interface.mjs
    ├── clap-module.mjs
    ├── ext
    │   ├── add-extension.mjs
    │   ├── audio-ports.mjs
    │   ├── log.mjs
    │   ├── params.mjs
    │   └── state.mjs
    ├── generate-forwarding-wasm.mjs
    ├── hosted-plugin.mjs
    ├── instantiate.mjs
    └── wasi
    │   └── wasi_snapshot_preview1.mjs
├── index.html
├── plugin
    ├── clap-validator-plugin.wclap
    │   └── module.wasm
    ├── clapfirst-bad-distortion.wclap.tar.gz
    ├── freq-shifter.wclap.tar.gz
    └── hello-clap.wclap.tar.gz
├── rainbow-texture.jpg
└── wclap-service-worker.js


/Makefile:
--------------------------------------------------------------------------------
 1 | server:
 2 | 	python3 -m http.server
 3 | 
 4 | bundle:
 5 | 	npx rollup clap-host/clasm.mjs --file clasm.mjs --format es --sourcemap
 6 | 	
 7 | 	npx rollup clap-host/clasm.mjs --file clasm.js --format umd --output.name Clasm --no-esModule --strict --sourcemap
 8 | 
 9 | 
10 | minify:
11 | 	npx uglify-js ./clasm.mjs -o ./clasm.min.mjs \
12 | 		--source-map "content=clasm.mjs.map,url=clasm.min.mjs.map" \
13 | 		--warn --compress passes=10 \
14 | 		--mangle --mangle-props "regex=/^(m_|#)/" \
15 | 		--output-opts ascii_only
16 | 
17 | 	npx uglify-js ./clasm.js -o ./clasm.min.js \
18 | 		--source-map "content=clasm.js.map,url=clasm.min.js.map" \
19 | 		--warn --compress passes=10 \
20 | 		--mangle --mangle-props "regex=/^(m_|#)/" \
21 | 		--output-opts ascii_only
22 | 


--------------------------------------------------------------------------------
/Notes.md:
--------------------------------------------------------------------------------
 1 | # CLAP WASM notes
 2 | 
 3 | Here are some notes for compiing a CLAP plugin to a self-contained `.wasm` file (no JS support needed);
 4 | 
 5 | ## General
 6 | 
 7 | The WASM module needs to export:
 8 | 
 9 | * `memory`
10 | * `clap_entry` - pointer to the entry object
11 | * `malloc(size)` - allocates memory for the host to use
12 | * a growable WebAssembly.Table (full of function references)
13 | 
14 | We need `malloc` because the host needs to provide pointers to structures and audio buffers.  Rather than structuring the WASM module as a shared library (which isn't currently standardised), the plugin module is self-contained but allows the host to inject itself.
15 | 
16 | ### Finding the Table
17 | 
18 | Plugins should only export one function Table, and hosts may throw if there's more than one candidate.  LLVM calls this table `__indirect_function_table`, but hosts shouldn't assume that.
19 | 
20 | ### Resizable Table/`memory`
21 | 
22 | The Table export needs to be growable, so that the host can import an arbitrary number of its own functions.
23 | 
24 | The `memory` export is *probably* resizable, since the plugin doesn't know how much memory the host will ask for with `malloc()`.  A host might(?) also constructing an arbitrary number of plugin instances.
25 | 
26 | ### Emscripten flags
27 | 
28 | None of these requirements/behaviours are specific to Emscripten, but it's pretty common, so 'here are some useful flags for the Emscripten linker:
29 | 
30 | * `-sEXPORTED_FUNCTIONS=_clap_entry,_malloc`: not sure what the `_` is about here - they're not present in the actual exports
31 | * `-sPURE_WASI`: no Emscripten-specific imports (`emscripten_notify_memory_growth`)
32 | * `-sSTANDALONE_WASM`: otherwise Emscripten does various things (e.g. renaming exports) which assume a matching custom JS loader
33 | * `--export-table`: exports the function Table
34 | * `-sALLOW_TABLE_GROWTH`: the Table is growable
35 | * `--no-entry`: don't expect a `main()`
36 | * `-sINITIAL_MEMORY=512kb -sALLOW_MEMORY_GROWTH`: up to you and your specific plugin - it'll complain at build time if the initial memory is too small
37 | 
38 | ## Threads
39 | 
40 | Each WebAssembly instance is single-threaded, and multi-threading is done by having multiple instances (perhaps of different modules!) using shared memory.  This means that (if you import shared `memory` instead of exporting it) you could have calls being made on separate UI/audio threads.
41 | 
42 | Many non-browser engines don't support shared memory anyway (and in a browser you need to [lock everything down](https://hacks.mozilla.org/2020/07/safely-reviving-shared-memory/) before you can pass memory around).  Even where supported, you can't spawn your own threads (for now) from inside the WebAssembly module.
43 | 
44 | However, threads are most commonly used for passing messages between the audio/UI components.  If a WASM build doesn't include the `clap.gui` extension, then the threads might not be necessary either.
45 | 
46 | ### C++
47 | 
48 | With Emscripten at least, you can still have a `std::thread` but actually starting one throws an error.  Therefore, if you only start the `std::thread` when you actually need it (e.g. when the GUI is opened) that can avoid the problem.
49 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Browser-based Web-CLAP host
 2 | 
 3 | This is a _very_ WIP proof-of-concept host for WCLAP ([Web CLAP](https://github.com/free-audio/web-clap)) plugins.  Although this host is browser-based, a similar approach could be used for non-web contexts.
 4 | 
 5 | ## Design
 6 | 
 7 | There are three layers:
 8 | 
 9 | ### CLAP host
10 | 
11 | The source for this is in `clap-host/`, with the main entry point being `clapModule()` from `clap-module.mjs`.  This takes the [WebAssembly Module](https://developer.mozilla.org/en-US/docs/WebAssembly/JavaScript_interface/Module) for a CLAP plugin, and lets you query/create plugin instances.
12 | 
13 | Rather than wrap the CLAP API in any way, `clap-interface.mjs` makes it easy to define and read/write C structs in the WebAssembly memory, call functions (from function pointers), proxy your own JS functions as function pointers, and add CLAP extensions.  The core CLAP types/extensions are already defined.
14 | 
15 | ### AudioWorkletNode / AudioWorkletProcessor
16 | 
17 | This fetches/compiles a `.wasm`, and uses the Module to construct an AudioWorkletProcessor.  This processor uses the CLAP host helpers (above) to configure/activate the plugin and process audio blocks.
18 | 
19 | The AudioWorkletNode has proxy methods added to it, which asynchronously scan/update parameters and save/load state, by posting messages across to the processor.  It also receives events from the processor (such as "state marked dirty").
20 | 
21 | They also use the WIP `clap.web/1` draft extension, which (if supported) opens a web-page and passes arbitrary messages between the web-page and the plugin, allowing plugins to present a web-based UI.  Since this host is running in the browser, this web-view is loaded in an `<iframe>`.
22 | 
23 | ### Service Worker
24 | 
25 | WCLAP bundles might contain multiple resources, in which case they should be served as `.tar.gz` archives.  The main page registers a Service Worker which can fetch these bundles, extract them, and serve them as if they were individual resources.
26 | 


--------------------------------------------------------------------------------
/audio/loop.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Signalsmith-Audio/wasm-clap-browserhost/b267e772fe3c3afbb85d05cc227a342d1327b187/audio/loop.mp3


--------------------------------------------------------------------------------
/audio/twang.m4a:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Signalsmith-Audio/wasm-clap-browserhost/b267e772fe3c3afbb85d05cc227a342d1327b187/audio/twang.m4a


--------------------------------------------------------------------------------
/audioworkletnode-clap.mjs:
--------------------------------------------------------------------------------
  1 | import clapModule from "./clap-host/clap-module.mjs";
  2 | 
  3 | let moduleAdded = Symbol();
  4 | 
  5 | function addRemoteMethods(node) {
  6 | }
  7 | 
  8 | export default class ClapModule {
  9 | 	url;
 10 | 	#m_modulePromise;
 11 | 
 12 | 	constructor(moduleOptions) {
 13 | 		if (typeof moduleOptions === 'string') moduleOptions = {url: moduleOptions};
 14 | 		
 15 | 		let url = moduleOptions?.url;
 16 | 		// If we specify a directory (ends in `/`) then use `module.wasm`
 17 | 		if (/\.(wasm-clap|wclap)$/.test(url)) url += '/'; // Assume .wasm-clap is a bundle directory
 18 | 		if (/\/$/.test(url)) url += "module.wasm";
 19 | 		this.url = new URL(url, location.href).href;
 20 | 
 21 | 		this.#m_modulePromise = moduleOptions.module || WebAssembly.compileStreaming(fetch(this.url));
 22 | 	}
 23 | 	
 24 | 	async plugins(processorOptions) {
 25 | 		let module = await clapModule({
 26 | 			url: this.url,
 27 | 			module: await this.#m_modulePromise
 28 | 		});
 29 | 		return module.plugins;
 30 | 	}
 31 | 	
 32 | 	async createNode(audioContext, pluginId, nodeOptions) {
 33 | 		if (!nodeOptions && typeof pluginId === 'object') {
 34 | 			nodeOptions = pluginId;
 35 | 			pluginId = null;
 36 | 		}
 37 | 		nodeOptions = nodeOptions || {
 38 | 			numberOfInputs: 1,
 39 | 			numberOfOutputs: 1,
 40 | 			outputChannelCount: [2],
 41 | 		};
 42 | 		nodeOptions.processorOptions = {
 43 | 			url: this.url,
 44 | 			module: await this.#m_modulePromise,
 45 | 			pluginId: pluginId
 46 | 		};
 47 | 
 48 | 		if (!audioContext[moduleAdded]) {
 49 | 			await audioContext.audioWorklet.addModule('./audioworkletprocessor-clap.mjs');
 50 | 		}
 51 | 		audioContext[moduleAdded] = true;
 52 | 
 53 | 		let effectNode = new AudioWorkletNode(audioContext, 'audioworkletprocessor-clap', nodeOptions);
 54 | 		
 55 | 		let responseMap = Object.create(null);
 56 | 		let idCounter = 0;
 57 | 		function addRemoteMethod(name) {
 58 | 			effectNode[name] = (...args) => {
 59 | 				let requestId = idCounter++;
 60 | 				
 61 | 				effectNode.port.postMessage([requestId, name, args]);
 62 | 				
 63 | 				return new Promise((pass, fail) => {
 64 | 					responseMap[requestId] = {m_pass: pass, m_fail: fail};
 65 | 				});
 66 | 			};
 67 | 		}
 68 | 		
 69 | 		// Hacky event-handling
 70 | 		effectNode.events = {};
 71 | 		
 72 | 		return new Promise(resolve => {
 73 | 			effectNode.port.onmessage = e => {
 74 | 				let {desc, methods, webview} = e.data;
 75 | 				effectNode.descriptor = desc;
 76 | 				methods.forEach(addRemoteMethod);
 77 | 
 78 | 				let iframe = null;
 79 | 
 80 | 				effectNode.port.onmessage = e => {
 81 | 					let data = e.data;
 82 | 					if (data instanceof ArrayBuffer) {
 83 | 						// it's a message from the plugin
 84 | 						if (iframe) iframe.contentWindow.postMessage(data, '*');
 85 | 						return;
 86 | 					}
 87 | 					if (typeof data[0] === 'string') {
 88 | 						// it's an event - call a handler if there is one
 89 | 						let handler = effectNode.events[data[0]];
 90 | 						if (handler) {
 91 | 							handler(data[1]);
 92 | 						} else {
 93 | 							console.error("unhandled event:", ...data);
 94 | 						}
 95 | 						return;
 96 | 					}
 97 | 					let response = responseMap[data[0]];
 98 | 					if (data[1]) {
 99 | 						response.m_fail(data[1]);
100 | 					} else {
101 | 						response.m_pass(data[2]);
102 | 					}
103 | 				};
104 | 				
105 | 				if (webview) {
106 | 					let messageHandler = e => {
107 | 						if (e.source === iframe?.contentWindow) {
108 | 							let data = e.data;
109 | 							if (!(data instanceof ArrayBuffer)) throw Error("messages must be ArrayBuffers");
110 | 							effectNode.port.postMessage(data);
111 | 						}
112 | 					};
113 | 					let visibilityHandler;
114 | 					effectNode.openInterface = () => {
115 | 						iframe = document.createElement('iframe');
116 | 						window.addEventListener('message', messageHandler);
117 | 						window.addEventListener('visibilitychange', visibilityHandler = () => {
118 | 							effectNode.webviewOpen(true, !document.hidden);
119 | 						});
120 | 						iframe.src = new URL(webview.startPage, this.url);
121 | 						effectNode.webviewOpen(true, !document.hidden);
122 | 						return iframe;
123 | 					};
124 | 					effectNode.closeInterface = () => {
125 | 						effectNode.webviewOpen(false);
126 | 						if (iframe) {
127 | 							window.removeEventListener('message', messageHandler);
128 | 							window.removeEventListener('visibilitychange', visibilityHandler);
129 | 						}
130 | 						iframe = null;
131 | 					}
132 | 				}
133 | 
134 | 				resolve(effectNode);
135 | 			};
136 | 		});
137 | 	}
138 | }
139 | 


--------------------------------------------------------------------------------
/audioworkletprocessor-clap.mjs:
--------------------------------------------------------------------------------
  1 | import clapModule from "./clap-host/clap-module.mjs";
  2 | 
  3 | clapModule.addExtension("clap.web/1", {
  4 | 	wasm: {
  5 | 		ext_web_is_open: 'ip',
  6 | 		ext_web_send: 'ippi'
  7 | 	},
  8 | 	js: {
  9 | 		ext_web_is_open() {
 10 | 			// never open for now
 11 | 			return false;
 12 | 		},
 13 | 		// This is the name on the host struct, so it means the plugin has sent us a message
 14 | 		ext_web_send(voidPointer, length) {
 15 | 			return false;
 16 | 		}
 17 | 	},
 18 | 	addTypes(api, methods) {
 19 | 		api.clap_plugin_web = api.makeStruct(
 20 | 			{get_start: api.makeFunc(api.pointer, api.pointer, api.u32)},
 21 | 			{receive: api.makeFunc(api.pointer, api.pointer, api.u32)}
 22 | 		);
 23 | 		api.clap_host_web = api.makeStruct(
 24 | 			{is_open: api.makeFunc(api.pointer)},
 25 | 			{send: api.makeFunc(api.pointer, api.pointer, api.u32)}
 26 | 		);
 27 | 		return api.save(api.clap_host_web, {
 28 | 			is_open: methods.ext_web_is_open,
 29 | 			send: methods.ext_web_send
 30 | 		});
 31 | 	},
 32 | 	readPlugin(api, pointer, pluginPtr) {
 33 | 		let web = api.clap_plugin_web(pointer, pluginPtr);
 34 | 		let buffer = api.tempBytes(1024);
 35 | 		if (!web.get_start(buffer, 1024)) return null;
 36 | 		return {
 37 | 			startPage: api.fromArg(api.string, buffer),
 38 | 			send: message => {
 39 | 				let messageArr = new Uint8Array(message);
 40 | 				let buffer = this.api.tempTyped(Uint8Array, messageArr.length);
 41 | 				buffer.set(messageArr);
 42 | 				web.receive(buffer, buffer.length)
 43 | 			}
 44 | 		};
 45 | 	}
 46 | });
 47 | clapModule.addExtension("clap.webview/1", {
 48 | 	wasm: {
 49 | 		ext_webview_is_open: 'ip',
 50 | 		ext_webview_send: 'ippi'
 51 | 	},
 52 | 	js: {
 53 | 		ext_webview_is_open() {
 54 | 			// never open for now
 55 | 			return false;
 56 | 		},
 57 | 		// This is the name on the host struct, so it means the plugin has sent us a message
 58 | 		ext_webview_send(voidPointer, length) {
 59 | 			return false;
 60 | 		}
 61 | 	},
 62 | 	addTypes(api, methods) {
 63 | 		api.clap_plugin_webview = api.makeStruct(
 64 | 			{provide_starting_uri: api.makeFunc(api.pointer, api.pointer, api.u32)},
 65 | 			{receive: api.makeFunc(api.pointer, api.pointer, api.u32)}
 66 | 		);
 67 | 		api.clap_host_webview = api.makeStruct(
 68 | 			{is_open: api.makeFunc(api.pointer)},
 69 | 			{send: api.makeFunc(api.pointer, api.pointer, api.u32)}
 70 | 		);
 71 | 		return api.save(api.clap_host_webview, {
 72 | 			is_open: methods.ext_webview_is_open,
 73 | 			send: methods.ext_webview_send
 74 | 		});
 75 | 	},
 76 | 	readPlugin(api, pointer, pluginPtr) {
 77 | 		let webview = api.clap_plugin_webview(pointer, pluginPtr);
 78 | 		let buffer = api.tempBytes(1024);
 79 | 		if (!webview.provide_starting_uri(buffer, 1024)) return null;
 80 | 		return {
 81 | 			startPage: api.fromArg(api.string, buffer),
 82 | 			send: message => {
 83 | 				let messageArr = new Uint8Array(message);
 84 | 				let buffer = this.api.tempTyped(Uint8Array, messageArr.length);
 85 | 				buffer.set(messageArr);
 86 | 				webview.receive(buffer, buffer.length)
 87 | 			}
 88 | 		};
 89 | 	}
 90 | });
 91 | 
 92 | class AudioWorkletProcessorClap extends AudioWorkletProcessor {
 93 | 	inputChannelCounts = [];
 94 | 	outputChannelCounts = [];
 95 | 	clapPlugin;
 96 | 	maxFramesCount = 1024;
 97 | 
 98 | 	constructor(options) {
 99 | 		super();
100 | 
101 | 		let clapOptions = options.processorOptions;
102 | 		if (!clapOptions) throw Error("no processorOptions");
103 | 		clapModule(options?.processorOptions).then(async module => {
104 | 			let pluginId = clapOptions.pluginId;
105 | 			if (!pluginId) {
106 | 				let pluginIndex = clapOptions.pluginIndex || 0;
107 | 				pluginId = module.plugins[pluginIndex].id;
108 | 			}
109 | 			
110 | 			let clapPlugin = await module.create(pluginId);
111 | 			Object.assign(clapPlugin.hostJs, this.makeHostMethods());
112 | 			this.clapPlugin = clapPlugin;
113 | 			this.clapUpdateAudioPorts();
114 | 			this.clapActivate();
115 | 			
116 | 			// initial message lists plugin descriptor and remote methods
117 | 			let webview = this.clapPlugin.ext['clap.webview/1'] || this.clapPlugin.ext['clap.web/1'];
118 | 			this.port.postMessage({
119 | 				desc: clapPlugin.api.clap_plugin_descriptor(clapPlugin.plugin.desc),
120 | 				methods: Object.keys(this.remoteMethods),
121 | 				webview: webview && {startPage: webview.startPage},
122 | 				audioPorts: {'in': this.audioPortsIn, 'out': this.audioPortsOut}
123 | 			});
124 | 		});
125 | 		
126 | 		// subsequent messages are proxied method calls
127 | 		this.port.onmessage = async event => {
128 | 			if (this.fatalError) return;
129 | 			
130 | 			let data = event.data;
131 | 			if (data instanceof ArrayBuffer) {
132 | 
133 | 			
134 | 				let webview = this.clapPlugin.ext['clap.webview/1'] || this.clapPlugin.ext['clap.web/1'];
135 | 				if (webview) webview.send(data);
136 | 				return;
137 | 			}
138 | 			let [requestId, method, args] = data;
139 | 
140 | 			try {
141 | 				let result = await this.remoteMethods[method].call(this, ...args);
142 | 				this.port.postMessage([requestId, null, result]);
143 | 				this.mainThreadCallbackIfNeeded();
144 | 			} catch (e) {
145 | 				this.failWithError(e);
146 | 				this.port.postMessage([requestId, e]);
147 | 			}
148 | 		};
149 | 	}
150 | 
151 | 	fatalError = null;
152 | 	failWithError(e) {
153 | 		this.fatalError = e;
154 | 	}
155 | 	
156 | 	webviewIsOpen = false;
157 | 	
158 | 	streamInput = {pointer: 0, length: 0};
159 | 	streamOutput = {
160 | 		buffer: new Uint8Array(16284),
161 | 		index: 0,
162 | 		result: new Uint8Array(0),
163 | 		clear() {
164 | 			this.index = 0;
165 | 			this.result = this.buffer.subarray(0, 0);
166 | 		}
167 | 	};
168 | 	
169 | 	wantsMainThreadCallback = false;
170 | 	mainThreadCallbackIfNeeded() {
171 | 		if (!this.wantsMainThreadCallback) return;
172 | 		this.wantsMainThreadCallback = false;
173 | 		try {
174 | 			this.clapPlugin.plugin.on_main_thread();
175 | 		} catch (e) {
176 | 			this.failWithError(e);
177 | 		}
178 | 	}
179 | 	
180 | 	pendingEvents = [];
181 | 	makeHostMethods() {
182 | 		return {
183 | 			input_events_size: () => this.pendingEvents.length,
184 | 			input_events_get: i => this.pendingEvents[i],
185 | 			output_events_try_push: ptr => false,
186 | 
187 | 			request_restart() {throw Error("not implemented");},
188 | 			request_process() {throw Error("not implemented");},
189 | 			request_callback: () => {
190 | 				this.wantsMainThreadCallback = true;
191 | 			},
192 | 
193 | 			istream_read: (voidPointer, length) => {
194 | 				length = Number(length);
195 | 				let streamInput = this.streamInput;
196 | 				if (!streamInput) throw Error("set .clapStreamInput={pointer:..., length: ...} before passing an istream");
197 | 				let bytes = Math.min(length, streamInput.length);
198 | 				if (bytes > 0) {
199 | 					let tmpBlock = this.clapPlugin.api.asTyped(Uint8Array, streamInput.pointer, bytes);
200 | 					let readBlock = this.clapPlugin.api.asTyped(Uint8Array, voidPointer, bytes);
201 | 					readBlock.set(tmpBlock);
202 | 					streamInput.pointer += bytes;
203 | 					streamInput.length -= bytes;
204 | 				}
205 | 				return BigInt(bytes);
206 | 			},
207 | 			ostream_write: (voidPointer, length) => {
208 | 				length = Number(length);
209 | 				let streamOutput = this.streamOutput;
210 | 				let bytes = Math.min(length, streamOutput.buffer.length - streamOutput.index);
211 | 				if (bytes > 0) {
212 | 					let writeBlock = this.clapPlugin.api.asTyped(Uint8Array, voidPointer, bytes);
213 | 					let bufferBlock = streamOutput.buffer.subarray(streamOutput.index, bytes);
214 | 					bufferBlock.set(writeBlock);
215 | 					streamOutput.index += bytes;
216 | 					streamOutput.result = streamOutput.buffer.subarray(0, streamOutput.index);
217 | 				}
218 | 				if (!bytes && length > 0) return -1n; // error (we ran out of space);
219 | 				return BigInt(bytes);
220 | 			},
221 | 			
222 | 			ext_params_rescan: flags => {
223 | 				this.port.postMessage(['params_rescan', flags]);
224 | 			},
225 | 
226 | 			ext_webview_is_open: () => this.webviewIsOpen,
227 | 			// plugin sent to us
228 | 			ext_webview_send: (ptr, length) => {
229 | 				if (!this.webIsOpen) return false;
230 | 				let message8 = this.clapPlugin.api.asTyped(Uint8Array, ptr, length);
231 | 				let message = message8.slice().buffer;
232 | 				this.port.postMessage(message, [message]); // copy the buffer, and transfer ownership of the copy
233 | 			},
234 | 			// Older draft version, for compatibility
235 | 			ext_web_is_open: () => this.webviewIsOpen,
236 | 			// plugin sent to us
237 | 			ext_web_send: (ptr, length) => {
238 | 				if (!this.webIsOpen) return false;
239 | 				let message8 = this.clapPlugin.api.asTyped(Uint8Array, ptr, length);
240 | 				let message = message8.slice().buffer;
241 | 				this.port.postMessage(message, [message]); // copy the buffer, and transfer ownership of the copy
242 | 			},
243 | 
244 | 			ext_state_mark_dirty: () => {
245 | 				this.port.postMessage(['state_mark_dirty', null]);
246 | 			}
247 | 		};
248 | 	};
249 | 	
250 | 	remoteMethods = {
251 | 		saveState() {
252 | 			let plugin = this.clapPlugin;
253 | 			let state = plugin.ext['clap.state'];
254 | 			if (!state) throw Error("plugin doesn't support clap.state");
255 | 			this.streamOutput.clear();
256 | 			if (!state.save(plugin.hostPointers.ostream)) {
257 | 				throw Error("state.save() returned false");
258 | 			}
259 | 			let stateArray = this.streamOutput.result.slice(); // TODO: transfer ownership, to avoid allocation/GC from this
260 | 			return stateArray.buffer;
261 | 		},
262 | 		loadState(stateArray) {
263 | 			stateArray = new Uint8Array(ArrayBuffer.isView(stateArray) ? stateArray.buffer : stateArray);
264 | 
265 | 			let plugin = this.clapPlugin;
266 | 			let state = plugin.ext['clap.state'];
267 | 			if (!state) throw Error("plugin doesn't support clap.state");
268 | 			
269 | 			let tmpArr = plugin.api.tempTyped(Uint8Array, stateArray.length);
270 | 			tmpArr.set(stateArray);
271 | 			this.streamInput = {pointer: tmpArr.byteOffset, length: stateArray.length};
272 | 			
273 | 			if (!state.load(plugin.hostPointers.istream)) {
274 | 				throw Error("state.load() returned false");
275 | 			}
276 | 			return true;
277 | 		},
278 | 		setParam(id, value) {
279 | 			let plugin = this.clapPlugin;
280 | 			let params = plugin.ext['clap.params'];
281 | 			if (!params) throw Error("clap.params not supported");
282 | 			
283 | 			let eventPtr = plugin.api.temp(plugin.api.clap_event_param_value, {
284 | 				header: {
285 | 					size: plugin.api.sizeof(plugin.api.clap_event_param_value),
286 | 					time: 0,
287 | 					space_id: 0, // CLAP_CORE_EVENT_SPACE_ID
288 | 					type: plugin.api.CLAP_EVENT_PARAM_VALUE,
289 | 					flags: 0
290 | 				},
291 | 				param_id: id,
292 | 				cookie: 0,
293 | 				note_id: -1,
294 | 				port_index: -1,
295 | 				channel: -1,
296 | 				key: -1,
297 | 				
298 | 				value: value
299 | 			});
300 | 			this.pendingEvents = [eventPtr];
301 | 			// Single-threaded, so no reason not to immediately flush
302 | 			params.flush(plugin.hostPointers.input_events, plugin.hostPointers.output_events);
303 | 			this.pendingEvents = [];
304 | 			
305 | 			return this.remoteMethods.getParam.call(this, id);
306 | 		},
307 | 		getParam(id) {
308 | 			let plugin = this.clapPlugin;
309 | 			let params = plugin.ext['clap.params'];
310 | 			if (!params) throw Error("clap.params not supported");
311 | 			
312 | 			let valuePtr = plugin.api.tempBytes(8, 8);
313 | 			params.get_value(id, valuePtr);
314 | 			let value = plugin.api.f64(valuePtr);
315 | 		
316 | 			let textBuffer = plugin.api.temp(plugin.api.clap_name, "?");
317 | 			let text = value + "";
318 | 			if (params.value_to_text(id, value, textBuffer, plugin.api.CLAP_NAME_SIZE)) {
319 | 				text = plugin.api.clap_name(textBuffer);
320 | 			}
321 | 			return {value: value, text: text};
322 | 		},
323 | 		getParams() {
324 | 			let plugin = this.clapPlugin;
325 | 			let params = plugin.ext['clap.params'];
326 | 			if (!params) {
327 | 				console.error("clap.params not supported");
328 | 				return [];
329 | 			}
330 | 
331 | 			let paramInfo = [];
332 | 			for (let i = 0; i < params.count(); ++i) {
333 | 				let infoPtr = plugin.api.temp(plugin.api.clap_param_info, {});
334 | 				params.get_info(i, infoPtr);
335 | 				let info = plugin.api.clap_param_info(infoPtr);
336 | 				let flags = {
337 | 					stepped: !!(info.flags&1),
338 | 					periodic: !!(info.flags&2),
339 | 					hidden: !!(info.flags&4),
340 | 					readonly: !!(info.flags&8),
341 | 					bypass: !!(info.flags&16),
342 | 					automatable: (info.flags&32) ? {
343 | 						note: !!(info.flags&64),
344 | 						key: !!(info.flags&128),
345 | 						channel: !!(info.flags&256),
346 | 						port: !!(info.flags&512)
347 | 					} : false,
348 | 					modulatable: (info.flags&1024) ? {
349 | 						note: !!(info.flags&2048),
350 | 						key: !!(info.flags&4096),
351 | 						channel: !!(info.flags&8192),
352 | 						port: !!(info.flags&16384)
353 | 					} : false,
354 | 					requiresProcess: !!(info.flags&32768),
355 | 					isEnum: !!(info.flags&(65536))
356 | 				};
357 | 				info.flags = flags;
358 | 				info.value = this.remoteMethods.getParam.call(this, info.id);
359 | 				paramInfo.push(info);
360 | 			}
361 | 			return paramInfo;
362 | 		},
363 | 		webviewOpen(isOpen, isShowing) {
364 | 			console.log('isShowing should go through the clap.gui extension');
365 | 			return this.webIsOpen = isOpen;
366 | 		},
367 | 		performance() {
368 | 			return {js: this.#averageJsMs, wasm: this.#averageWasmMs};
369 | 		}
370 | 	};
371 | 
372 | 	clapActivate() {
373 | 		if (this.fatalError) return;
374 | 		
375 | 		let {api, plugin} = this.clapPlugin;
376 | 		if (!plugin.activate(sampleRate, 1, this.maxFramesCount)) {
377 | 			console.error("plugin.activate() failed");
378 | 			this.clapPlugin.unbind(); // disconnects and cleans up
379 | 			this.clapPlugin = null;
380 | 		}
381 | 		if (!plugin.start_processing()) {
382 | 			plugin.deactivate();
383 | 			console.error("plugin.start_processing() failed");
384 | 			this.clapPlugin.unbind(); // disconnects and cleans up
385 | 			this.clapPlugin = null;
386 | 		}
387 | 	}
388 | 	
389 | 	clapUpdateAudioPorts() {
390 | 		if (this.fatalError) return;
391 | 
392 | 		let {api, plugin} = this.clapPlugin;
393 | 		this.audioPortsIn = [];
394 | 		this.audioPortsOut = [];
395 | 		let audioPortsExt = this.clapPlugin.ext['clap.audio-ports'];
396 | 		if (audioPortsExt) {
397 | 			for (let isInput = 0; isInput < 2; ++isInput) {
398 | 				let list = (isInput ? this.audioPortsOut : this.audioPortsIn);
399 | 				let count = audioPortsExt.count(isInput);
400 | 				for (let i = 0; i < count; ++i) {
401 | 					let portPtr = api.temp(api.clap_audio_port_info, {});
402 | 					audioPortsExt.get(i, isInput, portPtr);
403 | 					let port = api.clap_audio_port_info(portPtr);
404 | 					list.push(port);
405 | 				}
406 | 			}
407 | 		}
408 | 	}
409 | 	
410 | 	#averageJsMs = 0;
411 | 	#averageWasmMs = 0;
412 | 	
413 | 	process(inputs, outputs, parameters) {
414 | 		if (this.fatalError) return false;
415 | 		let jsStartTime = Date.now();
416 | 		if (!this.clapPlugin) return true; // outputs are pre-filled with silence
417 | 		let {api, plugin} = this.clapPlugin;
418 | 
419 | 		let blockLength = (outputs[0] || inputs[0])[0].length;
420 | 
421 | 		/*
422 | 		if (inputs.length != this.audioPortsIn.length) {
423 | 			throw Error("input audio-port mismatch");
424 | 		}
425 | 		if (outputs.length != this.audioPortsOut.length) {
426 | 			throw Error("output audio-port mismatch");
427 | 		}
428 | 		*/
429 | 
430 | 		let audioBuffersInput = this.audioPortsIn.map((audioPortIn, portIndex) => {
431 | 			let input = inputs[portIndex];
432 | 			
433 | 			// Sometimes if an input is stopped (or we're missing a port!), it gives us 0 input channels, so we have to make up our own
434 | 			if (!input?.length) {
435 | 				input = [];
436 | 				// use some host space to make a fake buffer without allocating
437 | 				let fakeInput = api.tempTyped(Float32Array, blockLength);
438 | 				fakeInput.fill(0);
439 | 				for (let i = 0; i < audioPortIn.channel_count; ++i) {
440 | 					input.push(fakeInput);
441 | 				}
442 | 			}
443 | 			
444 | 			// Use host memory for audio buffers
445 | 			let inputBufferPointers = api.tempTyped(api.pointer, audioPortIn.channel_count);
446 | 			let inputBufferBlock = api.tempTyped(Float32Array, blockLength*audioPortIn.channel_count);
447 | 			for (let index = 0; index < audioPortIn.channel_count; ++index) {
448 | 				let channel = input[index%input.length];
449 | 				let bufferPtr = inputBufferBlock.byteOffset + blockLength*index*4;
450 | 				inputBufferPointers[index] = bufferPtr;
451 | 
452 | 				let array = inputBufferBlock.subarray(blockLength*index, blockLength*(index + 1));
453 | 				array.set(channel);
454 | 			}
455 | 			
456 | 			return {
457 | 				data32: inputBufferPointers,
458 | 				data64: 0,
459 | 				channel_count: audioPortIn.channel_count,
460 | 				latency: 0,
461 | 				constant_mask: 0n // BigInt
462 | 			};
463 | 		});
464 | 
465 | 		let allOutputPointers = [];
466 | 		let audioBuffersOutput = this.audioPortsOut.map((audioPortOut, portIndex) => {
467 | 			let outputBufferPointers = api.tempTyped(api.pointer, audioPortOut.channel_count);
468 | 			let outputBufferBlock = api.tempTyped(Float32Array, blockLength*audioPortOut.channel_count);
469 | 			outputBufferBlock.fill(0.2); // not terrible, but deliberately not correct (for debugging)
470 | 			for (let index = 0; index < audioPortOut.channel_count; ++index) {
471 | 				let bufferPtr = outputBufferBlock.byteOffset + blockLength*index*4;
472 | 				outputBufferPointers[index] = bufferPtr;
473 | 				outputBufferBlock[index*blockLength] = 0.1; // bzzzzz
474 | 			}
475 | 			allOutputPointers.push(outputBufferPointers.slice(0));
476 | 			
477 | 			return {
478 | 				data32: outputBufferPointers,
479 | 				data64: 0,
480 | 				channel_count: audioPortOut.channel_count,
481 | 				latency: 0,
482 | 				constant_mask: 0n // BigInt
483 | 			};
484 | 		});
485 | 
486 | 		// This writes them contiguously, so the first pointer can act as an array
487 | 		let audioInputPtrs = audioBuffersInput.map(b => api.temp(api.clap_audio_buffer, b));
488 | 		let audioOutputPtr = audioBuffersOutput.map(b => api.temp(api.clap_audio_buffer, b));
489 | 		
490 | 		// Write the audio buffers to the temporary scratch space
491 | 		let processPtr = api.temp(api.clap_process, {
492 | 			steady_time: -1n,
493 | 			frames_count: blockLength,
494 | 			transport: 0, //null
495 | 			audio_inputs: audioInputPtrs[0],
496 | 			audio_outputs: audioOutputPtr[0],
497 | 			audio_inputs_count: this.audioPortsIn.length,
498 | 			audio_outputs_count: this.audioPortsOut.length,
499 | 			in_events: this.clapPlugin.hostPointers.input_events,
500 | 			out_events: this.clapPlugin.hostPointers.output_events
501 | 		});
502 | 		
503 | 		let wasmStartTime, wasmEndTime;
504 | 		let status;
505 | 		try {
506 | 			wasmStartTime = Date.now();
507 | 			status = plugin.process(processPtr);
508 | 			this.mainThreadCallbackIfNeeded();
509 | 			wasmEndTime = Date.now();
510 | 		} catch (e) {
511 | 			this.failWithError(e);
512 | 			return false;
513 | 		}
514 | 		if (status == api.CLAP_PROCESS_ERROR) {
515 | 			console.error("CLAP_PROCESS_ERROR");
516 | 			return false;
517 | 		}
518 | 		
519 | 		// Read audio buffers out again
520 | 		outputs.forEach((output, portIndex) => {
521 | 			let audioPort = this.audioPortsOut[portIndex];
522 | 			if (!audioPort) return;
523 | 			let outputPointers = allOutputPointers[portIndex];
524 | 			output.forEach((channel, index) => {
525 | 				index = index%audioPort.channel_count;
526 | 				let array = api.asTyped(Float32Array, outputPointers[index], blockLength);
527 | 				channel.set(array);
528 | 			});
529 | 		});
530 | 
531 | 		let jsEndTime = Date.now();
532 | 		this.#averageJsMs += (jsEndTime - jsStartTime - this.#averageJsMs)*0.01;
533 | 		this.#averageWasmMs += (wasmEndTime - wasmStartTime - this.#averageWasmMs)*0.01;
534 | 
535 | 		if (status === api.CLAP_PROCESS_SLEEP) {
536 | 			return inputs.some(input => input.length); // continue only if there's more input
537 | 		}
538 | 		if (status === api.CLAP_PROCESS_TAIL) {
539 | 			console.log("CLAP_PROCESS_TAIL not supported")
540 | 			return inputs.some(input => input.length);
541 | 		}
542 | 		if (status === api.CLAP_PROCESS_CONTINUE_IF_NOT_QUIET) {
543 | 			let energy = 0;
544 | 			outputs.forEach(output => {
545 | 				output.forEach(channel => {
546 | 					channel.forEach(x => energy += x*x);
547 | 				});
548 | 			});
549 | 			return (energy >= 1e-6);
550 | 		}
551 | 		return true;
552 | 	}
553 | }
554 | 
555 | registerProcessor('audioworkletprocessor-clap', AudioWorkletProcessorClap);
556 | 


--------------------------------------------------------------------------------
/clap-host/clap-interface.mjs:
--------------------------------------------------------------------------------
  1 | /** Returns a low-level interface to a CLAP WebAssembly instance.
  2 | 
  3 | A section of memory is allocated up-front for host use.  If we overflow this, we fail and the instance is not recoverable.
  4 | 
  5 | The following properties are provided:
  6 | 	* `.clap_entry`: the entry point
  7 | 	* `.save(type, value)`: permanently writes a value to the host memory, returning a pointer to it
  8 | 	
  9 | Everything else is a type, provided as a function: `(pointer, ?bind) => ` dereferenced/parsed value.  All pointers are untyped, so you need to dereference them using the correct type.  The `bind` argument is only used for `struct`s, where any functions are bound as methods (passing the `struct` pointer as the first argument).
 10 | 
 11 | Numeric types (and pointers) are mapped to JS numbers, `const char *` to JS strings, structs to JS objects, functions to callable JS functions.
 12 | 
 13 | For dynamically-sized arrays, CLAP points to an array of pointers, terminated by a null pointer.  We create these types using `pointerArray()`, but really it's only ever used with pointers or strings (which is a pointer in C, but we interpret differently).
 14 | 
 15 | Internally, each type has methods:
 16 | 	* `m_read(address, bind)`: same as the main type function
 17 | 	* `m_writeArg(value)`: write any supporting data to scratch memory, returns a value which a WebAssembly function can accept
 18 | 	* `m_write(value)`: write the value to scratch memory (after any supporting data)
 19 | */
 20 | export default function clapInterface(instance, hostMemorySize=1024*1024, logFn=null) {
 21 | 	let fullTypeKey = Symbol();
 22 | 	let memory = instance.exports.memory;
 23 | 	let functionTable = null;
 24 | 	if (!functionTable) {
 25 | 		for (let key in instance.exports) {
 26 | 			if (instance.exports[key] instanceof WebAssembly.Table) {
 27 | 				if (functionTable) throw Error("multiple function tables");
 28 | 				functionTable = instance.exports[key];
 29 | 			}
 30 | 		}
 31 | 	}
 32 | 	if (!functionTable) throw Error("no function table found");
 33 | 	
 34 | 	function importFunctions(wasmFunctions) {
 35 | 		let keys = Object.keys(wasmFunctions);
 36 | 		let fnOffset = functionTable.grow(keys.length);
 37 | 		let fnPointers = Object.create(null);
 38 | 		keys.forEach((key, i) => {
 39 | 			functionTable.set(fnOffset + i, wasmFunctions[key]);
 40 | 			fnPointers[key] = fnOffset + i
 41 | 		});
 42 | 		return fnPointers;
 43 | 	}
 44 | 
 45 | 	// Reserve some memory for host use
 46 | 	let hostMemory = instance.exports.malloc(hostMemorySize);
 47 | 	let scratchMemory = hostMemory; // the end of any saved values
 48 | 	let scratchPointer, view;
 49 | 	let funcCallDepth = 0;
 50 | 	function resetView() {
 51 | 		view = new DataView(memory.buffer);
 52 | 	}
 53 | 	function resetScratch() {
 54 | 		scratchPointer = scratchMemory;
 55 | 	}
 56 | 	function overflowCheck() {
 57 | 		if (scratchPointer > hostMemory + hostMemorySize) {
 58 | 			throw Error(`Host memory exceeded (${scratchPointer - hostMemory}/${hostMemorySize})`);
 59 | 		}
 60 | 	}
 61 | 	resetScratch();
 62 | 	resetView();
 63 | 	// Permanently save a value to memory, returning the pointer
 64 | 	function writePersistent(type, value) {
 65 | 		if (funcCallDepth) throw Error("writePersistent() from within plugin call");
 66 | 		resetScratch();
 67 | 		while (scratchPointer%type.m_alignment) ++scratchPointer;
 68 | 
 69 | 		type.m_write(value); // writes to the start of the scratch area
 70 | 		overflowCheck();
 71 | 		scratchMemory = scratchPointer; // move the scratch boundary
 72 | 		return scratchPointer - type.m_bytes;
 73 | 	}
 74 | 	// Temporarily write a value - it will still be valid after a *single* native call
 75 | 	function writeTemporary(type, value) {
 76 | 		while (scratchPointer%type.m_alignment) ++scratchPointer;
 77 | 
 78 | 		type.m_write(value); // writes to the start of the scratch area
 79 | 		overflowCheck();
 80 | 		return scratchPointer - type.m_bytes;
 81 | 	}
 82 | 	function reserveTemporary(bytes, alignment) {
 83 | 		alignment = alignment || 1;
 84 | 		while (scratchPointer%alignment) ++scratchPointer;
 85 | 		let pointer = scratchPointer;
 86 | 		scratchPointer += bytes;
 87 | 		return pointer;
 88 | 	}
 89 | 	
 90 | 	// Fixed types
 91 | 	function numberType(bytes, getter, setter, TypedArray) {
 92 | 		return {
 93 | 			m_canBeArg: true,
 94 | 			m_TypedArray: TypedArray,
 95 | 			m_alignment: bytes,
 96 | 			m_bytes: bytes,
 97 | 			m_read(address) {
 98 | 				if (address%bytes) throw Error("alignment");
 99 | 				return view[getter](address, true);
100 | 			},
101 | 			m_write(value) {
102 | 				if (scratchPointer%bytes) throw Error("alignment");
103 | 				view[setter](scratchPointer, value, true);
104 | 				scratchPointer += bytes;
105 | 			},
106 | 			m_writeArg(value) {
107 | 				return value;
108 | 			}
109 | 		}
110 | 	};
111 | 	const u8 = numberType(1, 'getUint8', 'setUint8', Uint8Array);
112 | 	const i8 = numberType(1, 'getInt8', 'setInt8', Int8Array);
113 | 	const u16 = numberType(2, 'getUint16', 'setUint16', Uint16Array);
114 | 	const i16 = numberType(2, 'getInt16', 'setInt16', Int16Array);
115 | 	const u32 = numberType(4, 'getUint32', 'setUint32', Uint32Array);
116 | 	const i32 = numberType(4, 'getInt32', 'setInt32', Int32Array);
117 | 	const u64 = numberType(8, 'getBigUint64', 'setBigUint64', BigUint64Array);
118 | 	const i64 = numberType(8, 'getBigInt64', 'setBigInt64', BigInt64Array);
119 | 	const f32 = numberType(4, 'getFloat32', 'setFloat32', Float32Array);
120 | 	const f64 = numberType(8, 'getFloat64', 'setFloat64', Float64Array);
121 | 	// wasm32
122 | 	const size = u32;
123 | 	const pointer = {
124 | 		m_canBeArg: true,
125 | 		m_TypedArray: Uint32Array,
126 | 		m_alignment: 4,
127 | 		m_bytes: 4,
128 | 		m_read(address) {
129 | 			if (address%4) throw Error("alignment");
130 | 			return view.getUint32(address, true);
131 | 		},
132 | 		m_write(value) {
133 | 			if (scratchPointer%4) throw Error("alignment");
134 | 			if (ArrayBuffer.isView(value)) value = value.byteOffset;
135 | 			view.setUint32(scratchPointer, value, true);
136 | 			scratchPointer += 4;
137 | 		},
138 | 		m_writeArg(value) {
139 | 			if (ArrayBuffer.isView(value)) value = value.byteOffset;
140 | 			return value;
141 | 		}
142 | 	};
143 | 	
144 | 	function fixedChars(bytes, isString) {
145 | 		return {
146 | 			m_alignment: 1,
147 | 			m_bytes: bytes,
148 | 			m_read(address) {
149 | 				if (isString) {
150 | 					return string.m_readArg(address);
151 | 				}
152 | 				let array = new Uint8Array(bytes);
153 | 				for (let i = 0; i < bytes; ++i) {
154 | 					array[i] = view.getUint8(address + i);
155 | 				}
156 | 				array.toString = () => {
157 | 					let result = "";
158 | 					for (let i = 0; i < bytes; ++i) {
159 | 						let c = array[i];
160 | 						if (!c) break;
161 | 						result += String.fromCharCode(c);
162 | 					}
163 | 					return result;
164 | 				};
165 | 				return array;
166 | 			},
167 | 			m_write(value) {
168 | 				if (typeof value === 'string') {
169 | 					for (let i = 0; i < bytes && i < value.length; ++i) {
170 | 						view.setUint8(scratchPointer + i, value.charCodeAt(i));
171 | 					}
172 | 					// Fill the rest with 0
173 | 					for (let i = value.length; i < bytes; ++i) view.setUint8(scratchPointer + i, 0);
174 | 				} else if (value && typeof value === 'object') {
175 | 					for (let i = 0; i < bytes; ++i) {
176 | 						view.setUint8(scratchPointer + i, value[i]);
177 | 					}
178 | 				} else {
179 | 					value = value || 0;
180 | 					for (let i = 0; i < bytes; ++i) {
181 | 						view.setUint8(scratchPointer + i);
182 | 					}
183 | 				}
184 | 				scratchPointer += bytes;
185 | 			},
186 | 			m_writeArg(value) {
187 | 				return value;
188 | 			}
189 | 		};
190 | 	}
191 | 	
192 | 	const string = {
193 | 		m_canBeArg: true,
194 | 		m_alignment: pointer.m_alignment,
195 | 		m_bytes: pointer.m_bytes,
196 | 		m_readArg(cPointer) {
197 | 			let result = "";
198 | 			while (1) {
199 | 				let code = view.getUint8(cPointer);
200 | 				if (code == 0) break;
201 | 				result += String.fromCharCode(code);
202 | 				++cPointer;
203 | 			}
204 | 			return result;
205 | 		},
206 | 		m_read(address) {
207 | 			return string.m_readArg(pointer.m_read(address));
208 | 		},
209 | 		m_write(value) {
210 | 			value = string.m_writeArg(value);
211 | 			pointer.m_write(value);
212 | 		},
213 | 		m_writeArg(value) {
214 | 			if (typeof value !== 'string') return value;
215 | 
216 | 			let startPtr = scratchPointer;
217 | 			for (let i = 0; i < value.length; ++i) {
218 | 				view.setUint8(scratchPointer, value.charCodeAt(i)); // TODO: proper UTF-8 encoding
219 | 				++scratchPointer;
220 | 			}
221 | 			view.setUint8(scratchPointer, 0); // null terminator
222 | 			++scratchPointer;
223 | 			return startPtr;
224 | 		}
225 | 	};
226 | 	// An array of pointers (or things the same size as pointers)
227 | 	function pointerArray(itemType) {
228 | 		itemType = itemType || pointer;
229 | 		let type = {
230 | 			m_alignment: pointer.m_alignment,
231 | 			m_bytes: pointer.m_bytes,
232 | 			m_readArg(itemPointer, bind) {
233 | 				let result = [];
234 | 				while (1) {
235 | 					let itemAsPointer = pointer.m_read(itemPointer);
236 | 					if (itemAsPointer == 0) break; // null pointer
237 | 					result.push(itemType.m_read(itemPointer, bind)); // we don't necessarily parse it as a pointer though
238 | 					itemPointer += pointer.m_bytes;
239 | 				}
240 | 				return result;
241 | 			},
242 | 			m_read(address, bind) {
243 | 				return type.m_readArg(pointer.m_read(address), bind);
244 | 			},
245 | 			m_write(obj) {
246 | 				throw Error("Can arrays be arguments?");
247 | 			},
248 | 			m_writeArg(obj) {
249 | 				throw Error("Can arrays be arguments?");
250 | 			}
251 | 		};
252 | 		return type;
253 | 	};
254 | 	function struct(...members) {
255 | 		let alignment = 1;
256 | 		let bytes = 0;
257 | 		members = members.map(entry => {
258 | 			for (let key in entry) {
259 | 				let type = privateType(entry[key]);
260 | 				// pad to alignment
261 | 				while (bytes%type.m_alignment) ++bytes;
262 | 				let offset = bytes;
263 | 				bytes += type.m_bytes;
264 | 				alignment = Math.max(alignment, type.m_alignment);
265 | 				return {
266 | 					m_key: key,
267 | 					m_offset: offset,
268 | 					m_type: type
269 | 				};
270 | 			}
271 | 		});
272 | 		let type = {
273 | 			m_alignment: alignment,
274 | 			m_bytes: bytes,
275 | 			m_readArg() {
276 | 				throw Error("can't readArg() a struct - it would have to be an object, but we don't get those from WASM");
277 | 			},
278 | 			m_read(address, bind) {
279 | 				let bindValue = (typeof bind === 'boolean') ? address : bind;
280 | 				let obj = {};
281 | 				members.forEach(entry => {
282 | 					let type = entry.m_type;
283 | 					let value = type.m_read(address + entry.m_offset);
284 | 					if (bind && typeof value === 'function') {
285 | 						value = value.bind(null, bindValue);
286 | 					}
287 | 					obj[entry.m_key] = value;
288 | 				});
289 | 				return obj;
290 | 			},
291 | 			m_write(obj) {
292 | 				// write any supporting data
293 | 				obj = type.m_writeArg(obj);
294 | 				// write the actual struct
295 | 				while (scratchPointer%alignment) ++scratchPointer;
296 | 				let address = scratchPointer;
297 | 				members.forEach((entry, i) => {
298 | 					scratchPointer = address + entry.m_offset;
299 | 					let type = entry.m_type, key = entry.m_key;
300 | 					type.m_write(obj[key]);
301 | 				});
302 | 			},
303 | 			m_writeArg(obj) {
304 | 				let newObj = {};
305 | 				members.forEach(entry => {
306 | 					let type = entry.m_type, key = entry.m_key;
307 | 					newObj[key] = type.m_writeArg(obj[key]);
308 | 				});
309 | 				return newObj;
310 | 			},
311 | 		};
312 | 		return publicType(type);
313 | 	}
314 | 	// A function signature (arguments only), used like: sig(fnAddr, 5, ptr, "foo")
315 | 	// The value is a callable function, which uses scratch memory for arguments if needed
316 | 	function func(...argTypes) {
317 | 		argTypes = argTypes.map(privateType);
318 | 		argTypes.forEach(type => {
319 | 			if (!type.m_canBeArg) throw Error("func() should only take numbers/strings/pointers");
320 | 		});
321 | 		let type = {
322 | 			m_bytes: pointer.m_bytes,
323 | 			m_alignment: pointer.m_alignment,
324 | 			m_readArg(fnPointer) {
325 | 				let wasmFn = functionTable.get(fnPointer);
326 | 				if (!wasmFn) return null; // functions can be null
327 | 				return (...args) => {
328 | 					++funcCallDepth;
329 | 					args = args.map((value, i) => {
330 | 						return argTypes[i].m_writeArg(value);
331 | 					});
332 | 					overflowCheck();
333 | 					let result = wasmFn(...args);
334 | 					resetView(); // any WASM call might've grown the memory
335 | 					if (--funcCallDepth == 0) resetScratch(); // we don't erase the data, but we reset the pointer, so we'll overwrite it on .save() or the next function call
336 | 					return result;
337 | 				};
338 | 			},
339 | 			m_read(address) {
340 | 				return type.m_readArg(pointer.m_read(address));
341 | 			},
342 | 			m_write(value) {
343 | 				if (typeof value === 'undefined') throw Error("missing function value - use null if deliberate");
344 | 				// If we're writing (e.g. to the host struct), it must be a function pointer
345 | 				return pointer.m_write(value);
346 | 			},
347 | 			m_writeArg(value) {
348 | 				return value;
349 | 			}
350 | 		};
351 | 		return publicType(type);
352 | 	}
353 | 	
354 | 	// Initial types
355 | 	let clap_version = struct(
356 | 		{major: u32},
357 | 		{minor: u32},
358 | 		{patch: u32}
359 | 	);
360 | 	let clap_plugin_entry = struct(
361 | 		{clap_version: clap_version},
362 | 		{init: func(string)},
363 | 		{deinit: func()},
364 | 		{get_factory: func(string)}
365 | 	);
366 | 
367 | 	// We expose a dereference method, but with the full type attached
368 | 	let api = {
369 | 		sizeof(type) {
370 | 			return privateType(type).m_bytes;
371 | 		},
372 | 		// returns the DataView to the memory, invalidated after any native method call
373 | 		dataView() {
374 | 			return view;
375 | 		},
376 | 		// returns the ArrayBuffer, invalidated after any native method call
377 | 		asTyped(TypedArray, start, length) {
378 | 			if (TypedArray[fullTypeKey]) { // actually one of our numerical types
379 | 				TypedArray = TypedArray[fullTypeKey].m_TypedArray;
380 | 			}
381 | 			let bpe = TypedArray.BYTES_PER_ELEMENT;
382 | 			if (!bpe) throw Error("not a TypedArray (or numeric type)");
383 | 			if (start%bpe) throw Error("start not aligned");
384 | 			return new TypedArray(memory.buffer, start, length);
385 | 		},
386 | 		memoryMaybeChanged: resetView,
387 | 
388 | 		log: logFn || console.log.bind(console),
389 | 		save(type, value) {
390 | 			return writePersistent(privateType(type), value);
391 | 		},
392 | 		// Writes a value to the scratch space, returning the pointer.  This can be used by the next native function call, and then remains valid until the next native function call OR call to temp()/tempBytes()
393 | 		temp(type, value) {
394 | 			return writeTemporary(privateType(type), value);
395 | 		},
396 | 		tempBytes: reserveTemporary,
397 | 		tempTyped(TypedArray, length) {
398 | 			if (TypedArray[fullTypeKey]) { // actually one of our numerical types
399 | 				TypedArray = TypedArray[fullTypeKey].m_TypedArray;
400 | 			}
401 | 			let bpe = TypedArray.BYTES_PER_ELEMENT;
402 | 			let ptr = reserveTemporary(length*bpe, bpe);
403 | 			return api.asTyped(TypedArray, ptr, length);
404 | 		},
405 | 		
406 | 		// Interprets a value (not a pointer!) as passed to an imported function
407 | 		fromArg(type, value) {
408 | 			return type[fullTypeKey].m_readArg(value);
409 | 		},
410 | 		// imports functions from another WASM module, returns their indices
411 | 		// Takes a map {name: [wasmFn], ...}, returns {name: fnIndex}
412 | 		importFunctions: importFunctions,
413 | 
414 | 		// For defining new types
415 | 		makeStruct: struct,
416 | 		makeFunc: func,
417 | 	};
418 | 
419 | 	function publicType(type) {
420 | 		if (type[fullTypeKey]) return type; // already the public version
421 | 		let read = type.m_read;
422 | 		read[fullTypeKey] = type;
423 | 		return read;
424 | 	}
425 | 	function privateType(type) {
426 | 		if (typeof type === 'string') {
427 | 			if (!(type in api)) throw Error("unknown type: " + type);
428 | 			type = api[type];
429 | 		}
430 | 		return type[fullTypeKey] || type;
431 | 	}
432 | 	function addType(name, type) {
433 | 		return api[name] = publicType(type);
434 | 	}
435 | 	function addTypes(obj, extra) {
436 | 		for (let key in obj) addType(key, obj[key]);
437 | 		if (extra) Object.assign(api, extra);
438 | 	}
439 | 
440 | 	addTypes({
441 | 		// numeric types
442 | 		bool: i32, // wasm32
443 | 		i8: i8,
444 | 		u8: u8,
445 | 		i16: i16,
446 | 		u16: u16,
447 | 		i32: i32,
448 | 		u32: u32,
449 | 		i64: i64,
450 | 		u64: u64,
451 | 		f32: f32,
452 | 		f64, f64,
453 | 		size: size,
454 | 		pointer: pointer,
455 | 		string: string,
456 | 
457 | 		// We already defined these above
458 | 		clap_version: clap_version,
459 | 		clap_plugin_entry: clap_plugin_entry,
460 | 	});
461 | 	// fixedpoint.h
462 | 	let clap_beattime = i64;
463 | 	let clap_sectime = i64;
464 | 	addTypes({
465 | 		clap_beattime: clap_beattime,
466 | 		clap_sectime: clap_sectime
467 | 	}, {
468 | 		CLAP_BEATTIME_FACTOR: 2147483648,
469 | 		CLAP_SECTIME_FACTOR: 2147483648,
470 | 	});
471 | 	// id.h
472 | 	let clap_id = u32;
473 | 	addTypes({
474 | 		clap_id: clap_id
475 | 	}, {
476 | 		CLAP_INVALID_ID: 0xFFFFFFFF
477 | 	});
478 | 	// events.h
479 | 	let clap_event_header = struct(
480 | 		{size: u32},
481 | 		{time: u32},
482 | 		{space_id: u16},
483 | 		{type: u16},
484 | 		{flags: u32}
485 | 	);
486 | 	let clap_note_expression = i32;
487 | 	addTypes({
488 | 		clap_event_header: clap_event_header,
489 | 		clap_event_note: struct(
490 | 			{header: clap_event_header},
491 | 			{note_id: i32},
492 | 			{port_index: i16},
493 | 			{channel: i16},
494 | 			{key: i16},
495 | 			{velocity: f64}
496 | 		),
497 | 		clap_event_note_expression: struct(
498 | 			{header: clap_event_header},
499 | 			{expression_id: clap_note_expression},
500 | 			{note_id: i32},
501 | 			{port_index: i16},
502 | 			{channel: i16},
503 | 			{key: i16},
504 | 			{value: f64}
505 | 		),
506 | 		clap_event_param_value: struct(
507 | 			{header: clap_event_header},
508 | 			{param_id: clap_id},
509 | 			{cookie: pointer},
510 | 			{note_id: i32},
511 | 			{port_index: i16},
512 | 			{channel: i16},
513 | 			{key: i16},
514 | 			{value: f64}
515 | 		),
516 | 		clap_event_param_mod: struct(
517 | 			{header: clap_event_header},
518 | 			{param_id: clap_id},
519 | 			{cookie: pointer},
520 | 			{note_id: i32},
521 | 			{port_index: i16},
522 | 			{channel: i16},
523 | 			{key: i16},
524 | 			{value: f64}
525 | 		),
526 | 		clap_event_param_gesture: struct(
527 | 			{header: clap_event_header},
528 | 			{param_id: clap_id},
529 | 		),
530 | 		clap_event_transport: struct(
531 | 			{header: clap_event_header},
532 | 			{flags: u32},
533 | 			{song_pos_beats: clap_beattime},
534 | 			{song_pos_seconds: clap_sectime},
535 | 			{tempo: f64},
536 | 			{tempo_inc: f64},
537 | 			{loop_start_beats: clap_beattime},
538 | 			{loop_end_beats: clap_beattime},
539 | 			{loop_start_seconds: clap_sectime},
540 | 			{loop_end_seconds: clap_sectime},
541 | 			{bar_start: clap_beattime},
542 | 			{bar_number: i32},
543 | 			{tsig_num: u16},
544 | 			{tsig_denom: u16},
545 | 		),
546 | 		clap_event_midi: struct(
547 | 			{header: clap_event_header},
548 | 			{port_index: u16},
549 | 			{data: fixedChars(3)}
550 | 		),
551 | 		clap_event_midi_sysex: struct(
552 | 			{header: clap_event_header},
553 | 			{port_index: u16},
554 | 			{buffer: pointer},
555 | 			{size: u32}
556 | 		),
557 | 		clap_event_midi2: struct(
558 | 			{header: clap_event_header},
559 | 			{port_index: u16},
560 | 			{data: fixedChars(4)}
561 | 		),
562 | 		clap_input_events: struct(
563 | 			{ctx: pointer},
564 | 			{size: func(pointer)},
565 | 			{'get': func(pointer, u32)}
566 | 		),
567 | 		clap_output_events: struct(
568 | 			{ctx: pointer},
569 | 			{try_push: func(pointer, pointer)}
570 | 		)
571 | 	}, {
572 | 		CLAP_CORE_EVENT_SPACE_ID: 0,
573 | 
574 | 		CLAP_EVENT_IS_LIVE: 1,
575 | 		CLAP_EVENT_DONT_RECORD: 1<<1,
576 | 
577 | 		CLAP_EVENT_NOTE_ON: 0,
578 | 		CLAP_EVENT_NOTE_OFF: 1,
579 | 		CLAP_EVENT_NOTE_CHOKE: 2,
580 | 		CLAP_EVENT_NOTE_END: 3,
581 | 		CLAP_EVENT_NOTE_EXPRESSION: 4,
582 | 		CLAP_EVENT_PARAM_VALUE: 5,
583 | 		CLAP_EVENT_PARAM_MOD: 6,
584 | 		CLAP_EVENT_PARAM_GESTURE_BEGIN: 7,
585 | 		CLAP_EVENT_PARAM_GESTURE_END: 8,
586 | 		CLAP_EVENT_TRANSPORT: 9,
587 | 		CLAP_EVENT_MIDI: 10,
588 | 		CLAP_EVENT_MIDI_SYSEX: 11,
589 | 		CLAP_EVENT_MIDI2: 12,
590 | 
591 | 		CLAP_NOTE_EXPRESSION_VOLUME: 0,
592 | 		CLAP_NOTE_EXPRESSION_PAN: 1,
593 | 		CLAP_NOTE_EXPRESSION_TUNING: 2,
594 | 		CLAP_NOTE_EXPRESSION_VIBRATO: 3,
595 | 		CLAP_NOTE_EXPRESSION_EXPRESSION: 4,
596 | 		CLAP_NOTE_EXPRESSION_BRIGHTNESS: 5,
597 | 		CLAP_NOTE_EXPRESSION_PRESSURE: 6,
598 | 
599 | 		CLAP_TRANSPORT_HAS_TEMPO: 1<< 0,
600 | 		CLAP_TRANSPORT_HAS_BEATS_TIMELINE: 1<<1,
601 | 		CLAP_TRANSPORT_HAS_SECONDS_TIMELINE: 1<<2,
602 | 		CLAP_TRANSPORT_HAS_TIME_SIGNATURE: 1<<3,
603 | 		CLAP_TRANSPORT_IS_PLAYING: 1<<4,
604 | 		CLAP_TRANSPORT_IS_RECORDING: 1<<5,
605 | 		CLAP_TRANSPORT_IS_LOOP_ACTIVE: 1<<6,
606 | 		CLAP_TRANSPORT_IS_WITHIN_PRE_ROLL: 1<<7,
607 | 	});
608 | 	// audio-buffer.h
609 | 	addTypes({
610 | 		clap_audio_buffer: struct(
611 | 			{data32: pointer},
612 | 			{data64: pointer},
613 | 			{channel_count: u32},
614 | 			{latency: u32},
615 | 			{constant_mask: u64}
616 | 		)
617 | 	});
618 | 	// process.h
619 | 	addTypes({
620 | 		clap_process_status: i32,
621 | 		clap_process: struct(
622 | 			{steady_time: i64},
623 | 			{frames_count: u32},
624 | 			{transport: pointer},
625 | 			{audio_inputs: pointer},
626 | 			{audio_outputs: pointer},
627 | 			{audio_inputs_count: u32},
628 | 			{audio_outputs_count: u32},
629 | 			{in_events: pointer},
630 | 			{out_events: pointer}
631 | 		)
632 | 	}, {
633 | 		CLAP_PROCESS_ERROR: 0,
634 | 		CLAP_PROCESS_CONTINUE: 1,
635 | 		CLAP_PROCESS_CONTINUE_IF_NOT_QUIET: 2,
636 | 		CLAP_PROCESS_TAIL: 3,
637 | 		CLAP_PROCESS_SLEEP: 4,
638 | 	});
639 | 	// plugin-features.h just has string constants which I don't think we need
640 | 	// plugin.h
641 | 	addTypes({
642 | 		clap_plugin_descriptor: struct(
643 | 			{clap_version: clap_version},
644 | 			{id: string},
645 | 			{name: string},
646 | 			{vendor: string},
647 | 			{url: string},
648 | 			{manual_url: string},
649 | 			{support_url: string},
650 | 			{version: string},
651 | 			{description: string},
652 | 			{features: pointerArray(string)}
653 | 		),
654 | 		clap_plugin: struct(
655 | 			{desc: pointer},
656 | 			{plugin_data: pointer},
657 | 			{init: func(pointer)},
658 | 			{destroy: func(pointer)},
659 | 			{activate: func(pointer, f64, u32, u32)},
660 | 			{deactivate: func(pointer)},
661 | 			{start_processing: func(pointer)},
662 | 			{stop_processing: func(pointer)},
663 | 			{reset: func(pointer)},
664 | 			{process: func(pointer, pointer)},
665 | 			{get_extension: func(pointer, string)},
666 | 			{on_main_thread: func(pointer)}
667 | 		)
668 | 	});
669 | 	// host.h
670 | 	addTypes({
671 | 		clap_host: struct(
672 | 			{clap_version: clap_version},
673 | 			{host_data: pointer},
674 | 			{name: string},
675 | 			{vendor: string},
676 | 			{url: string},
677 | 			{version: string},
678 | 			{get_extension: func(pointer, string)},
679 | 			{request_restart: func(pointer)},
680 | 			{request_process: func(pointer)},
681 | 			{request_callback: func(pointer)},
682 | 		)
683 | 	})
684 | 	// universal-plugin-id.h
685 | 	addTypes({
686 | 		clap_universal_plugin_id: struct(
687 | 			{abi: string},
688 | 			{id: string}
689 | 		)
690 | 	});
691 | 
692 | 	// factory/plugin-factory.h
693 | 	addTypes({
694 | 		clap_plugin_factory: struct(
695 | 			{get_plugin_count: func(pointer)},
696 | 			{get_plugin_descriptor: func(pointer, u32)},
697 | 			{create_plugin: func(pointer, pointer, string)}
698 | 		),
699 | 	}, {
700 | 		CLAP_PLUGIN_FACTORY_ID: "clap.plugin-factory"
701 | 	});
702 | 
703 | 	// color.h
704 | 	addTypes({
705 | 		clap_color: struct(
706 | 			{alpha: u8},
707 | 			{red: u8},
708 | 			{green: u8},
709 | 			{blue: u8}
710 | 		),
711 | 	});
712 | 
713 | 	// stream.h
714 | 	addTypes({
715 | 		clap_istream: struct(
716 | 			{ctx: pointer},
717 | 			{read: func(pointer, pointer, i64)}
718 | 		),
719 | 		clap_ostream: struct(
720 | 			{ctx: pointer},
721 | 			{write: func(pointer, pointer, i64)}
722 | 		),
723 | 	});
724 | 
725 | 	// string-sizes.h
726 | 	api.CLAP_NAME_SIZE = 256;
727 | 	api.CLAP_PATH_SIZE = 1024;
728 | 	// For convenience
729 | 	addTypes({
730 | 		clap_name: fixedChars(api.CLAP_NAME_SIZE, true),
731 | 		clap_path: fixedChars(api.CLAP_PATH_SIZE, true)
732 | 	});
733 | 
734 | 	// timestamp.h
735 | 	addTypes({
736 | 		clap_timestamp: u64,
737 | 	}, {
738 | 		CLAP_TIMESTAMP_UNKNOWN: 0
739 | 	});
740 | 	
741 | 	return api;
742 | }
743 | 


--------------------------------------------------------------------------------
/clap-host/clap-module.mjs:
--------------------------------------------------------------------------------
  1 | import instantiate from "./instantiate.mjs";
  2 | import clapInterface from"./clap-interface.mjs";
  3 | 
  4 | import HostedPlugin from "./hosted-plugin.mjs";
  5 | import "./ext/log.mjs";
  6 | import "./ext/state.mjs";
  7 | import "./ext/params.mjs";
  8 | import "./ext/audio-ports.mjs";
  9 | 
 10 | async function clapHostBinding(moduleInstance, api, factory) {
 11 | 	let hostModule = await HostedPlugin.methodProxyModule();
 12 | 
 13 | 	// A map from host memory addresses to HostedPlugin instances
 14 | 	let hostPointerMap = {};
 15 | 	// A map of (probably!) unbound hosts
 16 | 	let hostPool = {};
 17 | 
 18 | 	let hostMethodImports = {};
 19 | 	WebAssembly.Module.imports(hostModule).forEach(v => {
 20 | 		if (v.kind === 'function' && v.module === 'proxy') {
 21 | 			let key = v.name;
 22 | 			hostMethodImports[key] = (hostPointer, ...args) => {
 23 | 				api.memoryMaybeChanged(); // we've been called _from_ native code - it might've resized before this point
 24 | 				let entry = hostPointerMap[hostPointer];
 25 | 				if (!entry) throw Error("WASM->JS callback with unfamiliar pointer");
 26 | 				return entry.m_methods[key].call(entry.m_this, ...args);
 27 | 			};
 28 | 		}
 29 | 	});
 30 | 	
 31 | 	let instance = await WebAssembly.instantiate(hostModule, {
 32 | 		proxy: hostMethodImports
 33 | 	});
 34 | 	// get the function IDs from adding the proxied methods to the plugin's Table
 35 | 	let hostFunctions = api.importFunctions(instance.exports);
 36 | 	// add any extension types, and store any one-off (reusable by all instances) extension structs
 37 | 	let staticExtensionPointers = HostedPlugin.setupExtensions(api, hostFunctions);
 38 | 	
 39 | 	let hostBinding = {
 40 | 		m_staticExtensionPointers: staticExtensionPointers,
 41 | 		m_methods: hostFunctions,
 42 | 		m_register(hostPointer, methods, thisArg) {
 43 | 			hostPointerMap[hostPointer] = {m_methods:methods, m_this: thisArg};
 44 | 		},
 45 | 		m_addToPool(key, host) {
 46 | 			hostPool[key] = host;
 47 | 		},
 48 | 		m_removeFromPool(key) {
 49 | 			delete hostPool[key];
 50 | 		},
 51 | 		m_getBound(pluginId) {
 52 | 			let bindable, shouldBind = (pluginId !== null);
 53 | 			if (shouldBind) {
 54 | 				for (let key in hostPool) {
 55 | 					let b = hostPool[key];
 56 | 					delete hostPool[key];
 57 | 					if (!b.plugin) {
 58 | 						bindable = b;
 59 | 						break;
 60 | 					}
 61 | 				}
 62 | 			}
 63 | 			if (!bindable) bindable = new HostedPlugin(api, hostBinding, factory);
 64 | 			if (shouldBind) bindable.bind(pluginId);
 65 | 			return bindable;
 66 | 		}
 67 | 	};
 68 | 	return hostBinding;
 69 | }
 70 | 
 71 | async function clapModule(options) {
 72 | 	let url = options.url;
 73 | 	let instance = await instantiate(options);
 74 | 
 75 | 	if (!('clap_entry' in instance.exports)) throw Error('no clap_entry found');
 76 | 	if (typeof instance.exports.malloc !=='function') throw Error('no malloc() found');
 77 | 	
 78 | 	let hostMemorySize = options.hostMemorySize || 1024*1024;
 79 | 	let api = clapInterface(instance, hostMemorySize, options.log);
 80 | 
 81 | 	let entryPtr = instance.exports.clap_entry;
 82 | 	let entry = api.clap_plugin_entry(entryPtr);
 83 | 	if (!entry.init(url)) {
 84 | 		throw Error("clap_entry.init() failed");
 85 | 	}
 86 | 	
 87 | 	let factoryPtr = entry.get_factory("clap.plugin-factory");
 88 | 	if (!factoryPtr) throw Error("no clap.plugin-factory");
 89 | 	let factory = api.clap_plugin_factory(factoryPtr, true /*bind functions as methods*/);
 90 | 
 91 | 	let hostBindingPromise = clapHostBinding(instance, api, factory);
 92 | 	let pluginCount = factory.get_plugin_count();
 93 | 	let plugins = [];
 94 | 	for (let i = 0; i < pluginCount; ++i) {
 95 | 		let descriptorPtr = factory.get_plugin_descriptor(i);
 96 | 		let descriptor = api.clap_plugin_descriptor(descriptorPtr);
 97 | 		plugins.push(descriptor);
 98 | 	}
 99 | 	
100 | 	return {
101 | 		url: url,
102 | 		version: entry.clap_version,
103 | 		plugins: plugins,
104 | 		async create(pluginId) {
105 | 			return (await hostBindingPromise).m_getBound(pluginId);
106 | 		}
107 | 	};
108 | }
109 | 
110 | clapModule.addExtension = HostedPlugin.addExtension.bind(HostedPlugin);
111 | 
112 | export {clapModule as default};
113 | 


--------------------------------------------------------------------------------
/clap-host/ext/add-extension.mjs:
--------------------------------------------------------------------------------
1 | import HostedPlugin from "../hosted-plugin.mjs"
2 | 
3 | export default HostedPlugin.addExtension.bind(HostedPlugin);
4 | 


--------------------------------------------------------------------------------
/clap-host/ext/audio-ports.mjs:
--------------------------------------------------------------------------------
 1 | import addExtension from "./add-extension.mjs"
 2 | 
 3 | addExtension("clap.audio-ports", {
 4 | 	wasm: {
 5 | 		ext_audio_ports_is_rescan_flag_supported: 'bpi',
 6 | 		ext_audio_ports_rescan: 'vpi',
 7 | 	},
 8 | 	js: {
 9 | 		ext_audio_ports_is_rescan_flag_supported(flags) {
10 | 			return false;
11 | 		},
12 | 		ext_audio_ports_rescan(paramId, flags) {
13 | 			throw Error("not implemented");
14 | 		},
15 | 	},
16 | 	// Add any supporting types to the API, and (optionally) return a static pointer for the extension, so all host instances can re-use the same one.
17 | 	addTypes: (api, methods) => {
18 | 		let func = api.makeFunc;
19 | 		let clap_audio_port_info = api.clap_audio_port_info = api.makeStruct(
20 | 			{id: api.clap_id},
21 | 			{name: api.clap_name},
22 | 			{flags: api.u32},
23 | 			{channel_count: api.u32},
24 | 			{port_type: api.string},
25 | 			{in_place_pair: api.clap_id}
26 | 		);
27 | 		api.clap_plugin_audio_ports = api.makeStruct(
28 | 			{count: func('pointer', 'bool')},
29 | 			{get: func('pointer', 'u32', 'bool', 'pointer')}
30 | 		);
31 | 		api.clap_host_audio_ports = api.makeStruct(
32 | 			{is_rescan_flag_supported: func('pointer', 'u32')},
33 | 			{rescan: func('pointer', 'u32')}
34 | 		);
35 | 
36 | 		Object.assign(api, {
37 | 			CLAP_PORT_MONO: "mono",
38 | 			CLAP_PORT_STEREO: "stereo",
39 | 
40 | 			CLAP_AUDIO_PORT_IS_MAIN: 1<<0,
41 | 			CLAP_AUDIO_PORT_SUPPORTS_64BITS: 1<<1,
42 | 			CLAP_AUDIO_PORT_PREFERS_64BITS: 1<<2,
43 | 			CLAP_AUDIO_PORT_REQUIRES_COMMON_SAMPLE_SIZE: 1<<3,
44 | 
45 | 			CLAP_AUDIO_PORTS_RESCAN_NAMES: 1<<0,
46 | 			CLAP_AUDIO_PORTS_RESCAN_FLAGS: 1<<1,
47 | 			CLAP_AUDIO_PORTS_RESCAN_CHANNEL_COUNT: 1<<2,
48 | 			CLAP_AUDIO_PORTS_RESCAN_PORT_TYPE: 1<<3,
49 | 			CLAP_AUDIO_PORTS_RESCAN_IN_PLACE_PAIR: 1<<4,
50 | 			CLAP_AUDIO_PORTS_RESCAN_LIST: 1<<5,
51 |    		});
52 | 		
53 | 		return api.save(api.clap_host_audio_ports, {
54 | 			is_rescan_flag_supported: methods.ext_audio_ports_is_rescan_flag_supported,
55 | 			rescan: methods.ext_audio_ports_rescan,
56 | 		});
57 | 	},
58 | 	// Write the host struct, returning the pointer for `get_extension()`
59 | 	/*
60 | 	writeHost(api, methods) {
61 | 		return api.save(api.clap_host_log, {
62 | 			log: methods.ext_log_log // WASM function pointer which proxies to the JS version
63 | 		})
64 | 	},
65 | 	*/
66 | 	// Read the plugin struct (if the plugin supports it) - the result goes in ext['clap.log']
67 | 	readPlugin(api, pointer, pluginPtr) {
68 | 		return api.clap_plugin_audio_ports(pointer, pluginPtr);
69 | 	},
70 | });
71 | 


--------------------------------------------------------------------------------
/clap-host/ext/log.mjs:
--------------------------------------------------------------------------------
 1 | import addExtension from "./add-extension.mjs"
 2 | 
 3 | addExtension("clap.log", {
 4 | 	wasm: {
 5 | 		ext_log_log: 'vpip'
 6 | 	},
 7 | 	js: {
 8 | 		ext_log_log(severity, message) {
 9 | 			let api = this.api;
10 | 			message = api.fromArg(api.string, message);
11 | 			api.log(`host log (${severity}): ${message}`);
12 | 		}
13 | 	},
14 | 	// Add any supporting types to the API, and (optionally) return a static pointer for the extension, so all host instances can re-use the same one.
15 | 	addTypes: (api, methods) => {
16 | 		let clap_log_severity = api.clap_log_severity = api.i32;
17 | 		api.clap_host_log = api.makeStruct(
18 | 			{log: api.makeFunc(api.pointer, clap_log_severity, api.string)}
19 | 		);
20 | 		Object.assign(api, {
21 | 			CLAP_LOG_DEBUG: 0,
22 | 			CLAP_LOG_INFO: 1,
23 | 			CLAP_LOG_WARNING: 2,
24 | 			CLAP_LOG_ERROR: 3,
25 | 			CLAP_LOG_FATAL: 4,
26 | 			CLAP_LOG_HOST_MISBEHAVING: 5,
27 | 			CLAP_LOG_PLUGIN_MISBEHAVING: 6,
28 | 		});
29 | 
30 | 		return api.save(api.clap_host_log, {
31 | 			log: methods.ext_log_log // WASM function pointer which proxies to the JS version
32 | 		})
33 | 	},
34 | 	// Write the host struct, returning the pointer for `get_extension()`
35 | 	/*
36 | 	writeHost(api, methods) {
37 | 		return api.save(api.clap_host_log, {
38 | 			log: methods.ext_log_log // WASM function pointer which proxies to the JS version
39 | 		})
40 | 	},
41 | 	*/
42 | 	// Read the plugin struct (if the plugin supports it) - the result goes in ext['clap.log']
43 | 	readPlugin(api, pointer, pluginPtr) {
44 | 		throw Error("Plugins shouldn't return clap.log: " + pointer);
45 | 	},
46 | });
47 | 


--------------------------------------------------------------------------------
/clap-host/ext/params.mjs:
--------------------------------------------------------------------------------
 1 | import addExtension from "./add-extension.mjs"
 2 | 
 3 | addExtension("clap.params", {
 4 | 	wasm: {
 5 | 		ext_params_rescan: 'vpi',
 6 | 		ext_params_clear: 'vpii',
 7 | 		ext_params_request_flush: 'vp'
 8 | 	},
 9 | 	js: {
10 | 		ext_params_rescan(flags) {
11 | 			throw Error("not implemented");
12 | 		},
13 | 		ext_params_clear(paramId, flags) {
14 | 			throw Error("not implemented");
15 | 		},
16 | 		ext_params_request_flush() {
17 | 			throw Error("not implemented");
18 | 		},
19 | 	},
20 | 	// Add any supporting types to the API, and (optionally) return a static pointer for the extension, so all host instances can re-use the same one.
21 | 	addTypes: (api, methods) => {
22 | 		let clap_param_info_flags = api.clap_param_info_flags = api.u32;
23 | 		api.clap_param_info = api.makeStruct(
24 | 			{id: api.clap_id},
25 | 			{flags: clap_param_info_flags},
26 | 			{cookie: api.pointer},
27 | 			{name: api.clap_name},
28 | 			{module: api.clap_path},
29 | 			{min_value: api.f64},
30 | 			{max_value: api.f64},
31 | 			{default_value: api.f64}
32 | 		);
33 | 		let func = api.makeFunc;
34 | 		api.clap_plugin_params = api.makeStruct(
35 | 			{count: func('pointer')},
36 | 			{get_info: func('pointer', 'u32', 'pointer')},
37 | 			{get_value: func('pointer', 'clap_id', 'pointer')},
38 | 			{value_to_text: func('pointer', 'clap_id', 'f64', 'pointer', 'u32')},
39 | 			{text_to_value: func('pointer', 'clap_id', 'string', 'pointer')},
40 | 			{flush: func('pointer', 'pointer', 'pointer')}
41 | 		);
42 | 		let clap_param_rescan_flags = api.clap_param_rescan_flags = api.u32;
43 | 		let clap_param_clear_flags = api.clap_param_clear_flags = api.u32;
44 | 		api.clap_host_params = api.makeStruct(
45 | 			{rescan: func('pointer', 'clap_param_rescan_flags')},
46 | 			{clear: func('pointer', 'clap_id', 'clap_param_clear_flags')},
47 | 			{request_flush: func('pointer')}
48 | 		);
49 | 		Object.assign(api, {
50 | 			CLAP_PARAM_IS_STEPPED: 1<<0,
51 | 			CLAP_PARAM_IS_PERIODIC: 1<<1,
52 | 			CLAP_PARAM_IS_HIDDEN: 1<<2,
53 | 			CLAP_PARAM_IS_READONLY: 1<<3,
54 | 			CLAP_PARAM_IS_BYPASS: 1<<4,
55 | 			CLAP_PARAM_IS_AUTOMATABLE: 1<<5,
56 | 			CLAP_PARAM_IS_AUTOMATABLE_PER_NOTE_ID: 1<<6,
57 | 			CLAP_PARAM_IS_AUTOMATABLE_PER_KEY: 1<<7,
58 | 			CLAP_PARAM_IS_AUTOMATABLE_PER_CHANNEL: 1<<8,
59 | 			CLAP_PARAM_IS_AUTOMATABLE_PER_PORT: 1<<9,
60 | 			CLAP_PARAM_IS_MODULATABLE: 1<<10,
61 | 			CLAP_PARAM_IS_MODULATABLE_PER_NOTE_ID: 1<<11,
62 | 			CLAP_PARAM_IS_MODULATABLE_PER_KEY: 1<<12,
63 | 			CLAP_PARAM_IS_MODULATABLE_PER_CHANNEL: 1<<13,
64 | 			CLAP_PARAM_IS_MODULATABLE_PER_PORT: 1<<14,
65 | 			CLAP_PARAM_REQUIRES_PROCESS: 1<<15,
66 | 			CLAP_PARAM_IS_ENUM: 1<<16,
67 | 
68 | 			CLAP_PARAM_RESCAN_VALUES: 1<<0,
69 | 			CLAP_PARAM_RESCAN_TEXT: 1<<1,
70 | 			CLAP_PARAM_RESCAN_INFO: 1<<2,
71 | 			CLAP_PARAM_RESCAN_ALL: 1<<3,
72 | 
73 | 			CLAP_PARAM_CLEAR_ALL: 1<<0,
74 | 			CLAP_PARAM_CLEAR_AUTOMATIONS: 1<<1,
75 | 			CLAP_PARAM_CLEAR_MODULATIONS: 1<<2,
76 | 		});
77 | 		
78 | 		return api.save(api.clap_host_params, {
79 | 			rescan: methods.ext_params_rescan,
80 | 			clear: methods.ext_params_clear,
81 | 			request_flush: methods.ext_params_request_flush
82 | 		});
83 | 	},
84 | 	// Write the host struct, returning the pointer for `get_extension()`
85 | 	/*
86 | 	writeHost(api, methods) {
87 | 		return api.save(api.clap_host_log, {
88 | 			log: methods.ext_log_log // WASM function pointer which proxies to the JS version
89 | 		})
90 | 	},
91 | 	*/
92 | 	// Read the plugin struct (if the plugin supports it) - the result goes in ext['clap.log']
93 | 	readPlugin(api, pointer, pluginPtr) {
94 | 		return api.clap_plugin_params(pointer, pluginPtr);
95 | 	},
96 | });
97 | 


--------------------------------------------------------------------------------
/clap-host/ext/state.mjs:
--------------------------------------------------------------------------------
 1 | import addExtension from "./add-extension.mjs"
 2 | 
 3 | addExtension("clap.state", {
 4 | 	wasm: {
 5 | 		ext_state_mark_dirty: 'vp'
 6 | 	},
 7 | 	js: {
 8 | 		ext_state_mark_dirty(severity, message) {
 9 | 			// nothing by default
10 | 		}
11 | 	},
12 | 	// Add any supporting types to the API, and (optionally) return a static pointer for the extension, so all host instances can re-use the same one.
13 | 	addTypes: (api, methods) => {
14 | 		api.clap_plugin_state = api.makeStruct(
15 | 			{save: api.makeFunc(api.pointer, api.pointer)},
16 | 			{load: api.makeFunc(api.pointer, api.pointer)}
17 | 		);
18 | 		api.clap_host_state = api.makeStruct(
19 | 			{mark_dirty: api.makeFunc(api.pointer)}
20 | 		);
21 | 
22 | 		return api.save(api.clap_host_state, {
23 | 			mark_dirty: methods.ext_state_mark_dirty
24 | 		});
25 | 	},
26 | 	// Write the host struct, returning the pointer for `get_extension()`
27 | 	/*
28 | 	writeHost(api, methods) {
29 | 		return api.save(api.clap_host_log, {
30 | 			log: methods.ext_log_log // WASM function pointer which proxies to the JS version
31 | 		})
32 | 	},
33 | 	*/
34 | 	// Read the plugin struct (if the plugin supports it) - the result goes in ext['clap.???']
35 | 	readPlugin(api, pointer, pluginPtr) {
36 | 		return api.clap_plugin_state(pointer, pluginPtr);
37 | 	},
38 | });
39 | 


--------------------------------------------------------------------------------
/clap-host/generate-forwarding-wasm.mjs:
--------------------------------------------------------------------------------
 1 | export default function generateForwardingModuleWasm(methodSignatures) {
 2 | 	let typeCodes = {
 3 | 		b: 0x7F, // bool (32-bit in wasm32)
 4 | 		p: 0x7F, // pointer
 5 | 		s: 0x7F, // size
 6 | 		i: 0x7F, // i32
 7 | 		I: 0x7E, // i64
 8 | 		f: 0x7D, // f32
 9 | 		F: 0x7C // f64
10 | 	};
11 | 	function encodeUint(arr, v) {
12 | 		while (v >= 0x80) {
13 | 			arr.push(0x80 | (v&0x7F));
14 | 			v >>= 7;
15 | 		}
16 | 		arr.push(v);
17 | 		return arr;
18 | 	}
19 | 	function encodeName(arr, str) {
20 | 		encodeUint(arr, str.length);
21 | 		for (let i = 0; i < str.length; ++i) {
22 | 			arr.push(str.charCodeAt(i)%0x7F);
23 | 		}
24 | 	}
25 | 	let typeCount = 0;
26 | 	let typeWasm = [], importWasm = [], exportWasm = [];
27 | 	let typeMap = {};
28 | 	let methodNames = Object.keys(methodSignatures);
29 | 	methodNames.forEach((key, fIndex) => {
30 | 		let sig = methodSignatures[key]; // code using the four basic types
31 | 		let typeIndex;
32 | 		if (sig in typeMap) {
33 | 			// reuse existing type
34 | 			typeIndex = methodSignatures[key] = typeMap[sig];
35 | 		} else {
36 | 			// Add an entry to the type section
37 | 			typeIndex = typeMap[sig] = typeCount++;
38 | 			typeWasm.push(0x60); // function type
39 | 			encodeUint(typeWasm, sig.length - 1); // argument count
40 | 			for (let i = 1; i < sig.length; ++i) {
41 | 				typeWasm.push(typeCodes[sig[i]]);
42 | 			}
43 | 			if (sig[0] == 'v') {
44 | 				typeWasm.push(0); // no result (void)
45 | 			} else {
46 | 				typeWasm.push(0x01);
47 | 				typeWasm.push(typeCodes[sig[0]]);
48 | 			}
49 | 		}
50 | 		encodeName(importWasm, "proxy");
51 | 		encodeName(importWasm, key);
52 | 		importWasm.push(0x00); // function import
53 | 		encodeUint(importWasm, typeIndex); // type index
54 | 		
55 | 		encodeName(exportWasm, key);
56 | 		exportWasm.push(0x00); // function export
57 | 		encodeUint(exportWasm, fIndex);
58 | 	});
59 | 
60 | 	// Each section starts with the number of entries
61 | 	typeWasm = encodeUint([], typeCount).concat(typeWasm);
62 | 	let methodCount = encodeUint([], methodNames.length);
63 | 	importWasm = methodCount.concat(importWasm);
64 | 	exportWasm = methodCount.concat(exportWasm);
65 | 
66 | 	return new Uint8Array([
67 | 		0x00, 0x61, 0x73, 0x6D, // magic: \0asm
68 | 		0x01, 0x00, 0x00, 0x00, // v1
69 | 		
70 | 		0x01, // type section
71 | 		encodeUint([], typeWasm.length),
72 | 		typeWasm,
73 | 		
74 | 		0x02, // import section
75 | 		encodeUint([], importWasm.length),
76 | 		importWasm,
77 | 		
78 | 		0x07, // export section
79 | 		encodeUint([], exportWasm.length),
80 | 		exportWasm
81 | 	].flat());
82 | };
83 | 


--------------------------------------------------------------------------------
/clap-host/hosted-plugin.mjs:
--------------------------------------------------------------------------------
  1 | import generateForwardingModuleWasm from "./generate-forwarding-wasm.mjs";
  2 | 
  3 | export default class HostedPlugin {
  4 | 	static #m_wasmMethods = {
  5 | 		get_extension: 'ppp',
  6 | 		request_restart: 'vp',
  7 | 		request_process: 'vp',
  8 | 		request_callback: 'vp',
  9 | 		input_events_size: 'ip',
 10 | 		input_events_get: 'ppi',
 11 | 		output_events_try_push: 'ipp',
 12 | 		istream_read: 'IppI',
 13 | 		ostream_write: 'IppI'
 14 | 	};
 15 | 	static #m_modulePromise;
 16 | 	static methodProxyModule() {
 17 | 		// Cache the promise, but we can remove it later if we add more methods etc.
 18 | 		if (!HostedPlugin.#m_modulePromise) {
 19 | 			let wasmCode = generateForwardingModuleWasm(HostedPlugin.#m_wasmMethods);
 20 | 			HostedPlugin.#m_modulePromise = WebAssembly.compile(wasmCode);
 21 | 		}
 22 | 		return HostedPlugin.#m_modulePromise;
 23 | 	};
 24 | 
 25 | 	static #m_extensions = {};
 26 | 	static addExtension(key, extension) {
 27 | 		HostedPlugin.#m_modulePromise = null;
 28 | 		Object.assign(HostedPlugin.#m_wasmMethods, extension.wasm);
 29 | 		for (let m in extension.wasm) {
 30 | 			if (typeof extension.js?.[m] !== 'function') throw Error("no JS for " + m);
 31 | 		}
 32 | 		HostedPlugin.#m_extensions[key] = extension;
 33 | 	}
 34 | 	static setupExtensions(api, methods) {
 35 | 		let staticExtensionPointers = Object.create(null);
 36 | 		for (let key in HostedPlugin.#m_extensions) {
 37 | 			let extension = HostedPlugin.#m_extensions[key];
 38 | 			if (extension.addTypes) {
 39 | 				let maybePointer = extension.addTypes(api, methods);
 40 | 				if (maybePointer) {
 41 | 					staticExtensionPointers[key] = maybePointer;
 42 | 				}
 43 | 			}
 44 | 		}
 45 | 		return staticExtensionPointers;
 46 | 	}
 47 | 
 48 | 	#m_factory;
 49 | 	#m_hostBinding;
 50 | 
 51 | 	// low-level interface
 52 | 	api;
 53 | 	// function struct, as returned from api
 54 | 	plugin = null;
 55 | 	// plugin extension structs (if the plugin supports them)
 56 | 	ext = {};
 57 | 
 58 | 	// our extension pointers
 59 | 	hostExt = {};
 60 | 	
 61 | 	// WASM pointers to our various structs
 62 | 	hostPointers = {};
 63 | 	// WASM function pointers for the host methods
 64 | 	hostMethods = {};
 65 | 	// JS implementations - replace these to customise behaviour
 66 | 	hostJs = {
 67 | 		get_extension(cStr) {
 68 | 			let str = this.api.fromArg(this.api.string, cStr);
 69 | 			return this.hostExt[str] || 0;
 70 | 		},
 71 | 		request_restart() {throw Error("not implemented");},
 72 | 		request_process() {throw Error("not implemented");},
 73 | 		request_callback() {throw Error("not implemented");},
 74 | 		input_events_size() {return 0;},
 75 | 		input_events_get(i) {throw Error("not implemented");},
 76 | 		output_events_try_push(eventPtr) {return false;},
 77 | 		istream_read(buffer, size) {throw Error("not implemented");},
 78 | 		ostream_write(buffer, size) {throw Error("not implemented");},
 79 | 	};
 80 | 	
 81 | 	read_istream(istreamPtr, maxLength=16384) {
 82 | 		let offset = 0;
 83 | 		let buffer = this.api.tempTyped(this.api.u8, maxLength);
 84 | 		let istream = this.api.clap_istream(istreamPtr);
 85 | 		while (offset < buffer.length) {
 86 | 			let sub = buffer.subarray(offset);
 87 | 			let bytes = istream.read(istreamPtr, sub, BigInt(sub.length));
 88 | 			if (bytes < 0) return false;
 89 | 			if (!bytes) break;
 90 | 			offset += Number(bytes);
 91 | 		}
 92 | 		return buffer.subarray(0, offset);
 93 | 	}
 94 | 
 95 | 	constructor(api, hostBinding, factory) {
 96 | 		let methods = Object.assign(this.hostMethods, hostBinding.m_methods);
 97 | 		Object.freeze(methods);
 98 | 
 99 | 		this.api = api;
100 | 		this.#m_factory = factory;
101 | 		this.#m_hostBinding = hostBinding;
102 | 
103 | 		Object.assign(this.hostExt, hostBinding.m_staticExtensionPointers);
104 | 		for (let key in HostedPlugin.#m_extensions) {
105 | 			let extension = HostedPlugin.#m_extensions[key];
106 | 			if (extension.writeHost) {
107 | 				this.hostExt[key] = extension.writeHost(api, methods);
108 | 			}
109 | 		}
110 | 
111 | 		// Registers the methods to place in the host structs
112 | 		let jsMethods = this.hostJs;
113 | 		for (let key in HostedPlugin.#m_extensions) {
114 | 			let extension = HostedPlugin.#m_extensions[key];
115 | 			Object.assign(jsMethods, extension.js);
116 | 		}
117 | 		
118 | 		let hostPointers = Object.assign(this.hostPointers, {
119 | 			host: api.save(api.clap_host, {
120 | 				clap_version: {major: 1, minor: 2, patch: 2},
121 | 				host_data: 0,
122 | 				name: 'WASM-CLAP host',
123 | 				vendor: 'Signalsmith Audio',
124 | 				url: '',
125 | 				version: '0.0.1',
126 | 				get_extension: methods.get_extension,
127 | 				request_restart: methods.request_restart,
128 | 				request_process: methods.request_process,
129 | 				request_callback: methods.request_callback
130 | 			}),
131 | 			input_events: api.save(api.clap_input_events, {
132 | 				ctx: 0,
133 | 				size: methods.input_events_size,
134 | 				'get': methods.input_events_get
135 | 			}),
136 | 			output_events: api.save(api.clap_output_events, {
137 | 				ctx: 0,
138 | 				try_push: methods.output_events_try_push
139 | 			}),
140 | 			istream: api.save(api.clap_istream, {
141 | 				ctx: 0,
142 | 				read:methods.istream_read
143 | 			}),
144 | 			ostream: api.save(api.clap_ostream, {
145 | 				ctx: 0,
146 | 				write:methods.ostream_write
147 | 			}),
148 | 		});
149 | 		
150 | 		Object.freeze(hostPointers);
151 | 		for (let key in hostPointers) {
152 | 			hostBinding.m_register(hostPointers[key], jsMethods, this);
153 | 		}
154 | 	}
155 | 
156 | 	bind(pluginId) {
157 | 		this.#m_hostBinding.m_removeFromPool(this.hostPointers.host);
158 | 		
159 | 		if (this.plugin) throw Error("bind(): already bound");
160 | 	
161 | 		let pluginPtr = this.#m_factory.create_plugin(this.hostPointers.host, pluginId);
162 | 		if (!pluginPtr) throw Error("failed to create plugin");
163 | 		this.plugin = this.api.clap_plugin(pluginPtr, true);
164 | 		if (!this.plugin.init()) {
165 | 			this.plugin.destroy();
166 | 			throw Error("plugin.init() failed");
167 | 		}
168 | 
169 | 		for (let key in HostedPlugin.#m_extensions) {
170 | 			let extension = HostedPlugin.#m_extensions[key];
171 | 			if (extension.readPlugin) {
172 | 				let pluginExtPtr = this.plugin.get_extension(key);
173 | 				if (pluginExtPtr) {
174 | 					this.ext[key] = extension.readPlugin.call(this, this.api, pluginExtPtr, pluginPtr);
175 | 				}
176 | 			}
177 | 		}
178 | 	}
179 | 
180 | 	unbind() {
181 | 		this.#m_hostBinding.m_addToPool(this.hostPointers.host);
182 | 		
183 | 		if (!this.plugin) throw Error("unbind(): not bound");
184 | 		this.plugin.destroy();
185 | 		this.plugin = null;
186 | 		this.ext = {};
187 | 	}
188 | }
189 | 


--------------------------------------------------------------------------------
/clap-host/instantiate.mjs:
--------------------------------------------------------------------------------
 1 | import wasi_snapshot_preview1 from "./wasi/wasi_snapshot_preview1.mjs";
 2 | 
 3 | // Later, we can inspect the imports to see if needs WASI, expects a memory import etc.
 4 | export default async function instantiate(options) {
 5 | 	let url = options.url;
 6 | 	if (!url) throw Error("missing `url` option");
 7 | 	let instance = options.instance;
 8 | 	if (!instance) {
 9 | 		let module = options.module;
10 | 		if (!module) {
11 | 			module = WebAssembly.compileStreaming(fetch(url));
12 | 		}
13 | 
14 | 		let imports = options.imports || {};
15 | 		if (!imports.wasi_snapshot_preview1) {
16 | 			imports.wasi_snapshot_preview1 = wasi_snapshot_preview1();
17 | 		}
18 | 
19 | 		instance = await WebAssembly.instantiate(await module, imports);
20 | 		// this seems to be the convention
21 | 		imports.wasi_snapshot_preview1.instance = instance;
22 | 		
23 | 		// WASI entry points for standalone / dynamic
24 | 		instance.exports._start?.();
25 | 		instance.exports._initialize?.();
26 | 	}
27 | 	return instance;
28 | }
29 | 


--------------------------------------------------------------------------------
/clap-host/wasi/wasi_snapshot_preview1.mjs:
--------------------------------------------------------------------------------
  1 | function wasi_snapshot_preview1(args=[], env={}, fileResolver) {
  2 | 	for (let key in env) {
  3 | 		if (typeof env[key] !== 'string') env[key] += "";
  4 | 	}
  5 | 	
  6 | 	if (!fileResolver) fileResolver = () => null;
  7 | 	
  8 | 	let fileHandles = {};
  9 | 	function groupNewlines(fn) {
 10 | 		let pending = "";
 11 | 		return {
 12 | 			offset: 0,
 13 | 			length: 0,
 14 | 			write(arr) {
 15 | 				for (let i = 0; i < arr.length; ++i) {
 16 | 					let c = String.fromCharCode(arr[i]);
 17 | 					if (c == '\n') {
 18 | 						fn(pending);
 19 | 						pending = "";
 20 | 					} else {
 21 | 						pending += c;
 22 | 					}
 23 | 				}
 24 | 			}
 25 | 		};
 26 | 	}
 27 | 	fileHandles[1] = groupNewlines(console.log.bind(console)); // stdout
 28 | 	fileHandles[2] = groupNewlines(console.error.bind(console)); // stderr
 29 | 
 30 | 	let memory = null;
 31 | 	let wasi = {
 32 | 		// This seems to be the convention
 33 | 		set instance(instance) {
 34 | 			memory = instance.exports.memory;
 35 | 		},
 36 | 		environ_sizes_get(pCount, pSize) {
 37 | 			let count = 0, size = 0;
 38 | 			for (let key in env) {
 39 | 				++count;
 40 | 				size += env[key].length + 1;
 41 | 			}
 42 | 			let view = new DataView(memory.buffer);
 43 | 			view.setUint32(pCount, count, true);
 44 | 			view.setUint32(pSize, size, true);
 45 | 			return 0;
 46 | 		},
 47 | 		environ_get(pArray, pBuffer) {
 48 | 			let view = new DataView(memory.buffer);
 49 | 			let arr8 = new Uint8Array(memory.buffer);
 50 | 			
 51 | 			let count = 0, size = 0;
 52 | 			for (let key in env) {
 53 | 				let value = env[key];
 54 | 				// Set the pointer
 55 | 				view.setUint32(pArray + count*4, pBuffer + size, true);
 56 | 				// Copy the string
 57 | 				for (let i = 0; i < value.length; ++i) {
 58 | 					arr8[pBuffer + size + i] = value.charCodeAt[i];
 59 | 				}
 60 | 				arr8[pBuffer + size + value.length] = 0; // null-terminated string
 61 | 
 62 | 				++count;
 63 | 				size += value.length + 1;
 64 | 			}
 65 | 			return 0;
 66 | 		},
 67 | 		fd_seek(fd, offset, relativeTo) {
 68 | 			let file = fileHandles[fd];
 69 | 			if (!file) return 9; // bad file handle
 70 | 			
 71 | 			// POSIX lseek constants
 72 | 			if (relativeTo == 1) { // SEEK_CUR
 73 | 				file.offset += offset;
 74 | 			} else if (relativeTo == 2) { // SEEK_END
 75 | 				file.offset = file.length - offset;
 76 | 			} else { // SEEK_SET
 77 | 				file.offset = offset;
 78 | 			}
 79 | 			return file.offset;
 80 | 		},
 81 | 		fd_write(fd, pVectors, nVectors, pWritten) {
 82 | 			let file = fileHandles[fd];
 83 | 			if (!file) return 9; // bad file handle
 84 | 			
 85 | 			let view = new DataView(memory.buffer);
 86 | 			let arr8 = new Uint8Array(memory.buffer);
 87 | 			// Everything goes to the console
 88 | 			let written = 0;
 89 | 			for (let n = 0; n < nVectors; ++n) {
 90 | 				let pData = view.getUint32(pVectors + n*8, true);
 91 | 				let length = view.getUint32(pVectors + n*8 + 4, true);
 92 | 				file.write(arr8.subarray(pData, pData + length));
 93 | 				written += length;
 94 | 			}
 95 | 			view.setUint32(pWritten, written, true);
 96 | 			return 0;
 97 | 		},
 98 | 		fd_read(fd, pVectors, nVectors, pWritten) {
 99 | 			console.log("fd_read()");
100 | 			let file = fileHandles[fd];
101 | 			if (!file) file = {
102 | 				read() {
103 | 				}
104 | 			};
105 | 
106 | 			let view = new DataView(memory.buffer);
107 | 			let arr8 = new Uint8Array(memory.buffer);
108 | 			// Everything goes to the console
109 | 			let written = 0;
110 | 			for (let n = 0; n < nVectors; ++n) {
111 | 				let pData = view.getUint32(pVectors + n*8, true);
112 | 				let length = view.getUint32(pVectors + n*8 + 4, true);
113 | 				file.read(arr8.subarray(pData, pData + length));
114 | 				written += length;
115 | 			}
116 | 			view.setUint32(pWritten, written, true);
117 | 			return 0;
118 | 		},
119 | 		random_get(ptr, nBytes) { // TODO: a more secure generator
120 | 			let arr8 = new Uint8Array(memory);
121 | 			for (let i = 0; i < nBytes; ++i) {
122 | 				arr8[ptr + i] = Math.floor(Math.random()*256);
123 | 			}
124 | 		}
125 | 	};
126 | 
127 | 	// List adapted from https://github.com/nodejs/uvwasi?tab=readme-ov-file#system-calls
128 | 	'args_get,args_sizes_get,clock_res_get,clock_time_get,environ_get,environ_sizes_get,fd_advise,fd_allocate,fd_close,fd_datasync,fd_fdstat_get,fd_fdstat_set_flags,fd_fdstat_set_rights,fd_filestat_get,fd_filestat_set_size,fd_filestat_set_times,fd_pread,fd_prestat_get,fd_prestat_dir_name,fd_pwrite,fd_read,fd_readdir,fd_renumber,fd_seek,fd_sync,fd_tell,fd_write,path_create_directory,path_filestat_get,path_filestat_set_times,path_link,path_open,path_readlink,path_remove_directory,path_rename,path_symlink,path_unlink_file,poll_oneoff,proc_exit,proc_raise,random_get,sched_yield,sock_recv,sock_send,sock_shutdown'.split(',').forEach(key => {
129 | 		if (!wasi[key]) {
130 | 			wasi[key] = (...args) => {
131 | 				console.error(`Missing WASI: ${key}(${args.join(', ')})`);
132 | 				debugger;
133 | 				throw Error('WASI: ' + key + '(' + args.join(', ') + ')');
134 | 				return 0;
135 | 			};
136 | 		}
137 | 	});
138 | 	return wasi;
139 | };
140 | 
141 | export default wasi_snapshot_preview1;
142 | 


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | 	<head>
  4 | 		<meta charset="UTF-8">
  5 | 		<meta name="viewport" content="width=device-width, initial-scale=1">
  6 | 		<title>CLAP-WASM player</title>
  7 | 		<style>
  8 | 			* {
  9 | 				box-sizing: border-box;
 10 | 			}
 11 | 			body {
 12 | 				display: grid;
 13 | 				grid-template-areas: "audio buttons cpu" "main main main";
 14 | 				grid-template-rows: min-content 1fr;
 15 | 				grid-template-columns: 2fr minmax(min-content, 1fr) 2rem;
 16 | 				
 17 | 				position: fixed;
 18 | 				margin: 0;
 19 | 				padding: 1rem;
 20 | 				gap: 1rem;
 21 | 				left: 0;
 22 | 				top: 0;
 23 | 				width: 100vw;
 24 | 				height: 100vh;
 25 | 				overflow: auto;
 26 | 				
 27 | 				font-family: Verdana, sans-serif;
 28 | 				background: #444;
 29 | 				color: #FFF;
 30 | 			}
 31 | 			@media (max-width: 400pt) {
 32 | 				body {
 33 | 					grid-template-areas: "audio cpu" "buttons buttons" "main main";
 34 | 					grid-template-rows: min-content 2rem 1fr;
 35 | 					grid-template-columns: 1fr 2rem;
 36 | 				}
 37 | 			}
 38 | 			audio {
 39 | 				grid-area: audio;
 40 | 				width: 100%;
 41 | 				opacity: 0.98;
 42 | 			}
 43 | 			#background {
 44 | 				position: fixed;
 45 | 				left: 0;
 46 | 				top: 0;
 47 | 				width: 100vmax;
 48 | 				height: 100vmin;
 49 | 				object-fit: cover;
 50 | 				z-index: -1;
 51 | 				pointer-events: none;
 52 | 			}
 53 | 			@media (max-aspect-ratio: 1) {
 54 | 				#background {
 55 | 					transform-origin: 50vmin 50vmin;
 56 | 					transform: rotate(90deg);
 57 | 				}
 58 | 			}
 59 | 			#buttons, #tabs {
 60 | 				grid-area: buttons;
 61 | 				display: flex;
 62 | 				align-items: stretch;
 63 | 				justify-content: stretch;
 64 | 				min-height: 2rem;
 65 | 			}
 66 | 			button, select {
 67 | 				font: inherit;
 68 | 				border: 2px solid #CCC;
 69 | 				background: linear-gradient(#FFF, #DDD);
 70 | 				border-width: 2px 1px;
 71 | 				flex-grow: 1;
 72 | 				cursor: pointer;
 73 | 			}
 74 | 			select {
 75 | 				font-size: 0.8em;
 76 | 				white-space: normal;
 77 | 			}
 78 | 			button:focus, select:focus {
 79 | 				border-color: #AAA;
 80 | 			}
 81 | 			button:hover, select:hover {
 82 | 				filter: brightness(1.2);
 83 | 				-webkit-filter: brightness(1.2);
 84 | 			}
 85 | 			button:active, select:active {
 86 | 				background: linear-gradient(#DDD, #FFF);
 87 | 				border-color: #888;
 88 | 			}
 89 | 			button:first-child, select:first-child {
 90 | 				border-left-width: 2px;
 91 | 				border-radius: 0.5rem 0 0 0.5rem;
 92 | 			}
 93 | 			button:last-child, select:last-child {
 94 | 				border-right-width: 2px;
 95 | 				border-radius: 0 0.5rem 0.5rem 0;
 96 | 			}
 97 | 			#cpu {
 98 | 				display: flex;
 99 | 				align-items: center;
100 | 				justify-content: center;
101 | 				font-size: 0.75rem;
102 | 				opacity: 0.5;
103 | 			}
104 | 			main {
105 | 				grid-area: main;
106 | 				display: flex;
107 | 				padding: 1rem;
108 | 				gap: 1rem;
109 | 				flex-direction: column;
110 | 				background: #FFFAF272;
111 | 				color: #000;
112 | 				border-radius: 0.3rem;
113 | 				box-shadow: 0px 2px 2px -1px #0003;
114 | 				overflow: auto;
115 | 			}
116 | 			fieldset {
117 | 				width: 100%;
118 | 				max-width: 650pt;
119 | 				margin: 0 auto;
120 | 				background: #FFF;
121 | 				border: none;
122 | 				border-radius: 0.3rem;
123 | 				box-shadow: 0px 2px 2px -1px #0003;
124 | 			}
125 | 			iframe {
126 | 				flex-grow: 1;
127 | 				/* funky border to make it clearer which part of the UI is hosted*/
128 | 				background: #6F6;
129 | 				border: 1px dashed #F0F;
130 | 				box-shadow: 0px 0px 3px #F0FC;
131 | 			}
132 | 			label {
133 | 				display: grid;
134 | 				grid-template-areas: 'name input output';
135 | 				grid-template-columns: 1fr 3fr minmax(5rex, 1fr);
136 | 				width: 100%;
137 | 			}
138 | 			input[type=range] {
139 | 				width: 100%;
140 | 			}
141 | 			output, .name {
142 | 				margin: 0.5rem;
143 | 			}
144 | 			output {
145 | 				overflow: hidden;
146 | 				mask: linear-gradient(-90deg, #FFF0, #FFFD 1em, #FFF 2em);
147 | 			}
148 | 			.name {
149 | 				text-align: right;
150 | 			}
151 | 			.file-drop {
152 | 				opacity: 0.5;
153 | 				filter: greyscale(0.5);
154 | 				-webkit-filter: greyscale(0.5);
155 | 			}
156 | 			button.active {
157 | 				background: #048;
158 | 				color: #FFF;
159 | 			}
160 | 		</style>
161 | 	</head>
162 | 	<body>
163 | 		<script>
164 | 			let serviceWorkerReady = (async serviceWorker => {
165 | 				if (!serviceWorker.controller) {
166 | 					// either there's no controller (no registations), or it's a hard-refresh (existing registrations will be bypassed, so remove them)
167 | 					const registrations = await serviceWorker.getRegistrations();
168 | 					await Promise.all(registrations.map(r => r.unregister()));
169 | 
170 | 					// Also delete the associated cache
171 | 					caches.delete("wclap");
172 | 
173 | 					await serviceWorker.register("./wclap-service-worker.js", {updateViaCache: 'all'});
174 | 				}
175 | 				// Poll until it's ready (takes a bit longer on hard refresh)
176 | 				return new Promise(pass => {
177 | 					let ms = 10;
178 | 					function check() {
179 | 						if (serviceWorker.controller) return pass(serviceWorker.controller.scriptURL + "/");
180 | 						console.log("waiting for serviceWorker");
181 | 						if (ms > 100) return location.reload(); // If there's another tab open still holding onto the previous registration, we'd wait forever, so just refresh again
182 | 						setTimeout(check, ms += 10);
183 | 					}
184 | 					check();
185 | 				});
186 | 			})(navigator.serviceWorker);
187 | 		</script>
188 | 		<img id="background" src="rainbow-texture.jpg">
189 | 		<audio id="media" controls loop crossorigin></audio>
190 | 		<div id="buttons">
191 | 			<select id="select-plugin-id" title="select plugin"></select>
192 | 			<button id="button-link" title="copy link with state">🔗</button>
193 | 			<button id="button-stopengine" title="stop audio engine">🛑</button>
194 | 			<button id="button-reset" title="reset / reload">❌</button>
195 | 		</div>
196 | 		<div id="cpu"></div>
197 | 		<main>
198 | 			<div id="tabs">
199 | 				<button id="tab-params">parameters</button>
200 | 				<button id="tab-ui">UI</button>
201 | 			</div>
202 | 			<fieldset id="params"></fieldset>
203 | 		</main>
204 | 		<script type="module">
205 | 			import ClapModule from "./audioworkletnode-clap.mjs";
206 | 			// import "./audioworkletprocessor-clap.mjs";
207 | 			
208 | 			let queryParams = new URLSearchParams(window.location.search);
209 | 			function updateQuery() {
210 | 				history.replaceState(null, null, '?' + queryParams);
211 | 			}
212 | 
213 | 			let $ = document.querySelector.bind(document);
214 | 			let audioContext = new AudioContext();
215 | 			
216 | 			let audioElement = $('audio');
217 | 			audioElement.src = queryParams.get('audio') || 'audio/loop.mp3';
218 | 			let audioSource = audioContext.createMediaElementSource(audioElement);
219 | 			
220 | 			document.body.addEventListener('dragover', e => {
221 | 				document.body.classList.add('file-drop');
222 | 				e.preventDefault();
223 | 				e.stopPropagation();
224 | 			});
225 | 			document.body.addEventListener('dragcancel', e => {
226 | 				document.body.classList.remove('file-drop');
227 | 			});
228 | 			document.body.addEventListener('drop', e => {
229 | 				document.body.classList.remove('file-drop');
230 | 				let file = e.dataTransfer.items?.[0]?.getAsFile?.() || e.dataTransfer.files?.[0];
231 | 				if (/^blob:/.test(audioElement.src)) {
232 | 					URL.revokeObjectURL(audioElement.src);
233 | 				}
234 | 				audioElement.src = URL.createObjectURL(file);
235 | 				audioElement.play();
236 | 				e.preventDefault();
237 | 				e.stopPropagation();
238 | 			});
239 | 			
240 | 			['mousedown', 'focus'].forEach(name => {
241 | 				window.addEventListener(name, e => {
242 | 					if (queryParams.has('autostart')) audioContext.resume(name);
243 | 				}, {capture: true});
244 | 			});
245 | 			if (!queryParams.has('autostart')) {
246 | 				audioContext.suspend();
247 | 			}
248 | 			['play'].forEach(name => {
249 | 				window.addEventListener(name, e => audioContext.resume(name), {capture: true});
250 | 			});
251 | 			
252 | 			function blip(message, event) {
253 | 				let span = document.createElement('span');
254 | 				span.setAttribute('style', 'display:block;padding: 0.5rem;position:absolute;background:#FFF;color:#555;font-size:0.8rem;border-radius:0.3rem;box-shadow:0px 2px 4px #0008;z-index:10000');
255 | 				span.textContent = message;
256 | 				(event?.target || document.body).append(span);
257 | 				span.onclick = e => {
258 | 					span.remove();
259 | 					e.preventDefault;
260 | 					e.stopPropagation();
261 | 				};
262 | 				setTimeout(_ => span.remove(), 1500);
263 | 			}
264 | 
265 | 			$('#select-plugin-id').onchange = _ => {
266 | 				let id = $('#select-plugin-id').value;
267 | 				queryParams.set("plugin", id);
268 | 				queryParams.delete('state');
269 | 				// Reloads the whole page
270 | 				location.href = '?' + queryParams;
271 | 			};
272 | 			$('#button-link').onclick = async e => {
273 | 				navigator.clipboard.writeText(location.href);
274 | 				await updateQueryState();
275 | 				await navigator.clipboard.writeText(location.href);
276 | 				blip("copied", e);
277 | 			};
278 | 			$('#button-stopengine').onclick = _ => {
279 | 				audioElement.pause();
280 | 				audioContext.suspend();
281 | 			};
282 | 			$('#button-reset').onclick = _ => {
283 | 				queryParams.delete('state');
284 | 				// Reloads the whole page
285 | 				location.href = '?' + queryParams;
286 | 			};
287 | 			
288 | 			let tarGzPrefixUrl = await serviceWorkerReady;
289 | 			let wasmUrl = queryParams.get('module') || 'plugin/freq-shifter.wclap.tar.gz';
290 | 			if (/\.tar\.gz$/.test(wasmUrl)) {
291 | 				wasmUrl = tarGzPrefixUrl + encodeURIComponent(new URL(wasmUrl, location).href) + "/";
292 | 			}
293 | 			let module = new ClapModule(wasmUrl);
294 | 			let pluginId = queryParams.get('plugin') || null;
295 | 			module.plugins().then(plugins => {
296 | 				let select = $('#select-plugin-id');
297 | 				if (plugins.length <= 1) {
298 | 					select.remove();
299 | 					return
300 | 				}
301 | 				plugins.forEach(plugin => {
302 | 					let option = document.createElement('option');
303 | 					option.value = plugin.id;
304 | 					option.textContent = plugin.name;
305 | 					console.log(plugin);
306 | 					
307 | 					select.appendChild(option);
308 | 					if (plugin.id == pluginId) {
309 | 						option.selected = true;
310 | 						select.value = pluginId;
311 | 					}
312 | 				});
313 | 			});
314 | 			let effectNode = await module.createNode(audioContext, pluginId, {
315 | 				numberOfInputs: 1,
316 | 				numberOfOutputs: 1,
317 | 				outputChannelCount: [2]
318 | 			});
319 | 			if (queryParams.get('state')) {
320 | 				let binary = atob(queryParams.get('state').replace(/-/g, '+').replace(/_/g, '/'));
321 | 				let array = new Uint8Array(binary.length);
322 | 				array.forEach((c, i) => array[i] = binary.charCodeAt(i));
323 | 				await effectNode.loadState(array.buffer);
324 | 			}
325 | 			audioSource.connect(effectNode);
326 | 			effectNode.connect(audioContext.destination);
327 | 			globalThis.effectNode = effectNode;
328 | 			
329 | 			let paramUpdateFns = [];
330 | 			effectNode.events.params_rescan = flags => {
331 | 				paramUpdateFns.forEach(fn => fn());
332 | 			};
333 | 			let updateQueryStateTimer = null;
334 | 			async function updateQueryState() {
335 | 				updateQueryStateTimer = null;
336 | 				
337 | 				let state = await effectNode.saveState();
338 | 				state = new Uint8Array(ArrayBuffer.isView(state) ? state.buffer : state);
339 | 				let binary = "";
340 | 				state.forEach(c => binary += String.fromCharCode(c));
341 | 				queryParams.set('state', btoa(binary).replace(/\+/g, '-').replace(/\//g, '_'));
342 | 				updateQuery();
343 | 			}
344 | 			effectNode.events.state_mark_dirty = async () => {
345 | 				if (updateQueryStateTimer) return;
346 | 				updateQueryStateTimer = setTimeout(updateQueryState, 100);
347 | 			};
348 | 			
349 | 			function makeSlider(param) {
350 | 				let group = $('#params');
351 | 				let label = document.createElement('label');
352 | 				
353 | 				let name = document.createElement('span');
354 | 				name.classList.add('name');
355 | 				name.append(param.name);
356 | 
357 | 				let input = document.createElement('input');
358 | 				input.type = 'range';
359 | 				input.min = param.min_value;
360 | 				input.max = param.max_value;
361 | 				input.step = param.flags.stepped ? 1 : 1e-6;
362 | 				let writeValue = input.oninput = async e => {
363 | 					param.value = await effectNode.setParam(param.id, parseFloat(input.value));
364 | 					output.textContent = param.value.text;
365 | 				};
366 | 				let readValue = async e => {
367 | 					param.value = await effectNode.getParam(param.id);
368 | 					input.value = param.value.value;
369 | 					output.textContent = param.value.text;
370 | 				};
371 | 				readValue();
372 | 				paramUpdateFns.push(readValue);
373 | 				input.ondblclick = e => {
374 | 					input.value = param.default_value;
375 | 					writeValue();
376 | 				};
377 | 				
378 | 				let output = document.createElement('output');
379 | 				output.textContent = param.value.text;
380 | 
381 | 				label.append(name, input, output);
382 | 				group.append(label);
383 | 			}
384 | 
385 | 			let params = await effectNode.getParams();
386 | 			params.forEach(makeSlider);
387 | 
388 | 			let iframe;
389 | 			function selectTab(webUi) {
390 | 				if (iframe) {
391 | 					// tell the effect that the webview is closed
392 | 					effectNode.closeInterface();
393 | 					iframe.remove();
394 | 					iframe = null;
395 | 				}
396 | 
397 | 				if (webUi) {
398 | 					$('#tab-params').classList.remove("active");
399 | 					$('#tab-ui').classList.add("active");
400 | 					$('#params').style.display = 'none';
401 | 					if (effectNode.openInterface) {
402 | 						iframe = effectNode.openInterface();
403 | 						$('main').append(iframe);
404 | 					}
405 | 				} else {
406 | 					$('#tab-params').classList.add("active");
407 | 					$('#tab-ui').classList.remove("active");
408 | 					let group = $('#params').style.display = 'block';
409 | 				}
410 | 			}
411 | 			if (effectNode.openInterface) {
412 | 				$('#tab-params').addEventListener('click', _ => selectTab(false));
413 | 				$('#tab-ui').addEventListener('click', _ => selectTab(true));
414 | 				selectTab(true);
415 | 			} else {
416 | 				$('#tabs').style.display = 'none';
417 | 				selectTab(false);
418 | 			}
419 | 			
420 | 			setInterval(async _ => {
421 | 				let ms = await effectNode.performance();
422 | 				let blockMs = 128*1000/audioContext.sampleRate;
423 | 				let ratioWasm = ms.wasm/blockMs;
424 | 				let ratioJs = ms.js/blockMs - ratioWasm;
425 | 				$('#cpu').textContent = `${(ratioWasm*100).toFixed(1)}%\n${(ratioJs*100).toFixed(1)}%`;
426 | 			}, 1000);
427 | 		</script>
428 | 	</body>
429 | </html>
430 | 


--------------------------------------------------------------------------------
/plugin/clap-validator-plugin.wclap/module.wasm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Signalsmith-Audio/wasm-clap-browserhost/b267e772fe3c3afbb85d05cc227a342d1327b187/plugin/clap-validator-plugin.wclap/module.wasm


--------------------------------------------------------------------------------
/plugin/clapfirst-bad-distortion.wclap.tar.gz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Signalsmith-Audio/wasm-clap-browserhost/b267e772fe3c3afbb85d05cc227a342d1327b187/plugin/clapfirst-bad-distortion.wclap.tar.gz


--------------------------------------------------------------------------------
/plugin/freq-shifter.wclap.tar.gz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Signalsmith-Audio/wasm-clap-browserhost/b267e772fe3c3afbb85d05cc227a342d1327b187/plugin/freq-shifter.wclap.tar.gz


--------------------------------------------------------------------------------
/plugin/hello-clap.wclap.tar.gz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Signalsmith-Audio/wasm-clap-browserhost/b267e772fe3c3afbb85d05cc227a342d1327b187/plugin/hello-clap.wclap.tar.gz


--------------------------------------------------------------------------------
/rainbow-texture.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Signalsmith-Audio/wasm-clap-browserhost/b267e772fe3c3afbb85d05cc227a342d1327b187/rainbow-texture.jpg


--------------------------------------------------------------------------------
/wclap-service-worker.js:
--------------------------------------------------------------------------------
  1 | const CACHE_KEY = "wclap";
  2 | const PROXY_BASE = self.location.href + "/";
  3 | 
  4 | self.addEventListener("install", e => {
  5 | 	self.skipWaiting(); // don't wait for all existing pages to close
  6 | })
  7 | self.addEventListener("activate", e => {
  8 | 	e.waitUntil(clients.claim());
  9 | });
 10 | 
 11 | self.addEventListener("fetch", e => {
 12 | 	let request = e.request;
 13 | 	e.respondWith((async () => {
 14 | 		let cachedResponse = await caches.match(request);
 15 | 		if (cachedResponse) return cachedResponse;
 16 | 		if (request.method == 'GET' && request.url.startsWith(PROXY_BASE)) {
 17 | 			let suffix = request.url.substr(PROXY_BASE.length);
 18 | 			let suffixTrimmed = suffix.replace(/\/.*/, '');
 19 | 			// next path component is .tar.gz URL, percent-encoded
 20 | 			let bundleUrl = decodeURIComponent(suffixTrimmed);
 21 | 			
 22 | 			let tarResponse = await fetch(altRequest(bundleUrl));
 23 | 			await addCacheFromTarGz(tarResponse, PROXY_BASE + suffixTrimmed + "/");
 24 | 
 25 | 			// Check the cache again
 26 | 			cachedResponse = await caches.match(request);
 27 | 			return cachedResponse || new Response(null, {status: 404});
 28 | 		} else {
 29 | 			return fetch(request);
 30 | 		}
 31 | 	})());
 32 | 
 33 | 	function altRequest(url) {
 34 | 		return new Request(url); // TODO: same credentials/etc
 35 | 	}
 36 | 
 37 | 	async function addCacheFromTarGz(tarResponse, baseUrl) {
 38 | 		let stream = new DecompressionStream('gzip');
 39 | 		stream = tarResponse.body.pipeThrough(stream);
 40 | 		let arrayBuffer = await (new Response(stream)).arrayBuffer();
 41 | 		
 42 | 		let cache = await caches.open(CACHE_KEY);
 43 | 
 44 | 		let tarFileStream = new UntarFileStream(arrayBuffer);
 45 | 		let promises = [];
 46 | 		while (tarFileStream.hasNext()) {
 47 | 			let file = tarFileStream.next();
 48 | 			if (file.type == '0' || file.type == "\0" || file.type == "") {
 49 | 				let fileUrl = new URL(file.name, baseUrl).href;
 50 | 				let fileRequest = altRequest(fileUrl);
 51 | 				let fileExt = fileUrl.replace(/.*\./, '').toLowerCase();
 52 | 				let fileResponse = new Response(file.buffer, {
 53 | 					status: tarResponse.status,
 54 | 					statusText: tarResponse.statusText,
 55 | 					headers: {
 56 | 						'Content-Type': ext2Mime[fileExt] || 'application/octet-stream'
 57 | 					}
 58 | 				});
 59 | 				promises.push(cache.put(fileRequest, fileResponse));
 60 | 			}
 61 | 		}
 62 | 		return Promise.all(promises);
 63 | 	}
 64 | });
 65 | 
 66 | // data from https://github.com/jshttp/mime-db
 67 | let ext2Mime = {};
 68 | /* let packed = [];
 69 | for (let key in mimeDb) {
 70 |     if (!/\/(prs\.|vnd\.|x-)/.test(key) && mimeDb[key].extensions) {
 71 |         packed.push([key].concat(mimeDb[key].extensions))
 72 |     }
 73 | }
 74 | packed = packed.map(p => p.join(',')).join('|');
 75 | */
 76 | "application/andrew-inset,ez|application/appinstaller,appinstaller|application/applixware,aw|application/appx,appx|application/appxbundle,appxbundle|application/atom+xml,atom|application/atomcat+xml,atomcat|application/atomdeleted+xml,atomdeleted|application/atomsvc+xml,atomsvc|application/atsc-dwd+xml,dwd|application/atsc-held+xml,held|application/atsc-rsat+xml,rsat|application/automationml-aml+xml,aml|application/automationml-amlx+zip,amlx|application/bdoc,bdoc|application/calendar+xml,xcs|application/ccxml+xml,ccxml|application/cdfx+xml,cdfx|application/cdmi-capability,cdmia|application/cdmi-container,cdmic|application/cdmi-domain,cdmid|application/cdmi-object,cdmio|application/cdmi-queue,cdmiq|application/cpl+xml,cpl|application/cu-seeme,cu|application/cwl,cwl|application/dash+xml,mpd|application/dash-patch+xml,mpp|application/davmount+xml,davmount|application/docbook+xml,dbk|application/dssc+der,dssc|application/dssc+xml,xdssc|application/ecmascript,ecma|application/emma+xml,emma|application/emotionml+xml,emotionml|application/epub+zip,epub|application/exi,exi|application/express,exp|application/fdf,fdf|application/fdt+xml,fdt|application/font-tdpfr,pfr|application/geo+json,geojson|application/gml+xml,gml|application/gpx+xml,gpx|application/gxf,gxf|application/gzip,gz|application/hjson,hjson|application/hyperstudio,stk|application/inkml+xml,ink,inkml|application/ipfix,ipfix|application/its+xml,its|application/java-archive,jar,war,ear|application/java-serialized-object,ser|application/java-vm,class|application/javascript,js|application/json,json,map|application/json5,json5|application/jsonml+json,jsonml|application/ld+json,jsonld|application/lgr+xml,lgr|application/lost+xml,lostxml|application/mac-binhex40,hqx|application/mac-compactpro,cpt|application/mads+xml,mads|application/manifest+json,webmanifest|application/marc,mrc|application/marcxml+xml,mrcx|application/mathematica,ma,nb,mb|application/mathml+xml,mathml|application/mbox,mbox|application/media-policy-dataset+xml,mpf|application/mediaservercontrol+xml,mscml|application/metalink+xml,metalink|application/metalink4+xml,meta4|application/mets+xml,mets|application/mmt-aei+xml,maei|application/mmt-usd+xml,musd|application/mods+xml,mods|application/mp21,m21,mp21|application/mp4,mp4,mpg4,mp4s,m4p|application/msix,msix|application/msixbundle,msixbundle|application/msword,doc,dot|application/mxf,mxf|application/n-quads,nq|application/n-triples,nt|application/node,cjs|application/octet-stream,bin,dms,lrf,mar,so,dist,distz,pkg,bpk,dump,elc,deploy,exe,dll,deb,dmg,iso,img,msi,msp,msm,buffer|application/oda,oda|application/oebps-package+xml,opf|application/ogg,ogx|application/omdoc+xml,omdoc|application/onenote,onetoc,onetoc2,onetmp,onepkg|application/oxps,oxps|application/p2p-overlay+xml,relo|application/patch-ops-error+xml,xer|application/pdf,pdf|application/pgp-encrypted,pgp|application/pgp-keys,asc|application/pgp-signature,sig,asc|application/pics-rules,prf|application/pkcs10,p10|application/pkcs7-mime,p7m,p7c|application/pkcs7-signature,p7s|application/pkcs8,p8|application/pkix-attr-cert,ac|application/pkix-cert,cer|application/pkix-crl,crl|application/pkix-pkipath,pkipath|application/pkixcmp,pki|application/pls+xml,pls|application/postscript,ai,eps,ps|application/provenance+xml,provx|application/pskc+xml,pskcxml|application/raml+yaml,raml|application/rdf+xml,rdf,owl|application/reginfo+xml,rif|application/relax-ng-compact-syntax,rnc|application/resource-lists+xml,rl|application/resource-lists-diff+xml,rld|application/rls-services+xml,rs|application/route-apd+xml,rapd|application/route-s-tsid+xml,sls|application/route-usd+xml,rusd|application/rpki-ghostbusters,gbr|application/rpki-manifest,mft|application/rpki-roa,roa|application/rsd+xml,rsd|application/rss+xml,rss|application/rtf,rtf|application/sbml+xml,sbml|application/scvp-cv-request,scq|application/scvp-cv-response,scs|application/scvp-vp-request,spq|application/scvp-vp-response,spp|application/sdp,sdp|application/senml+xml,senmlx|application/sensml+xml,sensmlx|application/set-payment-initiation,setpay|application/set-registration-initiation,setreg|application/shf+xml,shf|application/sieve,siv,sieve|application/smil+xml,smi,smil|application/sparql-query,rq|application/sparql-results+xml,srx|application/sql,sql|application/srgs,gram|application/srgs+xml,grxml|application/sru+xml,sru|application/ssdl+xml,ssdl|application/ssml+xml,ssml|application/swid+xml,swidtag|application/tei+xml,tei,teicorpus|application/thraud+xml,tfi|application/timestamped-data,tsd|application/toml,toml|application/trig,trig|application/ttml+xml,ttml|application/ubjson,ubj|application/urc-ressheet+xml,rsheet|application/urc-targetdesc+xml,td|application/voicexml+xml,vxml|application/wasm,wasm|application/watcherinfo+xml,wif|application/widget,wgt|application/winhlp,hlp|application/wsdl+xml,wsdl|application/wspolicy+xml,wspolicy|application/xaml+xml,xaml|application/xcap-att+xml,xav|application/xcap-caps+xml,xca|application/xcap-diff+xml,xdf|application/xcap-el+xml,xel|application/xcap-ns+xml,xns|application/xenc+xml,xenc|application/xfdf,xfdf|application/xhtml+xml,xhtml,xht|application/xliff+xml,xlf|application/xml,xml,xsl,xsd,rng|application/xml-dtd,dtd|application/xop+xml,xop|application/xproc+xml,xpl|application/xslt+xml,xsl,xslt|application/xspf+xml,xspf|application/xv+xml,mxml,xhvml,xvml,xvm|application/yang,yang|application/yin+xml,yin|application/zip,zip|audio/3gpp,3gpp|audio/aac,adts,aac|audio/adpcm,adp|audio/amr,amr|audio/basic,au,snd|audio/midi,mid,midi,kar,rmi|audio/mobile-xmf,mxmf|audio/mp3,mp3|audio/mp4,m4a,mp4a|audio/mpeg,mpga,mp2,mp2a,mp3,m2a,m3a|audio/ogg,oga,ogg,spx,opus|audio/s3m,s3m|audio/silk,sil|audio/wav,wav|audio/wave,wav|audio/webm,weba|audio/xm,xm|font/collection,ttc|font/otf,otf|font/ttf,ttf|font/woff,woff|font/woff2,woff2|image/aces,exr|image/apng,apng|image/avci,avci|image/avcs,avcs|image/avif,avif|image/bmp,bmp,dib|image/cgm,cgm|image/dicom-rle,drle|image/dpx,dpx|image/emf,emf|image/fits,fits|image/g3fax,g3|image/gif,gif|image/heic,heic|image/heic-sequence,heics|image/heif,heif|image/heif-sequence,heifs|image/hej2k,hej2|image/hsj2,hsj2|image/ief,ief|image/jls,jls|image/jp2,jp2,jpg2|image/jpeg,jpeg,jpg,jpe|image/jph,jph|image/jphc,jhc|image/jpm,jpm,jpgm|image/jpx,jpx,jpf|image/jxl,jxl|image/jxr,jxr|image/jxra,jxra|image/jxrs,jxrs|image/jxs,jxs|image/jxsc,jxsc|image/jxsi,jxsi|image/jxss,jxss|image/ktx,ktx|image/ktx2,ktx2|image/png,png|image/sgi,sgi|image/svg+xml,svg,svgz|image/t38,t38|image/tiff,tif,tiff|image/tiff-fx,tfx|image/webp,webp|image/wmf,wmf|message/disposition-notification,disposition-notification|message/global,u8msg|message/global-delivery-status,u8dsn|message/global-disposition-notification,u8mdn|message/global-headers,u8hdr|message/rfc822,eml,mime|model/3mf,3mf|model/gltf+json,gltf|model/gltf-binary,glb|model/iges,igs,iges|model/jt,jt|model/mesh,msh,mesh,silo|model/mtl,mtl|model/obj,obj|model/prc,prc|model/step+xml,stpx|model/step+zip,stpz|model/step-xml+zip,stpxz|model/stl,stl|model/u3d,u3d|model/vrml,wrl,vrml|model/x3d+binary,x3db,x3dbz|model/x3d+fastinfoset,x3db|model/x3d+vrml,x3dv,x3dvz|model/x3d+xml,x3d,x3dz|model/x3d-vrml,x3dv|text/cache-manifest,appcache,manifest|text/calendar,ics,ifb|text/coffeescript,coffee,litcoffee|text/css,css|text/csv,csv|text/html,html,htm,shtml|text/jade,jade|text/javascript,js,mjs|text/jsx,jsx|text/less,less|text/markdown,md,markdown|text/mathml,mml|text/mdx,mdx|text/n3,n3|text/plain,txt,text,conf,def,list,log,in,ini|text/richtext,rtx|text/rtf,rtf|text/sgml,sgml,sgm|text/shex,shex|text/slim,slim,slm|text/spdx,spdx|text/stylus,stylus,styl|text/tab-separated-values,tsv|text/troff,t,tr,roff,man,me,ms|text/turtle,ttl|text/uri-list,uri,uris,urls|text/vcard,vcard|text/vtt,vtt|text/wgsl,wgsl|text/xml,xml|text/yaml,yaml,yml|video/3gpp,3gp,3gpp|video/3gpp2,3g2|video/h261,h261|video/h263,h263|video/h264,h264|video/iso.segment,m4s|video/jpeg,jpgv|video/jpm,jpm,jpgm|video/mj2,mj2,mjp2|video/mp2t,ts,m2t,m2ts,mts|video/mp4,mp4,mp4v,mpg4|video/mpeg,mpeg,mpg,mpe,m1v,m2v|video/ogg,ogv|video/quicktime,qt,mov|video/webm,webm".split('|').forEach(p => {
 77 | 	p = p.split(',');
 78 | 	p.slice(1).forEach(ext => ext2Mime[ext] = p[0]);
 79 | });
 80 | 
 81 | // Taken from js-untar: https://github.com/InvokIT/js-untar/blob/master/src/untar-worker.js @license MIT
 82 | /*
 83 | The MIT License (MIT)
 84 | 
 85 | Copyright (c) 2015 Sebastian Jørgensen
 86 | 
 87 | Permission is hereby granted, free of charge, to any person obtaining a copy
 88 | of this software and associated documentation files (the "Software"), to deal
 89 | in the Software without restriction, including without limitation the rights
 90 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 91 | copies of the Software, and to permit persons to whom the Software is
 92 | furnished to do so, subject to the following conditions:
 93 | 
 94 | The above copyright notice and this permission notice shall be included in all
 95 | copies or substantial portions of the Software.
 96 | 
 97 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 98 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 99 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
100 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
101 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
102 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
103 | SOFTWARE.
104 |  */
105 | function decodeUTF8(e){for(var r="",t=0;t<e.length;){var i=e[t++];if(127<i){if(191<i&&i<224){if(e.length<=t)throw"UTF-8 decode: incomplete 2-byte sequence";i=(31&i)<<6|63&e[t]}else if(223<i&&i<240){if(e.length<=t+1)throw"UTF-8 decode: incomplete 3-byte sequence";i=(15&i)<<12|(63&e[t])<<6|63&e[++t]}else{if(!(239<i&&i<248))throw"UTF-8 decode: unknown multibyte start 0x"+i.toString(16)+" at index "+(t-1);if(e.length<=t+2)throw"UTF-8 decode: incomplete 4-byte sequence";i=(7&i)<<18|(63&e[t])<<12|(63&e[++t])<<6|63&e[++t]}++t}if(i<=65535)r+=String.fromCharCode(i);else{if(!(i<=1114111))throw"UTF-8 decode: code point 0x"+i.toString(16)+" exceeds UTF-16 reach";i-=65536,r=(r+=String.fromCharCode(i>>10|55296))+String.fromCharCode(1023&i|56320)}}return r}function PaxHeader(e){this._fields=e}function TarFile(){}function UntarStream(e){this._bufferView=new DataView(e),this._position=0}function UntarFileStream(e){this._stream=new UntarStream(e),this._globalPaxHeader=null}PaxHeader.parse=function(e){for(var r=new Uint8Array(e),t=[];0<r.length;){var i=parseInt(decodeUTF8(r.subarray(0,r.indexOf(32)))),n=decodeUTF8(r.subarray(0,i)).match(/^\d+ ([^=]+)=(.*)\n$/);if(null===n)throw new Error("Invalid PAX header data format.");var a=n[1],n=n[2],a=(0===n.length?n=null:null!==n.match(/^\d+$/)&&(n=parseInt(n)),{name:a,value:n});t.push(a),r=r.subarray(i)}return new PaxHeader(t)},PaxHeader.prototype={applyHeader:function(t){this._fields.forEach(function(e){var r=e.name,e=e.value;"path"===r?(r="name",void 0!==t.prefix&&delete t.prefix):"linkpath"===r&&(r="linkname"),null===e?delete t[r]:t[r]=e})}},UntarStream.prototype={readString:function(e){for(var r=+e,t=[],i=0;i<e;++i){var n=this._bufferView.getUint8(this.position()+ +i,!0);if(0===n)break;t.push(n)}return this.seek(r),String.fromCharCode.apply(null,t)},readBuffer:function(e){var r,t,i;return"function"==typeof ArrayBuffer.prototype.slice?r=this._bufferView.buffer.slice(this.position(),this.position()+e):(r=new ArrayBuffer(e),t=new Uint8Array(r),i=new Uint8Array(this._bufferView.buffer,this.position(),e),t.set(i)),this.seek(e),r},seek:function(e){this._position+=e},peekUint32:function(){return this._bufferView.getUint32(this.position(),!0)},position:function(e){if(void 0===e)return this._position;this._position=e},size:function(){return this._bufferView.byteLength}},UntarFileStream.prototype={hasNext:function(){return this._stream.position()+4<this._stream.size()&&0!==this._stream.peekUint32()},next:function(){return this._readNextFile()},_readNextFile:function(){var e=this._stream,r=new TarFile,t=!1,i=null,n=e.position()+512;switch(r.name=e.readString(100),r.mode=e.readString(8),r.uid=parseInt(e.readString(8)),r.gid=parseInt(e.readString(8)),r.size=parseInt(e.readString(12),8),r.mtime=parseInt(e.readString(12),8),r.checksum=parseInt(e.readString(8)),r.type=e.readString(1),r.linkname=e.readString(100),r.ustarFormat=e.readString(6),-1<r.ustarFormat.indexOf("ustar")&&(r.version=e.readString(2),r.uname=e.readString(32),r.gname=e.readString(32),r.devmajor=parseInt(e.readString(8)),r.devminor=parseInt(e.readString(8)),r.namePrefix=e.readString(155),0<r.namePrefix.length)&&(r.name=r.namePrefix+"/"+r.name),e.position(n),r.type){case"0":case"":r.buffer=e.readBuffer(r.size);break;case"1":case"2":case"3":case"4":case"5":case"6":case"7":break;case"g":t=!0,this._globalPaxHeader=PaxHeader.parse(e.readBuffer(r.size));break;case"x":t=!0,i=PaxHeader.parse(e.readBuffer(r.size))}void 0===r.buffer&&(r.buffer=new ArrayBuffer(0));n+=r.size;return r.size%512!=0&&(n+=512-r.size%512),e.position(n),t&&(r=this._readNextFile()),null!==this._globalPaxHeader&&this._globalPaxHeader.applyHeader(r),null!==i&&i.applyHeader(r),r}};
106 | 


--------------------------------------------------------------------------------