@bevyra/avatar 0.0.0-stage → 0.1.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +33 -2
- package/dist/assets/bevyra-core-Bskcl7l_.js +195 -0
- package/dist/assets/clientOnlyAvatarWorker-C6wTIDwp.js +2119 -0
- package/dist/assets/clientOnlySourceWorker-CNVdGzNy.js +7347 -0
- package/dist/assets/ort.wasm.min-BcBtKW3v.js +1400 -0
- package/dist/assets/ort.webgpu.min-BqBLsdhU.js +1856 -0
- package/dist/assets/rustAvatarWorker-vggdUXxI.js +1702 -0
- package/dist/assets/teacherCorrectorWorker-Deu0CCPs.js +1406 -0
- package/dist/assets/workerHelpers-BkWezgrb.js +31 -0
- package/dist/bevyra-avatar-sdk.js +3367 -0
- package/dist/ort/ort-wasm-simd-threaded.jsep.mjs +136 -0
- package/dist/ort/ort-wasm-simd-threaded.jsep.wasm +0 -0
- package/dist/ort/ort-wasm-simd-threaded.mjs +68 -0
- package/dist/ort/ort-wasm-simd-threaded.wasm +0 -0
- package/dist/runtime/bevyra-core.js +1515 -0
- package/dist/runtime/bevyra-core.wasm +0 -0
- package/dist/runtime/closure_router.onnx +0 -0
- package/dist/runtime/runtime-manifest.json +27 -0
- package/dist/sdk-manifest.json +70 -0
- package/index.d.ts +25 -0
- package/index.js +108 -0
- package/package.json +12 -4
|
@@ -0,0 +1,1515 @@
|
|
|
1
|
+
/* @ts-self-types="./bevyra-core.d.ts" */
|
|
2
|
+
import { startWorkers } from './snippets/wasm-bindgen-rayon-38edf6e439f6d70d/src/workerHelpers.js';
|
|
3
|
+
|
|
4
|
+
|
|
5
|
+
/**
|
|
6
|
+
* Runtime-loaded browser core. Unlike EmbeddedAvatar this contains no
|
|
7
|
+
* avatar or model bytes at compile time. JavaScript is limited to browser
|
|
8
|
+
* APIs and a shape-agnostic ORT bridge.
|
|
9
|
+
*/
|
|
10
|
+
export class BrowserAvatarCore {
|
|
11
|
+
__destroy_into_raw() {
|
|
12
|
+
const ptr = this.__wbg_ptr;
|
|
13
|
+
this.__wbg_ptr = 0;
|
|
14
|
+
BrowserAvatarCoreFinalization.unregister(this);
|
|
15
|
+
return ptr;
|
|
16
|
+
}
|
|
17
|
+
free() {
|
|
18
|
+
const ptr = this.__destroy_into_raw();
|
|
19
|
+
wasm.__wbg_browseravatarcore_free(ptr, 0);
|
|
20
|
+
}
|
|
21
|
+
/**
|
|
22
|
+
* @param {number} index
|
|
23
|
+
* @param {Float32Array} output
|
|
24
|
+
* @param {number} token_count
|
|
25
|
+
* @param {number} dim
|
|
26
|
+
*/
|
|
27
|
+
accept_encoder_output(index, output, token_count, dim) {
|
|
28
|
+
try {
|
|
29
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
30
|
+
const ptr0 = passArrayF32ToWasm0(output, wasm.__wbindgen_export);
|
|
31
|
+
const len0 = WASM_VECTOR_LEN;
|
|
32
|
+
wasm.browseravatarcore_accept_encoder_output(retptr, this.__wbg_ptr, index, ptr0, len0, token_count, dim);
|
|
33
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
34
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
35
|
+
if (r1) {
|
|
36
|
+
throw takeObject(r0);
|
|
37
|
+
}
|
|
38
|
+
} finally {
|
|
39
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
40
|
+
}
|
|
41
|
+
}
|
|
42
|
+
/**
|
|
43
|
+
* @param {Uint32Array} indices
|
|
44
|
+
* @param {Uint8Array} decoded_bgr
|
|
45
|
+
*/
|
|
46
|
+
add_source_frames(indices, decoded_bgr) {
|
|
47
|
+
try {
|
|
48
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
49
|
+
const ptr0 = passArray32ToWasm0(indices, wasm.__wbindgen_export);
|
|
50
|
+
const len0 = WASM_VECTOR_LEN;
|
|
51
|
+
const ptr1 = passArray8ToWasm0(decoded_bgr, wasm.__wbindgen_export);
|
|
52
|
+
const len1 = WASM_VECTOR_LEN;
|
|
53
|
+
wasm.browseravatarcore_add_source_frames(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
54
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
55
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
56
|
+
if (r1) {
|
|
57
|
+
throw takeObject(r0);
|
|
58
|
+
}
|
|
59
|
+
} finally {
|
|
60
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
61
|
+
}
|
|
62
|
+
}
|
|
63
|
+
/**
|
|
64
|
+
* @param {Uint32Array} indices
|
|
65
|
+
* @param {number} len
|
|
66
|
+
*/
|
|
67
|
+
add_source_frames_staged(indices, len) {
|
|
68
|
+
try {
|
|
69
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
70
|
+
const ptr0 = passArray32ToWasm0(indices, wasm.__wbindgen_export);
|
|
71
|
+
const len0 = WASM_VECTOR_LEN;
|
|
72
|
+
wasm.browseravatarcore_add_source_frames_staged(retptr, this.__wbg_ptr, ptr0, len0, len);
|
|
73
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
74
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
75
|
+
if (r1) {
|
|
76
|
+
throw takeObject(r0);
|
|
77
|
+
}
|
|
78
|
+
} finally {
|
|
79
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
80
|
+
}
|
|
81
|
+
}
|
|
82
|
+
/**
|
|
83
|
+
* @param {number} prepared_len
|
|
84
|
+
* @param {number} dim
|
|
85
|
+
* @returns {Uint32Array}
|
|
86
|
+
*/
|
|
87
|
+
cached_predictor_shape(prepared_len, dim) {
|
|
88
|
+
try {
|
|
89
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
90
|
+
wasm.browseravatarcore_cached_predictor_shape(retptr, this.__wbg_ptr, prepared_len, dim);
|
|
91
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
92
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
93
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
94
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
95
|
+
if (r3) {
|
|
96
|
+
throw takeObject(r2);
|
|
97
|
+
}
|
|
98
|
+
var v1 = getArrayU32FromWasm0(r0, r1).slice();
|
|
99
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
100
|
+
return v1;
|
|
101
|
+
} finally {
|
|
102
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
103
|
+
}
|
|
104
|
+
}
|
|
105
|
+
/**
|
|
106
|
+
* @returns {Uint32Array}
|
|
107
|
+
*/
|
|
108
|
+
corrector_source_indices() {
|
|
109
|
+
try {
|
|
110
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
111
|
+
wasm.browseravatarcore_corrector_source_indices(retptr, this.__wbg_ptr);
|
|
112
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
113
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
114
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
115
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
116
|
+
if (r3) {
|
|
117
|
+
throw takeObject(r2);
|
|
118
|
+
}
|
|
119
|
+
var v1 = getArrayU32FromWasm0(r0, r1).slice();
|
|
120
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
121
|
+
return v1;
|
|
122
|
+
} finally {
|
|
123
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
124
|
+
}
|
|
125
|
+
}
|
|
126
|
+
/**
|
|
127
|
+
* @param {number} index
|
|
128
|
+
* @returns {Float32Array}
|
|
129
|
+
*/
|
|
130
|
+
encoder_input(index) {
|
|
131
|
+
try {
|
|
132
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
133
|
+
wasm.browseravatarcore_encoder_input(retptr, this.__wbg_ptr, index);
|
|
134
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
135
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
136
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
137
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
138
|
+
if (r3) {
|
|
139
|
+
throw takeObject(r2);
|
|
140
|
+
}
|
|
141
|
+
var v1 = getArrayF32FromWasm0(r0, r1).slice();
|
|
142
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
143
|
+
return v1;
|
|
144
|
+
} finally {
|
|
145
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
146
|
+
}
|
|
147
|
+
}
|
|
148
|
+
/**
|
|
149
|
+
* @param {number} samples
|
|
150
|
+
* @returns {Uint32Array}
|
|
151
|
+
*/
|
|
152
|
+
encoder_shape(samples) {
|
|
153
|
+
try {
|
|
154
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
155
|
+
wasm.browseravatarcore_encoder_shape(retptr, this.__wbg_ptr, samples);
|
|
156
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
157
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
158
|
+
var v1 = getArrayU32FromWasm0(r0, r1).slice();
|
|
159
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
160
|
+
return v1;
|
|
161
|
+
} finally {
|
|
162
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
163
|
+
}
|
|
164
|
+
}
|
|
165
|
+
/**
|
|
166
|
+
* @returns {number}
|
|
167
|
+
*/
|
|
168
|
+
f32_output_len() {
|
|
169
|
+
const ret = wasm.browseravatarcore_f32_output_len(this.__wbg_ptr);
|
|
170
|
+
return ret >>> 0;
|
|
171
|
+
}
|
|
172
|
+
/**
|
|
173
|
+
* @returns {number}
|
|
174
|
+
*/
|
|
175
|
+
f32_output_ptr() {
|
|
176
|
+
const ret = wasm.browseravatarcore_f32_output_ptr(this.__wbg_ptr);
|
|
177
|
+
return ret >>> 0;
|
|
178
|
+
}
|
|
179
|
+
/**
|
|
180
|
+
* Returns JSON metadata; large buffers remain zero-copy typed-array
|
|
181
|
+
* returns through take_audio_pcm and internal clause storage.
|
|
182
|
+
* @param {boolean} flush
|
|
183
|
+
* @returns {string}
|
|
184
|
+
*/
|
|
185
|
+
finish_audio(flush) {
|
|
186
|
+
let deferred2_0;
|
|
187
|
+
let deferred2_1;
|
|
188
|
+
try {
|
|
189
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
190
|
+
wasm.browseravatarcore_finish_audio(retptr, this.__wbg_ptr, flush);
|
|
191
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
192
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
193
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
194
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
195
|
+
var ptr1 = r0;
|
|
196
|
+
var len1 = r1;
|
|
197
|
+
if (r3) {
|
|
198
|
+
ptr1 = 0; len1 = 0;
|
|
199
|
+
throw takeObject(r2);
|
|
200
|
+
}
|
|
201
|
+
deferred2_0 = ptr1;
|
|
202
|
+
deferred2_1 = len1;
|
|
203
|
+
return getStringFromWasm0(ptr1, len1);
|
|
204
|
+
} finally {
|
|
205
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
206
|
+
wasm.__wbindgen_export2(deferred2_0, deferred2_1, 1);
|
|
207
|
+
}
|
|
208
|
+
}
|
|
209
|
+
/**
|
|
210
|
+
* @param {Float32Array} corrected
|
|
211
|
+
* @param {number} corrector_ms
|
|
212
|
+
* @returns {Uint8Array}
|
|
213
|
+
*/
|
|
214
|
+
finish_corrector(corrected, corrector_ms) {
|
|
215
|
+
try {
|
|
216
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
217
|
+
const ptr0 = passArrayF32ToWasm0(corrected, wasm.__wbindgen_export);
|
|
218
|
+
const len0 = WASM_VECTOR_LEN;
|
|
219
|
+
wasm.browseravatarcore_finish_corrector(retptr, this.__wbg_ptr, ptr0, len0, corrector_ms);
|
|
220
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
221
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
222
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
223
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
224
|
+
if (r3) {
|
|
225
|
+
throw takeObject(r2);
|
|
226
|
+
}
|
|
227
|
+
var v2 = getArrayU8FromWasm0(r0, r1).slice();
|
|
228
|
+
wasm.__wbindgen_export2(r0, r1 * 1, 1);
|
|
229
|
+
return v2;
|
|
230
|
+
} finally {
|
|
231
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
232
|
+
}
|
|
233
|
+
}
|
|
234
|
+
/**
|
|
235
|
+
* @param {number} len
|
|
236
|
+
* @param {number} corrector_ms
|
|
237
|
+
* @returns {number}
|
|
238
|
+
*/
|
|
239
|
+
finish_corrector_staged(len, corrector_ms) {
|
|
240
|
+
try {
|
|
241
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
242
|
+
wasm.browseravatarcore_finish_corrector_staged(retptr, this.__wbg_ptr, len, corrector_ms);
|
|
243
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
244
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
245
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
246
|
+
if (r2) {
|
|
247
|
+
throw takeObject(r1);
|
|
248
|
+
}
|
|
249
|
+
return r0 >>> 0;
|
|
250
|
+
} finally {
|
|
251
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
252
|
+
}
|
|
253
|
+
}
|
|
254
|
+
/**
|
|
255
|
+
* @param {number} clause_id
|
|
256
|
+
* @param {Float32Array} embeddings
|
|
257
|
+
* @returns {Uint32Array}
|
|
258
|
+
*/
|
|
259
|
+
finish_motion_plan(clause_id, embeddings) {
|
|
260
|
+
try {
|
|
261
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
262
|
+
const ptr0 = passArrayF32ToWasm0(embeddings, wasm.__wbindgen_export);
|
|
263
|
+
const len0 = WASM_VECTOR_LEN;
|
|
264
|
+
wasm.browseravatarcore_finish_motion_plan(retptr, this.__wbg_ptr, clause_id, ptr0, len0);
|
|
265
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
266
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
267
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
268
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
269
|
+
if (r3) {
|
|
270
|
+
throw takeObject(r2);
|
|
271
|
+
}
|
|
272
|
+
var v2 = getArrayU32FromWasm0(r0, r1).slice();
|
|
273
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
274
|
+
return v2;
|
|
275
|
+
} finally {
|
|
276
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
277
|
+
}
|
|
278
|
+
}
|
|
279
|
+
/**
|
|
280
|
+
* @param {Float32Array} latents
|
|
281
|
+
* @param {number} predictor_ms
|
|
282
|
+
* @returns {Float32Array}
|
|
283
|
+
*/
|
|
284
|
+
finish_predictor(latents, predictor_ms) {
|
|
285
|
+
try {
|
|
286
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
287
|
+
const ptr0 = passArrayF32ToWasm0(latents, wasm.__wbindgen_export);
|
|
288
|
+
const len0 = WASM_VECTOR_LEN;
|
|
289
|
+
wasm.browseravatarcore_finish_predictor(retptr, this.__wbg_ptr, ptr0, len0, predictor_ms);
|
|
290
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
291
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
292
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
293
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
294
|
+
if (r3) {
|
|
295
|
+
throw takeObject(r2);
|
|
296
|
+
}
|
|
297
|
+
var v2 = getArrayF32FromWasm0(r0, r1).slice();
|
|
298
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
299
|
+
return v2;
|
|
300
|
+
} finally {
|
|
301
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
302
|
+
}
|
|
303
|
+
}
|
|
304
|
+
/**
|
|
305
|
+
* @param {Float32Array} latents
|
|
306
|
+
* @param {number} predictor_ms
|
|
307
|
+
* @returns {Float32Array}
|
|
308
|
+
*/
|
|
309
|
+
finish_predictor_cached(latents, predictor_ms) {
|
|
310
|
+
try {
|
|
311
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
312
|
+
const ptr0 = passArrayF32ToWasm0(latents, wasm.__wbindgen_export);
|
|
313
|
+
const len0 = WASM_VECTOR_LEN;
|
|
314
|
+
wasm.browseravatarcore_finish_predictor_cached(retptr, this.__wbg_ptr, ptr0, len0, predictor_ms);
|
|
315
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
316
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
317
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
318
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
319
|
+
if (r3) {
|
|
320
|
+
throw takeObject(r2);
|
|
321
|
+
}
|
|
322
|
+
var v2 = getArrayF32FromWasm0(r0, r1).slice();
|
|
323
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
324
|
+
return v2;
|
|
325
|
+
} finally {
|
|
326
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
327
|
+
}
|
|
328
|
+
}
|
|
329
|
+
/**
|
|
330
|
+
* @param {number} len
|
|
331
|
+
* @param {number} predictor_ms
|
|
332
|
+
* @returns {number}
|
|
333
|
+
*/
|
|
334
|
+
finish_predictor_cached_staged(len, predictor_ms) {
|
|
335
|
+
try {
|
|
336
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
337
|
+
wasm.browseravatarcore_finish_predictor_cached_staged(retptr, this.__wbg_ptr, len, predictor_ms);
|
|
338
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
339
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
340
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
341
|
+
if (r2) {
|
|
342
|
+
throw takeObject(r1);
|
|
343
|
+
}
|
|
344
|
+
return r0 >>> 0;
|
|
345
|
+
} finally {
|
|
346
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
347
|
+
}
|
|
348
|
+
}
|
|
349
|
+
/**
|
|
350
|
+
* @param {number} len
|
|
351
|
+
* @param {number} predictor_ms
|
|
352
|
+
* @returns {number}
|
|
353
|
+
*/
|
|
354
|
+
finish_predictor_staged(len, predictor_ms) {
|
|
355
|
+
try {
|
|
356
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
357
|
+
wasm.browseravatarcore_finish_predictor_staged(retptr, this.__wbg_ptr, len, predictor_ms);
|
|
358
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
359
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
360
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
361
|
+
if (r2) {
|
|
362
|
+
throw takeObject(r1);
|
|
363
|
+
}
|
|
364
|
+
return r0 >>> 0;
|
|
365
|
+
} finally {
|
|
366
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
367
|
+
}
|
|
368
|
+
}
|
|
369
|
+
/**
|
|
370
|
+
* @param {number} clause_id
|
|
371
|
+
* @param {Float32Array} embeddings
|
|
372
|
+
* @returns {Uint32Array}
|
|
373
|
+
*/
|
|
374
|
+
finish_trajectory_plan(clause_id, embeddings) {
|
|
375
|
+
try {
|
|
376
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
377
|
+
const ptr0 = passArrayF32ToWasm0(embeddings, wasm.__wbindgen_export);
|
|
378
|
+
const len0 = WASM_VECTOR_LEN;
|
|
379
|
+
wasm.browseravatarcore_finish_trajectory_plan(retptr, this.__wbg_ptr, clause_id, ptr0, len0);
|
|
380
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
381
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
382
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
383
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
384
|
+
if (r3) {
|
|
385
|
+
throw takeObject(r2);
|
|
386
|
+
}
|
|
387
|
+
var v2 = getArrayU32FromWasm0(r0, r1).slice();
|
|
388
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
389
|
+
return v2;
|
|
390
|
+
} finally {
|
|
391
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
392
|
+
}
|
|
393
|
+
}
|
|
394
|
+
/**
|
|
395
|
+
* @returns {number}
|
|
396
|
+
*/
|
|
397
|
+
height() {
|
|
398
|
+
const ret = wasm.browseravatarcore_height(this.__wbg_ptr);
|
|
399
|
+
return ret >>> 0;
|
|
400
|
+
}
|
|
401
|
+
/**
|
|
402
|
+
* @param {Float32Array} output
|
|
403
|
+
* @param {number} token_count
|
|
404
|
+
* @param {number} dim
|
|
405
|
+
* @param {number} idle_frames
|
|
406
|
+
*/
|
|
407
|
+
install_idle_embedding(output, token_count, dim, idle_frames) {
|
|
408
|
+
try {
|
|
409
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
410
|
+
const ptr0 = passArrayF32ToWasm0(output, wasm.__wbindgen_export);
|
|
411
|
+
const len0 = WASM_VECTOR_LEN;
|
|
412
|
+
wasm.browseravatarcore_install_idle_embedding(retptr, this.__wbg_ptr, ptr0, len0, token_count, dim, idle_frames);
|
|
413
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
414
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
415
|
+
if (r1) {
|
|
416
|
+
throw takeObject(r0);
|
|
417
|
+
}
|
|
418
|
+
} finally {
|
|
419
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
420
|
+
}
|
|
421
|
+
}
|
|
422
|
+
/**
|
|
423
|
+
* @param {Uint8Array} bytes
|
|
424
|
+
*/
|
|
425
|
+
install_segments(bytes) {
|
|
426
|
+
try {
|
|
427
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
428
|
+
const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
|
|
429
|
+
const len0 = WASM_VECTOR_LEN;
|
|
430
|
+
wasm.browseravatarcore_install_segments(retptr, this.__wbg_ptr, ptr0, len0);
|
|
431
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
432
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
433
|
+
if (r1) {
|
|
434
|
+
throw takeObject(r0);
|
|
435
|
+
}
|
|
436
|
+
} finally {
|
|
437
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
438
|
+
}
|
|
439
|
+
}
|
|
440
|
+
/**
|
|
441
|
+
* @param {Uint8Array} bytes
|
|
442
|
+
*/
|
|
443
|
+
install_trajectory_metadata(bytes) {
|
|
444
|
+
try {
|
|
445
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
446
|
+
const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
|
|
447
|
+
const len0 = WASM_VECTOR_LEN;
|
|
448
|
+
wasm.browseravatarcore_install_trajectory_metadata(retptr, this.__wbg_ptr, ptr0, len0);
|
|
449
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
450
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
451
|
+
if (r1) {
|
|
452
|
+
throw takeObject(r0);
|
|
453
|
+
}
|
|
454
|
+
} finally {
|
|
455
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
456
|
+
}
|
|
457
|
+
}
|
|
458
|
+
interrupt() {
|
|
459
|
+
wasm.browseravatarcore_interrupt(this.__wbg_ptr);
|
|
460
|
+
}
|
|
461
|
+
/**
|
|
462
|
+
* @param {Uint8Array} descriptor_zlib
|
|
463
|
+
* @param {Uint8Array} gaussians_zlib
|
|
464
|
+
* @param {Uint8Array} landmarks_bin
|
|
465
|
+
* @param {Uint8Array} face_mattes_bin
|
|
466
|
+
* @param {Uint8Array} motion_planner_zlib
|
|
467
|
+
* @param {Uint8Array} frame_zero_bgr
|
|
468
|
+
*/
|
|
469
|
+
constructor(descriptor_zlib, gaussians_zlib, landmarks_bin, face_mattes_bin, motion_planner_zlib, frame_zero_bgr) {
|
|
470
|
+
try {
|
|
471
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
472
|
+
const ptr0 = passArray8ToWasm0(descriptor_zlib, wasm.__wbindgen_export);
|
|
473
|
+
const len0 = WASM_VECTOR_LEN;
|
|
474
|
+
const ptr1 = passArray8ToWasm0(gaussians_zlib, wasm.__wbindgen_export);
|
|
475
|
+
const len1 = WASM_VECTOR_LEN;
|
|
476
|
+
const ptr2 = passArray8ToWasm0(landmarks_bin, wasm.__wbindgen_export);
|
|
477
|
+
const len2 = WASM_VECTOR_LEN;
|
|
478
|
+
const ptr3 = passArray8ToWasm0(face_mattes_bin, wasm.__wbindgen_export);
|
|
479
|
+
const len3 = WASM_VECTOR_LEN;
|
|
480
|
+
const ptr4 = passArray8ToWasm0(motion_planner_zlib, wasm.__wbindgen_export);
|
|
481
|
+
const len4 = WASM_VECTOR_LEN;
|
|
482
|
+
const ptr5 = passArray8ToWasm0(frame_zero_bgr, wasm.__wbindgen_export);
|
|
483
|
+
const len5 = WASM_VECTOR_LEN;
|
|
484
|
+
wasm.browseravatarcore_new(retptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
|
|
485
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
486
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
487
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
488
|
+
if (r2) {
|
|
489
|
+
throw takeObject(r1);
|
|
490
|
+
}
|
|
491
|
+
this.__wbg_ptr = r0;
|
|
492
|
+
BrowserAvatarCoreFinalization.register(this, this.__wbg_ptr, this);
|
|
493
|
+
return this;
|
|
494
|
+
} finally {
|
|
495
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
496
|
+
}
|
|
497
|
+
}
|
|
498
|
+
/**
|
|
499
|
+
* Shape descriptor consumed by the otherwise model-agnostic ORT
|
|
500
|
+
* adapter: [batch,audio_context,dim,batch,visual_channels,h,w,audio_len].
|
|
501
|
+
* @param {number} prepared_len
|
|
502
|
+
* @param {number} dim
|
|
503
|
+
* @returns {Uint32Array}
|
|
504
|
+
*/
|
|
505
|
+
predictor_shape(prepared_len, dim) {
|
|
506
|
+
try {
|
|
507
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
508
|
+
wasm.browseravatarcore_predictor_shape(retptr, this.__wbg_ptr, prepared_len, dim);
|
|
509
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
510
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
511
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
512
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
513
|
+
if (r3) {
|
|
514
|
+
throw takeObject(r2);
|
|
515
|
+
}
|
|
516
|
+
var v1 = getArrayU32FromWasm0(r0, r1).slice();
|
|
517
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
518
|
+
return v1;
|
|
519
|
+
} finally {
|
|
520
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
521
|
+
}
|
|
522
|
+
}
|
|
523
|
+
/**
|
|
524
|
+
* @returns {Uint32Array}
|
|
525
|
+
*/
|
|
526
|
+
predictor_source_indices() {
|
|
527
|
+
try {
|
|
528
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
529
|
+
wasm.browseravatarcore_predictor_source_indices(retptr, this.__wbg_ptr);
|
|
530
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
531
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
532
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
533
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
534
|
+
if (r3) {
|
|
535
|
+
throw takeObject(r2);
|
|
536
|
+
}
|
|
537
|
+
var v1 = getArrayU32FromWasm0(r0, r1).slice();
|
|
538
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
539
|
+
return v1;
|
|
540
|
+
} finally {
|
|
541
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
542
|
+
}
|
|
543
|
+
}
|
|
544
|
+
/**
|
|
545
|
+
* Starts one reference-equivalent drain operation. The bridge calls
|
|
546
|
+
* encoder_input/accept_encoder_output for each returned job count.
|
|
547
|
+
* @param {boolean} flush
|
|
548
|
+
* @returns {number}
|
|
549
|
+
*/
|
|
550
|
+
prepare_audio(flush) {
|
|
551
|
+
const ret = wasm.browseravatarcore_prepare_audio(this.__wbg_ptr, flush);
|
|
552
|
+
return ret >>> 0;
|
|
553
|
+
}
|
|
554
|
+
/**
|
|
555
|
+
* @param {boolean} flush
|
|
556
|
+
* @param {boolean} preserve_silence
|
|
557
|
+
* @returns {number}
|
|
558
|
+
*/
|
|
559
|
+
prepare_audio_preserving_silence(flush, preserve_silence) {
|
|
560
|
+
const ret = wasm.browseravatarcore_prepare_audio_preserving_silence(this.__wbg_ptr, flush, preserve_silence);
|
|
561
|
+
return ret >>> 0;
|
|
562
|
+
}
|
|
563
|
+
/**
|
|
564
|
+
* @param {number} clause_id
|
|
565
|
+
* @returns {Float32Array}
|
|
566
|
+
*/
|
|
567
|
+
prepare_motion_plan(clause_id) {
|
|
568
|
+
try {
|
|
569
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
570
|
+
wasm.browseravatarcore_prepare_motion_plan(retptr, this.__wbg_ptr, clause_id);
|
|
571
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
572
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
573
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
574
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
575
|
+
if (r3) {
|
|
576
|
+
throw takeObject(r2);
|
|
577
|
+
}
|
|
578
|
+
var v1 = getArrayF32FromWasm0(r0, r1).slice();
|
|
579
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
580
|
+
return v1;
|
|
581
|
+
} finally {
|
|
582
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
583
|
+
}
|
|
584
|
+
}
|
|
585
|
+
/**
|
|
586
|
+
* Plans a complete caller-owned 16 kHz hop before HuBERT runs. This
|
|
587
|
+
* keeps motion planning proportional to lightweight PCM prosody while
|
|
588
|
+
* the expensive audio/image inference remains independently batched.
|
|
589
|
+
* @param {Int16Array} pcm
|
|
590
|
+
* @param {number} sample_rate
|
|
591
|
+
* @returns {Float32Array}
|
|
592
|
+
*/
|
|
593
|
+
prepare_motion_plan_pcm(pcm, sample_rate) {
|
|
594
|
+
try {
|
|
595
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
596
|
+
const ptr0 = passArray16ToWasm0(pcm, wasm.__wbindgen_export);
|
|
597
|
+
const len0 = WASM_VECTOR_LEN;
|
|
598
|
+
wasm.browseravatarcore_prepare_motion_plan_pcm(retptr, this.__wbg_ptr, ptr0, len0, sample_rate);
|
|
599
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
600
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
601
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
602
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
603
|
+
if (r3) {
|
|
604
|
+
throw takeObject(r2);
|
|
605
|
+
}
|
|
606
|
+
var v2 = getArrayF32FromWasm0(r0, r1).slice();
|
|
607
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
608
|
+
return v2;
|
|
609
|
+
} finally {
|
|
610
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
611
|
+
}
|
|
612
|
+
}
|
|
613
|
+
/**
|
|
614
|
+
* @param {number} clause_id
|
|
615
|
+
* @param {number} start
|
|
616
|
+
* @param {number} count
|
|
617
|
+
* @param {Uint32Array} sources
|
|
618
|
+
* @param {number} stride
|
|
619
|
+
* @returns {Float32Array}
|
|
620
|
+
*/
|
|
621
|
+
prepare_predictor_window(clause_id, start, count, sources, stride) {
|
|
622
|
+
try {
|
|
623
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
624
|
+
const ptr0 = passArray32ToWasm0(sources, wasm.__wbindgen_export);
|
|
625
|
+
const len0 = WASM_VECTOR_LEN;
|
|
626
|
+
wasm.browseravatarcore_prepare_predictor_window(retptr, this.__wbg_ptr, clause_id, start, count, ptr0, len0, stride);
|
|
627
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
628
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
629
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
630
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
631
|
+
if (r3) {
|
|
632
|
+
throw takeObject(r2);
|
|
633
|
+
}
|
|
634
|
+
var v2 = getArrayF32FromWasm0(r0, r1).slice();
|
|
635
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
636
|
+
return v2;
|
|
637
|
+
} finally {
|
|
638
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
639
|
+
}
|
|
640
|
+
}
|
|
641
|
+
/**
|
|
642
|
+
* @param {number} clause_id
|
|
643
|
+
* @param {number} start
|
|
644
|
+
* @param {number} count
|
|
645
|
+
* @param {Uint32Array} sources
|
|
646
|
+
* @param {number} stride
|
|
647
|
+
* @param {Uint8Array} closure_route
|
|
648
|
+
* @returns {Float32Array}
|
|
649
|
+
*/
|
|
650
|
+
prepare_predictor_window_cached(clause_id, start, count, sources, stride, closure_route) {
|
|
651
|
+
try {
|
|
652
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
653
|
+
const ptr0 = passArray32ToWasm0(sources, wasm.__wbindgen_export);
|
|
654
|
+
const len0 = WASM_VECTOR_LEN;
|
|
655
|
+
const ptr1 = passArray8ToWasm0(closure_route, wasm.__wbindgen_export);
|
|
656
|
+
const len1 = WASM_VECTOR_LEN;
|
|
657
|
+
wasm.browseravatarcore_prepare_predictor_window_cached(retptr, this.__wbg_ptr, clause_id, start, count, ptr0, len0, stride, ptr1, len1);
|
|
658
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
659
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
660
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
661
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
662
|
+
if (r3) {
|
|
663
|
+
throw takeObject(r2);
|
|
664
|
+
}
|
|
665
|
+
var v3 = getArrayF32FromWasm0(r0, r1).slice();
|
|
666
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
667
|
+
return v3;
|
|
668
|
+
} finally {
|
|
669
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
670
|
+
}
|
|
671
|
+
}
|
|
672
|
+
/**
|
|
673
|
+
* @param {number} clause_id
|
|
674
|
+
* @param {number} start
|
|
675
|
+
* @param {number} count
|
|
676
|
+
* @param {Uint32Array} sources
|
|
677
|
+
* @param {number} stride
|
|
678
|
+
* @param {Uint8Array} closure_route
|
|
679
|
+
* @returns {number}
|
|
680
|
+
*/
|
|
681
|
+
prepare_predictor_window_cached_staged(clause_id, start, count, sources, stride, closure_route) {
|
|
682
|
+
try {
|
|
683
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
684
|
+
const ptr0 = passArray32ToWasm0(sources, wasm.__wbindgen_export);
|
|
685
|
+
const len0 = WASM_VECTOR_LEN;
|
|
686
|
+
const ptr1 = passArray8ToWasm0(closure_route, wasm.__wbindgen_export);
|
|
687
|
+
const len1 = WASM_VECTOR_LEN;
|
|
688
|
+
wasm.browseravatarcore_prepare_predictor_window_cached_staged(retptr, this.__wbg_ptr, clause_id, start, count, ptr0, len0, stride, ptr1, len1);
|
|
689
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
690
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
691
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
692
|
+
if (r2) {
|
|
693
|
+
throw takeObject(r1);
|
|
694
|
+
}
|
|
695
|
+
return r0 >>> 0;
|
|
696
|
+
} finally {
|
|
697
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
698
|
+
}
|
|
699
|
+
}
|
|
700
|
+
/**
|
|
701
|
+
* @param {number} clause_id
|
|
702
|
+
* @param {number} start
|
|
703
|
+
* @param {number} count
|
|
704
|
+
* @param {Uint32Array} sources
|
|
705
|
+
* @param {number} stride
|
|
706
|
+
* @param {Uint8Array} closure_route
|
|
707
|
+
* @returns {Float32Array}
|
|
708
|
+
*/
|
|
709
|
+
prepare_predictor_window_routed(clause_id, start, count, sources, stride, closure_route) {
|
|
710
|
+
try {
|
|
711
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
712
|
+
const ptr0 = passArray32ToWasm0(sources, wasm.__wbindgen_export);
|
|
713
|
+
const len0 = WASM_VECTOR_LEN;
|
|
714
|
+
const ptr1 = passArray8ToWasm0(closure_route, wasm.__wbindgen_export);
|
|
715
|
+
const len1 = WASM_VECTOR_LEN;
|
|
716
|
+
wasm.browseravatarcore_prepare_predictor_window_routed(retptr, this.__wbg_ptr, clause_id, start, count, ptr0, len0, stride, ptr1, len1);
|
|
717
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
718
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
719
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
720
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
721
|
+
if (r3) {
|
|
722
|
+
throw takeObject(r2);
|
|
723
|
+
}
|
|
724
|
+
var v3 = getArrayF32FromWasm0(r0, r1).slice();
|
|
725
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
726
|
+
return v3;
|
|
727
|
+
} finally {
|
|
728
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
729
|
+
}
|
|
730
|
+
}
|
|
731
|
+
/**
|
|
732
|
+
* @param {number} clause_id
|
|
733
|
+
* @param {number} start
|
|
734
|
+
* @param {number} count
|
|
735
|
+
* @param {Uint32Array} sources
|
|
736
|
+
* @param {number} stride
|
|
737
|
+
* @param {Uint8Array} closure_route
|
|
738
|
+
* @returns {number}
|
|
739
|
+
*/
|
|
740
|
+
prepare_predictor_window_routed_staged(clause_id, start, count, sources, stride, closure_route) {
|
|
741
|
+
try {
|
|
742
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
743
|
+
const ptr0 = passArray32ToWasm0(sources, wasm.__wbindgen_export);
|
|
744
|
+
const len0 = WASM_VECTOR_LEN;
|
|
745
|
+
const ptr1 = passArray8ToWasm0(closure_route, wasm.__wbindgen_export);
|
|
746
|
+
const len1 = WASM_VECTOR_LEN;
|
|
747
|
+
wasm.browseravatarcore_prepare_predictor_window_routed_staged(retptr, this.__wbg_ptr, clause_id, start, count, ptr0, len0, stride, ptr1, len1);
|
|
748
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
749
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
750
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
751
|
+
if (r2) {
|
|
752
|
+
throw takeObject(r1);
|
|
753
|
+
}
|
|
754
|
+
return r0 >>> 0;
|
|
755
|
+
} finally {
|
|
756
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
757
|
+
}
|
|
758
|
+
}
|
|
759
|
+
/**
|
|
760
|
+
* @param {number} clause_id
|
|
761
|
+
* @param {number} start
|
|
762
|
+
* @param {number} count
|
|
763
|
+
* @param {Uint32Array} sources
|
|
764
|
+
* @param {number} stride
|
|
765
|
+
*/
|
|
766
|
+
prepare_predictor_window_staged(clause_id, start, count, sources, stride) {
|
|
767
|
+
try {
|
|
768
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
769
|
+
const ptr0 = passArray32ToWasm0(sources, wasm.__wbindgen_export);
|
|
770
|
+
const len0 = WASM_VECTOR_LEN;
|
|
771
|
+
wasm.browseravatarcore_prepare_predictor_window_staged(retptr, this.__wbg_ptr, clause_id, start, count, ptr0, len0, stride);
|
|
772
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
773
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
774
|
+
if (r1) {
|
|
775
|
+
throw takeObject(r0);
|
|
776
|
+
}
|
|
777
|
+
} finally {
|
|
778
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
779
|
+
}
|
|
780
|
+
}
|
|
781
|
+
/**
|
|
782
|
+
* @param {number} clause_id
|
|
783
|
+
* @returns {Float32Array}
|
|
784
|
+
*/
|
|
785
|
+
prepare_trajectory_plan(clause_id) {
|
|
786
|
+
try {
|
|
787
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
788
|
+
wasm.browseravatarcore_prepare_trajectory_plan(retptr, this.__wbg_ptr, clause_id);
|
|
789
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
790
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
791
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
792
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
793
|
+
if (r3) {
|
|
794
|
+
throw takeObject(r2);
|
|
795
|
+
}
|
|
796
|
+
var v1 = getArrayF32FromWasm0(r0, r1).slice();
|
|
797
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
798
|
+
return v1;
|
|
799
|
+
} finally {
|
|
800
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
801
|
+
}
|
|
802
|
+
}
|
|
803
|
+
/**
|
|
804
|
+
* @returns {string}
|
|
805
|
+
*/
|
|
806
|
+
profile_json() {
|
|
807
|
+
let deferred2_0;
|
|
808
|
+
let deferred2_1;
|
|
809
|
+
try {
|
|
810
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
811
|
+
wasm.browseravatarcore_profile_json(retptr, this.__wbg_ptr);
|
|
812
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
813
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
814
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
815
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
816
|
+
var ptr1 = r0;
|
|
817
|
+
var len1 = r1;
|
|
818
|
+
if (r3) {
|
|
819
|
+
ptr1 = 0; len1 = 0;
|
|
820
|
+
throw takeObject(r2);
|
|
821
|
+
}
|
|
822
|
+
deferred2_0 = ptr1;
|
|
823
|
+
deferred2_1 = len1;
|
|
824
|
+
return getStringFromWasm0(ptr1, len1);
|
|
825
|
+
} finally {
|
|
826
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
827
|
+
wasm.__wbindgen_export2(deferred2_0, deferred2_1, 1);
|
|
828
|
+
}
|
|
829
|
+
}
|
|
830
|
+
/**
|
|
831
|
+
* @param {Int16Array} pcm
|
|
832
|
+
* @param {number} sample_rate
|
|
833
|
+
*/
|
|
834
|
+
push_audio(pcm, sample_rate) {
|
|
835
|
+
try {
|
|
836
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
837
|
+
const ptr0 = passArray16ToWasm0(pcm, wasm.__wbindgen_export);
|
|
838
|
+
const len0 = WASM_VECTOR_LEN;
|
|
839
|
+
wasm.browseravatarcore_push_audio(retptr, this.__wbg_ptr, ptr0, len0, sample_rate);
|
|
840
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
841
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
842
|
+
if (r1) {
|
|
843
|
+
throw takeObject(r0);
|
|
844
|
+
}
|
|
845
|
+
} finally {
|
|
846
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
847
|
+
}
|
|
848
|
+
}
|
|
849
|
+
/**
|
|
850
|
+
* @param {number} clause_id
|
|
851
|
+
*/
|
|
852
|
+
release_clause(clause_id) {
|
|
853
|
+
wasm.browseravatarcore_release_clause(this.__wbg_ptr, clause_id);
|
|
854
|
+
}
|
|
855
|
+
/**
|
|
856
|
+
* @param {number} len
|
|
857
|
+
* @returns {number}
|
|
858
|
+
*/
|
|
859
|
+
reserve_f32_input(len) {
|
|
860
|
+
const ret = wasm.browseravatarcore_reserve_f32_input(this.__wbg_ptr, len);
|
|
861
|
+
return ret >>> 0;
|
|
862
|
+
}
|
|
863
|
+
/**
|
|
864
|
+
* @param {number} len
|
|
865
|
+
* @returns {number}
|
|
866
|
+
*/
|
|
867
|
+
reserve_u8_input(len) {
|
|
868
|
+
const ret = wasm.browseravatarcore_reserve_u8_input(this.__wbg_ptr, len);
|
|
869
|
+
return ret >>> 0;
|
|
870
|
+
}
|
|
871
|
+
/**
|
|
872
|
+
* @param {number} clause_id
|
|
873
|
+
* @returns {Float32Array}
|
|
874
|
+
*/
|
|
875
|
+
router_input(clause_id) {
|
|
876
|
+
try {
|
|
877
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
878
|
+
wasm.browseravatarcore_router_input(retptr, this.__wbg_ptr, clause_id);
|
|
879
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
880
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
881
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
882
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
883
|
+
if (r3) {
|
|
884
|
+
throw takeObject(r2);
|
|
885
|
+
}
|
|
886
|
+
var v1 = getArrayF32FromWasm0(r0, r1).slice();
|
|
887
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
888
|
+
return v1;
|
|
889
|
+
} finally {
|
|
890
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
891
|
+
}
|
|
892
|
+
}
|
|
893
|
+
/**
|
|
894
|
+
* @param {number} clause_id
|
|
895
|
+
* @returns {Uint32Array}
|
|
896
|
+
*/
|
|
897
|
+
segment_plan(clause_id) {
|
|
898
|
+
try {
|
|
899
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
900
|
+
wasm.browseravatarcore_segment_plan(retptr, this.__wbg_ptr, clause_id);
|
|
901
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
902
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
903
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
904
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
905
|
+
if (r3) {
|
|
906
|
+
throw takeObject(r2);
|
|
907
|
+
}
|
|
908
|
+
var v1 = getArrayU32FromWasm0(r0, r1).slice();
|
|
909
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
910
|
+
return v1;
|
|
911
|
+
} finally {
|
|
912
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
913
|
+
}
|
|
914
|
+
}
|
|
915
|
+
/**
|
|
916
|
+
* @param {number} clause_id
|
|
917
|
+
* @param {number} offset
|
|
918
|
+
*/
|
|
919
|
+
set_clause_feature_offset(clause_id, offset) {
|
|
920
|
+
try {
|
|
921
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
922
|
+
wasm.browseravatarcore_set_clause_feature_offset(retptr, this.__wbg_ptr, clause_id, offset);
|
|
923
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
924
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
925
|
+
if (r1) {
|
|
926
|
+
throw takeObject(r0);
|
|
927
|
+
}
|
|
928
|
+
} finally {
|
|
929
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
930
|
+
}
|
|
931
|
+
}
|
|
932
|
+
/**
|
|
933
|
+
* @param {Float32Array} features
|
|
934
|
+
* @param {number} frames
|
|
935
|
+
* @param {number} dim
|
|
936
|
+
*/
|
|
937
|
+
set_full_audio_features(features, frames, dim) {
|
|
938
|
+
try {
|
|
939
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
940
|
+
const ptr0 = passArrayF32ToWasm0(features, wasm.__wbindgen_export);
|
|
941
|
+
const len0 = WASM_VECTOR_LEN;
|
|
942
|
+
wasm.browseravatarcore_set_full_audio_features(retptr, this.__wbg_ptr, ptr0, len0, frames, dim);
|
|
943
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
944
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
945
|
+
if (r1) {
|
|
946
|
+
throw takeObject(r0);
|
|
947
|
+
}
|
|
948
|
+
} finally {
|
|
949
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
950
|
+
}
|
|
951
|
+
}
|
|
952
|
+
/**
|
|
953
|
+
* @param {number} count
|
|
954
|
+
* @returns {Uint32Array}
|
|
955
|
+
*/
|
|
956
|
+
silence_plan(count) {
|
|
957
|
+
try {
|
|
958
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
959
|
+
wasm.browseravatarcore_silence_plan(retptr, this.__wbg_ptr, count);
|
|
960
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
961
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
962
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
963
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
964
|
+
if (r3) {
|
|
965
|
+
throw takeObject(r2);
|
|
966
|
+
}
|
|
967
|
+
var v1 = getArrayU32FromWasm0(r0, r1).slice();
|
|
968
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
969
|
+
return v1;
|
|
970
|
+
} finally {
|
|
971
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
972
|
+
}
|
|
973
|
+
}
|
|
974
|
+
/**
|
|
975
|
+
* @returns {Float32Array}
|
|
976
|
+
*/
|
|
977
|
+
take_audio_pcm() {
|
|
978
|
+
try {
|
|
979
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
980
|
+
wasm.browseravatarcore_take_audio_pcm(retptr, this.__wbg_ptr);
|
|
981
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
982
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
983
|
+
var v1 = getArrayF32FromWasm0(r0, r1).slice();
|
|
984
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
985
|
+
return v1;
|
|
986
|
+
} finally {
|
|
987
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
988
|
+
}
|
|
989
|
+
}
|
|
990
|
+
/**
|
|
991
|
+
* @param {number} count
|
|
992
|
+
* @returns {Uint32Array}
|
|
993
|
+
*/
|
|
994
|
+
trajectory_silence_plan(count) {
|
|
995
|
+
try {
|
|
996
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
997
|
+
wasm.browseravatarcore_trajectory_silence_plan(retptr, this.__wbg_ptr, count);
|
|
998
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
999
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1000
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1001
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
1002
|
+
if (r3) {
|
|
1003
|
+
throw takeObject(r2);
|
|
1004
|
+
}
|
|
1005
|
+
var v1 = getArrayU32FromWasm0(r0, r1).slice();
|
|
1006
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
1007
|
+
return v1;
|
|
1008
|
+
} finally {
|
|
1009
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1010
|
+
}
|
|
1011
|
+
}
|
|
1012
|
+
/**
|
|
1013
|
+
* Motion-compensated three-frame handoff between two fully rendered
|
|
1014
|
+
* RGBA frames. Callers retain the source frames and select t in (0,1).
|
|
1015
|
+
* @param {Uint8Array} left
|
|
1016
|
+
* @param {Uint8Array} right
|
|
1017
|
+
* @param {number} t
|
|
1018
|
+
* @returns {Uint8Array}
|
|
1019
|
+
*/
|
|
1020
|
+
tween_rgba(left, right, t) {
|
|
1021
|
+
try {
|
|
1022
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1023
|
+
const ptr0 = passArray8ToWasm0(left, wasm.__wbindgen_export);
|
|
1024
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1025
|
+
const ptr1 = passArray8ToWasm0(right, wasm.__wbindgen_export);
|
|
1026
|
+
const len1 = WASM_VECTOR_LEN;
|
|
1027
|
+
wasm.browseravatarcore_tween_rgba(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, t);
|
|
1028
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1029
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1030
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1031
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
1032
|
+
if (r3) {
|
|
1033
|
+
throw takeObject(r2);
|
|
1034
|
+
}
|
|
1035
|
+
var v3 = getArrayU8FromWasm0(r0, r1).slice();
|
|
1036
|
+
wasm.__wbindgen_export2(r0, r1 * 1, 1);
|
|
1037
|
+
return v3;
|
|
1038
|
+
} finally {
|
|
1039
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1040
|
+
}
|
|
1041
|
+
}
|
|
1042
|
+
/**
|
|
1043
|
+
* @returns {number}
|
|
1044
|
+
*/
|
|
1045
|
+
u8_output_len() {
|
|
1046
|
+
const ret = wasm.browseravatarcore_u8_output_len(this.__wbg_ptr);
|
|
1047
|
+
return ret >>> 0;
|
|
1048
|
+
}
|
|
1049
|
+
/**
|
|
1050
|
+
* @returns {number}
|
|
1051
|
+
*/
|
|
1052
|
+
u8_output_ptr() {
|
|
1053
|
+
const ret = wasm.browseravatarcore_u8_output_ptr(this.__wbg_ptr);
|
|
1054
|
+
return ret >>> 0;
|
|
1055
|
+
}
|
|
1056
|
+
/**
|
|
1057
|
+
* @returns {number}
|
|
1058
|
+
*/
|
|
1059
|
+
width() {
|
|
1060
|
+
const ret = wasm.browseravatarcore_width(this.__wbg_ptr);
|
|
1061
|
+
return ret >>> 0;
|
|
1062
|
+
}
|
|
1063
|
+
}
|
|
1064
|
+
if (Symbol.dispose) BrowserAvatarCore.prototype[Symbol.dispose] = BrowserAvatarCore.prototype.free;
|
|
1065
|
+
|
|
1066
|
+
/**
|
|
1067
|
+
* @param {string} data
|
|
1068
|
+
* @param {number} frames
|
|
1069
|
+
* @param {number} dim
|
|
1070
|
+
* @param {string} key
|
|
1071
|
+
* @returns {Float32Array}
|
|
1072
|
+
*/
|
|
1073
|
+
export function decode_embedding_payload(data, frames, dim, key) {
|
|
1074
|
+
try {
|
|
1075
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1076
|
+
const ptr0 = passStringToWasm0(data, wasm.__wbindgen_export, wasm.__wbindgen_export3);
|
|
1077
|
+
const len0 = WASM_VECTOR_LEN;
|
|
1078
|
+
const ptr1 = passStringToWasm0(key, wasm.__wbindgen_export, wasm.__wbindgen_export3);
|
|
1079
|
+
const len1 = WASM_VECTOR_LEN;
|
|
1080
|
+
wasm.decode_embedding_payload(retptr, ptr0, len0, frames, dim, ptr1, len1);
|
|
1081
|
+
var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
|
|
1082
|
+
var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
|
|
1083
|
+
var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
|
|
1084
|
+
var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
|
|
1085
|
+
if (r3) {
|
|
1086
|
+
throw takeObject(r2);
|
|
1087
|
+
}
|
|
1088
|
+
var v3 = getArrayF32FromWasm0(r0, r1).slice();
|
|
1089
|
+
wasm.__wbindgen_export2(r0, r1 * 4, 4);
|
|
1090
|
+
return v3;
|
|
1091
|
+
} finally {
|
|
1092
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1093
|
+
}
|
|
1094
|
+
}
|
|
1095
|
+
|
|
1096
|
+
/**
|
|
1097
|
+
* @param {number} num_threads
|
|
1098
|
+
* @returns {Promise<any>}
|
|
1099
|
+
*/
|
|
1100
|
+
export function initThreadPool(num_threads) {
|
|
1101
|
+
const ret = wasm.initThreadPool(num_threads);
|
|
1102
|
+
return takeObject(ret);
|
|
1103
|
+
}
|
|
1104
|
+
|
|
1105
|
+
export class wbg_rayon_PoolBuilder {
|
|
1106
|
+
static __wrap(ptr) {
|
|
1107
|
+
const obj = Object.create(wbg_rayon_PoolBuilder.prototype);
|
|
1108
|
+
obj.__wbg_ptr = ptr;
|
|
1109
|
+
wbg_rayon_PoolBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
|
|
1110
|
+
return obj;
|
|
1111
|
+
}
|
|
1112
|
+
__destroy_into_raw() {
|
|
1113
|
+
const ptr = this.__wbg_ptr;
|
|
1114
|
+
this.__wbg_ptr = 0;
|
|
1115
|
+
wbg_rayon_PoolBuilderFinalization.unregister(this);
|
|
1116
|
+
return ptr;
|
|
1117
|
+
}
|
|
1118
|
+
free() {
|
|
1119
|
+
const ptr = this.__destroy_into_raw();
|
|
1120
|
+
wasm.__wbg_wbg_rayon_poolbuilder_free(ptr, 0);
|
|
1121
|
+
}
|
|
1122
|
+
build() {
|
|
1123
|
+
wasm.wbg_rayon_poolbuilder_build(this.__wbg_ptr);
|
|
1124
|
+
}
|
|
1125
|
+
/**
|
|
1126
|
+
* @returns {number}
|
|
1127
|
+
*/
|
|
1128
|
+
numThreads() {
|
|
1129
|
+
const ret = wasm.wbg_rayon_poolbuilder_numThreads(this.__wbg_ptr);
|
|
1130
|
+
return ret >>> 0;
|
|
1131
|
+
}
|
|
1132
|
+
/**
|
|
1133
|
+
* @returns {number}
|
|
1134
|
+
*/
|
|
1135
|
+
receiver() {
|
|
1136
|
+
const ret = wasm.wbg_rayon_poolbuilder_receiver(this.__wbg_ptr);
|
|
1137
|
+
return ret >>> 0;
|
|
1138
|
+
}
|
|
1139
|
+
}
|
|
1140
|
+
if (Symbol.dispose) wbg_rayon_PoolBuilder.prototype[Symbol.dispose] = wbg_rayon_PoolBuilder.prototype.free;
|
|
1141
|
+
|
|
1142
|
+
/**
|
|
1143
|
+
* @param {number} receiver
|
|
1144
|
+
*/
|
|
1145
|
+
export function wbg_rayon_start_worker(receiver) {
|
|
1146
|
+
wasm.wbg_rayon_start_worker(receiver);
|
|
1147
|
+
}
|
|
1148
|
+
function __wbg_get_imports(memory) {
|
|
1149
|
+
const import0 = {
|
|
1150
|
+
__proto__: null,
|
|
1151
|
+
__wbg_Error_30c8987f7c2ed4e2: function(arg0, arg1) {
|
|
1152
|
+
const ret = Error(getStringFromWasm0(arg0, arg1));
|
|
1153
|
+
return addHeapObject(ret);
|
|
1154
|
+
},
|
|
1155
|
+
__wbg___wbindgen_is_undefined_8865fb403f8fe9d8: function(arg0) {
|
|
1156
|
+
const ret = getObject(arg0) === undefined;
|
|
1157
|
+
return ret;
|
|
1158
|
+
},
|
|
1159
|
+
__wbg___wbindgen_memory_caa4a6165639c8b5: function() {
|
|
1160
|
+
const ret = wasm.memory;
|
|
1161
|
+
return addHeapObject(ret);
|
|
1162
|
+
},
|
|
1163
|
+
__wbg___wbindgen_module_7115fb14045f9891: function() {
|
|
1164
|
+
const ret = wasmModule;
|
|
1165
|
+
return addHeapObject(ret);
|
|
1166
|
+
},
|
|
1167
|
+
__wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
|
|
1168
|
+
throw new Error(getStringFromWasm0(arg0, arg1));
|
|
1169
|
+
},
|
|
1170
|
+
__wbg_instanceof_Window_82d71df4eddf88bc: function(arg0) {
|
|
1171
|
+
let result;
|
|
1172
|
+
try {
|
|
1173
|
+
result = getObject(arg0) instanceof Window;
|
|
1174
|
+
} catch (_) {
|
|
1175
|
+
result = false;
|
|
1176
|
+
}
|
|
1177
|
+
const ret = result;
|
|
1178
|
+
return ret;
|
|
1179
|
+
},
|
|
1180
|
+
__wbg_now_aa4ccb83129e9e55: function() {
|
|
1181
|
+
const ret = Date.now();
|
|
1182
|
+
return ret;
|
|
1183
|
+
},
|
|
1184
|
+
__wbg_startWorkers_8b582d57e92bd2d4: function(arg0, arg1, arg2) {
|
|
1185
|
+
const ret = startWorkers(takeObject(arg0), takeObject(arg1), wbg_rayon_PoolBuilder.__wrap(arg2));
|
|
1186
|
+
return addHeapObject(ret);
|
|
1187
|
+
},
|
|
1188
|
+
__wbg_static_accessor_GLOBAL_266715b9d96ba635: function() {
|
|
1189
|
+
const ret = typeof global === 'undefined' ? null : global;
|
|
1190
|
+
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
|
1191
|
+
},
|
|
1192
|
+
__wbg_static_accessor_GLOBAL_THIS_10fb7dc1ae063179: function() {
|
|
1193
|
+
const ret = typeof globalThis === 'undefined' ? null : globalThis;
|
|
1194
|
+
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
|
1195
|
+
},
|
|
1196
|
+
__wbg_static_accessor_SELF_0b583911f537483a: function() {
|
|
1197
|
+
const ret = typeof self === 'undefined' ? null : self;
|
|
1198
|
+
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
|
1199
|
+
},
|
|
1200
|
+
__wbg_static_accessor_WINDOW_d7f903d1508cbdc4: function() {
|
|
1201
|
+
const ret = typeof window === 'undefined' ? null : window;
|
|
1202
|
+
return isLikeNone(ret) ? 0 : addHeapObject(ret);
|
|
1203
|
+
},
|
|
1204
|
+
__wbindgen_object_clone_ref: function(arg0) {
|
|
1205
|
+
const ret = getObject(arg0);
|
|
1206
|
+
return addHeapObject(ret);
|
|
1207
|
+
},
|
|
1208
|
+
__wbindgen_object_drop_ref: function(arg0) {
|
|
1209
|
+
takeObject(arg0);
|
|
1210
|
+
},
|
|
1211
|
+
memory: memory || new WebAssembly.Memory({initial:18,maximum:32768,shared:true}),
|
|
1212
|
+
};
|
|
1213
|
+
return {
|
|
1214
|
+
__proto__: null,
|
|
1215
|
+
"./bevyra-core_bg.js": import0,
|
|
1216
|
+
};
|
|
1217
|
+
}
|
|
1218
|
+
|
|
1219
|
+
const BrowserAvatarCoreFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
1220
|
+
? { register: () => {}, unregister: () => {} }
|
|
1221
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_browseravatarcore_free(ptr, 1));
|
|
1222
|
+
const wbg_rayon_PoolBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
1223
|
+
? { register: () => {}, unregister: () => {} }
|
|
1224
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_wbg_rayon_poolbuilder_free(ptr, 1));
|
|
1225
|
+
|
|
1226
|
+
function addHeapObject(obj) {
|
|
1227
|
+
if (heap_next === heap.length) heap.push(heap.length + 1);
|
|
1228
|
+
const idx = heap_next;
|
|
1229
|
+
heap_next = heap[idx];
|
|
1230
|
+
|
|
1231
|
+
heap[idx] = obj;
|
|
1232
|
+
return idx;
|
|
1233
|
+
}
|
|
1234
|
+
|
|
1235
|
+
function dropObject(idx) {
|
|
1236
|
+
if (idx < 1028) return;
|
|
1237
|
+
heap[idx] = heap_next;
|
|
1238
|
+
heap_next = idx;
|
|
1239
|
+
}
|
|
1240
|
+
|
|
1241
|
+
function getArrayF32FromWasm0(ptr, len) {
|
|
1242
|
+
ptr = ptr >>> 0;
|
|
1243
|
+
return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
|
|
1244
|
+
}
|
|
1245
|
+
|
|
1246
|
+
function getArrayU32FromWasm0(ptr, len) {
|
|
1247
|
+
ptr = ptr >>> 0;
|
|
1248
|
+
return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
|
|
1249
|
+
}
|
|
1250
|
+
|
|
1251
|
+
function getArrayU8FromWasm0(ptr, len) {
|
|
1252
|
+
ptr = ptr >>> 0;
|
|
1253
|
+
return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
|
|
1254
|
+
}
|
|
1255
|
+
|
|
1256
|
+
let cachedDataViewMemory0 = null;
|
|
1257
|
+
function getDataViewMemory0() {
|
|
1258
|
+
if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
|
|
1259
|
+
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
|
|
1260
|
+
}
|
|
1261
|
+
return cachedDataViewMemory0;
|
|
1262
|
+
}
|
|
1263
|
+
|
|
1264
|
+
let cachedFloat32ArrayMemory0 = null;
|
|
1265
|
+
function getFloat32ArrayMemory0() {
|
|
1266
|
+
if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.buffer !== wasm.memory.buffer) {
|
|
1267
|
+
cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
|
|
1268
|
+
}
|
|
1269
|
+
return cachedFloat32ArrayMemory0;
|
|
1270
|
+
}
|
|
1271
|
+
|
|
1272
|
+
function getStringFromWasm0(ptr, len) {
|
|
1273
|
+
return decodeText(ptr >>> 0, len);
|
|
1274
|
+
}
|
|
1275
|
+
|
|
1276
|
+
let cachedUint16ArrayMemory0 = null;
|
|
1277
|
+
function getUint16ArrayMemory0() {
|
|
1278
|
+
if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.buffer !== wasm.memory.buffer) {
|
|
1279
|
+
cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
|
|
1280
|
+
}
|
|
1281
|
+
return cachedUint16ArrayMemory0;
|
|
1282
|
+
}
|
|
1283
|
+
|
|
1284
|
+
let cachedUint32ArrayMemory0 = null;
|
|
1285
|
+
function getUint32ArrayMemory0() {
|
|
1286
|
+
if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.buffer !== wasm.memory.buffer) {
|
|
1287
|
+
cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
|
|
1288
|
+
}
|
|
1289
|
+
return cachedUint32ArrayMemory0;
|
|
1290
|
+
}
|
|
1291
|
+
|
|
1292
|
+
let cachedUint8ArrayMemory0 = null;
|
|
1293
|
+
function getUint8ArrayMemory0() {
|
|
1294
|
+
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.buffer !== wasm.memory.buffer) {
|
|
1295
|
+
cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
|
|
1296
|
+
}
|
|
1297
|
+
return cachedUint8ArrayMemory0;
|
|
1298
|
+
}
|
|
1299
|
+
|
|
1300
|
+
function getObject(idx) { return heap[idx]; }
|
|
1301
|
+
|
|
1302
|
+
let heap = new Array(1024).fill(undefined);
|
|
1303
|
+
heap.push(undefined, null, true, false);
|
|
1304
|
+
|
|
1305
|
+
let heap_next = heap.length;
|
|
1306
|
+
|
|
1307
|
+
function isLikeNone(x) {
|
|
1308
|
+
return x === undefined || x === null;
|
|
1309
|
+
}
|
|
1310
|
+
|
|
1311
|
+
function passArray16ToWasm0(arg, malloc) {
|
|
1312
|
+
const ptr = malloc(arg.length * 2, 2) >>> 0;
|
|
1313
|
+
getUint16ArrayMemory0().set(arg, ptr / 2);
|
|
1314
|
+
WASM_VECTOR_LEN = arg.length;
|
|
1315
|
+
return ptr;
|
|
1316
|
+
}
|
|
1317
|
+
|
|
1318
|
+
function passArray32ToWasm0(arg, malloc) {
|
|
1319
|
+
const ptr = malloc(arg.length * 4, 4) >>> 0;
|
|
1320
|
+
getUint32ArrayMemory0().set(arg, ptr / 4);
|
|
1321
|
+
WASM_VECTOR_LEN = arg.length;
|
|
1322
|
+
return ptr;
|
|
1323
|
+
}
|
|
1324
|
+
|
|
1325
|
+
function passArray8ToWasm0(arg, malloc) {
|
|
1326
|
+
const ptr = malloc(arg.length * 1, 1) >>> 0;
|
|
1327
|
+
getUint8ArrayMemory0().set(arg, ptr / 1);
|
|
1328
|
+
WASM_VECTOR_LEN = arg.length;
|
|
1329
|
+
return ptr;
|
|
1330
|
+
}
|
|
1331
|
+
|
|
1332
|
+
function passArrayF32ToWasm0(arg, malloc) {
|
|
1333
|
+
const ptr = malloc(arg.length * 4, 4) >>> 0;
|
|
1334
|
+
getFloat32ArrayMemory0().set(arg, ptr / 4);
|
|
1335
|
+
WASM_VECTOR_LEN = arg.length;
|
|
1336
|
+
return ptr;
|
|
1337
|
+
}
|
|
1338
|
+
|
|
1339
|
+
function passStringToWasm0(arg, malloc, realloc) {
|
|
1340
|
+
if (realloc === undefined) {
|
|
1341
|
+
const buf = cachedTextEncoder.encode(arg);
|
|
1342
|
+
const ptr = malloc(buf.length, 1) >>> 0;
|
|
1343
|
+
getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
|
|
1344
|
+
WASM_VECTOR_LEN = buf.length;
|
|
1345
|
+
return ptr;
|
|
1346
|
+
}
|
|
1347
|
+
|
|
1348
|
+
let len = arg.length;
|
|
1349
|
+
let ptr = malloc(len, 1) >>> 0;
|
|
1350
|
+
|
|
1351
|
+
const mem = getUint8ArrayMemory0();
|
|
1352
|
+
|
|
1353
|
+
let offset = 0;
|
|
1354
|
+
|
|
1355
|
+
for (; offset < len; offset++) {
|
|
1356
|
+
const code = arg.charCodeAt(offset);
|
|
1357
|
+
if (code > 0x7F) break;
|
|
1358
|
+
mem[ptr + offset] = code;
|
|
1359
|
+
}
|
|
1360
|
+
if (offset !== len) {
|
|
1361
|
+
if (offset !== 0) {
|
|
1362
|
+
arg = arg.slice(offset);
|
|
1363
|
+
}
|
|
1364
|
+
ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
|
|
1365
|
+
const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
|
|
1366
|
+
const ret = cachedTextEncoder.encodeInto(arg, view);
|
|
1367
|
+
|
|
1368
|
+
offset += ret.written;
|
|
1369
|
+
ptr = realloc(ptr, len, offset, 1) >>> 0;
|
|
1370
|
+
}
|
|
1371
|
+
|
|
1372
|
+
WASM_VECTOR_LEN = offset;
|
|
1373
|
+
return ptr;
|
|
1374
|
+
}
|
|
1375
|
+
|
|
1376
|
+
function takeObject(idx) {
|
|
1377
|
+
const ret = getObject(idx);
|
|
1378
|
+
dropObject(idx);
|
|
1379
|
+
return ret;
|
|
1380
|
+
}
|
|
1381
|
+
|
|
1382
|
+
let cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : undefined);
|
|
1383
|
+
if (cachedTextDecoder) cachedTextDecoder.decode();
|
|
1384
|
+
|
|
1385
|
+
const MAX_SAFARI_DECODE_BYTES = 2146435072;
|
|
1386
|
+
let numBytesDecoded = 0;
|
|
1387
|
+
function decodeText(ptr, len) {
|
|
1388
|
+
numBytesDecoded += len;
|
|
1389
|
+
if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
|
|
1390
|
+
cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
|
|
1391
|
+
cachedTextDecoder.decode();
|
|
1392
|
+
numBytesDecoded = len;
|
|
1393
|
+
}
|
|
1394
|
+
return cachedTextDecoder.decode(getUint8ArrayMemory0().slice(ptr, ptr + len));
|
|
1395
|
+
}
|
|
1396
|
+
|
|
1397
|
+
const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder() : undefined);
|
|
1398
|
+
|
|
1399
|
+
if (cachedTextEncoder) {
|
|
1400
|
+
cachedTextEncoder.encodeInto = function (arg, view) {
|
|
1401
|
+
const buf = cachedTextEncoder.encode(arg);
|
|
1402
|
+
view.set(buf);
|
|
1403
|
+
return {
|
|
1404
|
+
read: arg.length,
|
|
1405
|
+
written: buf.length
|
|
1406
|
+
};
|
|
1407
|
+
};
|
|
1408
|
+
}
|
|
1409
|
+
|
|
1410
|
+
let WASM_VECTOR_LEN = 0;
|
|
1411
|
+
|
|
1412
|
+
let wasmModule, wasmInstance, wasm;
|
|
1413
|
+
function __wbg_finalize_init(instance, module, thread_stack_size) {
|
|
1414
|
+
wasmInstance = instance;
|
|
1415
|
+
wasm = instance.exports;
|
|
1416
|
+
wasmModule = module;
|
|
1417
|
+
cachedDataViewMemory0 = null;
|
|
1418
|
+
cachedFloat32ArrayMemory0 = null;
|
|
1419
|
+
cachedUint16ArrayMemory0 = null;
|
|
1420
|
+
cachedUint32ArrayMemory0 = null;
|
|
1421
|
+
cachedUint8ArrayMemory0 = null;
|
|
1422
|
+
if (typeof thread_stack_size !== 'undefined' && (typeof thread_stack_size !== 'number' || thread_stack_size === 0 || thread_stack_size % 65536 !== 0)) {
|
|
1423
|
+
throw new Error('invalid stack size');
|
|
1424
|
+
}
|
|
1425
|
+
|
|
1426
|
+
wasm.__wbindgen_start(thread_stack_size);
|
|
1427
|
+
return wasm;
|
|
1428
|
+
}
|
|
1429
|
+
|
|
1430
|
+
async function __wbg_load(module, imports) {
|
|
1431
|
+
if (typeof Response === 'function' && module instanceof Response) {
|
|
1432
|
+
if (!module.ok) {
|
|
1433
|
+
throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
|
|
1434
|
+
}
|
|
1435
|
+
|
|
1436
|
+
if (typeof WebAssembly.instantiateStreaming === 'function') {
|
|
1437
|
+
try {
|
|
1438
|
+
return await WebAssembly.instantiateStreaming(module, imports);
|
|
1439
|
+
} catch (e) {
|
|
1440
|
+
const validResponse = expectedResponseType(module.type);
|
|
1441
|
+
|
|
1442
|
+
if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
|
|
1443
|
+
console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
|
|
1444
|
+
|
|
1445
|
+
} else { throw e; }
|
|
1446
|
+
}
|
|
1447
|
+
}
|
|
1448
|
+
|
|
1449
|
+
const bytes = await module.arrayBuffer();
|
|
1450
|
+
return await WebAssembly.instantiate(bytes, imports);
|
|
1451
|
+
} else {
|
|
1452
|
+
const instance = await WebAssembly.instantiate(module, imports);
|
|
1453
|
+
|
|
1454
|
+
if (instance instanceof WebAssembly.Instance) {
|
|
1455
|
+
return { instance, module };
|
|
1456
|
+
} else {
|
|
1457
|
+
return instance;
|
|
1458
|
+
}
|
|
1459
|
+
}
|
|
1460
|
+
|
|
1461
|
+
function expectedResponseType(type) {
|
|
1462
|
+
switch (type) {
|
|
1463
|
+
case 'basic': case 'cors': case 'default': return true;
|
|
1464
|
+
}
|
|
1465
|
+
return false;
|
|
1466
|
+
}
|
|
1467
|
+
}
|
|
1468
|
+
|
|
1469
|
+
function initSync(module, memory) {
|
|
1470
|
+
if (wasm !== undefined) return wasm;
|
|
1471
|
+
|
|
1472
|
+
let thread_stack_size
|
|
1473
|
+
if (module !== undefined) {
|
|
1474
|
+
if (Object.getPrototypeOf(module) === Object.prototype) {
|
|
1475
|
+
({module, memory, thread_stack_size} = module)
|
|
1476
|
+
} else {
|
|
1477
|
+
console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
|
|
1478
|
+
}
|
|
1479
|
+
}
|
|
1480
|
+
|
|
1481
|
+
const imports = __wbg_get_imports(memory);
|
|
1482
|
+
if (!(module instanceof WebAssembly.Module)) {
|
|
1483
|
+
module = new WebAssembly.Module(module);
|
|
1484
|
+
}
|
|
1485
|
+
const instance = new WebAssembly.Instance(module, imports);
|
|
1486
|
+
return __wbg_finalize_init(instance, module, thread_stack_size);
|
|
1487
|
+
}
|
|
1488
|
+
|
|
1489
|
+
async function __wbg_init(module_or_path, memory) {
|
|
1490
|
+
if (wasm !== undefined) return wasm;
|
|
1491
|
+
|
|
1492
|
+
let thread_stack_size
|
|
1493
|
+
if (module_or_path !== undefined) {
|
|
1494
|
+
if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
|
|
1495
|
+
({module_or_path, memory, thread_stack_size} = module_or_path)
|
|
1496
|
+
} else {
|
|
1497
|
+
console.warn('using deprecated parameters for the initialization function; pass a single object instead')
|
|
1498
|
+
}
|
|
1499
|
+
}
|
|
1500
|
+
|
|
1501
|
+
if (module_or_path === undefined) {
|
|
1502
|
+
module_or_path = new URL('bevyra-core_bg.wasm', import.meta.url);
|
|
1503
|
+
}
|
|
1504
|
+
const imports = __wbg_get_imports(memory);
|
|
1505
|
+
|
|
1506
|
+
if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
|
|
1507
|
+
module_or_path = fetch(module_or_path);
|
|
1508
|
+
}
|
|
1509
|
+
|
|
1510
|
+
const { instance, module } = await __wbg_load(await module_or_path, imports);
|
|
1511
|
+
|
|
1512
|
+
return __wbg_finalize_init(instance, module, thread_stack_size);
|
|
1513
|
+
}
|
|
1514
|
+
|
|
1515
|
+
export { initSync, __wbg_init as default };
|