react-native-audio-api 0.0.1 → 0.2.0

package/common/cpp/wrappers/BiquadFilterNodeWrapper.cpp

@@ -0,0 +1,60 @@
+#include "BiquadFilterNodeWrapper.h"
+
+namespace audioapi {
+
+std::shared_ptr<BiquadFilterNode>
+BiquadFilterNodeWrapper::getBiquadFilterNodeFromAudioNode() {
+  return std::static_pointer_cast<BiquadFilterNode>(node_);
+}
+
+BiquadFilterNodeWrapper::BiquadFilterNodeWrapper(
+    const std::shared_ptr<BiquadFilterNode> &biquadFilterNode)
+    : AudioNodeWrapper(biquadFilterNode) {
+  auto frequencyParam = biquadFilterNode->getFrequencyParam();
+  frequencyParam_ = std::make_shared<AudioParamWrapper>(frequencyParam);
+  auto detuneParam = biquadFilterNode->getDetuneParam();
+  detuneParam_ = std::make_shared<AudioParamWrapper>(detuneParam);
+  auto QParam = biquadFilterNode->getQParam();
+  QParam_ = std::make_shared<AudioParamWrapper>(QParam);
+  auto gainParam = biquadFilterNode->getGainParam();
+  gainParam_ = std::make_shared<AudioParamWrapper>(gainParam);
+}
+
+std::shared_ptr<AudioParamWrapper> BiquadFilterNodeWrapper::getFrequencyParam()
+    const {
+  return frequencyParam_;
+}
+
+std::shared_ptr<AudioParamWrapper> BiquadFilterNodeWrapper::getDetuneParam()
+    const {
+  return detuneParam_;
+}
+
+std::shared_ptr<AudioParamWrapper> BiquadFilterNodeWrapper::getQParam() const {
+  return QParam_;
+}
+
+std::shared_ptr<AudioParamWrapper> BiquadFilterNodeWrapper::getGainParam()
+    const {
+  return gainParam_;
+}
+
+std::string BiquadFilterNodeWrapper::getType() {
+  auto biquadFilterNode_ = getBiquadFilterNodeFromAudioNode();
+  return biquadFilterNode_->getType();
+}
+
+void BiquadFilterNodeWrapper::setType(const std::string &filterType) {
+  auto biquadFilterNode_ = getBiquadFilterNodeFromAudioNode();
+  biquadFilterNode_->setType(filterType);
+}
+
+void BiquadFilterNodeWrapper::getFrequencyResponse(
+    const std::vector<float> &frequencyArray,
+    std::vector<float> &magResponseOutput,
+    std::vector<float> &phaseResponseOutput) {
+  auto biquadFilterNode_ = getBiquadFilterNodeFromAudioNode();
+  biquadFilterNode_->getFrequencyResponse(
+      frequencyArray, magResponseOutput, phaseResponseOutput);
+}
+} // namespace audioapi

package/common/cpp/wrappers/BiquadFilterNodeWrapper.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "AudioNodeWrapper.h"
+#include "AudioParamWrapper.h"
+#include "BiquadFilterNode.h"
+
+namespace audioapi {
+
+class BiquadFilterNodeWrapper : public AudioNodeWrapper {
+ public:
+  explicit BiquadFilterNodeWrapper(
+      const std::shared_ptr<BiquadFilterNode> &biquadFilterNode);
+
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getFrequencyParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getDetuneParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getQParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getGainParam() const;
+  std::string getType();
+  void setType(const std::string &filterType);
+  void getFrequencyResponse(
+      const std::vector<float> &frequencyArray,
+      std::vector<float> &magResponseOutput,
+      std::vector<float> &phaseResponseOutput);
+
+ private:
+  std::shared_ptr<AudioParamWrapper> frequencyParam_;
+  std::shared_ptr<AudioParamWrapper> detuneParam_;
+  std::shared_ptr<AudioParamWrapper> QParam_;
+  std::shared_ptr<AudioParamWrapper> gainParam_;
+
+  std::shared_ptr<BiquadFilterNode> getBiquadFilterNodeFromAudioNode();
+};
+} // namespace audioapi

package/common/cpp/wrappers/GainNodeWrapper.cpp

