react-native-audio-api 0.5.5 → 0.6.0-rc.0

package/lib/typescript/web-core/OfflineAudioContext.d.ts

@@ -0,0 +1,34 @@
+import { ContextState, PeriodicWaveConstraints, OfflineAudioContextOptions, AudioBufferSourceNodeOptions } from '../types';
+import BaseAudioContext from './BaseAudioContext';
+import AnalyserNode from './AnalyserNode';
+import AudioDestinationNode from './AudioDestinationNode';
+import AudioBuffer from './AudioBuffer';
+import AudioBufferSourceNode from './AudioBufferSourceNode';
+import BiquadFilterNode from './BiquadFilterNode';
+import GainNode from './GainNode';
+import OscillatorNode from './OscillatorNode';
+import PeriodicWave from './PeriodicWave';
+import StereoPannerNode from './StereoPannerNode';
+export default class OfflineAudioContext implements BaseAudioContext {
+    readonly context: globalThis.OfflineAudioContext;
+    readonly destination: AudioDestinationNode;
+    readonly sampleRate: number;
+    constructor(options: OfflineAudioContextOptions);
+    constructor(numberOfChannels: number, length: number, sampleRate: number);
+    get currentTime(): number;
+    get state(): ContextState;
+    createOscillator(): OscillatorNode;
+    createGain(): GainNode;
+    createStereoPanner(): StereoPannerNode;
+    createBiquadFilter(): BiquadFilterNode;
+    createBufferSource(options?: AudioBufferSourceNodeOptions): Promise<AudioBufferSourceNode>;
+    createBuffer(numOfChannels: number, length: number, sampleRate: number): AudioBuffer;
+    createPeriodicWave(real: Float32Array, imag: Float32Array, constraints?: PeriodicWaveConstraints): PeriodicWave;
+    createAnalyser(): AnalyserNode;
+    decodeAudioDataSource(source: string): Promise<AudioBuffer>;
+    decodeAudioData(arrayBuffer: ArrayBuffer): Promise<AudioBuffer>;
+    startRendering(): Promise<AudioBuffer>;
+    resume(): Promise<void>;
+    suspend(suspendTime: number): Promise<void>;
+}
+//# sourceMappingURL=OfflineAudioContext.d.ts.map

