react-native-audio-api 0.6.4-nightly-a960beb-20250703 → 0.6.4-nightly-00c1dfe-20250704

package/README.md

@@ -4,7 +4,10 @@
 
 [![NPM latest](https://img.shields.io/npm/v/react-native-audio-api/latest)](https://www.npmjs.com/package/react-native-audio-api)
 [![NPM next](https://img.shields.io/npm/v/react-native-audio-api/next)](https://www.npmjs.com/package/react-native-audio-api?activeTab=versions)
-[![github ci](https://img.shields.io/github/actions/workflow/status/software-mansion/react-native-audio-api/ci.yml)](https://github.com/software-mansion/react-native-audio-api/actions)
+[![NPM nightly](https://img.shields.io/npm/v/react-native-audio-api/audio-api-nightly)](https://www.npmjs.com/package/react-native-audio-api?activeTab=versions)
+[![github ci](https://github.com/software-mansion/react-native-audio-api/actions/workflows/ci.yml/badge.svg)](https://github.com/software-mansion/react-native-audio-api/actions/workflows/ci.yml)
+[![NPM Audio Api publish nightly](https://github.com/software-mansion/react-native-audio-api/actions/workflows/npm-publish-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-audio-api/actions/workflows/npm-publish-nightly.yml)
+[![Audio Api tests](https://github.com/software-mansion/react-native-audio-api/actions/workflows/tests.yml/badge.svg)](https://github.com/software-mansion/react-native-audio-api/actions/workflows/tests.yml)
 
 `react-native-audio-api` provides system for controlling audio in React Native environment compatible with Web Audio API specification,
 allowing developers to generate and modify audio in exact same way it is possible in browsers.

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, 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 {
 
@@ -10,13 +12,51 @@ class AudioBus;
 class AudioDecoder {
  public:
   explicit AudioDecoder(float sampleRate): sampleRate_(sampleRate) {}
+  ~AudioDecoder() {
+    stretch_deinit(stretcher_);
+  }
 
   [[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;
+  StretchHandle stretcher_ =
+          stretch_init(static_cast<int>(sampleRate_ / 333.0f), static_cast<int>(sampleRate_ / 55.0f), 1,  0x1);
+
+  void changePlaybackSpeedIfNeeded(std::vector<int16_t> &buffer, size_t framesDecoded, float playbackSpeed) const {
+      if (playbackSpeed == 1.0f) {
+          return;
+      }
+
+      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_reset(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