@@ -0,0 +1,14 @@
+#include "GainNodeWrapper.h"
+
+namespace audioapi {
+
+GainNodeWrapper::GainNodeWrapper(const std::shared_ptr<GainNode> &gainNode)
+    : AudioNodeWrapper(gainNode) {
+  auto gainParam = gainNode->getGainParam();
+  gainParam_ = std::make_shared<AudioParamWrapper>(gainParam);
+}
+
+std::shared_ptr<AudioParamWrapper> GainNodeWrapper::getGainParam() const {
+  return gainParam_;
+}
+} // namespace audioapi

package/common/cpp/wrappers/GainNodeWrapper.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioNodeWrapper.h"
+#include "AudioParamWrapper.h"
+#include "GainNode.h"
+
+namespace audioapi {
+
+class GainNodeWrapper : public AudioNodeWrapper {
+ public:
+  explicit GainNodeWrapper(const std::shared_ptr<GainNode> &gainNode);
+
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getGainParam() const;
+
+ private:
+  std::shared_ptr<AudioParamWrapper> gainParam_;
+};
+} // namespace audioapi

package/common/cpp/wrappers/OscillatorNodeWrapper.cpp

@@ -0,0 +1,44 @@
+#include "OscillatorNodeWrapper.h"
+
+namespace audioapi {
+
+std::shared_ptr<OscillatorNode>
+OscillatorNodeWrapper::getOscillatorNodeFromAudioNode() {
+  return std::static_pointer_cast<OscillatorNode>(node_);
+}
+
+OscillatorNodeWrapper::OscillatorNodeWrapper(
+    const std::shared_ptr<OscillatorNode> &oscillator)
+    : AudioScheduledSourceNodeWrapper(oscillator) {
+  auto frequencyParam = oscillator->getFrequencyParam();
+  frequencyParam_ = std::make_shared<AudioParamWrapper>(frequencyParam);
+  auto detuneParam = oscillator->getDetuneParam();
+  detuneParam_ = std::make_shared<AudioParamWrapper>(detuneParam);
+}
+
+std::shared_ptr<AudioParamWrapper> OscillatorNodeWrapper::getFrequencyParam()
+    const {
+  return frequencyParam_;
+}
+
+std::shared_ptr<AudioParamWrapper> OscillatorNodeWrapper::getDetuneParam()
+    const {
+  return detuneParam_;
+}
+
+std::string OscillatorNodeWrapper::getType() {
+  auto oscillatorNode_ = getOscillatorNodeFromAudioNode();
+  return oscillatorNode_->getType();
+}
+
+void OscillatorNodeWrapper::setType(const std::string &type) {
+  auto oscillatorNode_ = getOscillatorNodeFromAudioNode();
+  oscillatorNode_->setType(type);
+}
+
+void OscillatorNodeWrapper::setPeriodicWave(
+    const std::shared_ptr<PeriodicWaveWrapper> &periodicWave) {
+  auto oscillatorNode_ = getOscillatorNodeFromAudioNode();
+  oscillatorNode_->setPeriodicWave(periodicWave->periodicWave_);
+}
+} // namespace audioapi

package/common/cpp/wrappers/OscillatorNodeWrapper.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "AudioParamWrapper.h"
+#include "AudioScheduledSourceNodeWrapper.h"
+#include "OscillatorNode.h"
+#include "PeriodicWaveWrapper.h"
+
+namespace audioapi {
+
+class OscillatorNodeWrapper : public AudioScheduledSourceNodeWrapper {
+ public:
+  explicit OscillatorNodeWrapper(
+      const std::shared_ptr<OscillatorNode> &oscillatorNode);
+
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getFrequencyParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getDetuneParam() const;
+  std::string getType();
+  void setType(const std::string &type);
+  void setPeriodicWave(
+      const std::shared_ptr<PeriodicWaveWrapper> &periodicWave);
+
+ private:
+  std::shared_ptr<AudioParamWrapper> frequencyParam_;
+  std::shared_ptr<AudioParamWrapper> detuneParam_;
+
+  std::shared_ptr<OscillatorNode> getOscillatorNodeFromAudioNode();
+};
+} // namespace audioapi

package/common/cpp/wrappers/PeriodicWaveWrapper.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <memory>
+
+#include "PeriodicWave.h"
+
+namespace audioapi {
+
+class PeriodicWaveWrapper {
+ public:
+  explicit PeriodicWaveWrapper(
+      const std::shared_ptr<PeriodicWave> &periodicWave)
+      : periodicWave_(periodicWave) {}
+
+  std::shared_ptr<PeriodicWave> periodicWave_;
+};
+} // namespace audioapi

