@siteed/audio-studio 3.0.0

package/plugin/src/index.ts

@@ -0,0 +1,285 @@
+import {
+    ConfigPlugin,
+    withAndroidManifest,
+    withInfoPlist,
+    AndroidConfig,
+} from '@expo/config-plugins'
+import { ExpoConfig } from '@expo/config-types'
+
+const MICROPHONE_USAGE = 'Allow $(PRODUCT_NAME) to access your microphone'
+const NOTIFICATION_USAGE = 'Show recording notifications and controls'
+const LOG_PREFIX = '[@siteed/expo-audio-studio]'
+
+function debugLog(message: string, ...args: unknown[]): void {
+    if (process.env.EXPO_DEBUG) {
+        console.log(`${LOG_PREFIX} ${message}`, ...args)
+    }
+}
+
+interface AudioStreamPluginOptions {
+    enablePhoneStateHandling?: boolean // Controls READ_PHONE_STATE permission
+    enableNotifications?: boolean
+    enableBackgroundAudio?: boolean
+    enableDeviceDetection?: boolean // Controls Bluetooth and USB permissions for device change detection
+    iosBackgroundModes?: {
+        useVoIP?: boolean
+        useAudio?: boolean
+        useProcessing?: boolean
+        useLocation?: boolean
+        useExternalAccessory?: boolean
+    }
+    iosConfig?: {
+        allowBackgroundAudioControls?: boolean
+        backgroundProcessingTitle?: string
+        microphoneUsageDescription?: string
+        notificationUsageDescription?: string
+    }
+}
+
+const withRecordingPermission: ConfigPlugin<AudioStreamPluginOptions> = (
+    config: ExpoConfig,
+    props: AudioStreamPluginOptions | void
+) => {
+    const options: AudioStreamPluginOptions = {
+        enablePhoneStateHandling: true, // Default to true for backward compatibility
+        enableNotifications: true,
+        enableBackgroundAudio: true,
+        enableDeviceDetection: true, // Default to true for backward compatibility
+        iosBackgroundModes: {
+            useVoIP: false,
+            useAudio: false,
+            useProcessing: false,
+            useLocation: false,
+            useExternalAccessory: false,
+        },
+        iosConfig: {
+            microphoneUsageDescription: MICROPHONE_USAGE,
+            notificationUsageDescription: NOTIFICATION_USAGE,
+        },
+        ...(props || {}),
+    }
+
+    const {
+        enablePhoneStateHandling,
+        enableNotifications,
+        enableBackgroundAudio,
+        enableDeviceDetection,
+    } = options
+
+    debugLog('📱 Configuring Recording Permissions Plugin...', options)
+
+    // iOS Configuration
+    config = withInfoPlist(config as any, (config) => {
+        // Always set the microphone usage description from options first
+        config.modResults['NSMicrophoneUsageDescription'] =
+            options.iosConfig?.microphoneUsageDescription ||
+            config.modResults['NSMicrophoneUsageDescription'] ||
+            MICROPHONE_USAGE
+
+        if (enableNotifications) {
+            config.modResults['NSUserNotificationsUsageDescription'] =
+                options.iosConfig?.notificationUsageDescription ||
+                config.modResults['NSUserNotificationsUsageDescription'] ||
+                NOTIFICATION_USAGE
+            config.modResults['NSUserNotificationAlertStyle'] = 'alert'
+        }
+
+        const existingBackgroundModes =
+            config.modResults.UIBackgroundModes || []
+
+        // If background audio is enabled with useAudio, add the audio background mode
+        if (
+            options.iosBackgroundModes?.useAudio === true &&
+            enableBackgroundAudio === true &&
+            !existingBackgroundModes.includes('audio')
+        ) {
+            // Add 'audio' background mode - REQUIRED for background recording
+            existingBackgroundModes.push('audio')
+            debugLog(
+                '✅ Added audio background mode for iOS background recording'
+            )
+
+            // Also ensure processing mode is recommended
+            if (options.iosBackgroundModes?.useProcessing !== true) {
+                console.warn(
+                    `${LOG_PREFIX} Warning: Background audio recording works best with both 'audio' and 'processing' background modes. Consider enabling 'useProcessing' in iosBackgroundModes.`
+                )
+            }
+        }
+
+        if (
+            options.iosBackgroundModes?.useVoIP === true &&
+            enablePhoneStateHandling === true
+        ) {
+            if (!existingBackgroundModes.includes('voip')) {
+                existingBackgroundModes.push('voip')
+            }
+            const existingCapabilities = (config.modResults
+                .UIRequiredDeviceCapabilities || []) as string[]
+            if (!existingCapabilities.includes('telephony')) {
+                existingCapabilities.push('telephony')
+            }
+            config.modResults.UIRequiredDeviceCapabilities =
+                existingCapabilities
+        }
+
+        // Add additional background modes only if explicitly set to true
+        if (options.iosBackgroundModes?.useProcessing === true) {
+            if (!existingBackgroundModes.includes('processing')) {
+                existingBackgroundModes.push('processing')
+            }
+            // Add processing info if enabled
+            // Note: We keep the 'audiostream' namespace for native modules to maintain compatibility
+            config.modResults.BGTaskSchedulerPermittedIdentifiers = [
+                'com.siteed.audiostream.processing',
+            ]
+        }
+
+        if (options.iosBackgroundModes?.useLocation === true) {
+            if (!existingBackgroundModes.includes('location')) {
+                existingBackgroundModes.push('location')
+            }
+        }
+
+        if (options.iosBackgroundModes?.useExternalAccessory === true) {
+            if (!existingBackgroundModes.includes('external-accessory')) {
+                existingBackgroundModes.push('external-accessory')
+            }
+        }
+
+        // Configure background processing info if enabled
+        if (options.iosConfig?.backgroundProcessingTitle) {
+            config.modResults.BGProcessingTaskTitle =
+                options.iosConfig.backgroundProcessingTitle
+        }
+
+        // Configure audio session behavior
+        if (options.iosConfig?.allowBackgroundAudioControls) {
+            config.modResults.UIBackgroundModes = [
+                ...existingBackgroundModes,
+                'remote-notification',
+            ]
+            config.modResults.MPNowPlayingInfoPropertyPlaybackRate = true
+        }
+
+        config.modResults.UIBackgroundModes = existingBackgroundModes
+        return config
+    })
+
+    // Android Configuration
+    config = withAndroidManifest(config as any, (config) => {
+        const basePermissions = ['android.permission.RECORD_AUDIO']
+
+        const optionalPermissions = [
+            enableNotifications && 'android.permission.POST_NOTIFICATIONS',
+            enablePhoneStateHandling && 'android.permission.READ_PHONE_STATE', // Only add if enabled
+            enableBackgroundAudio && 'android.permission.FOREGROUND_SERVICE',
+            enableBackgroundAudio &&
+                'android.permission.FOREGROUND_SERVICE_MICROPHONE',
+            enableBackgroundAudio && 'android.permission.WAKE_LOCK', // Keep device awake during background recording
+            // Device detection permissions (only if enabled)
+            enableDeviceDetection && 'android.permission.BLUETOOTH',
+            enableDeviceDetection && 'android.permission.BLUETOOTH_ADMIN',
+            enableDeviceDetection && 'android.permission.BLUETOOTH_CONNECT',
+            enableDeviceDetection && 'android.permission.USB_PERMISSION',
+        ].filter(Boolean) as string[]
+
+        const permissionsToAdd = [...basePermissions, ...optionalPermissions]
+
+        debugLog(
+            '📋 Existing Android permissions:',
+            config.modResults.manifest['uses-permission']?.map(
+                (p) => p.$?.['android:name']
+            ) || []
+        )
+
+        debugLog('➕ Adding Android permissions:', permissionsToAdd)
+
+        // Add each permission only if it doesn't exist
+        permissionsToAdd.forEach((permission) => {
+            AndroidConfig.Permissions.addPermission(
+                config.modResults,
+                permission
+            )
+        })
+
+        // Get the main application node
+        const mainApplication = config.modResults.manifest.application?.[0]
+        if (mainApplication) {
+            debugLog('📱 Configuring Android application components...')
+
+            // Add RecordingActionReceiver
+            if (!mainApplication.receiver) {
+                mainApplication.receiver = []
+            }
+
+            const receiverConfig = {
+                $: {
+                    'android:name': '.RecordingActionReceiver',
+                    'android:exported': 'false' as const,
+                },
+                'intent-filter': [
+                    {
+                        action: [
+                            { $: { 'android:name': 'PAUSE_RECORDING' } },
+                            { $: { 'android:name': 'RESUME_RECORDING' } },
+                            { $: { 'android:name': 'STOP_RECORDING' } },
+                        ],
+                    },
+                ],
+            }
+
+            const receiverIndex = mainApplication.receiver.findIndex(
+                (receiver: any) =>
+                    receiver.$?.['android:name'] === '.RecordingActionReceiver'
+            )
+
+            if (receiverIndex >= 0) {
+                mainApplication.receiver[receiverIndex] = receiverConfig
+            } else {
+                mainApplication.receiver.push(receiverConfig)
+            }
+
+            debugLog('✅ RecordingActionReceiver configured')
+
+            // Add AudioRecordingService
+            if (!mainApplication.service) {
+                mainApplication.service = []
+            }
+
+            const serviceConfig = {
+                $: {
+                    'android:name': '.AudioRecordingService',
+                    'android:enabled': 'true' as const,
+                    'android:exported': 'false' as const,
+                    'android:foregroundServiceType': 'microphone',
+                },
+            }
+
+            const serviceIndex = mainApplication.service.findIndex(
+                (service: any) =>
+                    service.$?.['android:name'] === '.AudioRecordingService'
+            )
+
+            if (serviceIndex >= 0) {
+                mainApplication.service[serviceIndex] = serviceConfig
+            } else {
+                mainApplication.service.push(serviceConfig)
+            }
+
+            debugLog('✅ AudioRecordingService configured')
+        } else {
+            console.error(
+                `${LOG_PREFIX} ❌ Main application node not found in Android Manifest`
+            )
+        }
+
+        return config
+    })
+
+    debugLog('✨ Recording Permissions Plugin configuration completed')
+    return config as any
+}
+
+// Export as default
+export default withRecordingPermission

