@bevyra/avatar 0.1.0 → 1.0.0

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.
@@ -1,1515 +0,0 @@
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 };