package/common/cpp/wrappers/StereoPannerNodeWrapper.cpp

@@ -0,0 +1,16 @@
+#include "StereoPannerNodeWrapper.h"
+
+namespace audioapi {
+
+StereoPannerNodeWrapper::StereoPannerNodeWrapper(
+    const std::shared_ptr<StereoPannerNode> &stereoPannerNode)
+    : AudioNodeWrapper(stereoPannerNode) {
+  auto panParam = stereoPannerNode->getPanParam();
+  panParam_ = std::make_shared<AudioParamWrapper>(panParam);
+}
+
+std::shared_ptr<AudioParamWrapper> StereoPannerNodeWrapper::getPanParam()
+    const {
+  return panParam_;
+}
+} // namespace audioapi

package/common/cpp/wrappers/StereoPannerNodeWrapper.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <memory>
+
+#include "AudioNodeWrapper.h"
+#include "AudioParamWrapper.h"
+#include "StereoPannerNode.h"
+
+namespace audioapi {
+
+class StereoPannerNodeWrapper : public AudioNodeWrapper {
+ public:
+  explicit StereoPannerNodeWrapper(
+      const std::shared_ptr<StereoPannerNode> &stereoPannerNode);
+
+  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getPanParam() const;
+
+ private:
+  std::shared_ptr<AudioParamWrapper> panParam_;
+};
+} // namespace audioapi

package/ios/AudioAPIModule.h

@@ -0,0 +1,24 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTInitializing.h>
+#if REACT_NATIVE_MINOR_VERSION >= 74
+#import <React/RCTRuntimeExecutorModule.h>
+#import <ReactCommon/RCTRuntimeExecutor.h>
+#endif // REACT_NATIVE_MINOR_VERSION >= 74
+#else // RCT_NEW_ARCH_ENABLED
+#import <React/RCTBridgeModule.h>
+#endif // RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTEventEmitter.h>
+
+@interface AudioAPIModule : RCTEventEmitter
+#ifdef RCT_NEW_ARCH_ENABLED
+                            <RCTInitializing
+#if REACT_NATIVE_MINOR_VERSION >= 74
+                             ,
+                             RCTRuntimeExecutorModule
+#endif // REACT_NATIVE_MINOR_VERSION >= 74
+#else
+                            <RCTBridgeModule
+#endif // RCT_NEW_ARCH_ENABLED
+                             >
+@end

package/ios/AudioAPIModule.mm

@@ -0,0 +1,44 @@
+#import "AudioAPIModule.h"
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTUtils.h>
+#import <jsi/jsi.h>
+
+#import "AudioAPIInstallerHostObject.h"
+#import "AudioAPIInstallerWrapper.h"
+
+@implementation AudioAPIModule
+
+RCT_EXPORT_MODULE(AudioAPIModule)
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
+{
+  NSLog(@"Installing JSI bindings for react-native-audio-api...");
+  RCTCxxBridge *cxxBridge = (RCTCxxBridge *)self.bridge;
+
+  if (cxxBridge == nil) {
+    NSLog(@"Error during getting bridge!");
+    return @false;
+  }
+
+  using namespace facebook;
+
+  auto jsRuntime = (jsi::Runtime *)cxxBridge.runtime;
+
+  if (jsRuntime == nil) {
+    NSLog(@"Error during getting jsRuntime!");
+    return @false;
+  }
+
+  auto &runtime = *jsRuntime;
+
+  auto wrapper = std::make_shared<audioapi::AudioAPIInstallerWrapper>();
+  auto hostObject = std::make_shared<audioapi::AudioAPIInstallerHostObject>(wrapper);
+  auto object = jsi::Object::createFromHostObject(runtime, hostObject);
+  runtime.global().setProperty(runtime, "__AudioAPIInstaller", std::move(object));
+
+  NSLog(@"Successfully installed JSI bindings for react-native-audio-api!");
+  return @true;
+}
+
+@end

