Vendor dependencies for 0.3.0 release

vendor/oboe-sys/oboe-ext/include/oboe/OboeExt.h

@@ -0,0 +1,102 @@
+#ifndef OBOE_EXT_H
+#define OBOE_EXT_H
+
+#include "oboe/Oboe.h"
+
+namespace oboe {
+  typedef std::shared_ptr<AudioStream> AudioStreamShared;
+
+  typedef void (*DropContextHandler)(void *context);
+
+  typedef DataCallbackResult (*AudioReadyHandler)(void *context,
+                                                  AudioStream *oboeStream,
+                                                  void *audioData,
+                                                  int32_t numFrames);
+
+  typedef void (*ErrorCloseHandler)(void *context,
+                                    AudioStream *oboeStream,
+                                    Result error);
+
+  class AudioStreamCallbackWrapper
+      : public AudioStreamDataCallback, public AudioStreamErrorCallback {
+  public:
+    AudioStreamCallbackWrapper(void *context,
+                               const DropContextHandler drop_context,
+                               const AudioReadyHandler audio_ready,
+                               const ErrorCloseHandler before_close,
+                               const ErrorCloseHandler after_close);
+
+    ~AudioStreamCallbackWrapper();
+
+    DataCallbackResult onAudioReady(AudioStream *oboeStream,
+                                    void *audioData,
+                                    int32_t numFrames);
+
+    void onErrorBeforeClose(AudioStream *oboeStream,
+                            Result error);
+
+    void onErrorAfterClose(AudioStream *oboeStream,
+                           Result error);
+
+  private:
+    void *_context;
+    const DropContextHandler _drop_context;
+    const AudioReadyHandler _audio_ready;
+    const ErrorCloseHandler _before_close;
+    const ErrorCloseHandler _after_close;
+  };
+
+  void AudioStreamBuilder_create(AudioStreamBuilder *builder);
+  void AudioStreamBuilder_delete(AudioStreamBuilder *builder);
+  void AudioStreamBuilder_setCallback(AudioStreamBuilder *builder,
+                                      void *context,
+                                      const DropContextHandler drop_context,
+                                      const AudioReadyHandler audio_ready,
+                                      const ErrorCloseHandler before_close,
+                                      const ErrorCloseHandler after_close);
+
+  AudioApi AudioStreamBuilder_getAudioApi(const AudioStreamBuilder *builder);
+  void AudioStreamBuilder_setAudioApi(AudioStreamBuilder *builder, AudioApi api);
+  AudioStreamBase* AudioStreamBuilder_getBase(AudioStreamBuilder *builder);
+
+  Result AudioStreamBuilder_openStreamShared(AudioStreamBuilder *builder,
+                                             AudioStreamShared *sharedStream);
+
+  void AudioStreamShared_clone(const AudioStreamShared *sharedStream,
+                               AudioStreamShared *newSharedStream);
+  void AudioStreamShared_delete(AudioStreamShared *sharedStream);
+  AudioStream *AudioStreamShared_deref(AudioStreamShared *sharedStream);
+  Result AudioStream_open(AudioStream *oboeStream);
+  Result AudioStream_close(AudioStream *oboeStream);
+  Result AudioStream_requestStart(AudioStream *oboeStream);
+  Result AudioStream_requestPause(AudioStream *oboeStream);
+  Result AudioStream_requestFlush(AudioStream *oboeStream);
+  Result AudioStream_requestStop(AudioStream *oboeStream);
+  StreamState AudioStream_getState(AudioStream *oboeStream);
+  Result AudioStream_waitForStateChange(AudioStream *oboeStream,
+                                        StreamState inputState,
+                                        StreamState *nextState,
+                                        int64_t timeoutNanoseconds);
+  ResultWithValue<int32_t>
+  AudioStream_setBufferSizeInFrames(AudioStream *oboeStream,
+                                    int32_t requestedFrames);
+  ResultWithValue<int32_t>
+  AudioStream_getXRunCount(AudioStream *oboeStream);
+  bool AudioStream_isXRunCountSupported(const AudioStream *oboeStream);
+  int32_t AudioStream_getFramesPerBurst(AudioStream *oboeStream);
+  ResultWithValue<double>
+  AudioStream_calculateLatencyMillis(AudioStream *oboeStream);
+  AudioApi AudioStream_getAudioApi(const AudioStream *oboeStream);
+  ResultWithValue<int32_t> AudioStream_read(AudioStream *oboeStream,
+                                            void* buffer,
+                                            int32_t numFrames,
+                                            int64_t timeoutNanoseconds);
+  ResultWithValue<int32_t> AudioStream_write(AudioStream *oboeStream,
+                                             const void* buffer,
+                                             int32_t numFrames,
+                                             int64_t timeoutNanoseconds);
+
+  AudioStreamBase* AudioStream_getBase(AudioStream *oboeStream);
+}
+
+#endif