package/plugin/tsconfig.json

@@ -0,0 +1,10 @@
+{
+    "extends": "expo-module-scripts/tsconfig.plugin",
+    "compilerOptions": {
+        "outDir": "build",
+        "lib": ["es2023", "dom"],
+        "rootDir": "src"
+    },
+    "include": ["./src"],
+    "exclude": ["**/__mocks__/*", "**/__tests__/*"]
+}

package/plugin/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/index.ts"],"version":"5.8.3"}

package/prebuilt/wasm/mel-spectrogram.js

@@ -0,0 +1,18 @@
+
+var createMelSpectrogramModule = (() => {
+  var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;
+  
+  return (
+function(moduleArg = {}) {
+
+var Module=moduleArg;var readyPromiseResolve,readyPromiseReject;Module["ready"]=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject});var moduleOverrides=Object.assign({},Module);var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof importScripts=="function";var ENVIRONMENT_IS_NODE=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string";var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var read_,readAsync,readBinary;if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href}else if(typeof document!="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src}if(_scriptDir){scriptDirectory=_scriptDir}if(scriptDirectory.startsWith("blob:")){scriptDirectory=""}else{scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1)}{read_=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText};if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=(url,onload,onerror)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=()=>{if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}onerror()};xhr.onerror=onerror;xhr.send(null)}}}else{}var out=Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.error.bind(console);Object.assign(Module,moduleOverrides);moduleOverrides=null;if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["quit"])quit_=Module["quit"];var wasmBinary;if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];if(typeof WebAssembly!="object"){abort("no native wasm support detected")}function intArrayFromBase64(s){var decoded=atob(s);var bytes=new Uint8Array(decoded.length);for(var i=0;i<decoded.length;++i){bytes[i]=decoded.charCodeAt(i)}return bytes}function tryParseAsDataURI(filename){if(!isDataURI(filename)){return}return intArrayFromBase64(filename.slice(dataURIPrefix.length))}var wasmMemory;var ABORT=false;var EXITSTATUS;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;function updateMemoryViews(){var b=wasmMemory.buffer;Module["HEAP8"]=HEAP8=new Int8Array(b);Module["HEAP16"]=HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);Module["HEAPU16"]=HEAPU16=new Uint16Array(b);Module["HEAP32"]=HEAP32=new Int32Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);Module["HEAPF32"]=HEAPF32=new Float32Array(b);Module["HEAPF64"]=HEAPF64=new Float64Array(b)}var __ATPRERUN__=[];var __ATINIT__=[];var __ATPOSTRUN__=[];var runtimeInitialized=false;function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(__ATPRERUN__)}function initRuntime(){runtimeInitialized=true;callRuntimeCallbacks(__ATINIT__)}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(__ATPOSTRUN__)}function addOnPreRun(cb){__ATPRERUN__.unshift(cb)}function addOnInit(cb){__ATINIT__.unshift(cb)}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb)}var runDependencies=0;var runDependencyWatcher=null;var dependenciesFulfilled=null;function addRunDependency(id){runDependencies++;Module["monitorRunDependencies"]?.(runDependencies)}function removeRunDependency(id){runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(runDependencies==0){if(runDependencyWatcher!==null){clearInterval(runDependencyWatcher);runDependencyWatcher=null}if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;EXITSTATUS=1;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e}var dataURIPrefix="data:application/octet-stream;base64,";var isDataURI=filename=>filename.startsWith(dataURIPrefix);var wasmBinaryFile;wasmBinaryFile="data:application/octet-stream;base64,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";if(!isDataURI(wasmBinaryFile)){wasmBinaryFile=locateFile(wasmBinaryFile)}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}var binary=tryParseAsDataURI(file);if(binary){return binary}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}function getBinaryPromise(binaryFile){return Promise.resolve().then(()=>getBinarySync(binaryFile))}function instantiateArrayBuffer(binaryFile,imports,receiver){return getBinaryPromise(binaryFile).then(binary=>WebAssembly.instantiate(binary,imports)).then(instance=>instance).then(receiver,reason=>{err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)})}function instantiateAsync(binary,binaryFile,imports,callback){return instantiateArrayBuffer(binaryFile,imports,callback)}function createWasm(){var info={"env":wasmImports,"wasi_snapshot_preview1":wasmImports};function receiveInstance(instance,module){wasmExports=instance.exports;wasmMemory=wasmExports["memory"];updateMemoryViews();addOnInit(wasmExports["__wasm_call_ctors"]);removeRunDependency("wasm-instantiate");return wasmExports}addRunDependency("wasm-instantiate");function receiveInstantiationResult(result){receiveInstance(result["instance"])}if(Module["instantiateWasm"]){try{return Module["instantiateWasm"](info,receiveInstance)}catch(e){err(`Module.instantiateWasm callback failed with error: ${e}`);readyPromiseReject(e)}}instantiateAsync(wasmBinary,wasmBinaryFile,info,receiveInstantiationResult).catch(readyPromiseReject);return{}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};function getValue(ptr,type="i8"){if(type.endsWith("*"))type="*";switch(type){case"i1":return HEAP8[ptr>>0];case"i8":return HEAP8[ptr>>0];case"i16":return HEAP16[ptr>>1];case"i32":return HEAP32[ptr>>2];case"i64":abort("to do getValue(i64) use WASM_BIGINT");case"float":return HEAPF32[ptr>>2];case"double":return HEAPF64[ptr>>3];case"*":return HEAPU32[ptr>>2];default:abort(`invalid type for getValue: ${type}`)}}var noExitRuntime=Module["noExitRuntime"]||true;class ExceptionInfo{constructor(excPtr){this.excPtr=excPtr;this.ptr=excPtr-24}set_type(type){HEAPU32[this.ptr+4>>2]=type}get_type(){return HEAPU32[this.ptr+4>>2]}set_destructor(destructor){HEAPU32[this.ptr+8>>2]=destructor}get_destructor(){return HEAPU32[this.ptr+8>>2]}set_caught(caught){caught=caught?1:0;HEAP8[this.ptr+12>>0]=caught}get_caught(){return HEAP8[this.ptr+12>>0]!=0}set_rethrown(rethrown){rethrown=rethrown?1:0;HEAP8[this.ptr+13>>0]=rethrown}get_rethrown(){return HEAP8[this.ptr+13>>0]!=0}init(type,destructor){this.set_adjusted_ptr(0);this.set_type(type);this.set_destructor(destructor)}set_adjusted_ptr(adjustedPtr){HEAPU32[this.ptr+16>>2]=adjustedPtr}get_adjusted_ptr(){return HEAPU32[this.ptr+16>>2]}get_exception_ptr(){var isPointer=___cxa_is_pointer_type(this.get_type());if(isPointer){return HEAPU32[this.excPtr>>2]}var adjusted=this.get_adjusted_ptr();if(adjusted!==0)return adjusted;return this.excPtr}}var exceptionLast=0;var uncaughtExceptionCount=0;var ___cxa_throw=(ptr,type,destructor)=>{var info=new ExceptionInfo(ptr);info.init(type,destructor);exceptionLast=ptr;uncaughtExceptionCount++;throw exceptionLast};var _abort=()=>{abort("")};var _emscripten_memcpy_js=(dest,src,num)=>HEAPU8.copyWithin(dest,src,src+num);var getHeapMax=()=>2147483648;var growMemory=size=>{var b=wasmMemory.buffer;var pages=(size-b.byteLength+65535)/65536;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}var alignUp=(x,multiple)=>x+(multiple-x%multiple)%multiple;for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignUp(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var _fd_close=fd=>52;var convertI32PairToI53Checked=(lo,hi)=>hi+2097152>>>0<4194305-!!lo?(lo>>>0)+hi*4294967296:NaN;function _fd_seek(fd,offset_low,offset_high,whence,newOffset){var offset=convertI32PairToI53Checked(offset_low,offset_high);return 70}var printCharBuffers=[null,[],[]];var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder("utf8"):undefined;var UTF8ArrayToString=(heapOrArray,idx,maxBytesToRead)=>{var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx<endPtr){var u0=heapOrArray[idx++];if(!(u0&128)){str+=String.fromCharCode(u0);continue}var u1=heapOrArray[idx++]&63;if((u0&224)==192){str+=String.fromCharCode((u0&31)<<6|u1);continue}var u2=heapOrArray[idx++]&63;if((u0&240)==224){u0=(u0&15)<<12|u1<<6|u2}else{u0=(u0&7)<<18|u1<<12|u2<<6|heapOrArray[idx++]&63}if(u0<65536){str+=String.fromCharCode(u0)}else{var ch=u0-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}}return str};var printChar=(stream,curr)=>{var buffer=printCharBuffers[stream];if(curr===0||curr===10){(stream===1?out:err)(UTF8ArrayToString(buffer,0));buffer.length=0}else{buffer.push(curr)}};var UTF8ToString=(ptr,maxBytesToRead)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):"";var SYSCALLS={varargs:undefined,get(){var ret=HEAP32[+SYSCALLS.varargs>>2];SYSCALLS.varargs+=4;return ret},getp(){return SYSCALLS.get()},getStr(ptr){var ret=UTF8ToString(ptr);return ret}};var _fd_write=(fd,iov,iovcnt,pnum)=>{var num=0;for(var i=0;i<iovcnt;i++){var ptr=HEAPU32[iov>>2];var len=HEAPU32[iov+4>>2];iov+=8;for(var j=0;j<len;j++){printChar(fd,HEAPU8[ptr+j])}num+=len}HEAPU32[pnum>>2]=num;return 0};var getCFunc=ident=>{var func=Module["_"+ident];return func};var writeArrayToMemory=(array,buffer)=>{HEAP8.set(array,buffer)};var lengthBytesUTF8=str=>{var len=0;for(var i=0;i<str.length;++i){var c=str.charCodeAt(i);if(c<=127){len++}else if(c<=2047){len+=2}else if(c>=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.charCodeAt(i);if(u>=55296&&u<=57343){var u1=str.charCodeAt(++i);u=65536+((u&1023)<<10)|u1&1023}if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}}heap[outIdx]=0;return outIdx-startIdx};var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);var stringToUTF8OnStack=str=>{var size=lengthBytesUTF8(str)+1;var ret=stackAlloc(size);stringToUTF8(str,ret,size);return ret};var ccall=(ident,returnType,argTypes,args,opts)=>{var toC={"string":str=>{var ret=0;if(str!==null&&str!==undefined&&str!==0){ret=stringToUTF8OnStack(str)}return ret},"array":arr=>{var ret=stackAlloc(arr.length);writeArrayToMemory(arr,ret);return ret}};function convertReturnValue(ret){if(returnType==="string"){return UTF8ToString(ret)}if(returnType==="boolean")return Boolean(ret);return ret}var func=getCFunc(ident);var cArgs=[];var stack=0;if(args){for(var i=0;i<args.length;i++){var converter=toC[argTypes[i]];if(converter){if(stack===0)stack=stackSave();cArgs[i]=converter(args[i])}else{cArgs[i]=args[i]}}}var ret=func.apply(null,cArgs);function onDone(ret){if(stack!==0)stackRestore(stack);return convertReturnValue(ret)}ret=onDone(ret);return ret};var cwrap=(ident,returnType,argTypes,opts)=>{var numericArgs=!argTypes||argTypes.every(type=>type==="number"||type==="boolean");var numericRet=returnType!=="string";if(numericRet&&numericArgs&&!opts){return getCFunc(ident)}return function(){return ccall(ident,returnType,argTypes,arguments,opts)}};var wasmImports={__cxa_throw:___cxa_throw,abort:_abort,emscripten_memcpy_js:_emscripten_memcpy_js,emscripten_resize_heap:_emscripten_resize_heap,fd_close:_fd_close,fd_seek:_fd_seek,fd_write:_fd_write};var wasmExports=createWasm();var ___wasm_call_ctors=()=>(___wasm_call_ctors=wasmExports["__wasm_call_ctors"])();var _malloc=Module["_malloc"]=a0=>(_malloc=Module["_malloc"]=wasmExports["malloc"])(a0);var _free=Module["_free"]=a0=>(_free=Module["_free"]=wasmExports["free"])(a0);var _mel_spectrogram_compute=Module["_mel_spectrogram_compute"]=(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11)=>(_mel_spectrogram_compute=Module["_mel_spectrogram_compute"]=wasmExports["mel_spectrogram_compute"])(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11);var _mel_spectrogram_free=Module["_mel_spectrogram_free"]=a0=>(_mel_spectrogram_free=Module["_mel_spectrogram_free"]=wasmExports["mel_spectrogram_free"])(a0);var _mel_spectrogram_init=Module["_mel_spectrogram_init"]=(a0,a1,a2,a3,a4,a5,a6,a7)=>(_mel_spectrogram_init=Module["_mel_spectrogram_init"]=wasmExports["mel_spectrogram_init"])(a0,a1,a2,a3,a4,a5,a6,a7);var _mel_spectrogram_compute_frame=Module["_mel_spectrogram_compute_frame"]=(a0,a1,a2)=>(_mel_spectrogram_compute_frame=Module["_mel_spectrogram_compute_frame"]=wasmExports["mel_spectrogram_compute_frame"])(a0,a1,a2);var _mel_spectrogram_get_n_mels=Module["_mel_spectrogram_get_n_mels"]=()=>(_mel_spectrogram_get_n_mels=Module["_mel_spectrogram_get_n_mels"]=wasmExports["mel_spectrogram_get_n_mels"])();var _audio_features_compute=Module["_audio_features_compute"]=(a0,a1,a2,a3,a4,a5,a6,a7)=>(_audio_features_compute=Module["_audio_features_compute"]=wasmExports["audio_features_compute"])(a0,a1,a2,a3,a4,a5,a6,a7);var _audio_features_free=Module["_audio_features_free"]=a0=>(_audio_features_free=Module["_audio_features_free"]=wasmExports["audio_features_free"])(a0);var _audio_features_free_arrays=Module["_audio_features_free_arrays"]=a0=>(_audio_features_free_arrays=Module["_audio_features_free_arrays"]=wasmExports["audio_features_free_arrays"])(a0);var _audio_features_init=Module["_audio_features_init"]=(a0,a1,a2,a3,a4,a5)=>(_audio_features_init=Module["_audio_features_init"]=wasmExports["audio_features_init"])(a0,a1,a2,a3,a4,a5);var _audio_features_compute_frame=Module["_audio_features_compute_frame"]=(a0,a1,a2)=>(_audio_features_compute_frame=Module["_audio_features_compute_frame"]=wasmExports["audio_features_compute_frame"])(a0,a1,a2);var _audio_features_get_n_mfcc=Module["_audio_features_get_n_mfcc"]=()=>(_audio_features_get_n_mfcc=Module["_audio_features_get_n_mfcc"]=wasmExports["audio_features_get_n_mfcc"])();var stackSave=()=>(stackSave=wasmExports["stackSave"])();var stackRestore=a0=>(stackRestore=wasmExports["stackRestore"])(a0);var stackAlloc=a0=>(stackAlloc=wasmExports["stackAlloc"])(a0);var ___cxa_is_pointer_type=a0=>(___cxa_is_pointer_type=wasmExports["__cxa_is_pointer_type"])(a0);var dynCall_jiji=Module["dynCall_jiji"]=(a0,a1,a2,a3,a4)=>(dynCall_jiji=Module["dynCall_jiji"]=wasmExports["dynCall_jiji"])(a0,a1,a2,a3,a4);Module["ccall"]=ccall;Module["cwrap"]=cwrap;Module["getValue"]=getValue;var calledRun;dependenciesFulfilled=function runCaller(){if(!calledRun)run();if(!calledRun)dependenciesFulfilled=runCaller};function run(){if(runDependencies>0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve(Module);if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("")},1);doRun()},1)}else{doRun()}}if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}run();
+
+
+  return moduleArg.ready
+}
+);
+})();
+if (typeof exports === 'object' && typeof module === 'object')
+  module.exports = createMelSpectrogramModule;
+else if (typeof define === 'function' && define['amd'])
+  define([], () => createMelSpectrogramModule);