package/ios/AudioPlayer/AudioPlayer.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+typedef void (^RenderAudioBlock)(AudioBufferList* outputBuffer, int numFrames);
+
+@interface AudioPlayer : NSObject
+
+@property (nonatomic, strong) AVAudioEngine *audioEngine;
+@property (nonatomic, weak) AVAudioSession *audioSession;
+@property (nonatomic, strong) AVAudioFormat *format;
+@property (nonatomic, strong) AVAudioSourceNode *sourceNode;
+@property (nonatomic, copy) RenderAudioBlock renderAudio;
+
+- (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio;
+
+- (int)getSampleRate;
+
+- (int)getBufferSizeInFrames;
+
+- (void)start;
+
+- (void)stop;
+
+- (void)cleanup;
+
+@end

package/ios/AudioPlayer/AudioPlayer.m

@@ -0,0 +1,119 @@
+#import <AudioPlayer.h>
+
+@implementation AudioPlayer
+
+- (instancetype)initWithRenderAudioBlock:(RenderAudioBlock)renderAudio
+{
+  if (self = [super init]) {
+    self.renderAudio = [renderAudio copy];
+    self.audioEngine = [[AVAudioEngine alloc] init];
+    self.audioEngine.mainMixerNode.outputVolume = 1;
+
+    self.audioSession = AVAudioSession.sharedInstance;
+    NSError *error = nil;
+
+    // TODO:
+    // We will probably want to change it to AVAudioSessionCategoryPlayAndRecord in the future.
+    // Eventually we to make this a dynamic setting, if user of the lib wants to use recording features.
+    // But setting a recording category might require some setup first, so lets skip it for now :)
+    [self.audioSession setCategory:AVAudioSessionCategoryPlayback error:&error];
+
+    if (error != nil) {
+      @throw error;
+    }
+
+    [self.audioSession setActive:true error:&error];
+
+    if (error != nil) {
+      @throw error;
+    }
+
+    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:[self.audioSession sampleRate] channels:2];
+
+    __weak typeof(self) weakSelf = self;
+    _sourceNode = [[AVAudioSourceNode alloc] initWithFormat:self.format
+                                                renderBlock:^OSStatus(
+                                                    BOOL *isSilence,
+                                                    const AudioTimeStamp *timestamp,
+                                                    AVAudioFrameCount frameCount,
+                                                    AudioBufferList *outputData) {
+                                                  return [weakSelf renderCallbackWithIsSilence:isSilence
+                                                                                     timestamp:timestamp
+                                                                                    frameCount:frameCount
+                                                                                    outputData:outputData];
+                                                }];
+  }
+
+  return self;
+}
+
+- (int)getSampleRate
+{
+  return [self.audioSession sampleRate];
+}
+
+- (int)getBufferSizeInFrames
+{
+  // Note: might be important in the future.
+  // For some reason audioSession.IOBufferDuration is always 0.01, which for sample rate of 48k
+  // gives exactly 480 frames, while at the same time frameCount requested by AVAudioSourceEngine
+  // might vary f.e. between 555-560.
+  // preferredIOBufferDuration seems to be double the value (resulting in 960 frames),
+  // which is safer to base our internal AudioBus sizes.
+  // Buut no documentation => no guarantee :)
+  // If something is crackling when it should play silence, start here 📻
+  return (int)(self.audioSession.preferredIOBufferDuration * self.audioSession.sampleRate);
+}
+
+- (void)start
+{
+  [self.audioEngine attachNode:self.sourceNode];
+  [self.audioEngine connect:self.sourceNode to:self.audioEngine.mainMixerNode format:self.format];
+
+
+  if (!self.audioEngine.isRunning) {
+    NSError *error = nil;
+    if (![self.audioEngine startAndReturnError:&error]) {
+      NSLog(@"Error starting audio engine: %@", [error localizedDescription]);
+    }
+  }
+}
+
+- (void)stop
+{
+  [self.audioEngine detachNode:self.sourceNode];
+
+  if (self.audioEngine.isRunning) {
+    [self.audioEngine stop];
+  }
+
+  NSError *error = nil;
+  [self.audioSession setActive:false error:&error];
+
+  if (error != nil) {
+    @throw error;
+  }
+}
+
+- (void)cleanup
+{
+  self.audioEngine = nil;
+  self.audioSession = nil;
+  self.renderAudio = nil;
+}
+
+- (OSStatus)renderCallbackWithIsSilence:(BOOL *)isSilence
+                              timestamp:(const AudioTimeStamp *)timestamp
+                             frameCount:(AVAudioFrameCount)frameCount
+                             outputData:(AudioBufferList *)outputData
+{
+  if (outputData->mNumberBuffers < 2) {
+    return noErr; // Ensure we have stereo output
+  }
+
+  self.renderAudio(outputData, frameCount);
+
+  return noErr;
+}
+
+@end

