@siteed/expo-audio-stream 1.1.2 → 1.1.5

package/src/AudioAnalysis/AudioAnalysis.types.ts

@@ -1,84 +0,0 @@
-// packages/expo-audio-stream/src/AudioAnalysis/AudioAnalysis.types.ts
-
-/**
- * Represents various audio features extracted from an audio signal.
- */
-export interface AudioFeatures {
-    energy: number // The infinite integral of the squared signal, representing the overall energy of the audio.
-    mfcc: number[] // Mel-frequency cepstral coefficients, describing the short-term power spectrum of a sound.
-    rms: number // Root mean square value, indicating the amplitude of the audio signal.
-    minAmplitude: number // Minimum amplitude value in the audio signal.
-    maxAmplitude: number // Maximum amplitude value in the audio signal.
-    zcr: number // Zero-crossing rate, indicating the rate at which the signal changes sign.
-    spectralCentroid: number // The center of mass of the spectrum, indicating the brightness of the sound.
-    spectralFlatness: number // Measure of the flatness of the spectrum, indicating how noise-like the signal is.
-    spectralRolloff: number // The frequency below which a specified percentage (usually 85%) of the total spectral energy lies.
-    spectralBandwidth: number // The width of the spectrum, indicating the range of frequencies present.
-    chromagram: number[] // Chromagram, representing the 12 different pitch classes of the audio.
-    tempo: number // Estimated tempo of the audio signal, measured in beats per minute (BPM).
-    hnr: number // Harmonics-to-noise ratio, indicating the proportion of harmonics to noise in the audio signal.
-}
-
-/**
- * Options to specify which audio features to extract.
- */
-export interface AudioFeaturesOptions {
-    energy?: boolean
-    mfcc?: boolean
-    rms?: boolean
-    zcr?: boolean
-    spectralCentroid?: boolean
-    spectralFlatness?: boolean
-    spectralRolloff?: boolean
-    spectralBandwidth?: boolean
-    chromagram?: boolean
-    tempo?: boolean
-    hnr?: boolean
-}
-
-/**
- * Represents a single data point in the audio analysis.
- */
-export interface DataPoint {
-    id: number
-    amplitude: number
-    activeSpeech?: boolean
-    dB?: number
-    silent?: boolean
-    features?: AudioFeatures
-    startTime?: number
-    endTime?: number
-    // start / end position in bytes
-    startPosition?: number
-    endPosition?: number
-    // number of audio samples for this point (samples size depends on bit depth)
-    samples?: number
-    // TODO: speaker detection
-    speaker?: number
-}
-
-export type AmplitudeAlgorithm = 'peak' | 'rms'
-
-/**
- * Represents the complete data from the audio analysis.
- */
-export interface AudioAnalysis {
-    pointsPerSecond: number // How many consolidated value per second
-    durationMs: number // Duration of the audio in milliseconds
-    bitDepth: number // Bit depth of the audio
-    samples: number // Size of the audio in bytes
-    numberOfChannels: number // Number of audio channels
-    sampleRate: number // Sample rate of the audio
-    dataPoints: DataPoint[] // Array of data points from the analysis.
-    amplitudeAlgorithm: AmplitudeAlgorithm // Algorithm used to calculate amplitude values.
-    amplitudeRange: {
-        min: number
-        max: number
-    }
-    // TODO: speaker detection
-    speakerChanges?: {
-        timestamp: number // Timestamp of the speaker change in milliseconds.
-        speaker: number // Speaker identifier.
-    }[]
-}
-

package/src/AudioAnalysis/extractAudioAnalysis.ts

