react-native-audio-api 0.3.0-rc1 → 0.3.1

package/common/cpp/wrappers/AudioBufferSourceNodeWrapper.cpp

@@ -1,45 +0,0 @@
-#include "AudioBufferSourceNodeWrapper.h"
-
-namespace audioapi {
-
-AudioBufferSourceNodeWrapper::AudioBufferSourceNodeWrapper(
-    const std::shared_ptr<AudioBufferSourceNode> &audioBufferSourceNode)
-    : AudioScheduledSourceNodeWrapper(audioBufferSourceNode) {}
-
-std::shared_ptr<AudioBufferSourceNode>
-AudioBufferSourceNodeWrapper::getAudioBufferSourceNodeFromAudioNode() {
-  return std::static_pointer_cast<AudioBufferSourceNode>(node_);
-}
-
-bool AudioBufferSourceNodeWrapper::getLoop() {
-  auto audioBufferSourceNode = getAudioBufferSourceNodeFromAudioNode();
-  return audioBufferSourceNode->getLoop();
-}
-
-void AudioBufferSourceNodeWrapper::setLoop(bool loop) {
-  auto audioBufferSourceNode = getAudioBufferSourceNodeFromAudioNode();
-  audioBufferSourceNode->setLoop(loop);
-}
-
-std::shared_ptr<AudioBufferWrapper> AudioBufferSourceNodeWrapper::getBuffer() {
-  auto audioBufferSourceNode = getAudioBufferSourceNodeFromAudioNode();
-  auto buffer = audioBufferSourceNode->getBuffer();
-
-  if (!buffer) {
-    return {nullptr};
-  }
-
-  return std::make_shared<AudioBufferWrapper>(buffer);
-}
-
-void AudioBufferSourceNodeWrapper::setBuffer(
-    const std::shared_ptr<AudioBufferWrapper> &buffer) {
-  auto audioBufferSourceNode = getAudioBufferSourceNodeFromAudioNode();
-  if (!buffer) {
-    audioBufferSourceNode->setBuffer(std::shared_ptr<AudioBuffer>(nullptr));
-    return;
-  }
-
-  audioBufferSourceNode->setBuffer(buffer->audioBuffer_);
-}
-} // namespace audioapi

package/common/cpp/wrappers/AudioBufferSourceNodeWrapper.h

@@ -1,26 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <optional>
-
-#include "AudioBufferSourceNode.h"
-#include "AudioBufferWrapper.h"
-#include "AudioScheduledSourceNodeWrapper.h"
-
-namespace audioapi {
-
-class AudioBufferSourceNodeWrapper : public AudioScheduledSourceNodeWrapper {
- public:
-  explicit AudioBufferSourceNodeWrapper(
-      const std::shared_ptr<AudioBufferSourceNode> &audioBufferSourceNode);
-
-  void setLoop(bool loop);
-  [[nodiscard]] bool getLoop();
-  [[nodiscard]] std::shared_ptr<AudioBufferWrapper> getBuffer();
-  void setBuffer(const std::shared_ptr<AudioBufferWrapper> &buffer);
-
- private:
-  std::shared_ptr<AudioBufferSourceNode>
-  getAudioBufferSourceNodeFromAudioNode();
-};
-} // namespace audioapi

package/common/cpp/wrappers/AudioBufferWrapper.cpp

@@ -1,46 +0,0 @@
-#include "AudioBufferWrapper.h"
-
-namespace audioapi {
-
-AudioBufferWrapper::AudioBufferWrapper(
-    const std::shared_ptr<AudioBuffer> &audioBuffer)
-    : audioBuffer_(audioBuffer) {}
-
-int AudioBufferWrapper::getSampleRate() const {
-  return audioBuffer_->getSampleRate();
-}
-
-int AudioBufferWrapper::getLength() const {
-  return audioBuffer_->getLength();
-}
-
-double AudioBufferWrapper::getDuration() const {
-  return audioBuffer_->getDuration();
-}
-
-int AudioBufferWrapper::getNumberOfChannels() const {
-  return audioBuffer_->getNumberOfChannels();
-}
-
-float *AudioBufferWrapper::getChannelData(int channel) const {
-  return audioBuffer_->getChannelData(channel);
-}
-
-void AudioBufferWrapper::copyFromChannel(
-    float *destination,
-    int destinationLength,
-    int channelNumber,
-    int startInChannel) const {
-  audioBuffer_->copyFromChannel(
-      destination, destinationLength, channelNumber, startInChannel);
-}
-
-void AudioBufferWrapper::copyToChannel(
-    float *source,
-    int sourceLength,
-    int channelNumber,
-    int startInChannel) const {
-  audioBuffer_->copyToChannel(
-      source, sourceLength, channelNumber, startInChannel);
-}
-} // namespace audioapi

