Audio Package

npm install @proj-airi/audio

import * as audio from '@proj-airi/audio'
import * as audioContext from '@proj-airi/audio/audio-context'
import * as encoding from '@proj-airi/audio/encoding'

import { initializeAudioContext } from '@proj-airi/audio/audio-context'

const context = await initializeAudioContext(48000)
console.log('Sample rate:', context.sampleRate)

import {
  getAudioContextState,
  isAudioContextReady,
  getAudioContext,
  getCurrentTime
} from '@proj-airi/audio/audio-context'

const state = getAudioContextState()
// {
//   isReady: boolean
//   sampleRate: number
//   error: string
//   isInitializing: boolean
//   workletLoaded: boolean
//   currentTime: number
//   state: AudioContextState
// }

if (isAudioContextReady()) {
  const context = getAudioContext()
  const time = getCurrentTime()
}

interface State {
  isReady: boolean                    // Context is initialized and ready
  sampleRate: number                  // Actual sample rate
  error: string                       // Error message if initialization failed
  isInitializing: boolean             // Currently initializing
  workletLoaded: boolean              // Audio worklets are loaded
  currentTime: number                 // Current audio time
  state: AudioContextState            // Native context state
}

import { subscribeToAudioContext } from '@proj-airi/audio/audio-context'

const unsubscribe = subscribeToAudioContext((state) => {
  console.log('Audio context state:', state)
})

// Later: clean up subscription
unsubscribe()

import { createAudioSource } from '@proj-airi/audio/audio-context'

const stream = await navigator.mediaDevices.getUserMedia({ audio: true })
const source = createAudioSource(stream)

import { createAudioAnalyser } from '@proj-airi/audio/audio-context'

const analyser = createAudioAnalyser({
  fftSize: 2048,
  smoothingTimeConstant: 0.8,
  minDecibels: -90,
  maxDecibels: -10
})

// Connect to source
source.connect(analyser)

// Get frequency data
const dataArray = new Uint8Array(analyser.frequencyBinCount)
analyser.getByteFrequencyData(dataArray)

import { createAudioGainNode } from '@proj-airi/audio/audio-context'

const gainNode = createAudioGainNode(0.5)  // 50% volume

// Connect source -> gain -> destination
source.connect(gainNode)
gainNode.connect(context.destination)

// Change volume
gainNode.gain.value = 0.8

import { createResamplingWorkletNode } from '@proj-airi/audio/audio-context'

const workletNode = createResamplingWorkletNode(source, {
  inputSampleRate: 48000,
  outputSampleRate: 16000,
  channels: 1,
  converterType: 2,  // SRC_SINC_MEDIUM_QUALITY
  bufferSize: 4096
})

workletNode.port.onmessage = (event) => {
  const { audio } = event.data
  // Process resampled audio
}

import { toWav, toWAVBase64 } from '@proj-airi/audio/encoding'

// Encode to WAV ArrayBuffer
const wavBuffer = toWav(audioData, 16000, 1)

// Encode to base64 WAV
const base64Wav = toWAVBase64(audioData, 16000)

// Use as data URL
const audio = new Audio(`data:audio/wav;base64,${base64Wav}`)
audio.play()

import {
  removeAudioSource,
  removeAudioGainNode,
  removeAudioAnalyser,
  removeWorkletNode
} from '@proj-airi/audio/audio-context'

// Clean up nodes
removeAudioSource(source)
removeAudioGainNode(gainNode)
removeAudioAnalyser(analyser)
removeWorkletNode(workletNode)

import {
  suspendAudioContext,
  resumeAudioContext
} from '@proj-airi/audio/audio-context'

// Suspend to save CPU
await suspendAudioContext()

// Resume when needed
await resumeAudioContext()

import { cleanupAudioContext } from '@proj-airi/audio/audio-context'

// Clean up all nodes and close context
await cleanupAudioContext()

import {
  initializeAudioContext,
  createAudioSource,
  createResamplingWorkletNode,
  removeAudioSource,
  removeWorkletNode,
  cleanupAudioContext
} from '@proj-airi/audio/audio-context'
import { toWAVBase64 } from '@proj-airi/audio/encoding'

// Initialize
const context = await initializeAudioContext(48000)

// Get microphone access
const stream = await navigator.mediaDevices.getUserMedia({
  audio: {
    sampleRate: 48000,
    channelCount: 1,
    echoCancellation: true,
    noiseSuppression: true
  }
})

// Create audio pipeline
const source = createAudioSource(stream)
const worklet = createResamplingWorkletNode(source, {
  inputSampleRate: 48000,
  outputSampleRate: 16000,
  channels: 1
})

// Collect audio chunks
const chunks: Float32Array[] = []

worklet.port.onmessage = (event) => {
  if (event.data.audio) {
    chunks.push(new Float32Array(event.data.audio))
  }
}

// Start recording
console.log('Recording...')

// Stop after 5 seconds
setTimeout(async () => {
  // Stop recording
  stream.getTracks().forEach(track => track.stop())
  
  // Combine chunks
  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0)
  const combined = new Float32Array(totalLength)
  let offset = 0
  for (const chunk of chunks) {
    combined.set(chunk, offset)
    offset += chunk.length
  }
  
  // Encode to WAV
  const wav = toWAVBase64(combined.buffer, 16000)
  console.log('Recording complete:', wav.length, 'bytes')
  
  // Clean up
  removeAudioSource(source)
  removeWorkletNode(worklet)
  await cleanupAudioContext()
}, 5000)