react-native-audio-api/lib/commonjs/core/BaseAudioContext.js

react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _errors = require("../errors");
var _utils = require("../utils");
var _AnalyserNode = _interopRequireDefault(require("./AnalyserNode"));
var _AudioBuffer = _interopRequireDefault(require("./AudioBuffer"));
var _AudioBufferQueueSourceNode = _interopRequireDefault(require("./AudioBufferQueueSourceNode"));
var _AudioBufferSourceNode = _interopRequireDefault(require("./AudioBufferSourceNode"));
var _AudioDecoder = require("./AudioDecoder");
var _AudioDestinationNode = _interopRequireDefault(require("./AudioDestinationNode"));
var _BiquadFilterNode = _interopRequireDefault(require("./BiquadFilterNode"));
var _ConstantSourceNode = _interopRequireDefault(require("./ConstantSourceNode"));
var _ConvolverNode = _interopRequireDefault(require("./ConvolverNode"));
var _DelayNode = _interopRequireDefault(require("./DelayNode"));
var _GainNode = _interopRequireDefault(require("./GainNode"));
var _IIRFilterNode = _interopRequireDefault(require("./IIRFilterNode"));
var _OscillatorNode = _interopRequireDefault(require("./OscillatorNode"));
var _PeriodicWave = _interopRequireDefault(require("./PeriodicWave"));
var _RecorderAdapterNode = _interopRequireDefault(require("./RecorderAdapterNode"));
var _StereoPannerNode = _interopRequireDefault(require("./StereoPannerNode"));
var _StreamerNode = _interopRequireDefault(require("./StreamerNode"));
var _WaveShaperNode = _interopRequireDefault(require("./WaveShaperNode"));
var _WorkletNode = _interopRequireDefault(require("./WorkletNode"));
var _WorkletProcessingNode = _interopRequireDefault(require("./WorkletProcessingNode"));
var _WorkletSourceNode = _interopRequireDefault(require("./WorkletSourceNode"));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
class BaseAudioContext {
  constructor(context) {
    this.context = context;
    this.destination = new _AudioDestinationNode.default(this, context.destination);
    this.sampleRate = context.sampleRate;
  }
  get currentTime() {
    return this.context.currentTime;
  }
  get state() {
    return this.context.state;
  }
  async decodeAudioData(input, fetchOptions) {
    return await (0, _AudioDecoder.decodeAudioData)(input, this.sampleRate, fetchOptions);
  }
  async decodePCMInBase64(base64String, inputSampleRate, inputChannelCount, isInterleaved = true) {
    return await (0, _AudioDecoder.decodePCMInBase64)(base64String, inputSampleRate, inputChannelCount, isInterleaved);
  }
  createWorkletNode(callback, bufferLength, inputChannelCount, workletRuntime = 'AudioRuntime') {
    if (inputChannelCount < 1 || inputChannelCount > 32) {
      throw new _errors.NotSupportedError(`The number of input channels provided (${inputChannelCount}) can not be less than 1 or greater than 32`);
    }
    if (bufferLength < 1) {
      throw new _errors.NotSupportedError(`The buffer length provided (${bufferLength}) can not be less than 1`);
    }
    (0, _utils.assertWorkletsEnabled)();
    return new _WorkletNode.default(this, workletRuntime, callback, bufferLength, inputChannelCount);
  }
  createWorkletProcessingNode(callback, workletRuntime = 'AudioRuntime') {
    (0, _utils.assertWorkletsEnabled)();
    return new _WorkletProcessingNode.default(this, workletRuntime, callback);
  }
  createWorkletSourceNode(callback, workletRuntime = 'AudioRuntime') {
    (0, _utils.assertWorkletsEnabled)();
    return new _WorkletSourceNode.default(this, workletRuntime, callback);
  }
  createRecorderAdapter() {
    return new _RecorderAdapterNode.default(this);
  }
  createOscillator() {
    return new _OscillatorNode.default(this);
  }
  createStreamer(streamPath) {
    return new _StreamerNode.default(this, {
      streamPath
    });
  }
  createConstantSource() {
    return new _ConstantSourceNode.default(this);
  }
  createGain() {
    return new _GainNode.default(this);
  }
  createDelay(maxDelayTime) {
    if (maxDelayTime !== undefined) {
      return new _DelayNode.default(this, {
        maxDelayTime
      });
    } else {
      return new _DelayNode.default(this);
    }
  }
  createStereoPanner() {
    return new _StereoPannerNode.default(this);
  }
  createBiquadFilter() {
    return new _BiquadFilterNode.default(this);
  }
  createBufferSource(options) {
    if (options !== undefined) {
      return new _AudioBufferSourceNode.default(this, options);
    } else {
      return new _AudioBufferSourceNode.default(this);
    }
  }
  createIIRFilter(feedforward, feedback) {
    if (feedforward.length < 1 || feedforward.length > 20) {
      throw new _errors.NotSupportedError(`The provided feedforward array has length (${feedforward.length}) outside the range [1, 20]`);
    }
    if (feedback.length < 1 || feedback.length > 20) {
      throw new _errors.NotSupportedError(`The provided feedback array has length (${feedback.length}) outside the range [1, 20]`);
    }
    if (feedforward.every(value => value === 0)) {
      throw new _errors.InvalidStateError(`Feedforward array must contain at least one non-zero value`);
    }
    if (feedback[0] === 0) {
      throw new _errors.InvalidStateError(`First value of feedback array cannot be zero`);
    }
    return new _IIRFilterNode.default(this, {
      feedforward,
      feedback
    });
  }
  createBufferQueueSource(options) {
    if (options !== undefined) {
      return new _AudioBufferQueueSourceNode.default(this, options);
    } else {
      return new _AudioBufferQueueSourceNode.default(this);
    }
  }
  createBuffer(numberOfChannels, length, sampleRate) {
    return new _AudioBuffer.default({
      numberOfChannels,
      length,
      sampleRate
    });
  }
  createPeriodicWave(real, imag, constraints) {
    if (real.length !== imag.length) {
      throw new _errors.InvalidAccessError(`The lengths of the real (${real.length}) and imaginary (${imag.length}) arrays must match.`);
    }
    return new _PeriodicWave.default(this, {
      real,
      imag,
      ...constraints
    });
  }
  createAnalyser() {
    return new _AnalyserNode.default(this);
  }
  createConvolver() {
    return new _ConvolverNode.default(this);
  }
  createWaveShaper() {
    return new _WaveShaperNode.default(this);
  }
}
exports.default = BaseAudioContext;
//# sourceMappingURL=BaseAudioContext.js.map