package/common/cpp/wrappers/AudioBufferWrapper.h

@@ -1,30 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "AudioBuffer.h"
-
-namespace audioapi {
-
-class AudioBufferWrapper {
- public:
-  explicit AudioBufferWrapper(const std::shared_ptr<AudioBuffer> &audioBuffer);
-
-  std::shared_ptr<AudioBuffer> audioBuffer_;
-  [[nodiscard]] int getNumberOfChannels() const;
-  [[nodiscard]] int getLength() const;
-  [[nodiscard]] double getDuration() const;
-  [[nodiscard]] int getSampleRate() const;
-  [[nodiscard]] float *getChannelData(int channel) const;
-  void copyFromChannel(
-      float *destination,
-      int destinationLength,
-      int channelNumber,
-      int startInChannel = 0) const;
-  void copyToChannel(
-      float *source,
-      int sourceLength,
-      int channelNumber,
-      int startInChannel = 0) const;
-};
-} // namespace audioapi

package/common/cpp/wrappers/AudioContextWrapper.cpp

@@ -1,17 +0,0 @@
-#include "AudioContextWrapper.h"
-
-namespace audioapi {
-
-AudioContextWrapper::AudioContextWrapper(
-    const std::shared_ptr<AudioContext> &context)
-    : BaseAudioContextWrapper(context) {}
-
-void AudioContextWrapper::close() {
-  getAudioContextFromBaseAudioContext()->close();
-}
-
-std::shared_ptr<AudioContext>
-AudioContextWrapper::getAudioContextFromBaseAudioContext() {
-  return std::static_pointer_cast<AudioContext>(context_);
-}
-} // namespace audioapi

package/common/cpp/wrappers/AudioContextWrapper.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "AudioContext.h"
-#include "BaseAudioContextWrapper.h"
-
-namespace audioapi {
-
-class AudioContextWrapper : public BaseAudioContextWrapper {
- public:
-  explicit AudioContextWrapper(const std::shared_ptr<AudioContext> &context);
-
-  void close();
-
- private:
-  std::shared_ptr<AudioContext> getAudioContextFromBaseAudioContext();
-};
-} // namespace audioapi

package/common/cpp/wrappers/AudioDestinationNodeWrapper.h

@@ -1,16 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "AudioDestinationNode.h"
-#include "AudioNodeWrapper.h"
-
-namespace audioapi {
-
-class AudioDestinationNodeWrapper : public AudioNodeWrapper {
- public:
-  explicit AudioDestinationNodeWrapper(
-      const std::shared_ptr<AudioDestinationNode> &destinationNode)
-      : AudioNodeWrapper(destinationNode) {}
-};
-} // namespace audioapi

package/common/cpp/wrappers/AudioNodeWrapper.cpp

@@ -1,37 +0,0 @@
-#include "AudioNodeWrapper.h"
-
-namespace audioapi {
-
-AudioNodeWrapper::AudioNodeWrapper(const std::shared_ptr<AudioNode> &node)
-    : node_(node) {}
-
-int AudioNodeWrapper::getNumberOfInputs() const {
-  return node_->getNumberOfInputs();
-}
-
-int AudioNodeWrapper::getNumberOfOutputs() const {
-  return node_->getNumberOfOutputs();
-}
-
-int AudioNodeWrapper::getChannelCount() const {
-  return node_->getChannelCount();
-}
-
-std::string AudioNodeWrapper::getChannelCountMode() const {
-  return node_->getChannelCountMode();
-}
-
-std::string AudioNodeWrapper::getChannelInterpretation() const {
-  return node_->getChannelInterpretation();
-}
-
-void AudioNodeWrapper::connect(
-    const std::shared_ptr<AudioNodeWrapper> &node) const {
-  node_->connect(node->node_);
-}
-
-void AudioNodeWrapper::disconnect(
-    const std::shared_ptr<AudioNodeWrapper> &node) const {
-  node_->disconnect(node->node_);
-}
-} // namespace audioapi

