react-native-audio-api 0.3.0-rc1 → 0.3.1

package/common/cpp/core/BaseAudioContext.h

@@ -24,6 +24,7 @@ class AudioBufferSourceNode;
 
 #ifdef ANDROID
 class AudioPlayer;
+class AudioDecoder;
 #else
 class IOSAudioPlayer;
 class IOSAudioDecoder;
@@ -33,13 +34,14 @@ class BaseAudioContext {
  public:
   BaseAudioContext();
   ~BaseAudioContext();
+
   std::string getState();
   [[nodiscard]] int getSampleRate() const;
   [[nodiscard]] double getCurrentTime() const;
   [[nodiscard]] int getBufferSizeInFrames() const;
   [[nodiscard]] std::size_t getCurrentSampleFrame() const;
-
   std::shared_ptr<AudioDestinationNode> getDestination();
+
   std::shared_ptr<OscillatorNode> createOscillator();
   std::shared_ptr<GainNode> createGain();
   std::shared_ptr<StereoPannerNode> createStereoPanner();
@@ -52,11 +54,10 @@ class BaseAudioContext {
       float *imag,
       bool disableNormalization,
       int length);
-  std::shared_ptr<AudioBuffer> decodeAudioDataSource(const std::string &source);
 
+  std::shared_ptr<AudioBuffer> decodeAudioDataSource(const std::string &path);
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   std::function<void(AudioBus *, int)> renderAudio();
-
   AudioNodeManager *getNodeManager();
   [[nodiscard]] bool isRunning() const;
   [[nodiscard]] bool isClosed() const;
@@ -67,6 +68,7 @@ class BaseAudioContext {
 
 #ifdef ANDROID
   std::shared_ptr<AudioPlayer> audioPlayer_;
+  std::shared_ptr<AudioDecoder> audioDecoder_;
 #else
   std::shared_ptr<IOSAudioPlayer> audioPlayer_;
   std::shared_ptr<IOSAudioDecoder> audioDecoder_;

package/common/cpp/core/OscillatorNode.cpp

@@ -40,15 +40,20 @@ void OscillatorNode::setPeriodicWave(
 }
 
 void OscillatorNode::processNode(AudioBus *processingBus, int framesToProcess) {
+  size_t startOffset = 0;
+  size_t offsetLength = 0;
+
+  updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
+
   if (!isPlaying()) {
     processingBus->zero();
     return;
   }
 
-  double time = context_->getCurrentTime();
   double deltaTime = 1.0 / context_->getSampleRate();
+  double time = context_->getCurrentTime() + startOffset * deltaTime;
 
-  for (int i = 0; i < framesToProcess; i += 1) {
+  for (size_t i = startOffset; i < offsetLength; i += 1) {
     auto detuneRatio =
         std::pow(2.0f, detuneParam_->getValueAtTime(time) / 1200.0f);
     auto detunedFrequency =

package/common/cpp/jsi/JsiHostObject.cpp

@@ -0,0 +1,85 @@
+#include "JsiHostObject.h"
+
+namespace audioapi {
+JsiHostObject::JsiHostObject() {
+  propertyGetters_ = std::make_unique<std::unordered_map<
+      std::string,
+      jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>();
+  propertyFunctions_ = std::make_unique<std::unordered_map<
+      std::string,
+      jsi::Value (JsiHostObject::*)(
+          jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>>();
+  propertySetters_ = std::make_unique<std::unordered_map<
+      std::string,
+      void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>>();
+}
+
+std::vector<jsi::PropNameID> JsiHostObject::getPropertyNames(jsi::Runtime &rt) {
+  std::vector<jsi::PropNameID> propertyNames;
+  propertyNames.reserve(
+      propertyGetters_->size() + propertyFunctions_->size() +
+      propertySetters_->size());
+
+  for (const auto &it : *propertyGetters_) {
+    propertyNames.push_back(jsi::PropNameID::forUtf8(rt, it.first));
+  }
+
+  for (const auto &it : *propertyFunctions_) {
+    propertyNames.push_back(jsi::PropNameID::forAscii(rt, it.first));
+  }
+
+  for (const auto &it : *propertySetters_) {
+    propertyNames.push_back(jsi::PropNameID::forAscii(rt, it.first));
+  }
+
+  return propertyNames;
+}
+
+jsi::Value JsiHostObject::get(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &name) {
+  auto nameAsString = name.utf8(runtime);
+
+  auto propertyGetter = propertyGetters_->find(nameAsString);
+  if (propertyGetter != propertyGetters_->end()) {
+    auto dispatcher = [this, &propertyGetter](jsi::Runtime &runtime) {
+      return (this->*(propertyGetter->second))(runtime);
+    };
+
+    return dispatcher(runtime);
+  }
+
+  auto propertyFunction = propertyFunctions_->find(nameAsString);
+  if (propertyFunction != propertyFunctions_->end()) {
+    auto dispatcher = [this, &propertyFunction](
+                          jsi::Runtime &runtime,
+                          const jsi::Value &thisVal,
+                          const jsi::Value *args,
+                          size_t count) -> jsi::Value {
+      return (this->*(propertyFunction->second))(runtime, thisVal, args, count);
+    };
+
+    return jsi::Function::createFromHostFunction(runtime, name, 0, dispatcher);
+  }
+
+  return jsi::Value::undefined();
+}
+
+void JsiHostObject::set(
+    jsi::Runtime &runtime,
+    const jsi::PropNameID &name,
+    const jsi::Value &value) {
+  auto nameAsString = name.utf8(runtime);
+
+  auto propertySetter = propertySetters_->find(nameAsString);
+
+  if (propertySetter != propertySetters_->end()) {
+    auto dispatcher = [this, &propertySetter](
+                          jsi::Runtime &runtime, const jsi::Value &value) {
+      return (this->*(propertySetter->second))(runtime, value);
+    };
+
+    return dispatcher(runtime, value);
+  }
+}
+} // namespace audioapi

package/common/cpp/jsi/JsiHostObject.h

@@ -0,0 +1,94 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#define JSI_HOST_FUNCTION(NAME)  \
+  jsi::Value NAME(               \
+      jsi::Runtime &runtime,     \
+      const jsi::Value &thisVal, \
+      const jsi::Value *args,    \
+      size_t count)
+
+#define JSI_EXPORT_FUNCTION(CLASS, FUNCTION)                                \
+  std::make_pair(                                                           \
+      std::string(#FUNCTION),                                               \
+      static_cast<jsi::Value (JsiHostObject::*)(                            \
+          jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>( \
+          &CLASS::FUNCTION))
+
+#define JSI_PROPERTY_GETTER(name) jsi::Value name(jsi::Runtime &runtime)
+
+#define JSI_EXPORT_PROPERTY_GETTER(CLASS, FUNCTION)               \
+  std::make_pair(                                                 \
+      std::string(#FUNCTION),                                     \
+      static_cast<jsi::Value (JsiHostObject::*)(jsi::Runtime &)>( \
+          &CLASS::FUNCTION))
+
+#define JSI_PROPERTY_SETTER(name) \
+  void name(jsi::Runtime &runtime, const jsi::Value &value)
+
+#define JSI_EXPORT_PROPERTY_SETTER(CLASS, FUNCTION) \
+  std::make_pair(                                   \
+      std::string(#FUNCTION),                       \
+      static_cast<void (JsiHostObject::*)(          \
+          jsi::Runtime &, const jsi::Value &)>(&CLASS::FUNCTION))
+
+namespace audioapi {
+
+using namespace facebook;
+
+class JsiHostObject : public jsi::HostObject {
+ public:
+  JsiHostObject();
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
+
+  void set(
+      jsi::Runtime &runtime,
+      const jsi::PropNameID &name,
+      const jsi::Value &value) override;
+
+  template <typename... Args>
+  void addGetters(Args... args) {
+    (propertyGetters_->insert(args), ...);
+  }
+
+  template <typename... Args>
+  void addSetters(Args... args) {
+    (propertySetters_->insert(args), ...);
+  }
+
+  template <typename... Args>
+  void addFunctions(Args... args) {
+    (propertyFunctions_->insert(args), ...);
+  }
+
+ protected:
+  std::unique_ptr<std::unordered_map<
+      std::string,
+      jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>
+      propertyGetters_;
+
+  std::unique_ptr<std::unordered_map<
+      std::string,
+      jsi::Value (JsiHostObject::*)(
+          jsi::Runtime &,
+          const jsi::Value &,
+          const jsi::Value *,
+          size_t)>>
+      propertyFunctions_;
+
+  std::unique_ptr<std::unordered_map<
+      std::string,
+      void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>>
+      propertySetters_;
+};
+
+} // namespace audioapi

package/common/cpp/jsi/JsiPromise.cpp

@@ -0,0 +1,65 @@
+#include "JsiPromise.h"
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+#include <functional>
+
+namespace audioapi {
+
+using namespace facebook;
+
+jsi::Value PromiseVendor::createPromise(
+    const std::function<void(std::shared_ptr<Promise>)> &function) {
+  if (runtime_ == nullptr) {
+    throw 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, function](
+          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);
+        function(promise);
+
+        return jsi::Value::undefined();
+      });
+
+  // return new Promise((resolve, reject) => ...)
+  return promiseCtor.callAsConstructor(runtime, runPromise);
+}
+
+} // namespace audioapi

package/common/cpp/jsi/JsiPromise.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace audioapi {
+
+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)) {}
+
+  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,
+      const std::shared_ptr<react::CallInvoker> &callInvoker)
+      : runtime_(runtime), callInvoker_(callInvoker) {}
+
+ public:
+  jsi::Value createPromise(
+      const std::function<void(std::shared_ptr<Promise>)> &function);
+
+ private:
+  jsi::Runtime *runtime_;
+  std::shared_ptr<react::CallInvoker> callInvoker_;
+};
+
+} // namespace audioapi

package/common/cpp/utils/AudioUtils.cpp

@@ -0,0 +1,26 @@
+#include "AudioUtils.h"
+
+namespace audioapi::AudioUtils {
+size_t timeToSampleFrame(double time, int sampleRate) {
+  return static_cast<size_t>(time * sampleRate);
+}
+
+double sampleFrameToTime(int sampleFrame, int sampleRate) {
+  return static_cast<double>(sampleFrame) / sampleRate;
+}
+
+float linearInterpolate(
+    const float *source,
+    size_t firstIndex,
+    size_t secondIndex,
+    float factor) {
+  if (firstIndex == secondIndex && firstIndex >= 1) {
+    return source[firstIndex] +
+        factor * (source[firstIndex] - source[firstIndex - 1]);
+  }
+
+  return source[firstIndex] +
+      factor * (source[secondIndex] - source[firstIndex]);
+}
+
+} // namespace audioapi::AudioUtils

package/common/cpp/utils/AudioUtils.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <cstddef>
+
+namespace audioapi::AudioUtils {
+size_t timeToSampleFrame(double time, int sampleRate);
+
+double sampleFrameToTime(int sampleFrame, int sampleRate);
+
+float linearInterpolate(
+    const float *source,
+    size_t firstIndex,
+    size_t secondIndex,
+    float factor);
+
+} // namespace audioapi::AudioUtils

package/ios/AudioAPIModule.mm

@@ -1,13 +1,12 @@
 #import "AudioAPIModule.h"
 
-#import <ReactCommon/RCTTurboModule.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"
-#import "AudioAPIInstallerWrapper.h"
 
 @implementation AudioAPIModule
 
@@ -34,10 +33,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, jsRuntime, cxxBridge.jsCallInvoker);
-  auto object = jsi::Object::createFromHostObject(runtime, hostObject);
-  runtime.global().setProperty(runtime, "__AudioAPIInstaller", std::move(object));
+  auto hostObject = std::make_shared<audioapi::AudioAPIInstallerHostObject>(jsRuntime, cxxBridge.jsCallInvoker);
+  hostObject->install();
 
   NSLog(@"Successfully installed JSI bindings for react-native-audio-api!");
   return @true;

package/ios/AudioDecoder/AudioDecoder.h

@@ -10,7 +10,7 @@
 
 - (instancetype)initWithSampleRate:(int)sampleRate;
 
-- (const AudioBufferList *)decode:(NSString *)pathOrURL;
+- (const AudioBufferList *)decodeWithFile:(NSString *)path;
 
 - (void)cleanup;
 

package/ios/AudioDecoder/AudioDecoder.m

@@ -10,21 +10,7 @@
   return self;
 }
 
-- (const AudioBufferList *)decode:(NSString *)pathOrURL
-{
-  // check if the input is a URL or a local file path
-  NSURL *url = [NSURL URLWithString:pathOrURL];
-
-  if (url && url.scheme) {
-    self.buffer = [self decodeWithURL:url];
-  } else {
-    self.buffer = [self decodeWithFilePath:pathOrURL];
-  }
-
-  return self.buffer.audioBufferList;
-}
-
-- (AVAudioPCMBuffer *)decodeWithFilePath:(NSString *)path
+- (const AudioBufferList *)decodeWithFile:(NSString *)path
 {
   NSError *error = nil;
   NSURL *fileURL = [NSURL fileURLWithPath:path];
@@ -49,85 +35,12 @@
   }
 
   if (self.sampleRate != audioFile.processingFormat.sampleRate) {
-    return [self convertBuffer:buffer ToFormat:format];
-  }
-
-  return buffer;
-}
-
-- (AVAudioPCMBuffer *)decodeWithURL:(NSURL *)url
-{
-  __block NSURL *tempFileURL = nil;
-
-  dispatch_group_t group = dispatch_group_create();
-
-  dispatch_group_enter(group);
-
-  [self downloadFileFromURL:url
-                 completion:^(NSURL *downloadedFileURL, NSError *downloadError) {
-                   if (downloadError) {
-                     NSLog(@"Error downloading file: %@", downloadError.localizedDescription);
-                     tempFileURL = nil;
-                   } else {
-                     tempFileURL = downloadedFileURL;
-                   }
-
-                   dispatch_group_leave(group);
-                 }];
-
-  dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
-
-  if (!tempFileURL) {
-    NSLog(@"Cannot process given url");
-    return nil;
+    self.buffer = [self convertBuffer:buffer ToFormat:format];
+  } else {
+    self.buffer = buffer;
   }
 
-  return [self decodeWithFilePath:tempFileURL.path];
-}
-
-- (void)downloadFileFromURL:(NSURL *)url completion:(void (^)(NSURL *tempFileURL, NSError *error))completion
-{
-  // get unique file path in temporary dir
-  NSString *tempDirectory = NSTemporaryDirectory();
-  NSString *timestamp = [NSString stringWithFormat:@"_%@", @((long long)[[NSDate date] timeIntervalSince1970])];
-  NSString *fileNameWithTimestamp = [url.lastPathComponent stringByDeletingPathExtension];
-  fileNameWithTimestamp = [fileNameWithTimestamp stringByAppendingString:timestamp];
-  NSString *fileExtension =
-      [url.pathExtension length] > 0 ? [NSString stringWithFormat:@".%@", url.pathExtension] : @"";
-  NSString *tempFilePath =
-      [tempDirectory stringByAppendingPathComponent:[fileNameWithTimestamp stringByAppendingString:fileExtension]];
-  NSURL *tempFileURL = [NSURL fileURLWithPath:tempFilePath];
-
-  // download file
-  NSURLSession *session = [NSURLSession sharedSession];
-  NSURLSessionDownloadTask *downloadTask = [session
-      downloadTaskWithURL:url
-        completionHandler:^(NSURL *location, NSURLResponse *response, NSError *error) {
-          if (error) {
-            NSLog(@"Error downloading file: %@", error.localizedDescription);
-            if (completion) {
-              completion(nil, error);
-            }
-            return;
-          }
-
-          // move to generated file path in temporary dir
-          NSError *fileError = nil;
-          BOOL success = [[NSFileManager defaultManager] moveItemAtURL:location toURL:tempFileURL error:&fileError];
-          if (success) {
-            NSLog(@"File downloaded successfully to %@", tempFileURL.path);
-            if (completion) {
-              completion(tempFileURL, nil);
-            }
-          } else {
-            NSLog(@"Error moving downloaded file: %@", fileError.localizedDescription);
-            if (completion) {
-              completion(nil, fileError);
-            }
-          }
-        }];
-
-  [downloadTask resume];
+  return self.buffer.audioBufferList;
 }
 
 - (AVAudioPCMBuffer *)convertBuffer:(AVAudioPCMBuffer *)buffer ToFormat:(AVAudioFormat *)format
@@ -138,16 +51,15 @@
       [[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;
-    }
-  };
+      ^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];
 