package/lib/typescript/web-core/OfflineAudioContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OfflineAudioContext.d.ts","sourceRoot":"","sources":["../../../src/web-core/OfflineAudioContext.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,uBAAuB,EACvB,0BAA0B,EAC1B,4BAA4B,EAC7B,MAAM,UAAU,CAAC;AAElB,OAAO,gBAAgB,MAAM,oBAAoB,CAAC;AAClD,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAC1C,OAAO,oBAAoB,MAAM,wBAAwB,CAAC;AAC1D,OAAO,WAAW,MAAM,eAAe,CAAC;AACxC,OAAO,qBAAqB,MAAM,yBAAyB,CAAC;AAC5D,OAAO,gBAAgB,MAAM,oBAAoB,CAAC;AAClD,OAAO,QAAQ,MAAM,YAAY,CAAC;AAClC,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAC9C,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAC1C,OAAO,gBAAgB,MAAM,oBAAoB,CAAC;AAIlD,MAAM,CAAC,OAAO,OAAO,mBAAoB,YAAW,gBAAgB;IAClE,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC,mBAAmB,CAAC;IAEjD,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;gBAEhB,OAAO,EAAE,0BAA0B;gBACnC,gBAAgB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAsBxE,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED,IAAW,KAAK,IAAI,YAAY,CAE/B;IAED,gBAAgB,IAAI,cAAc;IAIlC,UAAU,IAAI,QAAQ;IAItB,kBAAkB,IAAI,gBAAgB;IAItC,kBAAkB,IAAI,gBAAgB;IAIhC,kBAAkB,CACtB,OAAO,CAAC,EAAE,4BAA4B,GACrC,OAAO,CAAC,qBAAqB,CAAC;IAgBjC,YAAY,CACV,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,GACjB,WAAW;IAwBd,kBAAkB,CAChB,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,YAAY,EAClB,WAAW,CAAC,EAAE,uBAAuB,GACpC,YAAY;IAYf,cAAc,IAAI,YAAY;IAIxB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAQ3D,eAAe,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAI/D,cAAc,IAAI,OAAO,CAAC,WAAW,CAAC;IAItC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAIvB,OAAO,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAGlD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-api",
-  "version": "0.5.5",
+  "version": "0.6.0-rc.0",
   "description": "react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification",
   "bin": {
     "setup-rn-audio-api-web": "./scripts/setup-rn-audio-api-web.js"
@@ -48,7 +48,7 @@
     "format:js": "prettier --write --list-different src",
     "format:android:cpp": "find android/src/ -path android/src/main/cpp/audioapi/android/libs -iname \"*.h\" -o -iname \"*.cpp\" | xargs clang-format -i",
     "format:android:kotlin": "ktlint -F 'android/src/main/java/**/*.kt'",
-    "format:ios": "find ios/ -iname \"*.h\" -o -iname \"*.m\" -o -iname \"*.mm\" -o -iname \"*.cpp\" | xargs clang-format -i",
+    "format:ios": "find ios/ \\( -iname \"*.h\" -o -iname \"*.m\" -o -iname \"*.mm\" -o -iname \"*.cpp\" \\) -not -path \"ios/audioapi/ios/*\" | xargs clang-format -i",
     "format:common": "find common/cpp/ -path 'common/cpp/audioapi/libs' -prune -iname \"*.h\" -o -iname \"*.cpp\" | xargs clang-format -i",
     "build": "bob build",
     "prepack": "cp ../../README.md ./README.md",

package/src/api.ts

@@ -1,13 +1,21 @@
 import NativeAudioAPIModule from './specs/NativeAudioAPIModule';
-import type { IAudioContext } from './interfaces';
+import type { IAudioContext, IOfflineAudioContext } from './interfaces';
 
 /* eslint-disable no-var */
 declare global {
   var createAudioContext: (sampleRate?: number) => IAudioContext;
+  var createOfflineAudioContext: (
+    numberOfChannels: number,
+    length: number,
+    sampleRate: number
+  ) => IOfflineAudioContext;
 }
 /* eslint-disable no-var */
 
-if (global.createAudioContext == null) {
+if (
+  global.createAudioContext == null ||
+  global.createOfflineAudioContext == null
+) {
   if (!NativeAudioAPIModule) {
     throw new Error(
       `Failed to install react-native-audio-api: The native module could not be found.`
@@ -20,6 +28,7 @@ if (global.createAudioContext == null) {
 export { default as AudioBuffer } from './core/AudioBuffer';
 export { default as AudioBufferSourceNode } from './core/AudioBufferSourceNode';
 export { default as AudioContext } from './core/AudioContext';
+export { default as OfflineAudioContext } from './core/OfflineAudioContext';
 export { default as AudioDestinationNode } from './core/AudioDestinationNode';
 export { default as AudioNode } from './core/AudioNode';
 export { default as AnalyserNode } from './core/AnalyserNode';
@@ -30,6 +39,7 @@ export { default as BiquadFilterNode } from './core/BiquadFilterNode';
 export { default as GainNode } from './core/GainNode';
 export { default as OscillatorNode } from './core/OscillatorNode';
 export { default as StereoPannerNode } from './core/StereoPannerNode';
+export { default as AudioManager } from './system';
 
 export {
   OscillatorType,

package/src/api.web.ts

@@ -1,6 +1,7 @@
 export { default as AudioBuffer } from './web-core/AudioBuffer';
 export { default as AudioBufferSourceNode } from './web-core/AudioBufferSourceNode';
 export { default as AudioContext } from './web-core/AudioContext';
+export { default as OfflineAudioContext } from './web-core/OfflineAudioContext';
 export { default as AudioDestinationNode } from './web-core/AudioDestinationNode';
 export { default as AudioNode } from './web-core/AudioNode';
 export { default as AnalyserNode } from './web-core/AnalyserNode';

package/src/core/AudioContext.ts

@@ -1,5 +1,6 @@
 import { IAudioContext } from '../interfaces';
 import BaseAudioContext from './BaseAudioContext';
+import AudioManager from '../system';
 import { AudioContextOptions } from '../types';
 import { NotSupportedError } from '../errors';
 
@@ -11,7 +12,11 @@ export default class AudioContext extends BaseAudioContext {
       );
     }
 
-    super(global.createAudioContext(options?.sampleRate));
+    super(
+      global.createAudioContext(
+        options?.sampleRate || AudioManager.getDevicePreferredSampleRate()
+      )
+    );
   }
 
   async close(): Promise<undefined> {

package/src/core/OfflineAudioContext.ts

@@ -0,0 +1,94 @@
+import { IOfflineAudioContext } from '../interfaces';
+import BaseAudioContext from './BaseAudioContext';
+import { OfflineAudioContextOptions } from '../types';
+import { InvalidStateError, NotSupportedError } from '../errors';
+import AudioBuffer from './AudioBuffer';
+
+export default class OfflineAudioContext extends BaseAudioContext {
+  private isSuspended: boolean;
+  private isRendering: boolean;
+  private duration: number;
+
+  constructor(options: OfflineAudioContextOptions);
+  constructor(numberOfChannels: number, length: number, sampleRate: number);
+  constructor(
+    arg0: OfflineAudioContextOptions | number,
+    arg1?: number,
+    arg2?: number
+  ) {
+    if (typeof arg0 === 'object') {
+      const { numberOfChannels, length, sampleRate } = arg0;
+      super(
+        global.createOfflineAudioContext(numberOfChannels, length, sampleRate)
+      );
+
+      this.duration = length / sampleRate;
+    } else if (
+      typeof arg0 === 'number' &&
+      typeof arg1 === 'number' &&
+      typeof arg2 === 'number'
+    ) {
+      super(global.createOfflineAudioContext(arg0, arg1, arg2));
+      this.duration = arg1 / arg2;
+    } else {
+      throw new NotSupportedError('Invalid constructor arguments');
+    }
+
+    this.isSuspended = false;
+    this.isRendering = false;
+  }
+
+  async resume(): Promise<undefined> {
+    if (!this.isRendering) {
+      throw new InvalidStateError(
+        'Cannot resume an OfflineAudioContext while rendering'
+      );
+    }
+
+    if (!this.isSuspended) {
+      throw new InvalidStateError(
+        'Cannot resume an OfflineAudioContext that is not suspended'
+      );
+    }
+
+    this.isSuspended = false;
+
+    await (this.context as IOfflineAudioContext).resume();
+  }
+
+  async suspend(suspendTime: number): Promise<undefined> {
+    if (suspendTime < 0) {
+      throw new InvalidStateError('suspendTime must be a non-negative number');
+    }
+
+    if (suspendTime < this.context.currentTime) {
+      throw new InvalidStateError(
+        `suspendTime must be greater than the current time: ${suspendTime}`
+      );
+    }
+
+    if (suspendTime > this.duration) {
+      throw new InvalidStateError(
+        `suspendTime must be less than the duration of the context: ${suspendTime}`
+      );
+    }
+
+    this.isSuspended = true;
+
+    await (this.context as IOfflineAudioContext).suspend(suspendTime);
+  }
+
+  async startRendering(): Promise<AudioBuffer> {
+    if (this.isRendering) {
+      throw new InvalidStateError('OfflineAudioContext is already rendering');
+    }
+
+    this.isRendering = true;
+
+    const audioBuffer = await (
+      this.context as IOfflineAudioContext
+    ).startRendering();
+
+    return new AudioBuffer(audioBuffer);
+  }
+}

package/src/interfaces.ts

@@ -9,6 +9,11 @@ import {
 
 export interface AudioAPIInstaller {
   createAudioContext: (sampleRate?: number) => IAudioContext;
+  createOfflineAudioContext: (
+    numberOfChannels: number,
+    length: number,
+    sampleRate: number
+  ) => IAudioContext;
 }
 
 export interface IBaseAudioContext {
@@ -43,6 +48,12 @@ export interface IAudioContext extends IBaseAudioContext {
   suspend(): Promise<void>;
 }
 
+export interface IOfflineAudioContext extends IBaseAudioContext {
+  resume(): Promise<void>;
+  suspend(suspendTime: number): Promise<void>;
+  startRendering(): Promise<IAudioBuffer>;
+}
+
 export interface IAudioNode {
   readonly context: BaseAudioContext;
   readonly numberOfInputs: number;

package/src/specs/NativeAudioManagerModule.ts

@@ -0,0 +1,51 @@
+import {
+  NativeModules,
+  DeviceEventEmitter,
+  NativeEventEmitter,
+  Platform,
+} from 'react-native';
+
+const NativeAudioManagerModule = NativeModules.AudioManagerModule;
+const eventEmitter = Platform.select({
+  ios: new NativeEventEmitter(NativeModules.AudioManagerModule),
+  android: DeviceEventEmitter,
+});
+
+if (!NativeAudioManagerModule || !eventEmitter) {
+  throw new Error(
+    `Failed to install react-native-audio-api: The native module could not be found.`
+  );
+}
+
+const AudioManagerModule = {
+  setLockScreenInfo(info: {
+    [key: string]: string | boolean | number | undefined;
+  }): void {
+    NativeAudioManagerModule.setLockScreenInfo(info);
+  },
+  resetLockScreenInfo(): void {
+    NativeAudioManagerModule.resetLockScreenInfo();
+  },
+  enableRemoteCommand(name: string, enabled: boolean): void {
+    NativeAudioManagerModule.enableRemoteCommand(name, enabled);
+  },
+  // audio session
+  setAudioSessionOptions(
+    category: string,
+    mode: string,
+    options: Array<string>,
+    active: boolean
+  ): void {
+    NativeAudioManagerModule.setAudioSessionOptions(
+      category,
+      mode,
+      options,
+      active
+    );
+  },
+  getDevicePreferredSampleRate(): number {
+    return NativeAudioManagerModule.getDevicePreferredSampleRate();
+  },
+};
+
+export { eventEmitter, AudioManagerModule };

package/src/specs/index.ts

@@ -0,0 +1,6 @@
+'use strict';
+
+import NativeAudioAPIModule from './NativeAudioAPIModule';
+import { AudioManagerModule, eventEmitter } from './NativeAudioManagerModule';
+
+export { NativeAudioAPIModule, AudioManagerModule, eventEmitter };

package/src/system/AudioManager.ts

@@ -0,0 +1,122 @@
+import { SessionOptions, LockScreenInfo, RemoteControl } from './types';
+import { AudioManagerModule, eventEmitter } from '../specs';
+import { EmitterSubscription } from 'react-native';
+
+class AudioManager {
+  setLockScreenInfo(info: LockScreenInfo) {
+    AudioManagerModule.setLockScreenInfo(info);
+  }
+
+  resetLockScreenInfo() {
+    AudioManagerModule.resetLockScreenInfo();
+  }
+
+  setAudioSessionOptions(options: SessionOptions) {
+    AudioManagerModule.setAudioSessionOptions(
+      options.iosCategory ?? '',
+      options.iosMode ?? '',
+      options.iosOptions ?? [],
+      options.active ?? true
+    );
+  }
+
+  getDevicePreferredSampleRate(): number {
+    return AudioManagerModule.getDevicePreferredSampleRate();
+  }
+
+  enableRemoteCommand(
+    name: RemoteControl,
+    enabled: boolean,
+    callback?: (value?: number) => void
+  ): EmitterSubscription | null {
+    AudioManagerModule.enableRemoteCommand(name, enabled);
+
+    let subscription = null;
+
+    if (enabled && callback) {
+      switch (name) {
+        case 'play':
+          subscription = eventEmitter!.addListener('onRemotePlay', callback);
+          break;
+
+        case 'pause':
+          subscription = eventEmitter!.addListener('onRemotePause', callback);
+          break;
+
+        case 'stop':
+          subscription = eventEmitter!.addListener('onRemoteStop', callback);
+          break;
+
+        case 'togglePlayPause':
+          subscription = eventEmitter!.addListener(
+            'onRemoteTogglePlayPause',
+            callback
+          );
+          break;
+
+        case 'changePlaybackRate':
+          subscription = eventEmitter!.addListener(
+            'onRemoteChangePlaybackRate',
+            callback
+          );
+          break;
+
+        case 'nextTrack':
+          subscription = eventEmitter!.addListener(
+            'onRemoteNextTrack',
+            callback
+          );
+          break;
+
+        case 'previousTrack':
+          subscription = eventEmitter!.addListener(
+            'onRemotePreviousTrack',
+            callback
+          );
+          break;
+
+        case 'skipForward':
+          subscription = eventEmitter!.addListener(
+            'onRemoteSkipForward',
+            callback
+          );
+          break;
+
+        case 'skipBackward':
+          subscription = eventEmitter!.addListener(
+            'onRemoteSkipBackward',
+            callback
+          );
+          break;
+
+        case 'seekForward':
+          subscription = eventEmitter!.addListener(
+            'onRemoteSeekForward',
+            callback
+          );
+          break;
+
+        case 'seekBackward':
+          subscription = eventEmitter!.addListener(
+            'onRemoteSeekBackward',
+            callback
+          );
+          break;
+
+        case 'changePlaybackPosition':
+          subscription = eventEmitter!.addListener(
+            'onRemoteChangePlaybackPosition',
+            callback
+          );
+          break;
+
+        default:
+          console.error('Unsupported RemoteControl action:', name);
+      }
+    }
+
+    return subscription;
+  }
+}
+
+export default new AudioManager();

package/src/system/index.ts

@@ -0,0 +1 @@
+export { default } from './AudioManager';

package/src/system/types.ts

@@ -0,0 +1,68 @@
+export type IOSCategory =
+  | 'record'
+  | 'ambient'
+  | 'playback'
+  | 'multiRoute'
+  | 'soloAmbient'
+  | 'playAndRecord';
+
+export type IOSMode =
+  | 'default'
+  | 'gameChat'
+  | 'videoChat'
+  | 'voiceChat'
+  | 'measurement'
+  | 'voicePrompt'
+  | 'spokenAudio'
+  | 'moviePlayback'
+  | 'videoRecording';
+
+export type IOSOption =
+  | 'duckOthers'
+  | 'allowAirPlay'
+  | 'mixWithOthers'
+  | 'allowBluetooth'
+  | 'defaultToSpeaker'
+  | 'allowBluetoothA2DP'
+  | 'overrideMutedMicrophoneInterruption'
+  | 'interruptSpokenAudioAndMixWithOthers';
+
+export interface SessionOptions {
+  iosMode?: IOSMode;
+  iosOptions?: IOSOption[];
+  iosCategory?: IOSCategory;
+  active?: boolean;
+}
+
+export type MediaState = 'state_playing' | 'state_paused' | 'state_stopped';
+
+interface BaseLockScreenInfo {
+  [key: string]: string | boolean | number | undefined;
+}
+
+export interface LockScreenInfo extends BaseLockScreenInfo {
+  title?: string;
+  artwork?: string;
+  artist?: string;
+  album?: string;
+  genre?: string;
+  duration?: number;
+  isLiveStream?: boolean;
+  state?: MediaState;
+  speed?: number;
+  elapsedTime?: number;
+}
+
+export type RemoteControl =
+  | 'play'
+  | 'pause'
+  | 'stop'
+  | 'togglePlayPause'
+  | 'changePlaybackRate'
+  | 'nextTrack'
+  | 'previousTrack'
+  | 'skipForward'
+  | 'skipBackward'
+  | 'seekForward'
+  | 'seekBackward'
+  | 'changePlaybackPosition';

package/src/types.ts

@@ -29,6 +29,12 @@ export interface AudioContextOptions {
   sampleRate: number;
 }
 
+export interface OfflineAudioContextOptions {
+  numberOfChannels: number;
+  length: number;
+  sampleRate: number;
+}
+
 export type WindowType = 'blackman' | 'hann';
 
 export interface AudioBufferSourceNodeOptions {

package/src/web-core/OfflineAudioContext.tsx

@@ -0,0 +1,163 @@
+import {
+  ContextState,
+  PeriodicWaveConstraints,
+  OfflineAudioContextOptions,
+  AudioBufferSourceNodeOptions,
+} from '../types';
+import { InvalidAccessError, NotSupportedError } from '../errors';
+import BaseAudioContext from './BaseAudioContext';
+import AnalyserNode from './AnalyserNode';
+import AudioDestinationNode from './AudioDestinationNode';
+import AudioBuffer from './AudioBuffer';
+import AudioBufferSourceNode from './AudioBufferSourceNode';
+import BiquadFilterNode from './BiquadFilterNode';
+import GainNode from './GainNode';
+import OscillatorNode from './OscillatorNode';
+import PeriodicWave from './PeriodicWave';
+import StereoPannerNode from './StereoPannerNode';
+
+import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
+
+export default class OfflineAudioContext implements BaseAudioContext {
+  readonly context: globalThis.OfflineAudioContext;
+
+  readonly destination: AudioDestinationNode;
+  readonly sampleRate: number;
+
+  constructor(options: OfflineAudioContextOptions);
+  constructor(numberOfChannels: number, length: number, sampleRate: number);
+  constructor(
+    arg0: OfflineAudioContextOptions | number,
+    arg1?: number,
+    arg2?: number
+  ) {
+    if (typeof arg0 === 'object') {
+      this.context = new window.OfflineAudioContext(arg0);
+    } else if (
+      typeof arg0 === 'number' &&
+      typeof arg1 === 'number' &&
+      typeof arg2 === 'number'
+    ) {
+      this.context = new window.OfflineAudioContext(arg0, arg1, arg2);
+    } else {
+      throw new NotSupportedError('Invalid constructor arguments');
+    }
+
+    this.sampleRate = this.context.sampleRate;
+    this.destination = new AudioDestinationNode(this, this.context.destination);
+  }
+
+  public get currentTime(): number {
+    return this.context.currentTime;
+  }
+
+  public get state(): ContextState {
+    return this.context.state as ContextState;
+  }
+
+  createOscillator(): OscillatorNode {
+    return new OscillatorNode(this, this.context.createOscillator());
+  }
+
+  createGain(): GainNode {
+    return new GainNode(this, this.context.createGain());
+  }
+
+  createStereoPanner(): StereoPannerNode {
+    return new StereoPannerNode(this, this.context.createStereoPanner());
+  }
+
+  createBiquadFilter(): BiquadFilterNode {
+    return new BiquadFilterNode(this, this.context.createBiquadFilter());
+  }
+
+  async createBufferSource(
+    options?: AudioBufferSourceNodeOptions
+  ): Promise<AudioBufferSourceNode> {
+    if (!options || !options.pitchCorrection) {
+      return new AudioBufferSourceNode(
+        this,
+        this.context.createBufferSource(),
+        false
+      );
+    }
+
+    await globalWasmPromise;
+
+    const wasmStretch = await window[globalTag](this.context);
+
+    return new AudioBufferSourceNode(this, wasmStretch, true);
+  }
+
+  createBuffer(
+    numOfChannels: number,
+    length: number,
+    sampleRate: number
+  ): AudioBuffer {
+    if (numOfChannels < 1 || numOfChannels >= 32) {
+      throw new NotSupportedError(
+        `The number of channels provided (${numOfChannels}) is outside the range [1, 32]`
+      );
+    }
+
+    if (length <= 0) {
+      throw new NotSupportedError(
+        `The number of frames provided (${length}) is less than or equal to the minimum bound (0)`
+      );
+    }
+
+    if (sampleRate < 8000 || sampleRate > 96000) {
+      throw new NotSupportedError(
+        `The sample rate provided (${sampleRate}) is outside the range [8000, 96000]`
+      );
+    }
+
+    return new AudioBuffer(
+      this.context.createBuffer(numOfChannels, length, sampleRate)
+    );
+  }
+
+  createPeriodicWave(
+    real: Float32Array,
+    imag: Float32Array,
+    constraints?: PeriodicWaveConstraints
+  ): PeriodicWave {
+    if (real.length !== imag.length) {
+      throw new InvalidAccessError(
+        `The lengths of the real (${real.length}) and imaginary (${imag.length}) arrays must match.`
+      );
+    }
+
+    return new PeriodicWave(
+      this.context.createPeriodicWave(real, imag, constraints)
+    );
+  }
+
+  createAnalyser(): AnalyserNode {
+    return new AnalyserNode(this, this.context.createAnalyser());
+  }
+
+  async decodeAudioDataSource(source: string): Promise<AudioBuffer> {
+    const arrayBuffer = await fetch(source).then((response) =>
+      response.arrayBuffer()
+    );
+
+    return this.decodeAudioData(arrayBuffer);
+  }
+
+  async decodeAudioData(arrayBuffer: ArrayBuffer): Promise<AudioBuffer> {
+    return new AudioBuffer(await this.context.decodeAudioData(arrayBuffer));
+  }
+
+  async startRendering(): Promise<AudioBuffer> {
+    return new AudioBuffer(await this.context.startRendering());
+  }
+
+  async resume(): Promise<void> {
+    await this.context.resume();
+  }
+
+  async suspend(suspendTime: number): Promise<void> {
+    await this.context.suspend(suspendTime);
+  }
+}