package/common/cpp/wrappers/AudioNodeWrapper.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "AudioNode.h"
-
-namespace audioapi {
-
-class AudioNodeWrapper {
- public:
-  explicit AudioNodeWrapper(const std::shared_ptr<AudioNode> &node);
-
-  [[nodiscard]] int getNumberOfInputs() const;
-  [[nodiscard]] int getNumberOfOutputs() const;
-  [[nodiscard]] int getChannelCount() const;
-  [[nodiscard]] std::string getChannelCountMode() const;
-  [[nodiscard]] std::string getChannelInterpretation() const;
-  void connect(const std::shared_ptr<AudioNodeWrapper> &node) const;
-  void disconnect(const std::shared_ptr<AudioNodeWrapper> &node) const;
-
- protected:
-  std::shared_ptr<AudioNode> node_;
-};
-} // namespace audioapi

package/common/cpp/wrappers/AudioParamWrapper.cpp

@@ -1,42 +0,0 @@
-#include "AudioParamWrapper.h"
-
-namespace audioapi {
-
-AudioParamWrapper::AudioParamWrapper(const std::shared_ptr<AudioParam> &param)
-    : param_(param) {}
-
-float AudioParamWrapper::getValue() const {
-  return param_->getValue();
-}
-
-void AudioParamWrapper::setValue(float value) const {
-  param_->setValue(value);
-}
-
-float AudioParamWrapper::getDefaultValue() const {
-  return param_->getDefaultValue();
-}
-
-float AudioParamWrapper::getMinValue() const {
-  return param_->getMinValue();
-}
-
-float AudioParamWrapper::getMaxValue() const {
-  return param_->getMaxValue();
-}
-
-void AudioParamWrapper::setValueAtTime(float value, double startTime) const {
-  param_->setValueAtTime(value, startTime);
-}
-
-void AudioParamWrapper::linearRampToValueAtTime(float value, double endTime)
-    const {
-  param_->linearRampToValueAtTime(value, endTime);
-}
-
-void AudioParamWrapper::exponentialRampToValueAtTime(
-    float value,
-    double endTime) const {
-  param_->exponentialRampToValueAtTime(value, endTime);
-}
-} // namespace audioapi

package/common/cpp/wrappers/AudioParamWrapper.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "AudioParam.h"
-
-namespace audioapi {
-
-class AudioParamWrapper {
- public:
-  explicit AudioParamWrapper(const std::shared_ptr<AudioParam> &param);
-
-  [[nodiscard]] float getValue() const;
-  void setValue(float value) const;
-  [[nodiscard]] float getDefaultValue() const;
-  [[nodiscard]] float getMinValue() const;
-  [[nodiscard]] float getMaxValue() const;
-  void setValueAtTime(float value, double startTime) const;
-  void linearRampToValueAtTime(float value, double endTime) const;
-  void exponentialRampToValueAtTime(float value, double endTime) const;
-
- private:
-  std::shared_ptr<AudioParam> param_;
-};
-} // namespace audioapi

package/common/cpp/wrappers/AudioScheduledSourceNodeWrapper.cpp