vendor/oboe-sys/oboe-ext/src/AudioStreamBuilderWrapper.cpp

@@ -0,0 +1,55 @@
+#include "oboe/OboeExt.h"
+
+namespace oboe {
+  /*void AudioStreamBuilder_init(AudioStreamBuilder *builder) {
+    new (builder) AudioStreamBuilder();
+  }
+
+  void AudioStreamBuilder_drop(AudioStreamBuilder *builder) {
+    builder->~AudioStreamBuilder();
+  }*/
+
+  void AudioStreamBuilder_create(AudioStreamBuilder *builder) {
+    new(builder) AudioStreamBuilder(); // call constructor on preallocated data buffer
+  }
+
+  void AudioStreamBuilder_delete(AudioStreamBuilder *builder) {
+    builder->~AudioStreamBuilder(); // call destructor directly to avoid free data
+  }
+
+  AudioApi AudioStreamBuilder_getAudioApi(const AudioStreamBuilder *builder) {
+    return builder->getAudioApi();
+  }
+
+  void AudioStreamBuilder_setAudioApi(AudioStreamBuilder *builder, AudioApi api) {
+    builder->setAudioApi(api);
+  }
+
+  /// Takes ownership of context (drop_context will be called to free it).
+  void AudioStreamBuilder_setCallback(AudioStreamBuilder *builder,
+                                      void *context,
+                                      const DropContextHandler drop_context,
+                                      const AudioReadyHandler audio_ready,
+                                      const ErrorCloseHandler before_close,
+                                      const ErrorCloseHandler after_close) {
+    auto s = std::make_shared<AudioStreamCallbackWrapper>(
+        context,
+        drop_context,
+        audio_ready,
+        before_close,
+        after_close);
+
+    builder->setDataCallback(s);
+    builder->setErrorCallback(s);
+  }
+
+  AudioStreamBase* AudioStreamBuilder_getBase(AudioStreamBuilder *builder) {
+    return static_cast<AudioStreamBase*>(builder);
+  }
+
+  Result AudioStreamBuilder_openStreamShared(AudioStreamBuilder *builder,
+                                             AudioStreamShared *sharedStream) {
+    new(sharedStream) std::shared_ptr<AudioStream>(); // call constructor on preallocated data buffer
+    return builder->openStream(*sharedStream);
+  }
+}

vendor/oboe-sys/oboe-ext/src/AudioStreamCallbackWrapper.cpp

@@ -0,0 +1,41 @@
+#include "oboe/OboeExt.h"
+
+#include <android/log.h>
+
+namespace oboe {
+  AudioStreamCallbackWrapper::
+  AudioStreamCallbackWrapper(void *context,
+                             const DropContextHandler drop_context,
+                             const AudioReadyHandler audio_ready,
+                             const ErrorCloseHandler before_close,
+                             const ErrorCloseHandler after_close):
+    _context(context),
+    _drop_context(drop_context),
+    _audio_ready(audio_ready),
+    _before_close(before_close),
+    _after_close(after_close) {}
+
+  AudioStreamCallbackWrapper
+   ::~AudioStreamCallbackWrapper() {
+     _drop_context(_context);
+  }
+
+  DataCallbackResult AudioStreamCallbackWrapper::
+  onAudioReady(AudioStream *oboeStream,
+               void *audioData,
+               int32_t numFrames) {
+    return _audio_ready(_context, oboeStream, audioData, numFrames);
+  }
+
+  void AudioStreamCallbackWrapper::
+  onErrorBeforeClose(AudioStream *oboeStream,
+                     Result error) {
+    _before_close(_context, oboeStream, error);
+  }
+
+  void AudioStreamCallbackWrapper::
+  onErrorAfterClose(AudioStream *oboeStream,
+                    Result error) {
+    _after_close(_context, oboeStream, error);
+  }
+}

