react-native-audio-api 0.2.0 → 0.3.0-rc2

package/common/cpp/utils/JsiPromise.cpp

@@ -0,0 +1,64 @@
+#include "JsiPromise.h"
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+#include <functional>
+
+namespace JsiPromise {
+
+using namespace facebook;
+
+jsi::Value PromiseVendor::createPromise(
+    std::function<void(std::shared_ptr<Promise>)> func) {
+  if (_runtime == nullptr) {
+    throw new std::runtime_error("Runtime was null!");
+  }
+  auto &runtime = *_runtime;
+  auto callInvoker = _callInvoker;
+
+  // get Promise constructor
+  auto promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
+
+  // create a "run" function (first Promise arg)
+  auto runPromise = jsi::Function::createFromHostFunction(
+      runtime,
+      jsi::PropNameID::forUtf8(runtime, "runPromise"),
+      2,
+      [callInvoker, func](
+          jsi::Runtime &runtime,
+          const jsi::Value &thisValue,
+          const jsi::Value *arguments,
+          size_t count) -> jsi::Value {
+        auto resolveLocal = arguments[0].asObject(runtime).asFunction(runtime);
+        auto resolve = std::make_shared<jsi::Function>(std::move(resolveLocal));
+        auto rejectLocal = arguments[1].asObject(runtime).asFunction(runtime);
+        auto reject = std::make_shared<jsi::Function>(std::move(rejectLocal));
+
+        auto resolveWrapper =
+            [resolve, &runtime, callInvoker](jsi::Value value) -> void {
+          auto valueShared = std::make_shared<jsi::Value>(std::move(value));
+          callInvoker->invokeAsync([resolve, &runtime, valueShared]() -> void {
+            resolve->call(runtime, *valueShared);
+          });
+        };
+
+        auto rejectWrapper = [reject, &runtime, callInvoker](
+                                 const std::string &errorMessage) -> void {
+          auto error = jsi::JSError(runtime, errorMessage);
+          auto errorShared = std::make_shared<jsi::JSError>(error);
+          callInvoker->invokeAsync([reject, &runtime, errorShared]() -> void {
+            reject->call(runtime, errorShared->value());
+          });
+        };
+
+        auto promise = std::make_shared<Promise>(resolveWrapper, rejectWrapper);
+        func(promise);
+
+        return jsi::Value::undefined();
+      });
+
+  // return new Promise((resolve, reject) => ...)
+  return promiseCtor.callAsConstructor(runtime, runPromise);
+}
+
+} // namespace JsiPromise

package/common/cpp/utils/JsiPromise.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace JsiPromise {
+
+using namespace facebook;
+
+class Promise {
+ public:
+  Promise(
+      std::function<void(jsi::Value)> resolve,
+      std::function<void(const std::string &)> reject)
+      : _resolve(std::move(resolve)), _reject(std::move(reject)) {}
+
+  bool isResolved;
+  void resolve(jsi::Value &&value) {
+    _resolve(std::forward<jsi::Value>(value));
+  }
+  void reject(const std::string &errorMessage) {
+    _reject(errorMessage);
+  }
+
+ private:
+  std::function<void(jsi::Value)> _resolve;
+  std::function<void(const std::string &)> _reject;
+};
+
+class PromiseVendor {
+ public:
+  PromiseVendor(
+      jsi::Runtime *runtime,
+      std::shared_ptr<react::CallInvoker> callInvoker)
+      : _runtime(runtime), _callInvoker(callInvoker) {}
+
+ public:
+  jsi::Value createPromise(std::function<void(std::shared_ptr<Promise>)> func);
+
+ private:
+  jsi::Runtime *_runtime;
+  std::shared_ptr<react::CallInvoker> _callInvoker;
+};
+
+} // namespace JsiPromise

package/common/cpp/utils/Locker.h