package/ios/AudioDecoder/IOSAudioDecoder.h

@@ -22,5 +22,7 @@ class IOSAudioDecoder {
   ~IOSAudioDecoder();
 
   AudioBus *decodeWithFilePath(const std::string &path);
+  // TODO: implement this
+  AudioBus *decodeWithArrayBuffer();
 };
 } // namespace audioapi

package/ios/AudioDecoder/IOSAudioDecoder.mm

@@ -19,7 +19,7 @@ IOSAudioDecoder::~IOSAudioDecoder()
 
 AudioBus *IOSAudioDecoder::decodeWithFilePath(const std::string &path)
 {
-  auto bufferList = [audioDecoder_ decode:[NSString stringWithUTF8String:path.c_str()]];
+  auto bufferList = [audioDecoder_ decodeWithFile:[NSString stringWithUTF8String:path.c_str()]];
   AudioBus *audioBus;
   if (bufferList) {
     auto numberOfChannels = bufferList->mNumberBuffers;
@@ -37,4 +37,10 @@ AudioBus *IOSAudioDecoder::decodeWithFilePath(const std::string &path)
 
   return audioBus;
 }
+
+AudioBus *IOSAudioDecoder::decodeWithArrayBuffer()
+{
+  // TODO: implement his
+  return new AudioBus(sampleRate_, 1, 1);
+}
 } // namespace audioapi