@@ -1,147 +0,0 @@
-// packages/expo-audio-stream/src/AudioAnalysis/extractAudioAnalysis.ts
-import {
-    AmplitudeAlgorithm,
-    AudioAnalysis,
-    AudioFeaturesOptions,
-} from './AudioAnalysis.types'
-import ExpoAudioStreamModule from '../ExpoAudioStreamModule'
-import { isWeb } from '../constants'
-import { getLogger } from '../logger'
-import { convertPCMToFloat32 } from '../utils/convertPCMToFloat32'
-import { getWavFileInfo, WavFileInfo } from '../utils/getWavFileInfo'
-import { InlineFeaturesExtractor } from '../workers/InlineFeaturesExtractor.web'
-
-const logger = getLogger('extractAudioAnalysis')
-
-export interface ExtractAudioAnalysisProps {
-    fileUri?: string // should provide either fileUri or arrayBuffer
-    wavMetadata?: WavFileInfo
-    arrayBuffer?: ArrayBuffer
-    bitDepth?: number
-    skipWavHeader?: boolean
-    durationMs?: number
-    sampleRate?: number
-    numberOfChannels?: number
-    algorithm?: AmplitudeAlgorithm
-    position?: number // Optional number of bytes to skip. Default is 0
-    length?: number // Optional number of bytes to read.
-    pointsPerSecond?: number // Optional number of points per second. Use to reduce the number of points and compute the number of datapoints to return.
-    features?: AudioFeaturesOptions
-    featuresExtratorUrl?: string
-}
-
-export const extractAudioAnalysis = async ({
-    fileUri,
-    pointsPerSecond = 20,
-    arrayBuffer,
-    bitDepth,
-    skipWavHeader = true,
-    durationMs,
-    sampleRate,
-    numberOfChannels,
-    algorithm = 'rms',
-    features,
-    featuresExtratorUrl,
-}: ExtractAudioAnalysisProps): Promise<AudioAnalysis> => {
-    if (isWeb) {
-        if (!arrayBuffer && !fileUri) {
-            throw new Error('Either arrayBuffer or fileUri must be provided')
-        }
-
-        if (!arrayBuffer) {
-            logger.log(`fetching fileUri`, fileUri)
-            const response = await fetch(fileUri!)
-
-            if (!response.ok) {
-                throw new Error(
-                    `Failed to fetch fileUri: ${response.statusText}`
-                )
-            }
-
-            arrayBuffer = await response.arrayBuffer()
-            logger.log(`fetched fileUri`, arrayBuffer.byteLength, arrayBuffer)
-        }
-
-        // Create a new copy of the ArrayBuffer to avoid detachment issues
-        const bufferCopy = arrayBuffer.slice(0)
-        logger.log(
-            `extractAudioAnalysis skipWavHeader=${skipWavHeader} bitDepth=${bitDepth} len=${bufferCopy.byteLength}`,
-            bufferCopy.slice(0, 100)
-        )
-
-        let actualBitDepth = bitDepth
-        if (!actualBitDepth) {
-            logger.log(
-                `extractAudioAnalysis bitDepth not provided -- getting wav file info`
-            )
-            const fileInfo = await getWavFileInfo(bufferCopy)
-            actualBitDepth = fileInfo.bitDepth
-        }
-        logger.log(`extractAudioAnalysis actualBitDepth=${actualBitDepth}`)
-
-        const {
-            pcmValues: channelData,
-            min,
-            max,
-        } = await convertPCMToFloat32({
-            buffer: arrayBuffer,
-            bitDepth: actualBitDepth,
-            skipWavHeader,
-        })
-        logger.log(
-            `extractAudioAnalysis skipWaveHeader=${skipWavHeader} convertPCMToFloat32 length=${channelData.length} range: [ ${min} :: ${max} ]`
-        )
-
-        return new Promise((resolve, reject) => {
-            let worker: Worker
-            if (featuresExtratorUrl) {
-                worker = new Worker(
-                    new URL(featuresExtratorUrl, window.location.href)
-                )
-            } else {
-                const blob = new Blob([InlineFeaturesExtractor], {
-                    type: 'application/javascript',
-                })
-                const url = URL.createObjectURL(blob)
-                worker = new Worker(url)
-            }
-
-            worker.onmessage = (event) => {
-                resolve(event.data.result)
-            }
-
-            worker.onerror = (error) => {
-                reject(error)
-            }
-
-            worker.postMessage({
-                command: 'process',
-                channelData,
-                sampleRate,
-                pointsPerSecond,
-                algorithm,
-                bitDepth,
-                fullAudioDurationMs: durationMs,
-                numberOfChannels,
-            })
-        })
-    } else {
-        if (!fileUri) {
-            throw new Error('fileUri is required')
-        }
-        logger.log(`extractAudioAnalysis`, {
-            fileUri,
-            pointsPerSecond,
-            algorithm,
-        })
-        const res = await ExpoAudioStreamModule.extractAudioAnalysis({
-            fileUri,
-            pointsPerSecond,
-            skipWavHeader,
-            algorithm,
-            features,
-        })
-        logger.log(`extractAudioAnalysis`, res)
-        return res
-    }
-}