package/ios/AudioPlayer/IOSAudioPlayer.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#ifdef __OBJC__ // when compiled as Objective-C++
+#import <AudioPlayer.h>
+#else // when compiled as C++
+typedef struct objc_object AudioPlayer;
+#endif // __OBJC__
+
+#include <functional>
+
+namespace audioapi {
+
+class AudioContext;
+class AudioBus;
+
+class IOSAudioPlayer {
+ protected:
+  AudioBus* audioBus_;
+  AudioPlayer* audioPlayer_;
+  std::function<void(AudioBus*, int)> renderAudio_;
+
+ public:
+  explicit IOSAudioPlayer(const std::function<void(AudioBus*, int)> &renderAudio);
+  ~IOSAudioPlayer();
+
+  int getSampleRate() const;
+  int getBufferSizeInFrames() const;
+
+  void start();
+  void stop();
+
+};
+} // namespace audioapi

package/ios/AudioPlayer/IOSAudioPlayer.mm

@@ -0,0 +1,57 @@
+#import <AVFoundation/AVFoundation.h>
+
+#include <AudioBus.h>
+#include <Constants.h>
+#include <AudioArray.h>
+#include <IOSAudioPlayer.h>
+
+namespace audioapi {
+
+IOSAudioPlayer::IOSAudioPlayer(const std::function<void(AudioBus*, int)> &renderAudio) : renderAudio_(renderAudio), audioBus_(0)
+{
+  RenderAudioBlock renderAudioBlock = ^(AudioBufferList* outputData, int numFrames) {
+    renderAudio_(audioBus_, numFrames);
+
+    for (int i = 0; i < outputData->mNumberBuffers; i += 1) {
+      float *outputBuffer = (float *)outputData->mBuffers[i].mData;
+
+      memcpy(outputBuffer, audioBus_->getChannel(i)->getData(), sizeof(float) * numFrames);
+    }
+  };
+
+  audioPlayer_ = [[AudioPlayer alloc] initWithRenderAudioBlock:renderAudioBlock];
+  audioBus_ = new AudioBus(getSampleRate(), getBufferSizeInFrames(), CHANNEL_COUNT);
+}
+
+IOSAudioPlayer::~IOSAudioPlayer()
+{
+  stop();
+  [audioPlayer_ cleanup];
+
+  if (audioBus_) {
+    delete audioBus_;
+    audioBus_ = 0;
+  }
+}
+
+void IOSAudioPlayer::start()
+{
+  return [audioPlayer_ start];
+}
+
+void IOSAudioPlayer::stop()
+{
+  return [audioPlayer_ stop];
+}
+
+int IOSAudioPlayer::getSampleRate() const
+{
+  return [audioPlayer_ getSampleRate];
+}
+
+int IOSAudioPlayer::getBufferSizeInFrames() const
+{
+  return [audioPlayer_ getBufferSizeInFrames];
+}
+
+} // namespace audioapi

package/lib/module/core/AudioBuffer.js

@@ -0,0 +1,37 @@
+import { IndexSizeError } from '../errors';
+export default class AudioBuffer {
+  /** @internal */
+
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.length = buffer.length;
+    this.duration = buffer.duration;
+    this.sampleRate = buffer.sampleRate;
+    this.numberOfChannels = buffer.numberOfChannels;
+  }
+  getChannelData(channel) {
+    if (channel < 0 || channel >= this.numberOfChannels) {
+      throw new IndexSizeError(`The channel number provided (${channel}) is outside the range [0, ${this.numberOfChannels - 1}]`);
+    }
+    return this.buffer.getChannelData(channel);
+  }
+  copyFromChannel(destination, channelNumber, startInChannel = 0) {
+    if (channelNumber < 0 || channelNumber >= this.numberOfChannels) {
+      throw new IndexSizeError(`The channel number provided (${channelNumber}) is outside the range [0, ${this.numberOfChannels - 1}]`);
+    }
+    if (startInChannel < 0 || startInChannel >= this.length) {
+      throw new IndexSizeError(`The startInChannel number provided (${startInChannel}) is outside the range [0, ${this.length - 1}]`);
+    }
+    this.buffer.copyFromChannel(destination, channelNumber, startInChannel);
+  }
+  copyToChannel(source, channelNumber, startInChannel = 0) {
+    if (channelNumber < 0 || channelNumber >= this.numberOfChannels) {
+      throw new IndexSizeError(`The channel number provided (${channelNumber}) is outside the range [0, ${this.numberOfChannels - 1}]`);
+    }
+    if (startInChannel < 0 || startInChannel >= this.length) {
+      throw new IndexSizeError(`The startInChannel number provided (${startInChannel}) is outside the range [0, ${this.length - 1}]`);
+    }
+    this.buffer.copyToChannel(source, channelNumber, startInChannel);
+  }
+}
+//# sourceMappingURL=AudioBuffer.js.map

