react-native-audio-api 0.6.5 → 0.7.0-nightly-fba4835-20250718

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(
@@ -31,31 +31,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;
@@ -65,8 +65,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(
@@ -81,52 +81,63 @@ 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,
+    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 leftChannelData = audioBus->getChannel(0)->getData();
+  auto rightChannelData = audioBus->getChannel(1)->getData();
+
+  for (size_t i = 0; i < outputFrames; ++i) {
+    auto sample = int16ToFloat(buffer[i]);
+    leftChannelData[i] = sample;
+    rightChannelData[i] = sample;
+  }
 
   return audioBus;
 }

package/android/src/main/java/com/swmansion/audioapi/system/MediaSessionCallback.kt

@@ -42,12 +42,12 @@ class MediaSessionCallback(
   }
 
   override fun onFastForward() {
-    val body = HashMap<String, Any>().apply { put("value", 10) }
+    val body = HashMap<String, Any>().apply { put("value", 15) }
     audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("remoteSkipForward", body)
   }
 
   override fun onRewind() {
-    val body = HashMap<String, Any>().apply { put("value", 10) }
+    val body = HashMap<String, Any>().apply { put("value", 15) }
     audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("remoteSkipBackward", body)
   }
 

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

@@ -219,30 +219,31 @@ JSI_HOST_FUNCTION(createBufferQueueSource) {
       return promise;
     }
 
-  JSI_HOST_FUNCTION(decodePCMAudioDataInBase64) {
-    auto b64 = args[0].getString(runtime).utf8(runtime);
-
-      auto promise = promiseVendor_->createPromise([this, b64](std::shared_ptr<Promise> promise) {
-          std::thread([this, b64, promise = std::move(promise)]() {
-              auto results = context_->decodeWithPCMInBase64(b64);
-
-              if (!results) {
-                  promise->reject("Failed to decode audio data source.");
-                  return;
-              }
-
-              auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(results);
-
-              promise->resolve([audioBufferHostObject = std::move(audioBufferHostObject)](jsi::Runtime &runtime) {
-                  auto jsiObject = jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
-                  jsiObject.setExternalMemoryPressure(runtime, audioBufferHostObject->getSizeInBytes());
-                  return jsiObject;
-              });
-          }).detach();
-      });
+    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, 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.");
+                    return;
+                }
+
+                auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(results);
+
+                promise->resolve([audioBufferHostObject = std::move(audioBufferHostObject)](jsi::Runtime &runtime) {
+                    auto jsiObject = jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
+                    jsiObject.setExternalMemoryPressure(runtime, audioBufferHostObject->getSizeInBytes());
+                    return jsiObject;
+                });
+            }).detach();
+        });
 
-      return promise;
-  }
+        return promise;
+    }
 
  protected:
   std::shared_ptr<BaseAudioContext> context_;

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

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

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

@@ -59,7 +59,7 @@ class BaseAudioContext {
 
   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);
 
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   [[nodiscard]] float getNyquistFrequency() const;

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