react-native-audio-api 0.12.1 → 0.12.2

package/common/cpp/audioapi/core/utils/buffer/SingleBufferProcessor.cpp

@@ -0,0 +1,95 @@
+#include <audioapi/core/utils/buffer/SingleBufferProcessor.h>
+
+#include <cmath>
+#include <cstddef>
+#include <memory>
+
+namespace audioapi {
+
+CursorState SingleBufferProcessor::advance(double rate) {
+  const double currentPosition = position_;
+  const auto index = static_cast<size_t>(currentPosition);
+  const auto factor = static_cast<float>(currentPosition - static_cast<double>(index));
+
+  size_t nextIndex;
+  if (direction_ == BufferProcessingDirection::FORWARD) {
+    nextIndex = index + 1;
+    if (nextIndex >= endFrame_) {
+      nextIndex = loop_ ? startFrame_ : index;
+    }
+  } else { // REVERSE — interpolate toward the previous sample.
+    if (index > startFrame_) {
+      nextIndex = index - 1;
+    } else {
+      nextIndex = loop_ ? endFrame_ - 1 : index;
+    }
+  }
+
+  position_ += rate;
+
+  const bool atEnd = shouldStop() &&
+      (currentPosition >= static_cast<double>(endFrame_) ||
+       currentPosition < static_cast<double>(startFrame_));
+
+  return {.index = index, .nextIndex = nextIndex, .factor = factor, .atEndOfBuffer = atEnd};
+}
+
+size_t SingleBufferProcessor::remainingInContiguousBlock() const {
+  if (atBoundary()) {
+    return 0;
+  }
+  if (direction_ == BufferProcessingDirection::REVERSE) {
+    // +1 because we read down to and including startFrame_
+    return currentIndex() - startFrame_ + 1;
+  }
+  // Pure size_t arithmetic — no double promotion, no fractional truncation.
+  return endFrame_ - currentIndex();
+}
+
+void SingleBufferProcessor::consume(size_t frames) {
+  if (direction_ == BufferProcessingDirection::REVERSE) {
+    position_ -= static_cast<double>(frames);
+  } else {
+    position_ += static_cast<double>(frames);
+  }
+}
+
+size_t SingleBufferProcessor::currentIndex() const {
+  return static_cast<size_t>(std::floor(position_));
+}
+
+std::shared_ptr<const AudioBuffer> SingleBufferProcessor::getBuffer() const {
+  return buffer_;
+}
+
+std::shared_ptr<const AudioBuffer> SingleBufferProcessor::getNextBuffer() const {
+  return buffer_;
+}
+
+bool SingleBufferProcessor::atBoundary() const {
+  return position_ < static_cast<double>(startFrame_) ||
+      position_ >= static_cast<double>(endFrame_);
+}
+
+bool SingleBufferProcessor::shouldStop() const {
+  return !loop_;
+}
+
+void SingleBufferProcessor::handleBoundary() {
+  if (shouldStop()) {
+    return;
+  }
+
+  if (endFrame_ <= startFrame_) {
+    return;
+  }
+  const auto range = static_cast<double>(endFrame_ - startFrame_);
+
+  if (position_ >= static_cast<double>(endFrame_)) {
+    position_ -= range;
+  } else if (position_ < static_cast<double>(startFrame_)) {
+    position_ += range;
+  }
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/core/utils/buffer/SingleBufferProcessor.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <audioapi/core/utils/buffer/BufferProcessingDirection.h>
+#include <audioapi/core/utils/buffer/BufferProcessorBase.h>
+
+#include <audioapi/utils/AudioBuffer.hpp>
+#include <cstddef>
+#include <memory>
+#include <utility>
+
+namespace audioapi {
+
+class SingleBufferProcessor : public BufferProcessorBase {
+ public:
+  SingleBufferProcessor() = default;
+
+  [[nodiscard]] bool atBoundary() const override;
+  [[nodiscard]] bool shouldStop() const override;
+
+  void setStartFrame(size_t startFrame) {
+    startFrame_ = startFrame;
+  }
+
+  void setEndFrame(size_t endFrame) {
+    endFrame_ = endFrame;
+  }
+
+  void setLoop(bool loop) {
+    loop_ = loop;
+  }
+
+  void setBuffer(std::shared_ptr<const AudioBuffer> buffer) {
+    buffer_ = std::move(buffer);
+  }
+
+ protected:
+  CursorState advance(double rate) override;
+  void consume(size_t frames) override;
+  [[nodiscard]] size_t remainingInContiguousBlock() const override;
+  [[nodiscard]] size_t currentIndex() const override;
+  [[nodiscard]] std::shared_ptr<const AudioBuffer> getBuffer() const override;
+  [[nodiscard]] std::shared_ptr<const AudioBuffer> getNextBuffer() const override;
+  void handleBoundary() override;
+
+ private:
+  std::shared_ptr<const AudioBuffer> buffer_ = nullptr;
+  bool loop_ = false;
+  size_t startFrame_ = 0;
+  size_t endFrame_ = 0;
+};
+
+} // namespace audioapi

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

@@ -1,18 +1,46 @@
-#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <cstdio>
 #include <memory>
-#include <string>
 #include <unordered_map>
+#include <utility>
 
 namespace audioapi {
 
 AudioEventHandlerRegistry::AudioEventHandlerRegistry(
     jsi::Runtime *runtime,
     const std::shared_ptr<react::CallInvoker> &callInvoker)
-    : IAudioEventHandlerRegistry(), callInvoker_(callInvoker), runtime_(runtime) {}
+    : callInvoker_(callInvoker), runtime_(runtime), isExiting_(false) {
+  auto [sender, receiver] = channels::spsc::channel<
+      DispatchEvent,
+      EVENT_DISPATCHER_SPSC_OVERFLOW_STRATEGY,
+      EVENT_DISPATCHER_SPSC_WAIT_STRATEGY>(kDispatchCapacity);
+  sender_ = std::move(sender);
+  receiver_ = std::move(receiver);
+
+  workerThread_ = std::thread([this]() {
+    while (!isExiting_.load(std::memory_order_acquire)) {
+      auto item = receiver_.receive();
+      if (isExiting_.load(std::memory_order_acquire)) {
+        break;
+      }
+
+      auto weak = weak_from_this();
+      callInvoker_->invokeAsync([weak, capturedItem = std::move(item)]() {
+        if (auto self = weak.lock()) {
+          self->handleEventOnJSThread(
+              capturedItem.event, capturedItem.listenerId, capturedItem.payload);
+        }
+      });
+    }
+  });
+}
 
 AudioEventHandlerRegistry::~AudioEventHandlerRegistry() {
+  isExiting_.store(true, std::memory_order_release);
+  sender_.send(DispatchEvent{});
+  if (workerThread_.joinable()) {
+    workerThread_.join();
+  }
   eventHandlers_.clear();
 }
 
@@ -22,13 +50,10 @@ uint64_t AudioEventHandlerRegistry::registerHandler(
   auto listenerId = listenerIdCounter_.fetch_add(1, std::memory_order_relaxed);
 
   if (runtime_ == nullptr) {
-    // If runtime is not valid, we cannot register the handler
     return 0;
   }
 
   auto weakSelf = weak_from_this();
-
-  // Read/Write on eventHandlers_ map only on the JS thread
   callInvoker_->invokeAsync([weakSelf, eventName, listenerId, handler]() {
     if (auto self = weakSelf.lock()) {
       self->eventHandlers_[eventName][listenerId] = handler;
@@ -40,24 +65,19 @@ uint64_t AudioEventHandlerRegistry::registerHandler(
 
 void AudioEventHandlerRegistry::unregisterHandler(AudioEvent eventName, uint64_t listenerId) {
   if (runtime_ == nullptr) {
-    // If runtime is not valid, we cannot unregister the handler
     return;
   }
 
   auto weakSelf = weak_from_this();
-
-  // Read/Write on eventHandlers_ map only on the JS thread
   callInvoker_->invokeAsync([weakSelf, eventName, listenerId]() {
     if (auto self = weakSelf.lock()) {
       auto it = self->eventHandlers_.find(eventName);
-
       if (it == self->eventHandlers_.end()) {
         return;
       }
 
       auto &handlersMap = it->second;
       auto handlerIt = handlersMap.find(listenerId);
-
       if (handlerIt != handlersMap.end()) {
         handlersMap.erase(handlerIt);
       }
@@ -65,167 +85,55 @@ void AudioEventHandlerRegistry::unregisterHandler(AudioEvent eventName, uint64_t
   });
 }
 
-// todo: refactor this method to be less complex and more readable
-// NOLINTNEXTLINE(readability-function-cognitive-complexity)
-void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
+bool AudioEventHandlerRegistry::dispatchEvent(
     AudioEvent eventName,
-    const std::unordered_map<std::string, EventValue> &body) {
+    uint64_t listenerId,
+    AudioEventPayload &&payload) noexcept {
   if (runtime_ == nullptr) {
-    // If runtime is not valid, we cannot unregister the handler
-    return;
+    return false;
   }
-
-  auto weakSelf = weak_from_this();
-
-  // Read/Write on eventHandlers_ map only on the JS thread
-  callInvoker_->invokeAsync([weakSelf, eventName, body]() {
-    if (auto self = weakSelf.lock()) {
-      auto it = self->eventHandlers_.find(eventName);
-
-      if (it == self->eventHandlers_.end()) {
-        // If the event name is not registered, we can skip invoking handlers
-        return;
-      }
-
-      auto handlersMap = it->second;
-
-      for (const auto &pair : handlersMap) {
-        auto handler = pair.second;
-
-        if (!handler || !handler->isFunction(*self->runtime_)) {
-          // If the handler is not valid, we can skip it
-          continue;
-        }
-
-        try {
-          jsi::Object eventObject(*self->runtime_);
-          // handle special logic for microphone, because we pass audio buffer
-          // which has significant size
-          if (eventName == AudioEvent::AUDIO_READY) {
-            auto bufferIt = body.find("buffer");
-            if (bufferIt != body.end()) {
-              auto bufferHostObject = std::static_pointer_cast<AudioBufferHostObject>(
-                  std::get<std::shared_ptr<jsi::HostObject>>(bufferIt->second));
-              eventObject = self->createEventObject(body, bufferHostObject->getSizeInBytes());
-            }
-          } else {
-            eventObject = self->createEventObject(body);
-          }
-          handler->call(*self->runtime_, eventObject);
-        } catch (const std::exception &e) {
-          // re-throw the exception to be handled by the caller
-          // std::exception is safe to parse by the rn bridge
-          throw;
-        } catch (...) {
-          printf("Unknown exception occurred while invoking handler for event: %d\n", eventName);
-        }
-      }
-    }
-  });
+  return sender_.try_send(
+             DispatchEvent{
+                 .event = eventName, .listenerId = listenerId, .payload = std::move(payload)}) ==
+      channels::spsc::ResponseStatus::SUCCESS;
 }
 
-// todo: refactor this method to be less complex and more readable
-// NOLINTNEXTLINE(readability-function-cognitive-complexity)
-void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
+void AudioEventHandlerRegistry::handleEventOnJSThread(
     AudioEvent eventName,
     uint64_t listenerId,
-    const std::unordered_map<std::string, EventValue> &body) {
-  if (runtime_ == nullptr) {
-    // If runtime is not valid, we cannot unregister the handler
+    const AudioEventPayload &payload) {
+  auto it = eventHandlers_.find(eventName);
+  if (it == eventHandlers_.end()) {
     return;
   }
 
-  auto weakSelf = weak_from_this();
-
-  // Read/Write on eventHandlers_ map only on the JS thread
-  callInvoker_->invokeAsync([weakSelf, eventName, listenerId, body]() {
-    if (auto self = weakSelf.lock()) {
-      auto it = self->eventHandlers_.find(eventName);
-
-      if (it == self->eventHandlers_.end()) {
-        // If the event name is not registered, we can skip invoking handlers
-        return;
-      }
-
-      auto handlerIt = it->second.find(listenerId);
-
-      if (handlerIt == it->second.end()) {
-        // If the listener ID is not registered, we can skip invoking handlers
-        return;
-      }
-
-      // Depending on how the AudioBufferSourceNode is handled on the JS side,
-      // it sometimes might enter race condition where the ABSN is deleted on JS
-      // side, but it is still processed on the audio thread, leading to a crash
-      // when f.e. `positionChanged` event is triggered.
-
-      // In case of debugging this, please increment the hours spent counter
-
-      // Hours spent on this: 8
-      try {
-        if (!handlerIt->second || !handlerIt->second->isFunction(*self->runtime_)) {
-          // If the handler is not valid, we can skip it
-          return;
-        }
-        jsi::Object eventObject(*self->runtime_);
-        // handle special logic for microphone, because we pass audio buffer which
-        // has significant size
-        if (eventName == AudioEvent::AUDIO_READY) {
-          auto bufferIt = body.find("buffer");
-          if (bufferIt != body.end()) {
-            auto bufferHostObject = std::static_pointer_cast<AudioBufferHostObject>(
-                std::get<std::shared_ptr<jsi::HostObject>>(bufferIt->second));
-            eventObject = self->createEventObject(body, bufferHostObject->getSizeInBytes());
-          }
-        } else {
-          eventObject = self->createEventObject(body);
-        }
-        handlerIt->second->call(*self->runtime_, eventObject);
-      } catch (const std::exception &e) {
-        // re-throw the exception to be handled by the caller
-        // std::exception is safe to parse by the rn bridge
-        throw;
-      } catch (...) {
-        printf("Unknown exception occurred while invoking handler for event: %d\n", eventName);
-      }
+  if (listenerId == kBroadcastListenerId) {
+    auto handlersCopy = it->second;
+    for (const auto &pair : handlersCopy) {
+      invokeHandler(pair.second, payload);
     }
-  });
-}
-
-jsi::Object AudioEventHandlerRegistry::createEventObject(
-    const std::unordered_map<std::string, EventValue> &body) {
-  auto eventObject = jsi::Object(*runtime_);
-
-  for (const auto &pair : body) {
-    const auto *name = pair.first.data();
-    const auto &value = pair.second;
-
-    if (std::holds_alternative<int>(value)) {
-      eventObject.setProperty(*runtime_, name, std::get<int>(value));
-    } else if (std::holds_alternative<double>(value)) {
-      eventObject.setProperty(*runtime_, name, std::get<double>(value));
-    } else if (std::holds_alternative<float>(value)) {
-      eventObject.setProperty(*runtime_, name, std::get<float>(value));
-    } else if (std::holds_alternative<bool>(value)) {
-      eventObject.setProperty(*runtime_, name, std::get<bool>(value));
-    } else if (std::holds_alternative<std::string>(value)) {
-      eventObject.setProperty(*runtime_, name, std::get<std::string>(value));
-    } else if (std::holds_alternative<std::shared_ptr<jsi::HostObject>>(value)) {
-      auto hostObject = jsi::Object::createFromHostObject(
-          *runtime_, std::get<std::shared_ptr<jsi::HostObject>>(value));
-      eventObject.setProperty(*runtime_, name, hostObject);
+  } else {
+    auto handlerIt = it->second.find(listenerId);
+    if (handlerIt != it->second.end()) {
+      invokeHandler(handlerIt->second, payload);
     }
   }
-
-  return eventObject;
 }
 
-jsi::Object AudioEventHandlerRegistry::createEventObject(
-    const std::unordered_map<std::string, EventValue> &body,
-    size_t memoryPressure) {
-  auto eventObject = createEventObject(body);
-  eventObject.setExternalMemoryPressure(*runtime_, memoryPressure);
-  return eventObject;
+void AudioEventHandlerRegistry::invokeHandler(
+    const std::shared_ptr<jsi::Function> &handler,
+    const AudioEventPayload &payload) {
+  if (!handler || !handler->isFunction(*runtime_)) {
+    return;
+  }
+  try {
+    auto eventObject = buildJsiObject(payload);
+    handler->call(*runtime_, eventObject);
+  } catch (const std::exception &) {
+    throw;
+  } catch (...) {
+    printf("Unknown exception occurred while invoking audio event handler\n");
+  }
 }
 
 } // namespace audioapi

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

@@ -2,24 +2,29 @@
 
 #include <ReactCommon/CallInvoker.h>
 #include <audioapi/events/AudioEvent.h>
+#include <audioapi/events/AudioEventPayload.h>
 #include <audioapi/events/IAudioEventHandlerRegistry.h>
+#include <audioapi/utils/Macros.h>
+#include <audioapi/utils/SpscChannel.hpp>
 #include <jsi/jsi.h>
 #include <atomic>
 #include <memory>
-#include <string>
+#include <thread>
 #include <unordered_map>
-#include <variant>
+
+inline constexpr auto EVENT_DISPATCHER_SPSC_OVERFLOW_STRATEGY =
+    audioapi::channels::spsc::OverflowStrategy::WAIT_ON_FULL;
+inline constexpr auto EVENT_DISPATCHER_SPSC_WAIT_STRATEGY =
+    audioapi::channels::spsc::WaitStrategy::ATOMIC_WAIT;
 
 namespace audioapi {
 using namespace facebook;
 
-using EventValue =
-    std::variant<int, float, double, std::string, bool, std::shared_ptr<jsi::HostObject>>;
-
-/// @brief A registry for audio event handlers.
-/// It allows registering, unregistering, and invoking event handlers for audio events.
-/// State changes are performed only on the JS thread.
-/// State access is thread-safe via the RN CallInvoker.
+/// @brief Registry for audio event handlers with built-in dispatcher.
+///
+/// Handlers are registered/unregistered on the JS thread.
+/// dispatchEvent() is lock-free and allocation-free — can be called from the
+/// Audio Thread.
 class AudioEventHandlerRegistry : public IAudioEventHandlerRegistry,
                                   public std::enable_shared_from_this<AudioEventHandlerRegistry> {
  public:
@@ -28,45 +33,59 @@ class AudioEventHandlerRegistry : public IAudioEventHandlerRegistry,
       const std::shared_ptr<react::CallInvoker> &callInvoker);
   ~AudioEventHandlerRegistry() override;
 
-  /// @brief Registers an event handler for a specific audio event.
-  /// @param eventName The name of the audio event.
-  /// @param handler The JavaScript function to be called when the event occurs.
-  /// @return A unique listener ID for the registered handler.
-  /// @note Thread safe
+  DELETE_COPY_AND_MOVE(AudioEventHandlerRegistry);
+
   uint64_t registerHandler(AudioEvent eventName, const std::shared_ptr<jsi::Function> &handler)
       override;
 
-  /// @brief Unregisters an event handler for a specific audio event using its listener ID.
-  /// @param eventName The name of the audio event.
-  /// @param listenerId The unique listener ID of the handler to be unregistered.
-  /// @note Thread safe
   void unregisterHandler(AudioEvent eventName, uint64_t listenerId) override;
 
-  /// @brief Invokes the event handler(s) for a specific event with the provided event body.
-  /// @note Thread safe
-  void invokeHandlerWithEventBody(
-      AudioEvent eventName,
-      const std::unordered_map<std::string, EventValue> &body) override;
-
-  /// @brief Invokes the event handler(s) for a specific event with the provided event body.
-  /// @note Thread safe
-  void invokeHandlerWithEventBody(
+  bool dispatchEvent(
       AudioEvent eventName,
       uint64_t listenerId,
-      const std::unordered_map<std::string, EventValue> &body) override;
+      AudioEventPayload &&payload) noexcept override;
 
  private:
-  std::atomic<uint64_t> listenerIdCounter_{1}; // Atomic counter for listener IDs
+  static constexpr size_t kDispatchCapacity = 256;
+
+  struct DispatchEvent {
+    AudioEvent event{};
+    uint64_t listenerId{kBroadcastListenerId};
+    AudioEventPayload payload{EmptyPayload{}};
+  };
 
+  using Sender = channels::spsc::Sender<
+      DispatchEvent,
+      EVENT_DISPATCHER_SPSC_OVERFLOW_STRATEGY,
+      EVENT_DISPATCHER_SPSC_WAIT_STRATEGY>;
+  using Receiver = channels::spsc::Receiver<
+      DispatchEvent,
+      EVENT_DISPATCHER_SPSC_OVERFLOW_STRATEGY,
+      EVENT_DISPATCHER_SPSC_WAIT_STRATEGY>;
+
+  std::atomic<uint64_t> listenerIdCounter_{1};
   const std::shared_ptr<react::CallInvoker> callInvoker_;
   jsi::Runtime *runtime_;
   std::unordered_map<AudioEvent, std::unordered_map<uint64_t, std::shared_ptr<jsi::Function>>>
       eventHandlers_;
 
-  jsi::Object createEventObject(const std::unordered_map<std::string, EventValue> &body);
-  jsi::Object createEventObject(
-      const std::unordered_map<std::string, EventValue> &body,
-      size_t memoryPressure);
+  Sender sender_;
+  Receiver receiver_;
+  std::atomic<bool> isExiting_;
+  std::thread workerThread_;
+
+  void handleEventOnJSThread(
+      AudioEvent eventName,
+      uint64_t listenerId,
+      const AudioEventPayload &payload);
+  void invokeHandler(
+      const std::shared_ptr<jsi::Function> &handler,
+      const AudioEventPayload &payload);
+
+  jsi::Object buildJsiObject(const AudioEventPayload &payload) {
+    return std::visit(
+        [this](auto &&p) -> jsi::Object { return p.toJsiObject(*runtime_); }, payload);
+  }
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/events/AudioEventPayload.h

@@ -0,0 +1,87 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <variant>
+
+namespace audioapi {
+
+// broadcast sentinel — listenerId 0 means dispatch to all registered handlers.
+static constexpr uint64_t kBroadcastListenerId = 0;
+
+struct EmptyPayload {
+  facebook::jsi::Object toJsiObject(facebook::jsi::Runtime &rt) const {
+    return facebook::jsi::Object(rt);
+  }
+};
+
+struct DoubleValuePayload {
+  double value;
+
+  facebook::jsi::Object toJsiObject(facebook::jsi::Runtime &rt) const {
+    facebook::jsi::Object obj(rt);
+    obj.setProperty(rt, "value", value);
+    return obj;
+  }
+};
+
+struct InterruptionPayload {
+  std::string type;
+  bool shouldResume;
+
+  facebook::jsi::Object toJsiObject(facebook::jsi::Runtime &rt) const {
+    facebook::jsi::Object obj(rt);
+    obj.setProperty(rt, "type", facebook::jsi::String::createFromUtf8(rt, type));
+    obj.setProperty(rt, "shouldResume", shouldResume);
+    return obj;
+  }
+};
+
+struct StringPayload {
+  std::string name;
+  std::string reason;
+
+  facebook::jsi::Object toJsiObject(facebook::jsi::Runtime &rt) const {
+    facebook::jsi::Object obj(rt);
+    obj.setProperty(rt, name.c_str(), facebook::jsi::String::createFromUtf8(rt, reason));
+    return obj;
+  }
+};
+
+struct BufferEndedPayload {
+  size_t bufferId;
+  bool isLastBufferInQueue;
+
+  facebook::jsi::Object toJsiObject(facebook::jsi::Runtime &rt) const {
+    facebook::jsi::Object obj(rt);
+    obj.setProperty(
+        rt, "bufferId", facebook::jsi::String::createFromUtf8(rt, std::to_string(bufferId)));
+    obj.setProperty(rt, "isLastBufferInQueue", isLastBufferInQueue);
+    return obj;
+  }
+};
+
+struct AudioReadyPayload {
+  std::shared_ptr<AudioBufferHostObject> buffer;
+  int numFrames;
+
+  facebook::jsi::Object toJsiObject(facebook::jsi::Runtime &rt) const {
+    facebook::jsi::Object obj(rt);
+    obj.setProperty(rt, "buffer", facebook::jsi::Object::createFromHostObject(rt, buffer));
+    obj.setProperty(rt, "numFrames", numFrames);
+    obj.setExternalMemoryPressure(rt, buffer->getSizeInBytes());
+    return obj;
+  }
+};
+
+using AudioEventPayload = std::variant<
+    EmptyPayload,
+    DoubleValuePayload,
+    InterruptionPayload,
+    StringPayload,
+    BufferEndedPayload,
+    AudioReadyPayload>;
+
+} // namespace audioapi