package/lib/module/core/AudioBuffer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["IndexSizeError","AudioBuffer","constructor","buffer","length","duration","sampleRate","numberOfChannels","getChannelData","channel","copyFromChannel","destination","channelNumber","startInChannel","copyToChannel","source"],"sourceRoot":"../../../src","sources":["core/AudioBuffer.ts"],"mappings":"AACA,SAASA,cAAc,QAAQ,WAAW;AAE1C,eAAe,MAAMC,WAAW,CAAC;EAK/B;;EAGAC,WAAWA,CAACC,MAAoB,EAAE;IAChC,IAAI,CAACA,MAAM,GAAGA,MAAM;IACpB,IAAI,CAACC,MAAM,GAAGD,MAAM,CAACC,MAAM;IAC3B,IAAI,CAACC,QAAQ,GAAGF,MAAM,CAACE,QAAQ;IAC/B,IAAI,CAACC,UAAU,GAAGH,MAAM,CAACG,UAAU;IACnC,IAAI,CAACC,gBAAgB,GAAGJ,MAAM,CAACI,gBAAgB;EACjD;EAEOC,cAAcA,CAACC,OAAe,EAAY;IAC/C,IAAIA,OAAO,GAAG,CAAC,IAAIA,OAAO,IAAI,IAAI,CAACF,gBAAgB,EAAE;MACnD,MAAM,IAAIP,cAAc,CACtB,gCAAgCS,OAAO,8BAA8B,IAAI,CAACF,gBAAgB,GAAG,CAAC,GAChG,CAAC;IACH;IACA,OAAO,IAAI,CAACJ,MAAM,CAACK,cAAc,CAACC,OAAO,CAAC;EAC5C;EAEOC,eAAeA,CACpBC,WAAqB,EACrBC,aAAqB,EACrBC,cAAsB,GAAG,CAAC,EACpB;IACN,IAAID,aAAa,GAAG,CAAC,IAAIA,aAAa,IAAI,IAAI,CAACL,gBAAgB,EAAE;MAC/D,MAAM,IAAIP,cAAc,CACtB,gCAAgCY,aAAa,8BAA8B,IAAI,CAACL,gBAAgB,GAAG,CAAC,GACtG,CAAC;IACH;IAEA,IAAIM,cAAc,GAAG,CAAC,IAAIA,cAAc,IAAI,IAAI,CAACT,MAAM,EAAE;MACvD,MAAM,IAAIJ,cAAc,CACtB,uCAAuCa,cAAc,8BAA8B,IAAI,CAACT,MAAM,GAAG,CAAC,GACpG,CAAC;IACH;IAEA,IAAI,CAACD,MAAM,CAACO,eAAe,CAACC,WAAW,EAAEC,aAAa,EAAEC,cAAc,CAAC;EACzE;EAEOC,aAAaA,CAClBC,MAAgB,EAChBH,aAAqB,EACrBC,cAAsB,GAAG,CAAC,EACpB;IACN,IAAID,aAAa,GAAG,CAAC,IAAIA,aAAa,IAAI,IAAI,CAACL,gBAAgB,EAAE;MAC/D,MAAM,IAAIP,cAAc,CACtB,gCAAgCY,aAAa,8BAA8B,IAAI,CAACL,gBAAgB,GAAG,CAAC,GACtG,CAAC;IACH;IAEA,IAAIM,cAAc,GAAG,CAAC,IAAIA,cAAc,IAAI,IAAI,CAACT,MAAM,EAAE;MACvD,MAAM,IAAIJ,cAAc,CACtB,uCAAuCa,cAAc,8BAA8B,IAAI,CAACT,MAAM,GAAG,CAAC,GACpG,CAAC;IACH;IAEA,IAAI,CAACD,MAAM,CAACW,aAAa,CAACC,MAAM,EAAEH,aAAa,EAAEC,cAAc,CAAC;EAClE;AACF","ignoreList":[]}