@@ -1,23 +0,0 @@
-#include "AudioScheduledSourceNodeWrapper.h"
-
-namespace audioapi {
-
-AudioScheduledSourceNodeWrapper::AudioScheduledSourceNodeWrapper(
-    const std::shared_ptr<AudioScheduledSourceNode> &audioScheduledSourceNode)
-    : AudioNodeWrapper(audioScheduledSourceNode) {}
-
-std::shared_ptr<AudioScheduledSourceNode>
-AudioScheduledSourceNodeWrapper::getAudioScheduledSourceNodeFromAudioNode() {
-  return std::static_pointer_cast<AudioScheduledSourceNode>(node_);
-}
-
-void AudioScheduledSourceNodeWrapper::start(double time) {
-  auto audioScheduledSourceNode = getAudioScheduledSourceNodeFromAudioNode();
-  audioScheduledSourceNode->start(time);
-}
-
-void AudioScheduledSourceNodeWrapper::stop(double time) {
-  auto audioScheduledSourceNode = getAudioScheduledSourceNodeFromAudioNode();
-  audioScheduledSourceNode->stop(time);
-}
-} // namespace audioapi

package/common/cpp/wrappers/AudioScheduledSourceNodeWrapper.h

@@ -1,23 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "AudioNodeWrapper.h"
-#include "AudioScheduledSourceNode.h"
-
-namespace audioapi {
-
-class AudioScheduledSourceNodeWrapper : public AudioNodeWrapper {
- public:
-  explicit AudioScheduledSourceNodeWrapper(
-      const std::shared_ptr<AudioScheduledSourceNode>
-          &audioScheduledSourceNode);
-
-  void start(double time);
-  void stop(double time);
-
- private:
-  std::shared_ptr<AudioScheduledSourceNode>
-  getAudioScheduledSourceNodeFromAudioNode();
-};
-} // namespace audioapi

package/common/cpp/wrappers/BaseAudioContextWrapper.cpp

@@ -1,83 +0,0 @@
-#include "BaseAudioContextWrapper.h"
-
-namespace audioapi {
-
-BaseAudioContextWrapper::BaseAudioContextWrapper(
-    const std::shared_ptr<BaseAudioContext> &context)
-    : context_(context) {
-  auto destination = context_->getDestination();
-  destination_ = std::make_shared<AudioDestinationNodeWrapper>(destination);
-}
-
-std::shared_ptr<AudioDestinationNodeWrapper>
-BaseAudioContextWrapper::getDestination() const {
-  return destination_;
-}
-
-std::string BaseAudioContextWrapper::getState() const {
-  return context_->getState();
-}
-
-int BaseAudioContextWrapper::getSampleRate() const {
-  return context_->getSampleRate();
-}
-
-double BaseAudioContextWrapper::getCurrentTime() const {
-  return context_->getCurrentTime();
-}
-
-std::shared_ptr<OscillatorNodeWrapper>
-BaseAudioContextWrapper::createOscillator() const {
-  auto oscillator = context_->createOscillator();
-  return std::make_shared<OscillatorNodeWrapper>(oscillator);
-}
-
-std::shared_ptr<GainNodeWrapper> BaseAudioContextWrapper::createGain() const {
-  auto gain = context_->createGain();
-  return std::make_shared<GainNodeWrapper>(gain);
-}
-
-std::shared_ptr<StereoPannerNodeWrapper>
-BaseAudioContextWrapper::createStereoPanner() const {
-  auto panner = context_->createStereoPanner();
-  return std::make_shared<StereoPannerNodeWrapper>(panner);
-}
-
-std::shared_ptr<BiquadFilterNodeWrapper>
-BaseAudioContextWrapper::createBiquadFilter() const {
-  auto filter = context_->createBiquadFilter();
-  return std::make_shared<BiquadFilterNodeWrapper>(filter);
-}
-
-std::shared_ptr<AudioBufferSourceNodeWrapper>
-BaseAudioContextWrapper::createBufferSource() const {
-  auto bufferSource = context_->createBufferSource();
-  return std::make_shared<AudioBufferSourceNodeWrapper>(bufferSource);
-}
-
-std::shared_ptr<AudioBufferWrapper> BaseAudioContextWrapper::createBuffer(
-    int numberOfChannels,
-    int length,
-    int sampleRate) const {
-  auto buffer = context_->createBuffer(numberOfChannels, length, sampleRate);
-  return std::make_shared<AudioBufferWrapper>(buffer);
-}
-
-std::shared_ptr<PeriodicWaveWrapper>
-BaseAudioContextWrapper::createPeriodicWave(
-    float *real,
-    float *imag,
-    bool disableNormalization,
-    int length) {
-  auto periodicWave =
-      context_->createPeriodicWave(real, imag, disableNormalization, length);
-  return std::make_shared<PeriodicWaveWrapper>(periodicWave);
-}
-
-std::shared_ptr<AudioBufferWrapper>
-BaseAudioContextWrapper::decodeAudioDataSource(const std::string &source) {
-  return std::make_shared<AudioBufferWrapper>(
-      context_->decodeAudioDataSource(source));
-}
-
-} // namespace audioapi