package/ios/AudioPlayer/AudioPlayer.m

@@ -62,7 +62,9 @@
   // 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

package/lib/module/core/AudioBufferSourceNode.js

@@ -1,8 +1,11 @@
 import AudioScheduledSourceNode from './AudioScheduledSourceNode';
 import AudioBuffer from './AudioBuffer';
+import AudioParam from './AudioParam';
 export default class AudioBufferSourceNode extends AudioScheduledSourceNode {
   constructor(context, node) {
     super(context, node);
+    this.detune = new AudioParam(node.detune);
+    this.playbackRate = new AudioParam(node.playbackRate);
   }
   get buffer() {
     const buffer = this.node.buffer;
@@ -24,5 +27,17 @@ export default class AudioBufferSourceNode extends AudioScheduledSourceNode {
   set loop(value) {
     this.node.loop = value;
   }
+  get loopStart() {
+    return this.node.loopStart;
+  }
+  set loopStart(value) {
+    this.node.loopStart = value;
+  }
+  get loopEnd() {
+    return this.node.loopEnd;
+  }
+  set loopEnd(value) {
+    this.node.loopEnd = value;
+  }
 }
 //# sourceMappingURL=AudioBufferSourceNode.js.map

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

@@ -1 +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":[]}
+{"version":3,"names":["AudioScheduledSourceNode","AudioBuffer","AudioParam","AudioBufferSourceNode","constructor","context","node","detune","playbackRate","buffer","loop","value","loopStart","loopEnd"],"sourceRoot":"../../../src","sources":["core/AudioBufferSourceNode.ts"],"mappings":"AACA,OAAOA,wBAAwB,MAAM,4BAA4B;AAEjE,OAAOC,WAAW,MAAM,eAAe;AACvC,OAAOC,UAAU,MAAM,cAAc;AAErC,eAAe,MAAMC,qBAAqB,SAASH,wBAAwB,CAAC;EAI1EI,WAAWA,CAACC,OAAyB,EAAEC,IAA4B,EAAE;IACnE,KAAK,CAACD,OAAO,EAAEC,IAAI,CAAC;IAEpB,IAAI,CAACC,MAAM,GAAG,IAAIL,UAAU,CAACI,IAAI,CAACC,MAAM,CAAC;IACzC,IAAI,CAACC,YAAY,GAAG,IAAIN,UAAU,CAACI,IAAI,CAACE,YAAY,CAAC;EACvD;EAEA,IAAWC,MAAMA,CAAA,EAAuB;IACtC,MAAMA,MAAM,GAAI,IAAI,CAACH,IAAI,CAA4BG,MAAM;IAC3D,IAAI,CAACA,MAAM,EAAE;MACX,OAAO,IAAI;IACb;IACA,OAAO,IAAIR,WAAW,CAACQ,MAAM,CAAC;EAChC;EAEA,IAAWA,MAAMA,CAACA,MAA0B,EAAE;IAC5C,IAAI,CAACA,MAAM,EAAE;MACV,IAAI,CAACH,IAAI,CAA4BG,MAAM,GAAG,IAAI;MACnD;IACF;IAEC,IAAI,CAACH,IAAI,CAA4BG,MAAM,GAAGA,MAAM,CAACA,MAAM;EAC9D;EAEA,IAAWC,IAAIA,CAAA,EAAY;IACzB,OAAQ,IAAI,CAACJ,IAAI,CAA4BI,IAAI;EACnD;EAEA,IAAWA,IAAIA,CAACC,KAAc,EAAE;IAC7B,IAAI,CAACL,IAAI,CAA4BI,IAAI,GAAGC,KAAK;EACpD;EAEA,IAAWC,SAASA,CAAA,EAAW;IAC7B,OAAQ,IAAI,CAACN,IAAI,CAA4BM,SAAS;EACxD;EAEA,IAAWA,SAASA,CAACD,KAAa,EAAE;IACjC,IAAI,CAACL,IAAI,CAA4BM,SAAS,GAAGD,KAAK;EACzD;EAEA,IAAWE,OAAOA,CAAA,EAAW;IAC3B,OAAQ,IAAI,CAACP,IAAI,CAA4BO,OAAO;EACtD;EAEA,IAAWA,OAAOA,CAACF,KAAa,EAAE;IAC/B,IAAI,CAACL,IAAI,CAA4BO,OAAO,GAAGF,KAAK;EACvD;AACF","ignoreList":[]}

package/lib/module/core/BaseAudioContext.js

@@ -7,7 +7,6 @@ import AudioBufferSourceNode from './AudioBufferSourceNode';
 import AudioBuffer from './AudioBuffer';
 import PeriodicWave from './PeriodicWave';
 import { InvalidAccessError } from '../errors';
-import { resolveAudioSource } from '../utils/resolveAudioSource';
 export default class BaseAudioContext {
   constructor(context) {
     this.context = context;
@@ -54,8 +53,8 @@ export default class BaseAudioContext {
     const disableNormalization = constraints?.disableNormalization ?? false;
     return new PeriodicWave(this.context.createPeriodicWave(real, imag, disableNormalization));
   }
-  async decodeAudioDataSource(source) {
-    const buffer = await this.context.decodeAudioDataSource(resolveAudioSource(source));
+  async decodeAudioDataSource(sourcePath) {
+    const buffer = await this.context.decodeAudioDataSource(sourcePath);
     return new AudioBuffer(buffer);
   }
 }