package/lib/module/core/AudioBufferSourceNode.js

@@ -0,0 +1,28 @@
+import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+import AudioBuffer from './AudioBuffer';
+export default class AudioBufferSourceNode extends AudioScheduledSourceNode {
+  constructor(context, node) {
+    super(context, node);
+  }
+  get buffer() {
+    const buffer = this.node.buffer;
+    if (!buffer) {
+      return null;
+    }
+    return new AudioBuffer(buffer);
+  }
+  set buffer(buffer) {
+    if (!buffer) {
+      this.node.buffer = null;
+      return;
+    }
+    this.node.buffer = buffer.buffer;
+  }
+  get loop() {
+    return this.node.loop;
+  }
+  set loop(value) {
+    this.node.loop = value;
+  }
+}
+//# sourceMappingURL=AudioBufferSourceNode.js.map

package/lib/module/core/AudioBufferSourceNode.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["AudioScheduledSourceNode","AudioBuffer","AudioBufferSourceNode","constructor","context","node","buffer","loop","value"],"sourceRoot":"../../../src","sources":["core/AudioBufferSourceNode.ts"],"mappings":"AACA,OAAOA,wBAAwB,MAAM,4BAA4B;AAEjE,OAAOC,WAAW,MAAM,eAAe;AAEvC,eAAe,MAAMC,qBAAqB,SAASF,wBAAwB,CAAC;EAC1EG,WAAWA,CAACC,OAAyB,EAAEC,IAA4B,EAAE;IACnE,KAAK,CAACD,OAAO,EAAEC,IAAI,CAAC;EACtB;EAEA,IAAWC,MAAMA,CAAA,EAAuB;IACtC,MAAMA,MAAM,GAAI,IAAI,CAACD,IAAI,CAA4BC,MAAM;IAC3D,IAAI,CAACA,MAAM,EAAE;MACX,OAAO,IAAI;IACb;IACA,OAAO,IAAIL,WAAW,CAACK,MAAM,CAAC;EAChC;EAEA,IAAWA,MAAMA,CAACA,MAA0B,EAAE;IAC5C,IAAI,CAACA,MAAM,EAAE;MACV,IAAI,CAACD,IAAI,CAA4BC,MAAM,GAAG,IAAI;MACnD;IACF;IAEC,IAAI,CAACD,IAAI,CAA4BC,MAAM,GAAGA,MAAM,CAACA,MAAM;EAC9D;EAEA,IAAWC,IAAIA,CAAA,EAAY;IACzB,OAAQ,IAAI,CAACF,IAAI,CAA4BE,IAAI;EACnD;EAEA,IAAWA,IAAIA,CAACC,KAAc,EAAE;IAC7B,IAAI,CAACH,IAAI,CAA4BE,IAAI,GAAGC,KAAK;EACpD;AACF","ignoreList":[]}

package/lib/module/core/AudioContext.js

@@ -0,0 +1,10 @@
+import BaseAudioContext from './BaseAudioContext';
+export default class AudioContext extends BaseAudioContext {
+  constructor() {
+    super(global.__AudioAPIInstaller.createAudioContext());
+  }
+  close() {
+    this.context.close();
+  }
+}
+//# sourceMappingURL=AudioContext.js.map

package/lib/module/core/AudioContext.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BaseAudioContext","AudioContext","constructor","global","__AudioAPIInstaller","createAudioContext","close","context"],"sourceRoot":"../../../src","sources":["core/AudioContext.ts"],"mappings":"AACA,OAAOA,gBAAgB,MAAM,oBAAoB;AAEjD,eAAe,MAAMC,YAAY,SAASD,gBAAgB,CAAC;EACzDE,WAAWA,CAAA,EAAG;IACZ,KAAK,CAACC,MAAM,CAACC,mBAAmB,CAACC,kBAAkB,CAAC,CAAC,CAAC;EACxD;EAEAC,KAAKA,CAAA,EAAS;IACX,IAAI,CAACC,OAAO,CAAmBD,KAAK,CAAC,CAAC;EACzC;AACF","ignoreList":[]}