package/common/cpp/wrappers/BaseAudioContextWrapper.h

@@ -1,50 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <utility>
-
-#include "AudioBufferSourceNodeWrapper.h"
-#include "AudioBufferWrapper.h"
-#include "AudioDestinationNodeWrapper.h"
-#include "BaseAudioContext.h"
-#include "BiquadFilterNodeWrapper.h"
-#include "GainNodeWrapper.h"
-#include "OscillatorNodeWrapper.h"
-#include "PeriodicWaveWrapper.h"
-#include "StereoPannerNodeWrapper.h"
-
-namespace audioapi {
-
-class BaseAudioContextWrapper {
- public:
-  explicit BaseAudioContextWrapper(
-      const std::shared_ptr<BaseAudioContext> &context);
-
-  [[nodiscard]] std::shared_ptr<AudioDestinationNodeWrapper> getDestination()
-      const;
-  [[nodiscard]] std::string getState() const;
-  [[nodiscard]] int getSampleRate() const;
-  [[nodiscard]] double getCurrentTime() const;
-  [[nodiscard]] std::shared_ptr<OscillatorNodeWrapper> createOscillator() const;
-  [[nodiscard]] std::shared_ptr<GainNodeWrapper> createGain() const;
-  [[nodiscard]] std::shared_ptr<StereoPannerNodeWrapper> createStereoPanner()
-      const;
-  [[nodiscard]] std::shared_ptr<BiquadFilterNodeWrapper> createBiquadFilter()
-      const;
-  [[nodiscard]] std::shared_ptr<AudioBufferSourceNodeWrapper>
-  createBufferSource() const;
-  [[nodiscard]] std::shared_ptr<AudioBufferWrapper>
-  createBuffer(int numberOfChannels, int length, int sampleRate) const;
-  [[nodiscard]] std::shared_ptr<PeriodicWaveWrapper> createPeriodicWave(
-      float *real,
-      float *imag,
-      bool disableNormalization,
-      int length);
-  std::shared_ptr<AudioBufferWrapper> decodeAudioDataSource(const std::string &source);
-
- protected:
-  std::shared_ptr<AudioDestinationNodeWrapper> destination_;
-  std::shared_ptr<BaseAudioContext> context_;
-};
-} // namespace audioapi

package/common/cpp/wrappers/BiquadFilterNodeWrapper.cpp

