github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/ttsengine/bindings/ffi_bindings.ts (about) 1 import { importModule, Application, heap, Pointer } from "@ffi"; 2 3 importModule("plat/js/webext/ttsengine", (A: Application) => { 4 const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser; 5 6 return { 7 "store_AudioBuffer": (ptr: Pointer, ref: heap.Ref<any>) => { 8 const x = A.H.get<any>(ref); 9 10 if (typeof x === "undefined") { 11 A.store.Bool(ptr + 19, false); 12 A.store.Ref(ptr + 0, undefined); 13 A.store.Bool(ptr + 17, false); 14 A.store.Int64(ptr + 8, 0); 15 A.store.Bool(ptr + 18, false); 16 A.store.Bool(ptr + 16, false); 17 } else { 18 A.store.Bool(ptr + 19, true); 19 A.store.Ref(ptr + 0, x["audioBuffer"]); 20 A.store.Bool(ptr + 17, "charIndex" in x ? true : false); 21 A.store.Int64(ptr + 8, x["charIndex"] === undefined ? 0 : (x["charIndex"] as number)); 22 A.store.Bool(ptr + 18, "isLastBuffer" in x ? true : false); 23 A.store.Bool(ptr + 16, x["isLastBuffer"] ? true : false); 24 } 25 }, 26 "load_AudioBuffer": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 27 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 28 29 x["audioBuffer"] = A.load.Ref(ptr + 0, undefined); 30 if (A.load.Bool(ptr + 17)) { 31 x["charIndex"] = A.load.Int64(ptr + 8); 32 } else { 33 delete x["charIndex"]; 34 } 35 if (A.load.Bool(ptr + 18)) { 36 x["isLastBuffer"] = A.load.Bool(ptr + 16); 37 } else { 38 delete x["isLastBuffer"]; 39 } 40 return create === A.H.TRUE ? A.H.push(x) : ref; 41 }, 42 43 "store_AudioStreamOptions": (ptr: Pointer, ref: heap.Ref<any>) => { 44 const x = A.H.get<any>(ref); 45 46 if (typeof x === "undefined") { 47 A.store.Bool(ptr + 16, false); 48 A.store.Int64(ptr + 0, 0); 49 A.store.Int64(ptr + 8, 0); 50 } else { 51 A.store.Bool(ptr + 16, true); 52 A.store.Int64(ptr + 0, x["bufferSize"] === undefined ? 0 : (x["bufferSize"] as number)); 53 A.store.Int64(ptr + 8, x["sampleRate"] === undefined ? 0 : (x["sampleRate"] as number)); 54 } 55 }, 56 "load_AudioStreamOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 57 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 58 59 x["bufferSize"] = A.load.Int64(ptr + 0); 60 x["sampleRate"] = A.load.Int64(ptr + 8); 61 return create === A.H.TRUE ? A.H.push(x) : ref; 62 }, 63 "constof_VoiceGender": (ref: heap.Ref<string>): number => { 64 const idx = ["male", "female"].indexOf(A.H.get(ref)); 65 return idx < 0 ? 0 : idx + 1; 66 }, 67 68 "store_SpeakOptions": (ptr: Pointer, ref: heap.Ref<any>) => { 69 const x = A.H.get<any>(ref); 70 71 if (typeof x === "undefined") { 72 A.store.Bool(ptr + 43, false); 73 A.store.Enum(ptr + 0, -1); 74 A.store.Ref(ptr + 4, undefined); 75 A.store.Bool(ptr + 40, false); 76 A.store.Float64(ptr + 8, 0); 77 A.store.Bool(ptr + 41, false); 78 A.store.Float64(ptr + 16, 0); 79 A.store.Ref(ptr + 24, undefined); 80 A.store.Bool(ptr + 42, false); 81 A.store.Float64(ptr + 32, 0); 82 } else { 83 A.store.Bool(ptr + 43, true); 84 A.store.Enum(ptr + 0, ["male", "female"].indexOf(x["gender"] as string)); 85 A.store.Ref(ptr + 4, x["lang"]); 86 A.store.Bool(ptr + 40, "pitch" in x ? true : false); 87 A.store.Float64(ptr + 8, x["pitch"] === undefined ? 0 : (x["pitch"] as number)); 88 A.store.Bool(ptr + 41, "rate" in x ? true : false); 89 A.store.Float64(ptr + 16, x["rate"] === undefined ? 0 : (x["rate"] as number)); 90 A.store.Ref(ptr + 24, x["voiceName"]); 91 A.store.Bool(ptr + 42, "volume" in x ? true : false); 92 A.store.Float64(ptr + 32, x["volume"] === undefined ? 0 : (x["volume"] as number)); 93 } 94 }, 95 "load_SpeakOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => { 96 const x = create === A.H.TRUE ? {} : A.H.get<any>(ref); 97 98 x["gender"] = A.load.Enum(ptr + 0, ["male", "female"]); 99 x["lang"] = A.load.Ref(ptr + 4, undefined); 100 if (A.load.Bool(ptr + 40)) { 101 x["pitch"] = A.load.Float64(ptr + 8); 102 } else { 103 delete x["pitch"]; 104 } 105 if (A.load.Bool(ptr + 41)) { 106 x["rate"] = A.load.Float64(ptr + 16); 107 } else { 108 delete x["rate"]; 109 } 110 x["voiceName"] = A.load.Ref(ptr + 24, undefined); 111 if (A.load.Bool(ptr + 42)) { 112 x["volume"] = A.load.Float64(ptr + 32); 113 } else { 114 delete x["volume"]; 115 } 116 return create === A.H.TRUE ? A.H.push(x) : ref; 117 }, 118 "has_OnPause": (): heap.Ref<boolean> => { 119 if (WEBEXT?.ttsEngine?.onPause && "addListener" in WEBEXT?.ttsEngine?.onPause) { 120 return A.H.TRUE; 121 } 122 return A.H.FALSE; 123 }, 124 "func_OnPause": (fn: Pointer): void => { 125 A.store.Ref(fn, WEBEXT.ttsEngine.onPause.addListener); 126 }, 127 "call_OnPause": (retPtr: Pointer, callback: heap.Ref<object>): void => { 128 const _ret = WEBEXT.ttsEngine.onPause.addListener(A.H.get<object>(callback)); 129 }, 130 "try_OnPause": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 131 try { 132 const _ret = WEBEXT.ttsEngine.onPause.addListener(A.H.get<object>(callback)); 133 return A.H.TRUE; 134 } catch (err: any) { 135 A.store.Ref(errPtr, err); 136 return A.H.FALSE; 137 } 138 }, 139 "has_OffPause": (): heap.Ref<boolean> => { 140 if (WEBEXT?.ttsEngine?.onPause && "removeListener" in WEBEXT?.ttsEngine?.onPause) { 141 return A.H.TRUE; 142 } 143 return A.H.FALSE; 144 }, 145 "func_OffPause": (fn: Pointer): void => { 146 A.store.Ref(fn, WEBEXT.ttsEngine.onPause.removeListener); 147 }, 148 "call_OffPause": (retPtr: Pointer, callback: heap.Ref<object>): void => { 149 const _ret = WEBEXT.ttsEngine.onPause.removeListener(A.H.get<object>(callback)); 150 }, 151 "try_OffPause": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 152 try { 153 const _ret = WEBEXT.ttsEngine.onPause.removeListener(A.H.get<object>(callback)); 154 return A.H.TRUE; 155 } catch (err: any) { 156 A.store.Ref(errPtr, err); 157 return A.H.FALSE; 158 } 159 }, 160 "has_HasOnPause": (): heap.Ref<boolean> => { 161 if (WEBEXT?.ttsEngine?.onPause && "hasListener" in WEBEXT?.ttsEngine?.onPause) { 162 return A.H.TRUE; 163 } 164 return A.H.FALSE; 165 }, 166 "func_HasOnPause": (fn: Pointer): void => { 167 A.store.Ref(fn, WEBEXT.ttsEngine.onPause.hasListener); 168 }, 169 "call_HasOnPause": (retPtr: Pointer, callback: heap.Ref<object>): void => { 170 const _ret = WEBEXT.ttsEngine.onPause.hasListener(A.H.get<object>(callback)); 171 A.store.Bool(retPtr, _ret); 172 }, 173 "try_HasOnPause": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 174 try { 175 const _ret = WEBEXT.ttsEngine.onPause.hasListener(A.H.get<object>(callback)); 176 A.store.Bool(retPtr, _ret); 177 return A.H.TRUE; 178 } catch (err: any) { 179 A.store.Ref(errPtr, err); 180 return A.H.FALSE; 181 } 182 }, 183 "has_OnResume": (): heap.Ref<boolean> => { 184 if (WEBEXT?.ttsEngine?.onResume && "addListener" in WEBEXT?.ttsEngine?.onResume) { 185 return A.H.TRUE; 186 } 187 return A.H.FALSE; 188 }, 189 "func_OnResume": (fn: Pointer): void => { 190 A.store.Ref(fn, WEBEXT.ttsEngine.onResume.addListener); 191 }, 192 "call_OnResume": (retPtr: Pointer, callback: heap.Ref<object>): void => { 193 const _ret = WEBEXT.ttsEngine.onResume.addListener(A.H.get<object>(callback)); 194 }, 195 "try_OnResume": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 196 try { 197 const _ret = WEBEXT.ttsEngine.onResume.addListener(A.H.get<object>(callback)); 198 return A.H.TRUE; 199 } catch (err: any) { 200 A.store.Ref(errPtr, err); 201 return A.H.FALSE; 202 } 203 }, 204 "has_OffResume": (): heap.Ref<boolean> => { 205 if (WEBEXT?.ttsEngine?.onResume && "removeListener" in WEBEXT?.ttsEngine?.onResume) { 206 return A.H.TRUE; 207 } 208 return A.H.FALSE; 209 }, 210 "func_OffResume": (fn: Pointer): void => { 211 A.store.Ref(fn, WEBEXT.ttsEngine.onResume.removeListener); 212 }, 213 "call_OffResume": (retPtr: Pointer, callback: heap.Ref<object>): void => { 214 const _ret = WEBEXT.ttsEngine.onResume.removeListener(A.H.get<object>(callback)); 215 }, 216 "try_OffResume": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 217 try { 218 const _ret = WEBEXT.ttsEngine.onResume.removeListener(A.H.get<object>(callback)); 219 return A.H.TRUE; 220 } catch (err: any) { 221 A.store.Ref(errPtr, err); 222 return A.H.FALSE; 223 } 224 }, 225 "has_HasOnResume": (): heap.Ref<boolean> => { 226 if (WEBEXT?.ttsEngine?.onResume && "hasListener" in WEBEXT?.ttsEngine?.onResume) { 227 return A.H.TRUE; 228 } 229 return A.H.FALSE; 230 }, 231 "func_HasOnResume": (fn: Pointer): void => { 232 A.store.Ref(fn, WEBEXT.ttsEngine.onResume.hasListener); 233 }, 234 "call_HasOnResume": (retPtr: Pointer, callback: heap.Ref<object>): void => { 235 const _ret = WEBEXT.ttsEngine.onResume.hasListener(A.H.get<object>(callback)); 236 A.store.Bool(retPtr, _ret); 237 }, 238 "try_HasOnResume": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 239 try { 240 const _ret = WEBEXT.ttsEngine.onResume.hasListener(A.H.get<object>(callback)); 241 A.store.Bool(retPtr, _ret); 242 return A.H.TRUE; 243 } catch (err: any) { 244 A.store.Ref(errPtr, err); 245 return A.H.FALSE; 246 } 247 }, 248 "has_OnSpeak": (): heap.Ref<boolean> => { 249 if (WEBEXT?.ttsEngine?.onSpeak && "addListener" in WEBEXT?.ttsEngine?.onSpeak) { 250 return A.H.TRUE; 251 } 252 return A.H.FALSE; 253 }, 254 "func_OnSpeak": (fn: Pointer): void => { 255 A.store.Ref(fn, WEBEXT.ttsEngine.onSpeak.addListener); 256 }, 257 "call_OnSpeak": (retPtr: Pointer, callback: heap.Ref<object>): void => { 258 const _ret = WEBEXT.ttsEngine.onSpeak.addListener(A.H.get<object>(callback)); 259 }, 260 "try_OnSpeak": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 261 try { 262 const _ret = WEBEXT.ttsEngine.onSpeak.addListener(A.H.get<object>(callback)); 263 return A.H.TRUE; 264 } catch (err: any) { 265 A.store.Ref(errPtr, err); 266 return A.H.FALSE; 267 } 268 }, 269 "has_OffSpeak": (): heap.Ref<boolean> => { 270 if (WEBEXT?.ttsEngine?.onSpeak && "removeListener" in WEBEXT?.ttsEngine?.onSpeak) { 271 return A.H.TRUE; 272 } 273 return A.H.FALSE; 274 }, 275 "func_OffSpeak": (fn: Pointer): void => { 276 A.store.Ref(fn, WEBEXT.ttsEngine.onSpeak.removeListener); 277 }, 278 "call_OffSpeak": (retPtr: Pointer, callback: heap.Ref<object>): void => { 279 const _ret = WEBEXT.ttsEngine.onSpeak.removeListener(A.H.get<object>(callback)); 280 }, 281 "try_OffSpeak": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 282 try { 283 const _ret = WEBEXT.ttsEngine.onSpeak.removeListener(A.H.get<object>(callback)); 284 return A.H.TRUE; 285 } catch (err: any) { 286 A.store.Ref(errPtr, err); 287 return A.H.FALSE; 288 } 289 }, 290 "has_HasOnSpeak": (): heap.Ref<boolean> => { 291 if (WEBEXT?.ttsEngine?.onSpeak && "hasListener" in WEBEXT?.ttsEngine?.onSpeak) { 292 return A.H.TRUE; 293 } 294 return A.H.FALSE; 295 }, 296 "func_HasOnSpeak": (fn: Pointer): void => { 297 A.store.Ref(fn, WEBEXT.ttsEngine.onSpeak.hasListener); 298 }, 299 "call_HasOnSpeak": (retPtr: Pointer, callback: heap.Ref<object>): void => { 300 const _ret = WEBEXT.ttsEngine.onSpeak.hasListener(A.H.get<object>(callback)); 301 A.store.Bool(retPtr, _ret); 302 }, 303 "try_HasOnSpeak": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 304 try { 305 const _ret = WEBEXT.ttsEngine.onSpeak.hasListener(A.H.get<object>(callback)); 306 A.store.Bool(retPtr, _ret); 307 return A.H.TRUE; 308 } catch (err: any) { 309 A.store.Ref(errPtr, err); 310 return A.H.FALSE; 311 } 312 }, 313 "has_OnSpeakWithAudioStream": (): heap.Ref<boolean> => { 314 if (WEBEXT?.ttsEngine?.onSpeakWithAudioStream && "addListener" in WEBEXT?.ttsEngine?.onSpeakWithAudioStream) { 315 return A.H.TRUE; 316 } 317 return A.H.FALSE; 318 }, 319 "func_OnSpeakWithAudioStream": (fn: Pointer): void => { 320 A.store.Ref(fn, WEBEXT.ttsEngine.onSpeakWithAudioStream.addListener); 321 }, 322 "call_OnSpeakWithAudioStream": (retPtr: Pointer, callback: heap.Ref<object>): void => { 323 const _ret = WEBEXT.ttsEngine.onSpeakWithAudioStream.addListener(A.H.get<object>(callback)); 324 }, 325 "try_OnSpeakWithAudioStream": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 326 try { 327 const _ret = WEBEXT.ttsEngine.onSpeakWithAudioStream.addListener(A.H.get<object>(callback)); 328 return A.H.TRUE; 329 } catch (err: any) { 330 A.store.Ref(errPtr, err); 331 return A.H.FALSE; 332 } 333 }, 334 "has_OffSpeakWithAudioStream": (): heap.Ref<boolean> => { 335 if (WEBEXT?.ttsEngine?.onSpeakWithAudioStream && "removeListener" in WEBEXT?.ttsEngine?.onSpeakWithAudioStream) { 336 return A.H.TRUE; 337 } 338 return A.H.FALSE; 339 }, 340 "func_OffSpeakWithAudioStream": (fn: Pointer): void => { 341 A.store.Ref(fn, WEBEXT.ttsEngine.onSpeakWithAudioStream.removeListener); 342 }, 343 "call_OffSpeakWithAudioStream": (retPtr: Pointer, callback: heap.Ref<object>): void => { 344 const _ret = WEBEXT.ttsEngine.onSpeakWithAudioStream.removeListener(A.H.get<object>(callback)); 345 }, 346 "try_OffSpeakWithAudioStream": ( 347 retPtr: Pointer, 348 errPtr: Pointer, 349 callback: heap.Ref<object> 350 ): heap.Ref<boolean> => { 351 try { 352 const _ret = WEBEXT.ttsEngine.onSpeakWithAudioStream.removeListener(A.H.get<object>(callback)); 353 return A.H.TRUE; 354 } catch (err: any) { 355 A.store.Ref(errPtr, err); 356 return A.H.FALSE; 357 } 358 }, 359 "has_HasOnSpeakWithAudioStream": (): heap.Ref<boolean> => { 360 if (WEBEXT?.ttsEngine?.onSpeakWithAudioStream && "hasListener" in WEBEXT?.ttsEngine?.onSpeakWithAudioStream) { 361 return A.H.TRUE; 362 } 363 return A.H.FALSE; 364 }, 365 "func_HasOnSpeakWithAudioStream": (fn: Pointer): void => { 366 A.store.Ref(fn, WEBEXT.ttsEngine.onSpeakWithAudioStream.hasListener); 367 }, 368 "call_HasOnSpeakWithAudioStream": (retPtr: Pointer, callback: heap.Ref<object>): void => { 369 const _ret = WEBEXT.ttsEngine.onSpeakWithAudioStream.hasListener(A.H.get<object>(callback)); 370 A.store.Bool(retPtr, _ret); 371 }, 372 "try_HasOnSpeakWithAudioStream": ( 373 retPtr: Pointer, 374 errPtr: Pointer, 375 callback: heap.Ref<object> 376 ): heap.Ref<boolean> => { 377 try { 378 const _ret = WEBEXT.ttsEngine.onSpeakWithAudioStream.hasListener(A.H.get<object>(callback)); 379 A.store.Bool(retPtr, _ret); 380 return A.H.TRUE; 381 } catch (err: any) { 382 A.store.Ref(errPtr, err); 383 return A.H.FALSE; 384 } 385 }, 386 "has_OnStop": (): heap.Ref<boolean> => { 387 if (WEBEXT?.ttsEngine?.onStop && "addListener" in WEBEXT?.ttsEngine?.onStop) { 388 return A.H.TRUE; 389 } 390 return A.H.FALSE; 391 }, 392 "func_OnStop": (fn: Pointer): void => { 393 A.store.Ref(fn, WEBEXT.ttsEngine.onStop.addListener); 394 }, 395 "call_OnStop": (retPtr: Pointer, callback: heap.Ref<object>): void => { 396 const _ret = WEBEXT.ttsEngine.onStop.addListener(A.H.get<object>(callback)); 397 }, 398 "try_OnStop": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 399 try { 400 const _ret = WEBEXT.ttsEngine.onStop.addListener(A.H.get<object>(callback)); 401 return A.H.TRUE; 402 } catch (err: any) { 403 A.store.Ref(errPtr, err); 404 return A.H.FALSE; 405 } 406 }, 407 "has_OffStop": (): heap.Ref<boolean> => { 408 if (WEBEXT?.ttsEngine?.onStop && "removeListener" in WEBEXT?.ttsEngine?.onStop) { 409 return A.H.TRUE; 410 } 411 return A.H.FALSE; 412 }, 413 "func_OffStop": (fn: Pointer): void => { 414 A.store.Ref(fn, WEBEXT.ttsEngine.onStop.removeListener); 415 }, 416 "call_OffStop": (retPtr: Pointer, callback: heap.Ref<object>): void => { 417 const _ret = WEBEXT.ttsEngine.onStop.removeListener(A.H.get<object>(callback)); 418 }, 419 "try_OffStop": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 420 try { 421 const _ret = WEBEXT.ttsEngine.onStop.removeListener(A.H.get<object>(callback)); 422 return A.H.TRUE; 423 } catch (err: any) { 424 A.store.Ref(errPtr, err); 425 return A.H.FALSE; 426 } 427 }, 428 "has_HasOnStop": (): heap.Ref<boolean> => { 429 if (WEBEXT?.ttsEngine?.onStop && "hasListener" in WEBEXT?.ttsEngine?.onStop) { 430 return A.H.TRUE; 431 } 432 return A.H.FALSE; 433 }, 434 "func_HasOnStop": (fn: Pointer): void => { 435 A.store.Ref(fn, WEBEXT.ttsEngine.onStop.hasListener); 436 }, 437 "call_HasOnStop": (retPtr: Pointer, callback: heap.Ref<object>): void => { 438 const _ret = WEBEXT.ttsEngine.onStop.hasListener(A.H.get<object>(callback)); 439 A.store.Bool(retPtr, _ret); 440 }, 441 "try_HasOnStop": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => { 442 try { 443 const _ret = WEBEXT.ttsEngine.onStop.hasListener(A.H.get<object>(callback)); 444 A.store.Bool(retPtr, _ret); 445 return A.H.TRUE; 446 } catch (err: any) { 447 A.store.Ref(errPtr, err); 448 return A.H.FALSE; 449 } 450 }, 451 "has_SendTtsAudio": (): heap.Ref<boolean> => { 452 if (WEBEXT?.ttsEngine && "sendTtsAudio" in WEBEXT?.ttsEngine) { 453 return A.H.TRUE; 454 } 455 return A.H.FALSE; 456 }, 457 "func_SendTtsAudio": (fn: Pointer): void => { 458 A.store.Ref(fn, WEBEXT.ttsEngine.sendTtsAudio); 459 }, 460 "call_SendTtsAudio": (retPtr: Pointer, requestId: number, audio: Pointer): void => { 461 const audio_ffi = {}; 462 463 audio_ffi["audioBuffer"] = A.load.Ref(audio + 0, undefined); 464 if (A.load.Bool(audio + 17)) { 465 audio_ffi["charIndex"] = A.load.Int64(audio + 8); 466 } 467 if (A.load.Bool(audio + 18)) { 468 audio_ffi["isLastBuffer"] = A.load.Bool(audio + 16); 469 } 470 471 const _ret = WEBEXT.ttsEngine.sendTtsAudio(requestId, audio_ffi); 472 }, 473 "try_SendTtsAudio": (retPtr: Pointer, errPtr: Pointer, requestId: number, audio: Pointer): heap.Ref<boolean> => { 474 try { 475 const audio_ffi = {}; 476 477 audio_ffi["audioBuffer"] = A.load.Ref(audio + 0, undefined); 478 if (A.load.Bool(audio + 17)) { 479 audio_ffi["charIndex"] = A.load.Int64(audio + 8); 480 } 481 if (A.load.Bool(audio + 18)) { 482 audio_ffi["isLastBuffer"] = A.load.Bool(audio + 16); 483 } 484 485 const _ret = WEBEXT.ttsEngine.sendTtsAudio(requestId, audio_ffi); 486 return A.H.TRUE; 487 } catch (err: any) { 488 A.store.Ref(errPtr, err); 489 return A.H.FALSE; 490 } 491 }, 492 "has_SendTtsEvent": (): heap.Ref<boolean> => { 493 if (WEBEXT?.ttsEngine && "sendTtsEvent" in WEBEXT?.ttsEngine) { 494 return A.H.TRUE; 495 } 496 return A.H.FALSE; 497 }, 498 "func_SendTtsEvent": (fn: Pointer): void => { 499 A.store.Ref(fn, WEBEXT.ttsEngine.sendTtsEvent); 500 }, 501 "call_SendTtsEvent": (retPtr: Pointer, requestId: number, event: Pointer): void => { 502 const event_ffi = {}; 503 504 if (A.load.Bool(event + 36)) { 505 event_ffi["charIndex"] = A.load.Int64(event + 0); 506 } 507 event_ffi["errorMessage"] = A.load.Ref(event + 8, undefined); 508 if (A.load.Bool(event + 37)) { 509 event_ffi["isFinalEvent"] = A.load.Bool(event + 12); 510 } 511 if (A.load.Bool(event + 38)) { 512 event_ffi["length"] = A.load.Int64(event + 16); 513 } 514 if (A.load.Bool(event + 39)) { 515 event_ffi["srcId"] = A.load.Float64(event + 24); 516 } 517 event_ffi["type"] = A.load.Enum(event + 32, [ 518 "start", 519 "end", 520 "word", 521 "sentence", 522 "marker", 523 "interrupted", 524 "cancelled", 525 "error", 526 "pause", 527 "resume", 528 ]); 529 530 const _ret = WEBEXT.ttsEngine.sendTtsEvent(requestId, event_ffi); 531 }, 532 "try_SendTtsEvent": (retPtr: Pointer, errPtr: Pointer, requestId: number, event: Pointer): heap.Ref<boolean> => { 533 try { 534 const event_ffi = {}; 535 536 if (A.load.Bool(event + 36)) { 537 event_ffi["charIndex"] = A.load.Int64(event + 0); 538 } 539 event_ffi["errorMessage"] = A.load.Ref(event + 8, undefined); 540 if (A.load.Bool(event + 37)) { 541 event_ffi["isFinalEvent"] = A.load.Bool(event + 12); 542 } 543 if (A.load.Bool(event + 38)) { 544 event_ffi["length"] = A.load.Int64(event + 16); 545 } 546 if (A.load.Bool(event + 39)) { 547 event_ffi["srcId"] = A.load.Float64(event + 24); 548 } 549 event_ffi["type"] = A.load.Enum(event + 32, [ 550 "start", 551 "end", 552 "word", 553 "sentence", 554 "marker", 555 "interrupted", 556 "cancelled", 557 "error", 558 "pause", 559 "resume", 560 ]); 561 562 const _ret = WEBEXT.ttsEngine.sendTtsEvent(requestId, event_ffi); 563 return A.H.TRUE; 564 } catch (err: any) { 565 A.store.Ref(errPtr, err); 566 return A.H.FALSE; 567 } 568 }, 569 "has_UpdateVoices": (): heap.Ref<boolean> => { 570 if (WEBEXT?.ttsEngine && "updateVoices" in WEBEXT?.ttsEngine) { 571 return A.H.TRUE; 572 } 573 return A.H.FALSE; 574 }, 575 "func_UpdateVoices": (fn: Pointer): void => { 576 A.store.Ref(fn, WEBEXT.ttsEngine.updateVoices); 577 }, 578 "call_UpdateVoices": (retPtr: Pointer, voices: heap.Ref<object>): void => { 579 const _ret = WEBEXT.ttsEngine.updateVoices(A.H.get<object>(voices)); 580 }, 581 "try_UpdateVoices": (retPtr: Pointer, errPtr: Pointer, voices: heap.Ref<object>): heap.Ref<boolean> => { 582 try { 583 const _ret = WEBEXT.ttsEngine.updateVoices(A.H.get<object>(voices)); 584 return A.H.TRUE; 585 } catch (err: any) { 586 A.store.Ref(errPtr, err); 587 return A.H.FALSE; 588 } 589 }, 590 }; 591 });