vendor/oboe-sys/oboe-ext/src/AudioStreamWrapper.cpp

@@ -0,0 +1,99 @@
+#include "oboe/OboeExt.h"
+
+namespace oboe {
+  void AudioStreamShared_clone(const AudioStreamShared *sharedStream,
+                               AudioStreamShared *newSharedStream) {
+    *newSharedStream = *sharedStream; // initialize with copy constructor
+  }
+
+  void AudioStreamShared_delete(AudioStreamShared *sharedStream) {
+    sharedStream->~shared_ptr(); // call destructor directly
+  }
+
+  AudioStream *AudioStreamShared_deref(AudioStreamShared *sharedStream) {
+    return sharedStream->get();
+  }
+
+  Result AudioStream_open(AudioStream *oboeStream) {
+    return oboeStream->open();
+  }
+
+  Result AudioStream_close(AudioStream *oboeStream) {
+    return oboeStream->close();
+  }
+
+  Result AudioStream_requestStart(AudioStream *oboeStream) {
+    return oboeStream->requestStart();
+  }
+
+  Result AudioStream_requestPause(AudioStream *oboeStream) {
+    return oboeStream->requestPause();
+  }
+
+  Result AudioStream_requestFlush(AudioStream *oboeStream) {
+    return oboeStream->requestFlush();
+  }
+
+  Result AudioStream_requestStop(AudioStream *oboeStream) {
+    return oboeStream->requestStop();
+  }
+
+  StreamState AudioStream_getState(AudioStream *oboeStream) {
+    return oboeStream->getState();
+  }
+
+  Result AudioStream_waitForStateChange(AudioStream *oboeStream,
+                                        StreamState inputState,
+                                        StreamState *nextState,
+                                        int64_t timeoutNanoseconds) {
+    return oboeStream->waitForStateChange(inputState,
+                                          nextState,
+                                          timeoutNanoseconds);
+  }
+
+  ResultWithValue<int32_t>
+  AudioStream_setBufferSizeInFrames(AudioStream *oboeStream,
+                                    int32_t requestedFrames) {
+    return oboeStream->setBufferSizeInFrames(requestedFrames);
+  }
+
+  ResultWithValue<int32_t>
+  AudioStream_getXRunCount(AudioStream *oboeStream) {
+    return oboeStream->getXRunCount();
+  }
+
+  bool AudioStream_isXRunCountSupported(const AudioStream *oboeStream) {
+    return oboeStream->isXRunCountSupported();
+  }
+
+  int32_t AudioStream_getFramesPerBurst(AudioStream *oboeStream) {
+    return oboeStream->getFramesPerBurst();
+  }
+
+  ResultWithValue<double>
+  AudioStream_calculateLatencyMillis(AudioStream *oboeStream) {
+    return oboeStream->calculateLatencyMillis();
+  }
+
+  AudioApi AudioStream_getAudioApi(const AudioStream *oboeStream) {
+    return oboeStream->getAudioApi();
+  }
+
+  ResultWithValue<int32_t> AudioStream_read(AudioStream *oboeStream,
+                                            void* buffer,
+                                            int32_t numFrames,
+                                            int64_t timeoutNanoseconds) {
+    return oboeStream->read(buffer, numFrames, timeoutNanoseconds);
+  }
+
+  ResultWithValue<int32_t> AudioStream_write(AudioStream *oboeStream,
+                                             const void* buffer,
+                                             int32_t numFrames,
+                                             int64_t timeoutNanoseconds) {
+    return oboeStream->write(buffer, numFrames, timeoutNanoseconds);
+  }
+
+  AudioStreamBase* AudioStream_getBase(AudioStream *oboeStream) {
+    return static_cast<AudioStreamBase*>(oboeStream);
+  }
+}