@@ -1,60 +0,0 @@
-#include "BiquadFilterNodeWrapper.h"
-
-namespace audioapi {
-
-std::shared_ptr<BiquadFilterNode>
-BiquadFilterNodeWrapper::getBiquadFilterNodeFromAudioNode() {
-  return std::static_pointer_cast<BiquadFilterNode>(node_);
-}
-
-BiquadFilterNodeWrapper::BiquadFilterNodeWrapper(
-    const std::shared_ptr<BiquadFilterNode> &biquadFilterNode)
-    : AudioNodeWrapper(biquadFilterNode) {
-  auto frequencyParam = biquadFilterNode->getFrequencyParam();
-  frequencyParam_ = std::make_shared<AudioParamWrapper>(frequencyParam);
-  auto detuneParam = biquadFilterNode->getDetuneParam();
-  detuneParam_ = std::make_shared<AudioParamWrapper>(detuneParam);
-  auto QParam = biquadFilterNode->getQParam();
-  QParam_ = std::make_shared<AudioParamWrapper>(QParam);
-  auto gainParam = biquadFilterNode->getGainParam();
-  gainParam_ = std::make_shared<AudioParamWrapper>(gainParam);
-}
-
-std::shared_ptr<AudioParamWrapper> BiquadFilterNodeWrapper::getFrequencyParam()
-    const {
-  return frequencyParam_;
-}
-
-std::shared_ptr<AudioParamWrapper> BiquadFilterNodeWrapper::getDetuneParam()
-    const {
-  return detuneParam_;
-}
-
-std::shared_ptr<AudioParamWrapper> BiquadFilterNodeWrapper::getQParam() const {
-  return QParam_;
-}
-
-std::shared_ptr<AudioParamWrapper> BiquadFilterNodeWrapper::getGainParam()
-    const {
-  return gainParam_;
-}
-
-std::string BiquadFilterNodeWrapper::getType() {
-  auto biquadFilterNode_ = getBiquadFilterNodeFromAudioNode();
-  return biquadFilterNode_->getType();
-}
-
-void BiquadFilterNodeWrapper::setType(const std::string &filterType) {
-  auto biquadFilterNode_ = getBiquadFilterNodeFromAudioNode();
-  biquadFilterNode_->setType(filterType);
-}
-
-void BiquadFilterNodeWrapper::getFrequencyResponse(
-    const std::vector<float> &frequencyArray,
-    std::vector<float> &magResponseOutput,
-    std::vector<float> &phaseResponseOutput) {
-  auto biquadFilterNode_ = getBiquadFilterNodeFromAudioNode();
-  biquadFilterNode_->getFrequencyResponse(
-      frequencyArray, magResponseOutput, phaseResponseOutput);
-}
-} // namespace audioapi

package/common/cpp/wrappers/BiquadFilterNodeWrapper.h

@@ -1,37 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "AudioNodeWrapper.h"
-#include "AudioParamWrapper.h"
-#include "BiquadFilterNode.h"
-
-namespace audioapi {
-
-class BiquadFilterNodeWrapper : public AudioNodeWrapper {
- public:
-  explicit BiquadFilterNodeWrapper(
-      const std::shared_ptr<BiquadFilterNode> &biquadFilterNode);
-
-  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getFrequencyParam() const;
-  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getDetuneParam() const;
-  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getQParam() const;
-  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getGainParam() const;
-  std::string getType();
-  void setType(const std::string &filterType);
-  void getFrequencyResponse(
-      const std::vector<float> &frequencyArray,
-      std::vector<float> &magResponseOutput,
-      std::vector<float> &phaseResponseOutput);
-
- private:
-  std::shared_ptr<AudioParamWrapper> frequencyParam_;
-  std::shared_ptr<AudioParamWrapper> detuneParam_;
-  std::shared_ptr<AudioParamWrapper> QParam_;
-  std::shared_ptr<AudioParamWrapper> gainParam_;
-
-  std::shared_ptr<BiquadFilterNode> getBiquadFilterNodeFromAudioNode();
-};
-} // namespace audioapi

package/common/cpp/wrappers/GainNodeWrapper.cpp

@@ -1,14 +0,0 @@
-#include "GainNodeWrapper.h"
-
-namespace audioapi {
-
-GainNodeWrapper::GainNodeWrapper(const std::shared_ptr<GainNode> &gainNode)
-    : AudioNodeWrapper(gainNode) {
-  auto gainParam = gainNode->getGainParam();
-  gainParam_ = std::make_shared<AudioParamWrapper>(gainParam);
-}
-
-std::shared_ptr<AudioParamWrapper> GainNodeWrapper::getGainParam() const {
-  return gainParam_;
-}
-} // namespace audioapi

package/common/cpp/wrappers/GainNodeWrapper.h

@@ -1,20 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "AudioNodeWrapper.h"
-#include "AudioParamWrapper.h"
-#include "GainNode.h"
-
-namespace audioapi {
-
-class GainNodeWrapper : public AudioNodeWrapper {
- public:
-  explicit GainNodeWrapper(const std::shared_ptr<GainNode> &gainNode);
-
-  [[nodiscard]] std::shared_ptr<AudioParamWrapper> getGainParam() const;
-
- private:
-  std::shared_ptr<AudioParamWrapper> gainParam_;
-};
-} // namespace audioapi