package/src/AudioAnalysis/extractWaveform.ts

@@ -1,25 +0,0 @@
-import ExpoAudioStreamModule from '../ExpoAudioStreamModule'
-import { getLogger } from '../logger'
-
-const logger = getLogger('extractWaveform')
-export interface ExtractWaveformProps {
-    fileUri: string
-    numberOfSamples: number
-    offset?: number
-    length?: number
-}
-export const extractWaveform = async ({
-    fileUri,
-    numberOfSamples,
-    offset = 0,
-    length,
-}: ExtractWaveformProps): Promise<unknown> => {
-    const res = await ExpoAudioStreamModule.extractAudioAnalysis({
-        fileUri,
-        numberOfSamples,
-        offset,
-        length,
-    })
-    logger.log(`extractWaveform`, res)
-    return res
-}

package/src/AudioRecorder.provider.tsx

@@ -1,70 +0,0 @@
-// packages/expo-audio-stream/src/AudioRecorder.provider.tsx
-import React, { createContext, useContext } from 'react'
-
-import { AudioAnalysis } from './AudioAnalysis/AudioAnalysis.types'
-import {
-    AudioRecording,
-    RecordingConfig,
-    StartRecordingResult,
-} from './ExpoAudioStream.types'
-import { UseAudioRecorderProps, useAudioRecorder } from './useAudioRecorder'
-
-export interface UseAudioRecorderState {
-    startRecording: (_: RecordingConfig) => Promise<StartRecordingResult>
-    stopRecording: () => Promise<AudioRecording | null>
-    pauseRecording: () => void
-    resumeRecording: () => void
-    isRecording: boolean
-    isPaused: boolean
-    durationMs: number // Duration of the recording
-    size: number // Size in bytes of the recorded audio
-    analysisData?: AudioAnalysis // Analysis data for the recording depending on enableProcessing flag
-}
-
-const initContext: UseAudioRecorderState = {
-    isRecording: false,
-    isPaused: false,
-    durationMs: 0,
-    size: 0,
-    startRecording: async () => {
-        throw new Error('AudioRecorderProvider not found')
-    },
-    stopRecording: async () => {
-        throw new Error('AudioRecorderProvider not found')
-    },
-    pauseRecording: () => {
-        throw new Error('AudioRecorderProvider not found')
-    },
-    resumeRecording: () => {
-        throw new Error('AudioRecorderProvider not found')
-    },
-}
-
-const AudioRecorderContext = createContext<UseAudioRecorderState>(initContext)
-
-interface AudioRecorderProviderProps {
-    children: React.ReactNode
-    config?: UseAudioRecorderProps
-}
-
-export const AudioRecorderProvider: React.FC<AudioRecorderProviderProps> = ({
-    children,
-    config = {},
-}) => {
-    const audioRecorder = useAudioRecorder(config)
-    return (
-        <AudioRecorderContext.Provider value={audioRecorder}>
-            {children}
-        </AudioRecorderContext.Provider>
-    )
-}
-
-export const useSharedAudioRecorder = () => {
-    const context = useContext(AudioRecorderContext)
-    if (!context) {
-        throw new Error(
-            'useSharedAudioRecorder must be used within an AudioRecorderProvider'
-        )
-    }
-    return context
-}

package/src/ExpoAudioStream.types.ts

