react-native-audio-api 0.9.0-nightly-7ecb495-20251008 → 0.9.1

package/common/cpp/audioapi/HostObjects/sources/AudioBufferHostObject.cpp

@@ -1,6 +1,7 @@
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 
 #include <audioapi/jsi/AudioArrayBuffer.h>
+#include <audioapi/utils/AudioBus.h>
 
 namespace audioapi {
 
@@ -42,14 +43,8 @@ JSI_PROPERTY_GETTER_IMPL(AudioBufferHostObject, numberOfChannels) {
 
 JSI_HOST_FUNCTION_IMPL(AudioBufferHostObject, getChannelData) {
   auto channel = static_cast<int>(args[0].getNumber());
-  auto channelData =
-      reinterpret_cast<uint8_t *>(audioBuffer_->getChannelData(channel));
-  auto length = static_cast<int>(audioBuffer_->getLength());
-  auto size = static_cast<int>(length * sizeof(float));
-
-  // reading or writing from this ArrayBuffer could cause a crash
-  // if underlying channelData is deallocated
-  auto audioArrayBuffer = std::make_shared<AudioArrayBuffer>(channelData, size);
+  auto audioArrayBuffer = std::make_shared<AudioArrayBuffer>(
+      audioBuffer_->bus_->getSharedChannel(channel));
   auto arrayBuffer = jsi::ArrayBuffer(runtime, audioArrayBuffer);
 
   auto float32ArrayCtor =

package/common/cpp/audioapi/core/AudioContext.cpp

@@ -6,6 +6,7 @@
 
 #include <audioapi/core/AudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
+#include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 
 namespace audioapi {
@@ -25,6 +26,7 @@ AudioContext::AudioContext(
 #endif
 
   sampleRate_ = sampleRate;
+  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate);
 
   if (initSuspended) {
     playerHasBeenStarted_ = false;

package/common/cpp/audioapi/core/BaseAudioContext.cpp

@@ -176,6 +176,41 @@ std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser() {
   return analyser;
 }
 
+std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
+    const std::string &path) {
+  auto audioBus = audioDecoder_->decodeWithFilePath(path);
+
+  if (!audioBus) {
+    return nullptr;
+  }
+
+  return std::make_shared<AudioBuffer>(audioBus);
+}
+
+std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioData(
+    const void *data,
+    size_t size) {
+  auto audioBus = audioDecoder_->decodeWithMemoryBlock(data, size);
+
+  if (!audioBus) {
+    return nullptr;
+  }
+
+  return std::make_shared<AudioBuffer>(audioBus);
+}
+
+std::shared_ptr<AudioBuffer> BaseAudioContext::decodeWithPCMInBase64(
+    const std::string &data,
+    float playbackSpeed) {
+  auto audioBus = audioDecoder_->decodeWithPCMInBase64(data, playbackSpeed);
+
+  if (!audioBus) {
+    return nullptr;
+  }
+
+  return std::make_shared<AudioBuffer>(audioBus);
+}
+
 AudioNodeManager *BaseAudioContext::getNodeManager() {
   return nodeManager_.get();
 }

package/common/cpp/audioapi/core/BaseAudioContext.h

@@ -3,14 +3,15 @@
 #include <audioapi/core/types/ContextState.h>
 #include <audioapi/core/types/OscillatorType.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
-#include <cassert>
-#include <complex>
-#include <cstddef>
+
 #include <functional>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
+#include <complex>
+#include <cstddef>
+#include <cassert>
 
 namespace audioapi {
 
@@ -26,6 +27,7 @@ class BiquadFilterNode;
 class AudioDestinationNode;
 class AudioBufferSourceNode;
 class AudioBufferQueueSourceNode;
+class AudioDecoder;
 class AnalyserNode;
 class AudioEventHandlerRegistry;
 class IAudioEventHandlerRegistry;
@@ -66,6 +68,10 @@ class BaseAudioContext {
       int length);
   std::shared_ptr<AnalyserNode> createAnalyser();
 
+  std::shared_ptr<AudioBuffer> decodeAudioDataSource(const std::string &path);
+  std::shared_ptr<AudioBuffer> decodeAudioData(const void *data, size_t size);
+  std::shared_ptr<AudioBuffer> decodeWithPCMInBase64(const std::string &data, float playbackSpeed);
+
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   [[nodiscard]] float getNyquistFrequency() const;
   AudioNodeManager *getNodeManager();
@@ -79,7 +85,9 @@ class BaseAudioContext {
 
   std::shared_ptr<AudioDestinationNode> destination_;
   // init in AudioContext or OfflineContext constructor
-  float sampleRate_{};
+  std::shared_ptr<AudioDecoder> audioDecoder_ {};
+  // init in AudioContext or OfflineContext constructor
+  float sampleRate_ {};
   ContextState state_ = ContextState::RUNNING;
   std::shared_ptr<AudioNodeManager> nodeManager_;
 

package/common/cpp/audioapi/core/OfflineAudioContext.cpp

@@ -3,6 +3,7 @@
 #include <audioapi/core/AudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
@@ -29,6 +30,7 @@ OfflineAudioContext::OfflineAudioContext(
       numberOfChannels_(numberOfChannels),
       currentSampleFrame_(0) {
   sampleRate_ = sampleRate;
+  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
   resultBus_ = std::make_shared<AudioBus>(
       static_cast<int>(length_), numberOfChannels_, sampleRate_);
 }

package/common/cpp/audioapi/core/effects/WorkletNode.cpp

@@ -9,25 +9,16 @@ WorkletNode::WorkletNode(
     size_t bufferLength,
     size_t inputChannelCount)
     : AudioNode(context),
-      buffRealLength_(bufferLength * sizeof(float)),
-      bufferLength_(bufferLength),
       workletRunner_(runtime),
       shareableWorklet_(worklet),
+      bufferLength_(bufferLength),
       inputChannelCount_(inputChannelCount),
       curBuffIndex_(0) {
-  buffs_.reserve(inputChannelCount_);
-  for (size_t i = 0; i < inputChannelCount_; ++i) {
-    buffs_.emplace_back(new uint8_t[buffRealLength_]);
-  }
+  bus_ = std::make_shared<AudioBus>(
+      bufferLength, inputChannelCount, context->getSampleRate());
   isInitialized_ = true;
 }
 
-WorkletNode::~WorkletNode() {
-  for (auto &buff : buffs_) {
-    delete[] buff;
-  }
-}
-
 std::shared_ptr<AudioBus> WorkletNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
@@ -40,17 +31,11 @@ std::shared_ptr<AudioBus> WorkletNode::processNode(
     size_t needsToProcess = framesToProcess - processed;
     size_t shouldProcess = std::min(framesToWorkletInvoke, needsToProcess);
 
-    for (size_t ch = 0; ch < channelCount_; ch++) {
-      /// here we copy
-      /// to   uint8_t* [curBuffIndex_, curBuffIndex_ + shouldProcess]
-      /// from float* [processed, processed + shouldProcess]
-      /// so as the we need to copy shouldProcess * sizeof(float) bytes
-      auto channelData = processingBus->getChannel(ch)->getData();
-      std::memcpy(
-          /* dest */ buffs_[ch] + curBuffIndex_ * sizeof(float),
-          /* src */ reinterpret_cast<const uint8_t *>(channelData + processed),
-          /* size */ shouldProcess * sizeof(float));
-    }
+    /// here we copy
+    /// to [curBuffIndex_, curBuffIndex_ + shouldProcess]
+    /// from [processed, processed + shouldProcess]
+    bus_->copy(processingBus.get(), processed, curBuffIndex_, shouldProcess);
+
     processed += shouldProcess;
     curBuffIndex_ += shouldProcess;
 
@@ -63,16 +48,19 @@ std::shared_ptr<AudioBus> WorkletNode::processNode(
             /// Arguments preparation
             auto jsArray = jsi::Array(uiRuntimeRaw, channelCount_);
             for (size_t ch = 0; ch < channelCount_; ch++) {
-              uint8_t *buffPtr = buffs_[ch];
-              buffs_[ch] = new uint8_t[buffRealLength_];
+              auto audioArray = std::make_shared<AudioArray>(bufferLength_);
+              audioArray->copy(bus_->getChannel(ch));
               auto sharedAudioArray =
-                  std::make_shared<AudioArrayBuffer>(buffPtr, buffRealLength_);
+                  std::make_shared<AudioArrayBuffer>(audioArray);
+              auto sharedAudioArraySize = sharedAudioArray->size();
               auto arrayBuffer =
                   jsi::ArrayBuffer(uiRuntimeRaw, std::move(sharedAudioArray));
+              arrayBuffer.setExternalMemoryPressure(
+                  uiRuntimeRaw, sharedAudioArraySize);
               jsArray.setValueAtIndex(uiRuntimeRaw, ch, std::move(arrayBuffer));
             }
-            jsArray.setExternalMemoryPressure(
-                uiRuntimeRaw, channelCount_ * buffRealLength_);
+
+            bus_->zero();
 
             workletRunner_.executeWorklet(
                 shareableWorklet_,

package/common/cpp/audioapi/core/effects/WorkletNode.h

@@ -42,7 +42,7 @@ class WorkletNode : public AudioNode {
       size_t inputChannelCount
   );
 
-  ~WorkletNode() override;
+  ~WorkletNode() override = default;
 
  protected:
   std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
@@ -51,10 +51,9 @@ class WorkletNode : public AudioNode {
  private:
   WorkletsRunner workletRunner_;
   std::shared_ptr<worklets::SerializableWorklet> shareableWorklet_;
-  std::vector<uint8_t*> buffs_;
+  std::shared_ptr<AudioBus> bus_;
 
   /// @brief Length of the byte buffer that will be passed to the AudioArrayBuffer
-  size_t buffRealLength_;
   size_t bufferLength_;
   size_t inputChannelCount_;
   size_t curBuffIndex_;

package/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp

@@ -16,13 +16,12 @@ WorkletProcessingNode::WorkletProcessingNode(
   outputBuffsHandles_.resize(maxChannelCount);
 
   for (size_t i = 0; i < maxChannelCount; ++i) {
-    auto inputBuff = new uint8_t[RENDER_QUANTUM_SIZE * sizeof(float)];
-    inputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(
-        inputBuff, RENDER_QUANTUM_SIZE * sizeof(float));
+    auto inputAudioArray = std::make_shared<AudioArray>(RENDER_QUANTUM_SIZE);
+    inputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(inputAudioArray);
 
-    auto outputBuff = new uint8_t[RENDER_QUANTUM_SIZE * sizeof(float)];
-    outputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(
-        outputBuff, RENDER_QUANTUM_SIZE * sizeof(float));
+    auto outputAudioArray = std::make_shared<AudioArray>(RENDER_QUANTUM_SIZE);
+    outputBuffsHandles_[i] =
+        std::make_shared<AudioArrayBuffer>(outputAudioArray);
   }
 }
 

package/common/cpp/audioapi/core/sources/AudioBuffer.h

@@ -37,6 +37,7 @@ class AudioBuffer : public std::enable_shared_from_this<AudioBuffer> {
  private:
   friend class AudioBufferSourceNode;
   friend class AudioBufferQueueSourceNode;
+  friend class AudioBufferHostObject;
 
   std::shared_ptr<AudioBus> bus_;
 };

package/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.cpp

@@ -27,10 +27,6 @@ AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(
       std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
 }
 
-AudioBufferBaseSourceNode::~AudioBufferBaseSourceNode() {
-  clearOnPositionChangedCallback();
-}
-
 std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getDetuneParam() const {
   return detuneParam_;
 }

package/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.h

@@ -15,7 +15,6 @@ class AudioParam;
 class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
  public:
   explicit AudioBufferBaseSourceNode(BaseAudioContext *context, bool pitchCorrection);
-  ~AudioBufferBaseSourceNode() override;
 
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;

package/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp

@@ -29,8 +29,6 @@ AudioBufferSourceNode::~AudioBufferSourceNode() {
 
   buffer_.reset();
   alignedBus_.reset();
-
-  clearOnLoopEndedCallback();
 }
 
 bool AudioBufferSourceNode::getLoop() const {

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp

@@ -16,10 +16,6 @@ AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
   numberOfInputs_ = 0;
 }
 
-AudioScheduledSourceNode::~AudioScheduledSourceNode() {
-  clearOnEndedCallback();
-}
-
 void AudioScheduledSourceNode::start(double when) {
   playbackState_ = PlaybackState::SCHEDULED;
   startTime_ = when;

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h

@@ -27,7 +27,6 @@ class AudioScheduledSourceNode : public AudioNode {
   // FINISHED: The node has finished playing.
   enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, STOP_SCHEDULED, FINISHED };
   explicit AudioScheduledSourceNode(BaseAudioContext *context);
-  ~AudioScheduledSourceNode() override;
 
   void start(double when);
   virtual void stop(double when);

package/common/cpp/audioapi/core/sources/StreamerNode.cpp

@@ -44,10 +44,14 @@ bool StreamerNode::initialize(const std::string &input_url) {
   }
 
   if (!openInput(input_url)) {
+    if (VERBOSE)
+      printf("Failed to open input\n");
     return false;
   }
 
   if (!findAudioStream() || !setupDecoder() || !setupResampler()) {
+    if (VERBOSE)
+      printf("Failed to find/setup audio stream\n");
     cleanup();
     return false;
   }
@@ -56,6 +60,8 @@ bool StreamerNode::initialize(const std::string &input_url) {
   frame_ = av_frame_alloc();
 
   if (pkt_ == nullptr || frame_ == nullptr) {
+    if (VERBOSE)
+      printf("Failed to allocate packet or frame\n");
     cleanup();
     return false;
   }
@@ -119,29 +125,24 @@ void StreamerNode::streamAudio() {
   while (streamFlag.load()) {
     if (pendingFrame_ != nullptr) {
       if (!processFrameWithResampler(pendingFrame_)) {
-        cleanup();
         return;
       }
     } else {
       if (av_read_frame(fmtCtx_, pkt_) < 0) {
-        cleanup();
         return;
       }
       if (pkt_->stream_index == audio_stream_index_) {
         if (avcodec_send_packet(codecCtx_, pkt_) != 0) {
-          cleanup();
           return;
         }
         if (avcodec_receive_frame(codecCtx_, frame_) != 0) {
-          cleanup();
           return;
         }
         if (!processFrameWithResampler(frame_)) {
-          cleanup();
           return;
         }
-        av_packet_unref(pkt_);
       }
+      av_packet_unref(pkt_);
     }
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
   }
@@ -174,6 +175,13 @@ std::shared_ptr<AudioBus> StreamerNode::processNode(
           (maxBufferSize_ - offsetLength) * sizeof(float));
     }
     bufferedBusIndex_ -= offsetLength;
+  } else {
+    if (VERBOSE)
+      printf(
+          "Buffer underrun: have %zu, need %zu\n",
+          bufferedBusIndex_,
+          (size_t)framesToProcess);
+    processingBus->zero();
   }
 
   return processingBus;
@@ -273,6 +281,8 @@ bool StreamerNode::setupDecoder() {
 
 void StreamerNode::cleanup() {
   streamFlag.store(false);
+  // cleanup cannot be called from the streaming thread so there is no need to
+  // check if we are in the same thread
   streamingThread_.join();
   if (swrCtx_ != nullptr) {
     swr_free(&swrCtx_);

package/common/cpp/audioapi/core/sources/StreamerNode.h

@@ -28,6 +28,8 @@ extern "C" {
 #include <string>
 #include <atomic>
 
+static bool constexpr VERBOSE = false;
+
 namespace audioapi {
 
 class AudioBus;
@@ -94,7 +96,7 @@ class StreamerNode : public AudioScheduledSourceNode {
 
   /**
    * @brief Open the input stream
-   * @param input_url The URL of the input stream
+   * @param inputUrl The URL of the input stream
    * @return true if successful, false otherwise
    * @note This function initializes the FFmpeg libraries and opens the input stream
    */

package/common/cpp/audioapi/core/sources/WorkletSourceNode.cpp

@@ -16,9 +16,8 @@ WorkletSourceNode::WorkletSourceNode(
   size_t outputChannelCount = this->getChannelCount();
   outputBuffsHandles_.resize(outputChannelCount);
   for (size_t i = 0; i < outputChannelCount; ++i) {
-    auto buff = new uint8_t[RENDER_QUANTUM_SIZE * sizeof(float)];
-    outputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(
-        buff, RENDER_QUANTUM_SIZE * sizeof(float));
+    auto audioArray = std::make_shared<AudioArray>(RENDER_QUANTUM_SIZE);
+    outputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(audioArray);
   }
 }
 

package/common/cpp/audioapi/core/utils/AudioDecoder.h

@@ -1,67 +1,124 @@
 #pragma once
 
-#include <audioapi/core/types/AudioFormat.h>
+#include <audioapi/libs/audio-stretch/stretch.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>
-#include <algorithm>
-#include <cstring>
 #include <memory>
 #include <string>
 #include <vector>
+#include <cstring>
+#include <algorithm>
 
 namespace audioapi {
 
-class AudioBuffer;
+enum class AudioFormat {
+  UNKNOWN,
+  WAV,
+  OGG,
+  FLAC,
+  AAC,
+  MP3,
+  M4A,
+  MP4,
+  MOV
+};
+
+class AudioBus;
 
 static constexpr int CHUNK_SIZE = 4096;
 
 class AudioDecoder {
  public:
-  AudioDecoder() = delete;
+  explicit AudioDecoder(float sampleRate) : sampleRate_(sampleRate) {}
 
-  [[nodiscard]] static std::shared_ptr<AudioBuffer> decodeWithFilePath(const std::string &path, float sampleRate);
-  [[nodiscard]] static std::shared_ptr<AudioBuffer>
-  decodeWithMemoryBlock(const void *data, size_t size, float sampleRate);
-  [[nodiscard]] static std::shared_ptr<AudioBuffer>
-  decodeWithPCMInBase64(const std::string &data, float inputSampleRate, int inputChannelCount, bool interleaved);
+  [[nodiscard]] std::shared_ptr<AudioBus> decodeWithFilePath(
+      const std::string &path) const;
+  [[nodiscard]] std::shared_ptr<AudioBus> decodeWithMemoryBlock(
+      const void *data,
+      size_t size) const;
+  [[nodiscard]] std::shared_ptr<AudioBus> decodeWithPCMInBase64(
+      const std::string &data,
+      float playbackSpeed) const;
 
  private:
-  static std::vector<float> readAllPcmFrames(ma_decoder &decoder, int outputChannels);
-  static std::shared_ptr<AudioBuffer>
-  makeAudioBufferFromFloatBuffer(const std::vector<float> &buffer, float outputSampleRate, int outputChannels);
+  float sampleRate_;
+  int numChannels_ = 2;
+
+  static std::vector<int16_t> readAllPcmFrames(
+      ma_decoder &decoder,
+      int numChannels,
+      ma_uint64 &outFramesRead);
+  static std::shared_ptr<AudioBus> makeAudioBusFromInt16Buffer(
+      const std::vector<int16_t> &buffer,
+      int numChannels,
+      float sampleRate);
+
+  void changePlaybackSpeedIfNeeded(
+      std::vector<int16_t> &buffer,
+      size_t framesDecoded,
+      int numChannels,
+      float playbackSpeed) const {
+    if (playbackSpeed == 1.0f) {
+      return;
+    }
+
+    auto stretcher = stretch_init(
+        static_cast<int>(sampleRate_ / 333.0f),
+        static_cast<int>(sampleRate_ / 55.0f),
+        numChannels,
+        0x1);
 
-  static AudioFormat detectAudioFormat(const void *data, size_t size) {
-    if (size < 12)
-      return AudioFormat::UNKNOWN;
-    const auto *bytes = static_cast<const unsigned char *>(data);
+    int maxOutputFrames = stretch_output_capacity(
+        stretcher, static_cast<int>(framesDecoded), 1 / playbackSpeed);
+    std::vector<int16_t> stretchedBuffer(maxOutputFrames);
+
+    int outputFrames = stretch_samples(
+        stretcher,
+        buffer.data(),
+        static_cast<int>(framesDecoded),
+        stretchedBuffer.data(),
+        1 / playbackSpeed);
+
+    outputFrames +=
+        stretch_flush(stretcher, stretchedBuffer.data() + (outputFrames));
+    stretchedBuffer.resize(outputFrames);
+
+    buffer = stretchedBuffer;
+
+    stretch_deinit(stretcher);
+  }
+
+  static AudioFormat detectAudioFormat(const void* data, size_t size) {
+    if (size < 12) return AudioFormat::UNKNOWN;
+    const auto* bytes = static_cast<const unsigned char*>(data);
 
     // WAV/RIFF
     if (std::memcmp(bytes, "RIFF", 4) == 0 && std::memcmp(bytes + 8, "WAVE", 4) == 0)
-      return AudioFormat::WAV;
+        return AudioFormat::WAV;
 
     // OGG
     if (std::memcmp(bytes, "OggS", 4) == 0)
-      return AudioFormat::OGG;
+        return AudioFormat::OGG;
 
     // FLAC
     if (std::memcmp(bytes, "fLaC", 4) == 0)
-      return AudioFormat::FLAC;
+        return AudioFormat::FLAC;
 
     // AAC starts with 0xFF 0xF1 or 0xFF 0xF9
     if (bytes[0] == 0xFF && (bytes[1] & 0xF6) == 0xF0)
-      return AudioFormat::AAC;
+        return AudioFormat::AAC;
 
     // MP3: "ID3" or 11-bit frame sync (0xFF 0xE0)
     if (std::memcmp(bytes, "ID3", 3) == 0)
-      return AudioFormat::MP3;
+        return AudioFormat::MP3;
     if (bytes[0] == 0xFF && (bytes[1] & 0xE0) == 0xE0)
-      return AudioFormat::MP3;
+        return AudioFormat::MP3;
 
     if (std::memcmp(bytes + 4, "ftyp", 4) == 0) {
-      if (std::memcmp(bytes + 8, "M4A ", 4) == 0)
-        return AudioFormat::M4A;
-      else if (std::memcmp(bytes + 8, "qt  ", 4) == 0)
-        return AudioFormat::MOV;
-      return AudioFormat::MP4;
+        if (std::memcmp(bytes + 8, "M4A ", 4) == 0)
+            return AudioFormat::M4A;
+        else if (std::memcmp(bytes + 8, "qt  ", 4) == 0)
+            return AudioFormat::MOV;
+        return AudioFormat::MP4;
     }
     return AudioFormat::UNKNOWN;
   }
@@ -69,21 +126,19 @@ class AudioDecoder {
   static inline bool pathHasExtension(const std::string &path, const std::vector<std::string> &extensions) {
     std::string pathLower = path;
     std::transform(pathLower.begin(), pathLower.end(), pathLower.begin(), ::tolower);
-    for (const auto &ext : extensions) {
-      if (pathLower.ends_with(ext))
-        return true;
+    for (const auto& ext : extensions) {
+        if (pathLower.ends_with(ext))
+            return true;
     }
     return false;
   }
 
+
   [[nodiscard]] static inline int16_t floatToInt16(float sample) {
-    return static_cast<int16_t>(sample * INT16_MAX);
+    return static_cast<int16_t>(sample * 32768.0f);
   }
   [[nodiscard]] static inline float int16ToFloat(int16_t sample) {
-    return static_cast<float>(sample) / INT16_MAX;
-  }
-  [[nodiscard]] static inline float uint8ToFloat(uint8_t byte1, uint8_t byte2) {
-    return static_cast<float>(static_cast<int16_t>((byte2 << 8) | byte1)) / INT16_MAX;
+    return static_cast<float>(sample) / 32768.0f;
   }
 };
 

package/common/cpp/audioapi/core/utils/Constants.h

@@ -10,10 +10,6 @@ namespace audioapi {
 static constexpr int RENDER_QUANTUM_SIZE = 128;
 static constexpr size_t MAX_FFT_SIZE = 32768;
 
-// stretcher
-static constexpr float UPPER_FREQUENCY_LIMIT_DETECTION = 333.0f;
-static constexpr float LOWER_FREQUENCY_LIMIT_DETECTION = 55.0f;
-
 // general
 static constexpr float MOST_POSITIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::max());
 static constexpr float MOST_NEGATIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::lowest());

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.cpp

@@ -156,8 +156,12 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
 
     // In case of debugging this, please increment the hours spent counter
 
-    // Hours spent on this: 5
+    // Hours spent on this: 8
     try {
+      if (!handlerIt->second || !handlerIt->second->isFunction(*runtime_)) {
+        // If the handler is not valid, we can skip it
+        return;
+      }
       jsi::Object eventObject(*runtime_);
       // handle special logic for microphone, because we pass audio buffer which
       // has significant size