react-native-audio-api 0.6.4-nightly-6fc62be-20250703 → 0.6.4-nightly-527099d-20250704

package/android/src/main/cpp/audioapi/android/core/AudioDecoder.cpp

@@ -14,8 +14,8 @@ namespace audioapi {
 std::shared_ptr<AudioBus> AudioDecoder::decodeWithFilePath(
     const std::string &path) const {
   ma_decoder decoder;
-  ma_decoder_config config =
-      ma_decoder_config_init(ma_format_f32, 2, static_cast<int>(sampleRate_));
+  ma_decoder_config config = ma_decoder_config_init(
+      ma_format_s16, numChannels_, static_cast<int>(sampleRate_));
   ma_result result = ma_decoder_init_file(path.c_str(), &config, &decoder);
   if (result != MA_SUCCESS) {
     __android_log_print(
@@ -32,31 +32,31 @@ std::shared_ptr<AudioBus> AudioDecoder::decodeWithFilePath(
   ma_uint64 totalFrameCount;
   ma_decoder_get_length_in_pcm_frames(&decoder, &totalFrameCount);
 
-  auto audioBus = std::make_shared<AudioBus>(
-      static_cast<int>(totalFrameCount), 2, sampleRate_);
-  auto *buffer = new float[totalFrameCount * 2];
+  std::vector<int16_t> buffer(totalFrameCount * numChannels_);
 
   ma_uint64 framesDecoded;
-  ma_decoder_read_pcm_frames(&decoder, buffer, totalFrameCount, &framesDecoded);
+  ma_decoder_read_pcm_frames(
+      &decoder, buffer.data(), totalFrameCount, &framesDecoded);
 
   if (framesDecoded == 0) {
     __android_log_print(ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode");
 
-    delete[] buffer;
     ma_decoder_uninit(&decoder);
-
     return nullptr;
   }
 
-  for (int i = 0; i < decoder.outputChannels; ++i) {
+  auto outputFrames = buffer.size() / numChannels_;
+  auto audioBus =
+      std::make_shared<AudioBus>(outputFrames, numChannels_, sampleRate_);
+
+  for (int i = 0; i < numChannels_; ++i) {
     auto channelData = audioBus->getChannel(i)->getData();
 
-    for (ma_uint64 j = 0; j < framesDecoded; ++j) {
-      channelData[j] = buffer[j * decoder.outputChannels + i];
+    for (ma_uint64 j = 0; j < outputFrames; ++j) {
+      channelData[j] = int16ToFloat(buffer[j * numChannels_ + i]);
     }
   }
 
-  delete[] buffer;
   ma_decoder_uninit(&decoder);
 
   return audioBus;
@@ -66,8 +66,8 @@ std::shared_ptr<AudioBus> AudioDecoder::decodeWithMemoryBlock(
     const void *data,
     size_t size) const {
   ma_decoder decoder;
-  ma_decoder_config config =
-      ma_decoder_config_init(ma_format_f32, 2, static_cast<int>(sampleRate_));
+  ma_decoder_config config = ma_decoder_config_init(
+      ma_format_s16, numChannels_, static_cast<int>(sampleRate_));
   ma_result result = ma_decoder_init_memory(data, size, &config, &decoder);
   if (result != MA_SUCCESS) {
     __android_log_print(
@@ -83,52 +83,60 @@ std::shared_ptr<AudioBus> AudioDecoder::decodeWithMemoryBlock(
   ma_uint64 totalFrameCount;
   ma_decoder_get_length_in_pcm_frames(&decoder, &totalFrameCount);
 
-  auto audioBus = std::make_shared<AudioBus>(
-      static_cast<int>(totalFrameCount), 2, sampleRate_);
-  auto *buffer = new float[totalFrameCount * 2];
+  std::vector<int16_t> buffer(totalFrameCount * numChannels_);
 
   ma_uint64 framesDecoded;
-  ma_decoder_read_pcm_frames(&decoder, buffer, totalFrameCount, &framesDecoded);
+  ma_decoder_read_pcm_frames(
+      &decoder, buffer.data(), totalFrameCount, &framesDecoded);
+
   if (framesDecoded == 0) {
     __android_log_print(ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode");
 
-    delete[] buffer;
     ma_decoder_uninit(&decoder);
-
     return nullptr;
   }
 
-  for (int i = 0; i < decoder.outputChannels; ++i) {
+  auto outputFrames = buffer.size() / numChannels_;
+  auto audioBus =
+      std::make_shared<AudioBus>(outputFrames, numChannels_, sampleRate_);
+
+  for (int i = 0; i < numChannels_; ++i) {
     auto channelData = audioBus->getChannel(i)->getData();
 
-    for (ma_uint64 j = 0; j < framesDecoded; ++j) {
-      channelData[j] = buffer[j * decoder.outputChannels + i];
+    for (ma_uint64 j = 0; j < outputFrames; ++j) {
+      channelData[j] = int16ToFloat(buffer[j * numChannels_ + i]);
     }
   }
 
-  delete[] buffer;
   ma_decoder_uninit(&decoder);
 
   return audioBus;
 }
 
 std::shared_ptr<AudioBus> AudioDecoder::decodeWithPCMInBase64(
-    const std::string &data) const {
+    const std::string &data,
+    const float playbackSpeed) const {
   auto decodedData = base64_decode(data, false);
 
   const auto uint8Data = reinterpret_cast<uint8_t *>(decodedData.data());
-  size_t frameCount = decodedData.size() / 2;
+  size_t framesDecoded = decodedData.size() / 2;
 
-  auto audioBus = std::make_shared<AudioBus>(frameCount, 1, sampleRate_);
-  auto channelData = audioBus->getChannel(0)->getData();
-
-  for (size_t i = 0; i < frameCount; ++i) {
-    auto sample =
+  std::vector<int16_t> buffer(framesDecoded);
+  for (size_t i = 0; i < framesDecoded; ++i) {
+    buffer[i] =
         static_cast<int16_t>((uint8Data[i * 2 + 1] << 8) | uint8Data[i * 2]);
-    channelData[i] = static_cast<float>(sample);
   }
 
-  dsp::multiplyByScalar(channelData, 1.0f / 32768.0f, channelData, frameCount);
+  changePlaybackSpeedIfNeeded(buffer, framesDecoded, 1, playbackSpeed);
+  auto outputFrames = buffer.size();
+
+  auto audioBus =
+      std::make_shared<AudioBus>(outputFrames, numChannels_, sampleRate_);
+  auto channelData = audioBus->getChannel(0)->getData();
+
+  for (size_t i = 0; i < outputFrames; ++i) {
+    channelData[i] = int16ToFloat(buffer[i]);
+  }
 
   return audioBus;
 }

package/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h

@@ -221,10 +221,11 @@ JSI_HOST_FUNCTION(createBufferQueueSource) {
 
   JSI_HOST_FUNCTION(decodePCMAudioDataInBase64) {
     auto b64 = args[0].getString(runtime).utf8(runtime);
+    auto playbackSpeed = static_cast<float>(args[1].getNumber());
 
-      auto promise = promiseVendor_->createPromise([this, b64](std::shared_ptr<Promise> promise) {
-          std::thread([this, b64, promise = std::move(promise)]() {
-              auto results = context_->decodeWithPCMInBase64(b64);
+      auto promise = promiseVendor_->createPromise([this, b64, playbackSpeed](std::shared_ptr<Promise> promise) {
+          std::thread([this, b64, playbackSpeed, promise = std::move(promise)]() {
+              auto results = context_->decodeWithPCMInBase64(b64, playbackSpeed);
 
               if (!results) {
                   promise->reject("Failed to decode audio data source.");

package/common/cpp/audioapi/core/AudioParam.cpp

@@ -18,10 +18,11 @@ AudioParam::AudioParam(
       minValue_(minValue),
       maxValue_(maxValue),
       context_(context),
-      audioBus_(std::make_shared<AudioBus>(
-          RENDER_QUANTUM_SIZE,
-          1,
-          context->getSampleRate())) {
+      audioBus_(
+          std::make_shared<AudioBus>(
+              RENDER_QUANTUM_SIZE,
+              1,
+              context->getSampleRate())) {
   startTime_ = 0;
   endTime_ = 0;
   startValue_ = value_;

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

@@ -145,9 +145,10 @@ std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioData(
 }
 
 std::shared_ptr<AudioBuffer> BaseAudioContext::decodeWithPCMInBase64(
-    const std::string &data) {
+    const std::string &data,
+    float playbackSpeed) {
 #ifndef AUDIO_API_TEST_SUITE
-  auto audioBus = audioDecoder_->decodeWithPCMInBase64(data);
+  auto audioBus = audioDecoder_->decodeWithPCMInBase64(data, playbackSpeed);
 
   if (!audioBus) {
     return nullptr;

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

@@ -60,7 +60,7 @@ class BaseAudioContext {
   #ifndef TESTING
   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);
+  std::shared_ptr<AudioBuffer> decodeWithPCMInBase64(const std::string &data, float playbackSpeed);
   #endif //TESTING
 
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);

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

@@ -1,7 +1,9 @@
 #pragma once
 
+#include <audioapi/libs/audio-stretch/stretch.h>
 #include <memory>
 #include <string>
+#include <vector>
 
 namespace audioapi {
 
@@ -13,10 +15,45 @@ class AudioDecoder {
 
   [[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) const;
+  [[nodiscard]] std::shared_ptr<AudioBus> decodeWithPCMInBase64(const std::string &data, float playbackSpeed) const;
 
  private:
   float sampleRate_;
+  int numChannels_ = 2;
+
+  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);
+
+      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);
+  }
+
+  [[nodiscard]] static inline int16_t floatToInt16(float sample) {
+    return static_cast<int16_t>(sample * 32768.0f);
+  }
+
+  [[nodiscard]] static inline float int16ToFloat(int16_t sample) {
+    return static_cast<float>(sample) / 32768.0f;
+  }
 };
 
 } // namespace audioapi