@@ -1,80 +0,0 @@
-// packages/expo-audio-stream/src/ExpoAudioStream.types.ts
-import {
-    AmplitudeAlgorithm,
-    AudioAnalysis,
-    AudioFeaturesOptions,
-} from './AudioAnalysis/AudioAnalysis.types'
-import { AudioAnalysisEvent } from './events'
-
-export interface AudioStreamStatus {
-    isRecording: boolean
-    isPaused: boolean
-    durationMs: number
-    size: number
-    interval: number
-    mimeType: string
-}
-
-export interface AudioDataEvent {
-    data: string | Float32Array
-    position: number
-    fileUri: string
-    eventDataSize: number
-    totalSize: number
-}
-
-export type EncodingType = 'pcm_32bit' | 'pcm_16bit' | 'pcm_8bit'
-export type SampleRate = 16000 | 44100 | 48000
-export type BitDepth = 8 | 16 | 32
-
-export interface Chunk {
-    text: string
-    timestamp: [number, number | null]
-}
-
-export interface TranscriberData {
-    id: string
-    isBusy: boolean
-    text: string
-    startTime: number
-    endTime: number
-    chunks: Chunk[]
-}
-
-export interface AudioRecording {
-    fileUri: string
-    filename: string
-    durationMs: number
-    size: number
-    mimeType: string
-    channels: number
-    bitDepth: BitDepth
-    sampleRate: SampleRate
-    transcripts?: TranscriberData[]
-    wavPCMData?: Float32Array // Full PCM data for the recording in WAV format (only on web, for native use the fileUri)
-    analysisData?: AudioAnalysis // Analysis data for the recording depending on enableProcessing flag
-}
-
-export interface StartRecordingResult {
-    fileUri: string
-    mimeType: string
-    channels?: number
-    bitDepth?: BitDepth
-    sampleRate?: SampleRate
-}
-
-export interface RecordingConfig {
-    sampleRate?: SampleRate // Sample rate for recording
-    channels?: 1 | 2 // 1 or 2 (MONO or STEREO)
-    encoding?: EncodingType // Encoding type for the recording
-    interval?: number // Interval in milliseconds at which to emit recording data
-
-    // Optional parameters for audio processing
-    enableProcessing?: boolean // Boolean to enable/disable audio processing (default is false)
-    pointsPerSecond?: number // Number of data points to extract per second of audio (default is 1000)
-    algorithm?: AmplitudeAlgorithm // Algorithm to use for amplitude computation (default is "rms")
-    features?: AudioFeaturesOptions // Feature options to extract (default is empty)
-
-    onAudioStream?: (_: AudioDataEvent) => Promise<void> // Callback function to handle audio stream
-    onAudioAnalysis?: (_: AudioAnalysisEvent) => Promise<void> // Callback function to handle audio features extraction results
-}

package/src/ExpoAudioStream.web.ts