@@ -7,8 +7,8 @@ namespace audioapi {
 // Small easy interface to manage locking
 class Locker {
  public:
-  Locker(): lockPtr_(0) {}
-  explicit Locker(std::mutex& lockPtr): lockPtr_(&lockPtr) {
+  Locker() : lockPtr_(0) {}
+  explicit Locker(std::mutex &lockPtr) : lockPtr_(&lockPtr) {
     lock();
   }
 
@@ -16,7 +16,9 @@ class Locker {
     unlock();
   }
 
-  explicit operator bool() const { return !!lockPtr_; }
+  explicit operator bool() const {
+    return !!lockPtr_;
+  }
 
   void lock() {
     if (lockPtr_) {
@@ -26,11 +28,11 @@ class Locker {
 
   void unlock() {
     if (lockPtr_) {
-    lockPtr_->unlock();
+      lockPtr_->unlock();
     }
   }
 
-  static Locker tryLock(std::mutex& lock) {
+  static Locker tryLock(std::mutex &lock) {
     Locker result = Locker();
 
     if (lock.try_lock()) {
@@ -41,7 +43,7 @@ class Locker {
   }
 
  private:
-  std::mutex* lockPtr_;
+  std::mutex *lockPtr_;
 };
 
 } // namespace audioapi

package/common/cpp/utils/VectorMath.cpp

@@ -115,8 +115,20 @@ float maximumMagnitude(
   return maximumValue;
 }
 
-void multiplyByScalarThenAddToOutput(const float* inputVector, float scalar, float* outputVector, size_t numberOfElementsToProcess) {
-    vDSP_vsma(inputVector, 1, &scalar, outputVector, 1, outputVector, 1, numberOfElementsToProcess);
+void multiplyByScalarThenAddToOutput(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess) {
+  vDSP_vsma(
+      inputVector,
+      1,
+      &scalar,
+      outputVector,
+      1,
+      outputVector,
+      1,
+      numberOfElementsToProcess);
 }
 
 #else
@@ -609,69 +621,73 @@ float maximumMagnitude(
   return max;
 }
 
-void multiplyByScalarThenAddToOutput(const float* inputVector, float scalar, float* outputVector, size_t numberOfElementsToProcess) {
-    size_t n = numberOfElementsToProcess;
+void multiplyByScalarThenAddToOutput(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess) {
+  size_t n = numberOfElementsToProcess;
 
 #if HAVE_X86_SSE2
-    // If the inputVector address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
-    while (!is16ByteAligned(inputVector) && n) {
-        *outputVector += scalar * *inputVector;
-        inputVector++;
-        outputVector++;
-        n--;
-    }
+  // If the inputVector address is not 16-byte aligned, the first several frames
+  // (at most three) should be processed separately.
+  while (!is16ByteAligned(inputVector) && n) {
+    *outputVector += scalar * *inputVector;
+    inputVector++;
+    outputVector++;
+    n--;
+  }
 
-    // Now the inputVector is aligned, use SSE.
-    size_t tailFrames = n % 4;
-    const float* endP = outputVector + n - tailFrames;
-
-    __m128 pSource;
-    __m128 dest;
-    __m128 temp;
-    __m128 mScale = _mm_set_ps1(scalar);
-
-    bool destAligned = is16ByteAligned(outputVector);
-
-#define SSE2_MULT_ADD(loadInstr, storeInstr)       \
-    while (outputVector < endP)                    \
-    {                                              \
-        pSource = _mm_load_ps(inputVector);        \
-        temp = _mm_mul_ps(pSource, mScale);        \
-        dest = _mm_##loadInstr##_ps(outputVector); \
-        dest = _mm_add_ps(dest, temp);             \
-        _mm_##storeInstr##_ps(outputVector, dest); \
-        inputVector += 4;                          \
-        outputVector += 4;                         \
-    }
+  // Now the inputVector is aligned, use SSE.
+  size_t tailFrames = n % 4;
+  const float *endP = outputVector + n - tailFrames;
+
+  __m128 pSource;
+  __m128 dest;
+  __m128 temp;
+  __m128 mScale = _mm_set_ps1(scalar);
+
+  bool destAligned = is16ByteAligned(outputVector);
+
+#define SSE2_MULT_ADD(loadInstr, storeInstr)   \
+  while (outputVector < endP) {                \
+    pSource = _mm_load_ps(inputVector);        \
+    temp = _mm_mul_ps(pSource, mScale);        \
+    dest = _mm_##loadInstr##_ps(outputVector); \
+    dest = _mm_add_ps(dest, temp);             \
+    _mm_##storeInstr##_ps(outputVector, dest); \
+    inputVector += 4;                          \
+    outputVector += 4;                         \
+  }
 
-    if (destAligned)
-        SSE2_MULT_ADD(load, store)
-    else
-        SSE2_MULT_ADD(loadu, storeu)
+  if (destAligned)
+    SSE2_MULT_ADD(load, store)
+  else
+    SSE2_MULT_ADD(loadu, storeu)
 
-    n = tailFrames;
+  n = tailFrames;
 #elif HAVE_ARM_NEON_INTRINSICS
-    size_t tailFrames = n % 4;
-    const float* endP = outputVector + n - tailFrames;
+  size_t tailFrames = n % 4;
+  const float *endP = outputVector + n - tailFrames;
 
-    float32x4_t k = vdupq_n_f32(scalar);
-    while (outputVector < endP) {
-        float32x4_t source = vld1q_f32(inputVector);
-        float32x4_t dest = vld1q_f32(outputVector);
+  float32x4_t k = vdupq_n_f32(scalar);
+  while (outputVector < endP) {
+    float32x4_t source = vld1q_f32(inputVector);
+    float32x4_t dest = vld1q_f32(outputVector);
 
-        dest = vmlaq_f32(dest, source, k);
-        vst1q_f32(outputVector, dest);
+    dest = vmlaq_f32(dest, source, k);
+    vst1q_f32(outputVector, dest);
 
-        inputVector += 4;
-        outputVector += 4;
-    }
-    n = tailFrames;
+    inputVector += 4;
+    outputVector += 4;
+  }
+  n = tailFrames;
 #endif
-    while (n--) {
-        *outputVector += *inputVector * scalar;
-        ++inputVector;
-        ++outputVector;
-    }
+  while (n--) {
+    *outputVector += *inputVector * scalar;
+    ++inputVector;
+    ++outputVector;
+  }
 }
 
 #endif

package/common/cpp/utils/android/FFTFrame.cpp

@@ -4,19 +4,20 @@
 
 namespace audioapi {
 void FFTFrame::inverse(float *timeDomainData) {
-    fftwf_complex *freqDomainData = fftwf_alloc_complex(size_ / 2);
-    for(int i = 0; i < size_ / 2; i++) {
-        freqDomainData[i][0] = realData_[i];
-        freqDomainData[i][1] = imaginaryData_[i];
-    }
+  fftwf_complex *freqDomainData = fftwf_alloc_complex(size_ / 2);
+  for (int i = 0; i < size_ / 2; i++) {
+    freqDomainData[i][0] = realData_[i];
+    freqDomainData[i][1] = imaginaryData_[i];
+  }
 
-    auto plan = fftwf_plan_dft_c2r_1d(size_, freqDomainData, timeDomainData, FFTW_ESTIMATE);
-    fftwf_execute(plan);
-    fftwf_destroy_plan(plan);
-    fftwf_free(freqDomainData);
+  auto plan = fftwf_plan_dft_c2r_1d(
+      size_, freqDomainData, timeDomainData, FFTW_ESTIMATE);
+  fftwf_execute(plan);
+  fftwf_destroy_plan(plan);
+  fftwf_free(freqDomainData);
 
-    VectorMath::multiplyByScalar(
-            timeDomainData, 1.0f / static_cast<float>(size_), timeDomainData, size_);
+  VectorMath::multiplyByScalar(
+      timeDomainData, 1.0f / static_cast<float>(size_), timeDomainData, size_);
 }
 } // namespace audioapi
 #endif

package/common/cpp/utils/ios/FFTFrame.cpp

@@ -11,7 +11,12 @@ void FFTFrame::inverse(float *timeDomainData) {
   freqDomainData.imagp = imaginaryData_;
 
   vDSP_fft_zrip(fftSetup_, &freqDomainData, 1, log2Size_, FFT_INVERSE);
-  vDSP_ztoc(&freqDomainData, 1, reinterpret_cast<DSPComplex *>(timeDomainData), 2, size_ / 2);
+  vDSP_ztoc(
+      &freqDomainData,
+      1,
+      reinterpret_cast<DSPComplex *>(timeDomainData),
+      2,
+      size_ / 2);
 
   // Scale the FFT data, beacuse of
   // https://developer.apple.com/library/archive/documentation/Performance/Conceptual/vDSP_Programming_Guide/UsingFourierTransforms/UsingFourierTransforms.html#//apple_ref/doc/uid/TP40005147-CH3-15892

package/common/cpp/wrappers/BaseAudioContextWrapper.cpp

@@ -73,4 +73,11 @@ BaseAudioContextWrapper::createPeriodicWave(
       context_->createPeriodicWave(real, imag, disableNormalization, length);
   return std::make_shared<PeriodicWaveWrapper>(periodicWave);
 }
+
+std::shared_ptr<AudioBufferWrapper>
+BaseAudioContextWrapper::decodeAudioDataSource(const std::string &path) {
+  return std::make_shared<AudioBufferWrapper>(
+      context_->decodeAudioDataSource(path));
+}
+
 } // namespace audioapi

package/common/cpp/wrappers/BaseAudioContextWrapper.h

@@ -41,6 +41,8 @@ class BaseAudioContextWrapper {
       float *imag,
       bool disableNormalization,
       int length);
+  std::shared_ptr<AudioBufferWrapper> decodeAudioDataSource(
+      const std::string &path);
 
  protected:
   std::shared_ptr<AudioDestinationNodeWrapper> destination_;

package/ios/AudioAPIModule.mm

@@ -1,7 +1,9 @@
 #import "AudioAPIModule.h"
 
 #import <React/RCTBridge+Private.h>
+#import <React/RCTBridge.h>
 #import <React/RCTUtils.h>
+#import <ReactCommon/RCTTurboModule.h>
 #import <jsi/jsi.h>
 
 #import "AudioAPIInstallerHostObject.h"
@@ -33,7 +35,8 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
   auto &runtime = *jsRuntime;
 
   auto wrapper = std::make_shared<audioapi::AudioAPIInstallerWrapper>();
-  auto hostObject = std::make_shared<audioapi::AudioAPIInstallerHostObject>(wrapper);
+  auto hostObject =
+      std::make_shared<audioapi::AudioAPIInstallerHostObject>(wrapper, jsRuntime, cxxBridge.jsCallInvoker);
   auto object = jsi::Object::createFromHostObject(runtime, hostObject);
   runtime.global().setProperty(runtime, "__AudioAPIInstaller", std::move(object));
 

package/ios/AudioDecoder/AudioDecoder.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+@interface AudioDecoder : NSObject
+
+@property (nonatomic, strong) AVAudioPCMBuffer *buffer;
+@property (nonatomic, assign) int sampleRate;
+
+- (instancetype)initWithSampleRate:(int)sampleRate;
+
+- (const AudioBufferList *)decodeWithFile:(NSString *)path;
+
+- (void)cleanup;
+
+@end

package/ios/AudioDecoder/AudioDecoder.m

@@ -0,0 +1,80 @@
+#import <AudioDecoder.h>
+
+@implementation AudioDecoder
+
+- (instancetype)initWithSampleRate:(int)sampleRate
+{
+  if (self = [super init]) {
+    self.sampleRate = sampleRate;
+  }
+  return self;
+}
+
+- (const AudioBufferList *)decodeWithFile:(NSString *)path
+{
+  NSError *error = nil;
+  NSURL *fileURL = [NSURL fileURLWithPath:path];
+  AVAudioFile *audioFile = [[AVAudioFile alloc] initForReading:fileURL error:&error];
+
+  if (error) {
+    NSLog(@"Error occurred while opening the audio file: %@", [error localizedDescription]);
+    return nil;
+  }
+  AVAudioPCMBuffer *buffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:[audioFile processingFormat]
+                                                           frameCapacity:[audioFile length]];
+
+  AVAudioFormat *format = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
+                                                           sampleRate:self.sampleRate
+                                                             channels:buffer.audioBufferList->mNumberBuffers
+                                                          interleaved:NO];
+
+  [audioFile readIntoBuffer:buffer error:&error];
+  if (error) {
+    NSLog(@"Error occurred while reading the audio file: %@", [error localizedDescription]);
+    return nil;
+  }
+
+  if (self.sampleRate != audioFile.processingFormat.sampleRate) {
+    self.buffer = [self convertBuffer:buffer ToFormat:format];
+  } else {
+    self.buffer = buffer;
+  }
+
+  return self.buffer.audioBufferList;
+}
+
+- (AVAudioPCMBuffer *)convertBuffer:(AVAudioPCMBuffer *)buffer ToFormat:(AVAudioFormat *)format
+{
+  NSError *error = nil;
+  AVAudioConverter *converter = [[AVAudioConverter alloc] initFromFormat:buffer.format toFormat:format];
+  AVAudioPCMBuffer *convertedBuffer =
+      [[AVAudioPCMBuffer alloc] initWithPCMFormat:format frameCapacity:(AVAudioFrameCount)buffer.frameCapacity];
+
+  AVAudioConverterInputBlock inputBlock =
+      ^AVAudioBuffer *(AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
+  {
+    if (buffer.frameLength > 0) {
+      *outStatus = AVAudioConverterInputStatus_HaveData;
+      return buffer;
+    } else {
+      *outStatus = AVAudioConverterInputStatus_NoDataNow;
+      return nil;
+    }
+  };
+
+  [converter convertToBuffer:convertedBuffer error:&error withInputFromBlock:inputBlock];
+
+  if (error) {
+    NSLog(@"Error occurred while converting the audio file: %@", [error localizedDescription]);
+    return nil;
+  }
+
+  return convertedBuffer;
+}
+
+- (void)cleanup
+{
+  self.buffer = nil;
+}
+
+@end

package/ios/AudioDecoder/IOSAudioDecoder.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <string>
+
+#ifdef __OBJC__ // when compiled as Objective-C++
+#import <AudioDecoder.h>
+#else // when compiled as C++
+typedef struct objc_object AudioDecoder;
+#endif // __OBJC__
+
+namespace audioapi {
+
+class AudioBus;
+
+class IOSAudioDecoder {
+ protected:
+  AudioDecoder *audioDecoder_;
+  int sampleRate_;
+
+ public:
+  IOSAudioDecoder(int sampleRate);
+  ~IOSAudioDecoder();
+
+  AudioBus *decodeWithFilePath(const std::string &path);
+  // TODO: implement this
+  AudioBus *decodeWithArrayBuffer();
+};
+} // namespace audioapi

package/ios/AudioDecoder/IOSAudioDecoder.mm

@@ -0,0 +1,46 @@
+#import <AVFoundation/AVFoundation.h>
+
+#include <AudioArray.h>
+#include <AudioBus.h>
+#include <IOSAudioDecoder.h>
+
+namespace audioapi {
+
+IOSAudioDecoder::IOSAudioDecoder(int sampleRate) : sampleRate_(sampleRate)
+{
+  audioDecoder_ = [[AudioDecoder alloc] initWithSampleRate:sampleRate_];
+}
+
+IOSAudioDecoder::~IOSAudioDecoder()
+{
+  [audioDecoder_ cleanup];
+  audioDecoder_ = nullptr;
+}
+
+AudioBus *IOSAudioDecoder::decodeWithFilePath(const std::string &path)
+{
+  auto bufferList = [audioDecoder_ decodeWithFile:[NSString stringWithUTF8String:path.c_str()]];
+  AudioBus *audioBus;
+  if (bufferList) {
+    auto numberOfChannels = bufferList->mNumberBuffers;
+    auto size = bufferList->mBuffers[0].mDataByteSize / sizeof(float);
+
+    audioBus = new AudioBus(sampleRate_, size, numberOfChannels);
+
+    for (int i = 0; i < numberOfChannels; i++) {
+      float *data = (float *)bufferList->mBuffers[i].mData;
+      memcpy(audioBus->getChannel(i)->getData(), data, sizeof(float) * size);
+    }
+  } else {
+    audioBus = new AudioBus(sampleRate_, 1, 1);
+  }
+
+  return audioBus;
+}
+
+AudioBus *IOSAudioDecoder::decodeWithArrayBuffer()
+{
+  // TODO: implement his
+  return new AudioBus(sampleRate_, 1, 1);
+}
+} // namespace audioapi

package/ios/AudioPlayer/AudioPlayer.h

@@ -3,7 +3,7 @@
 #import <AVFoundation/AVFoundation.h>
 #import <Foundation/Foundation.h>
 
-typedef void (^RenderAudioBlock)(AudioBufferList* outputBuffer, int numFrames);
+typedef void (^RenderAudioBlock)(AudioBufferList *outputBuffer, int numFrames);
 
 @interface AudioPlayer : NSObject
 

package/ios/AudioPlayer/AudioPlayer.m

@@ -62,7 +62,8 @@
   // 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);
+  double maxBufferDuration = fmax(0.02, fmax(self.audioSession.IOBufferDuration, self.audioSession.preferredIOBufferDuration));
+  return (int)(maxBufferDuration * self.audioSession.sampleRate + 1);
 }
 
 - (void)start
@@ -70,7 +71,6 @@
   [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]) {

package/ios/AudioPlayer/IOSAudioPlayer.h

@@ -15,12 +15,13 @@ class AudioBus;
 
 class IOSAudioPlayer {
  protected:
-  AudioBus* audioBus_;
-  AudioPlayer* audioPlayer_;
-  std::function<void(AudioBus*, int)> renderAudio_;
+  AudioBus *audioBus_;
+  AudioPlayer *audioPlayer_;
+  std::function<void(AudioBus *, int)> renderAudio_;
 
  public:
-  explicit IOSAudioPlayer(const std::function<void(AudioBus*, int)> &renderAudio);
+  explicit IOSAudioPlayer(
+      const std::function<void(AudioBus *, int)> &renderAudio);
   ~IOSAudioPlayer();
 
   int getSampleRate() const;
@@ -28,6 +29,5 @@ class IOSAudioPlayer {
 
   void start();
   void stop();
-
 };
 } // namespace audioapi

package/ios/AudioPlayer/IOSAudioPlayer.mm

@@ -1,15 +1,16 @@
 #import <AVFoundation/AVFoundation.h>
 
+#include <AudioArray.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)
+IOSAudioPlayer::IOSAudioPlayer(const std::function<void(AudioBus *, int)> &renderAudio)
+    : renderAudio_(renderAudio), audioBus_(0)
 {
-  RenderAudioBlock renderAudioBlock = ^(AudioBufferList* outputData, int numFrames) {
+  RenderAudioBlock renderAudioBlock = ^(AudioBufferList *outputData, int numFrames) {
     renderAudio_(audioBus_, numFrames);
 
     for (int i = 0; i < outputData->mNumberBuffers; i += 1) {

package/lib/module/core/BaseAudioContext.js

@@ -53,5 +53,9 @@ export default class BaseAudioContext {
     const disableNormalization = constraints?.disableNormalization ?? false;
     return new PeriodicWave(this.context.createPeriodicWave(real, imag, disableNormalization));
   }
+  async decodeAudioDataSource(sourcePath) {
+    const buffer = await this.context.decodeAudioDataSource(sourcePath);
+    return new AudioBuffer(buffer);
+  }
 }
 //# sourceMappingURL=BaseAudioContext.js.map