@@ -1,255 +0,0 @@
-// src/ExpoAudioStreamModule.web.ts
-import { EventEmitter } from 'expo-modules-core'
-
-import { AudioAnalysis } from './AudioAnalysis/AudioAnalysis.types'
-import {
-    AudioRecording,
-    AudioStreamStatus,
-    BitDepth,
-    RecordingConfig,
-    StartRecordingResult,
-} from './ExpoAudioStream.types'
-import { WebRecorder } from './WebRecorder.web'
-import { AudioEventPayload } from './events'
-import { getLogger } from './logger'
-import { encodingToBitDepth } from './utils/encodingToBitDepth'
-import { writeWavHeader } from './utils/writeWavHeader'
-
-export interface EmitAudioEventProps {
-    data: Float32Array
-    position: number
-}
-export type EmitAudioEventFunction = (_: EmitAudioEventProps) => void
-export type EmitAudioAnalysisFunction = (_: AudioAnalysis) => void
-
-export interface ExpoAudioStreamWebProps {
-    audioWorkletUrl: string
-    featuresExtratorUrl: string
-}
-
-const logger = getLogger('ExpoAudioStreamWeb')
-
-export class ExpoAudioStreamWeb extends EventEmitter {
-    customRecorder: WebRecorder | null
-    audioChunks: ArrayBuffer[]
-    isRecording: boolean
-    isPaused: boolean
-    recordingStartTime: number
-    pausedTime: number
-    currentDurationMs: number
-    currentSize: number
-    currentInterval: number
-    lastEmittedSize: number
-    lastEmittedTime: number
-    streamUuid: string | null
-    extension: 'webm' | 'wav' = 'wav' // Default extension is 'webm'
-    recordingConfig?: RecordingConfig
-    bitDepth: BitDepth // Bit depth of the audio
-    audioWorkletUrl: string
-    featuresExtratorUrl: string
-
-    constructor({
-        audioWorkletUrl,
-        featuresExtratorUrl,
-    }: ExpoAudioStreamWebProps) {
-        const mockNativeModule = {
-            addListener: () => {
-                // Not used on web
-            },
-            removeListeners: () => {
-                // Not used on web
-            },
-        }
-        super(mockNativeModule) // Pass the mock native module to the parent class
-
-        this.customRecorder = null
-        this.audioChunks = []
-        this.isRecording = false
-        this.isPaused = false
-        this.recordingStartTime = 0
-        this.pausedTime = 0
-        this.currentDurationMs = 0
-        this.currentSize = 0
-        this.bitDepth = 32 // Default
-        this.currentInterval = 1000 // Default interval in ms
-        this.lastEmittedSize = 0
-        this.lastEmittedTime = 0
-        this.streamUuid = null // Initialize UUID on first recording start
-        this.audioWorkletUrl = audioWorkletUrl
-        this.featuresExtratorUrl = featuresExtratorUrl
-    }
-
-    // Utility to handle user media stream
-    async getMediaStream() {
-        try {
-            return await navigator.mediaDevices.getUserMedia({ audio: true })
-        } catch (error) {
-            console.error('Failed to get media stream:', error)
-            throw error
-        }
-    }
-
-    // Start recording with options
-    async startRecording(recordingConfig: RecordingConfig = {}) {
-        if (this.isRecording) {
-            throw new Error('Recording is already in progress')
-        }
-
-        this.bitDepth = encodingToBitDepth({
-            encoding: recordingConfig.encoding ?? 'pcm_32bit',
-        })
-
-        const audioContext = new (window.AudioContext ||
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore - Allow webkitAudioContext for Safari
-            window.webkitAudioContext)()
-        const stream = await this.getMediaStream()
-
-        const source = audioContext.createMediaStreamSource(stream)
-
-        this.customRecorder = new WebRecorder({
-            audioContext,
-            source,
-            recordingConfig,
-            audioWorkletUrl: this.audioWorkletUrl,
-            emitAudioEventCallback: ({
-                data,
-                position,
-            }: EmitAudioEventProps) => {
-                this.audioChunks.push(data)
-                this.currentSize += data.byteLength
-                this.emitAudioEvent({ data, position })
-                this.lastEmittedTime = Date.now()
-                this.lastEmittedSize = this.currentSize
-            },
-            emitAudioAnalysisCallback: (audioAnalysisData: AudioAnalysis) => {
-                logger.log(`Emitted AudioAnalysis:`, audioAnalysisData)
-                this.emit('AudioAnalysis', audioAnalysisData)
-            },
-        })
-        await this.customRecorder.init()
-        this.customRecorder.start()
-
-        // // Set a timer to stop recording after 5 seconds
-        // setTimeout(() => {
-        //   logger.log("AUTO Stopping recording");
-        //   this.customRecorder?.stopAndPlay();
-        //   this.isRecording = false;
-        // }, 3000);
-
-        this.isRecording = true
-        this.recordingConfig = recordingConfig
-        this.recordingStartTime = Date.now()
-        this.pausedTime = 0
-        this.lastEmittedSize = 0
-        this.lastEmittedTime = 0
-        this.streamUuid = Date.now().toString()
-        const fileUri = `${this.streamUuid}.${this.extension}`
-        const streamConfig: StartRecordingResult = {
-            fileUri,
-            mimeType: `audio/${this.extension}`,
-            bitDepth: this.bitDepth,
-            channels: recordingConfig.channels ?? 1,
-            sampleRate: recordingConfig.sampleRate ?? 44100,
-        }
-        return streamConfig
-    }
-
-    emitAudioEvent({ data, position }: EmitAudioEventProps) {
-        const fileUri = `${this.streamUuid}.${this.extension}`
-        const audioEventPayload: AudioEventPayload = {
-            fileUri,
-            mimeType: `audio/${this.extension}`,
-            lastEmittedSize: this.lastEmittedSize, // Since this might be continuously streaming, adjust accordingly
-            deltaSize: data.byteLength,
-            position,
-            totalSize: this.currentSize,
-            buffer: data,
-            streamUuid: this.streamUuid ?? '', // Generate or manage UUID for stream identification
-        }
-
-        this.emit('AudioData', audioEventPayload)
-    }
-
-    // Stop recording
-    async stopRecording(): Promise<AudioRecording> {
-        if (!this.customRecorder) {
-            throw new Error('Recorder is not initialized')
-        }
-
-        const fullPcmBufferArray = await this.customRecorder.stop()
-
-        // concat all audio chunks
-        logger.debug(`Stopped recording`, fullPcmBufferArray)
-        this.isRecording = false
-        this.currentDurationMs = Date.now() - this.recordingStartTime
-
-        const wavConfig = {
-            buffer: fullPcmBufferArray.buffer,
-            sampleRate: this.recordingConfig?.sampleRate ?? 44100,
-            numChannels: this.recordingConfig?.channels ?? 1,
-            bitDepth: this.bitDepth,
-        }
-        logger.debug(`Writing wav header`, wavConfig)
-        const wavBuffer = writeWavHeader(wavConfig).slice(0)
-
-        // Create blob fileUri from audio chunks
-        const blob = new Blob([wavBuffer], {
-            type: `audio/${this.extension}`,
-        })
-        const fileUri = URL.createObjectURL(blob)
-
-        const result: AudioRecording = {
-            fileUri,
-            filename: `${this.streamUuid}.${this.extension}`,
-            wavPCMData: fullPcmBufferArray,
-            bitDepth: this.bitDepth,
-            channels: this.recordingConfig?.channels ?? 1,
-            sampleRate: this.recordingConfig?.sampleRate ?? 44100,
-            durationMs: this.currentDurationMs,
-            size: this.currentSize,
-            mimeType: `audio/${this.extension}`,
-        }
-
-        return result
-    }
-
-    // Pause recording
-    async pauseRecording() {
-        if (!this.isRecording || this.isPaused) {
-            throw new Error('Recording is not active or already paused')
-        }
-
-        if (this.customRecorder) {
-            this.customRecorder.pause()
-        }
-        this.isPaused = true
-        this.pausedTime = Date.now()
-    }
-
-    // Resume recording
-    async resumeRecording() {
-        if (!this.isPaused) {
-            throw new Error('Recording is not paused')
-        }
-
-        if (this.customRecorder) {
-            this.customRecorder.resume()
-        }
-        this.isPaused = false
-        this.recordingStartTime += Date.now() - this.pausedTime
-    }
-
-    // Get current status
-    status() {
-        const status: AudioStreamStatus = {
-            isRecording: this.isRecording,
-            isPaused: this.isPaused,
-            durationMs: Date.now() - this.recordingStartTime,
-            size: this.currentSize,
-            interval: this.currentInterval,
-            mimeType: `audio/${this.extension}`,
-        }
-        return status
-    }
-}

package/src/ExpoAudioStreamModule.ts

@@ -1,31 +0,0 @@
-import { requireNativeModule } from 'expo-modules-core'
-import { Platform } from 'react-native'
-
-import {
-    ExpoAudioStreamWeb,
-    ExpoAudioStreamWebProps,
-} from './ExpoAudioStream.web'
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let ExpoAudioStreamModule: any
-
-if (Platform.OS === 'web') {
-    let instance: ExpoAudioStreamWeb | null = null
-
-    ExpoAudioStreamModule = (webProps: ExpoAudioStreamWebProps) => {
-        if (!instance) {
-            instance = new ExpoAudioStreamWeb(webProps)
-        }
-        return instance
-    }
-    ExpoAudioStreamModule.requestPermissionsAsync = async () => {
-        return { status: 'granted' }
-    }
-    ExpoAudioStreamModule.getPermissionsAsync = async () => {
-        return { status: 'granted' }
-    }
-} else {
-    ExpoAudioStreamModule = requireNativeModule('ExpoAudioStream')
-}
-
-export default ExpoAudioStreamModule