MockCubeb.h - mozsearch

mozilla-central/dom/media/gtest/MockCubeb.h (file symbol)

Enable keyboard shortcuts

Source code

Revision control

Copy as Markdown

Other Tools

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this file,

 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef MOCKCUBEB_H_

#define MOCKCUBEB_H_

#include "AudioDeviceInfo.h"

#include "AudioGenerator.h"

#include "AudioVerifier.h"

#include "MediaEventSource.h"

#include "mozilla/DataMutex.h"

#include "mozilla/MozPromise.h"

#include "mozilla/Result.h"

#include "mozilla/ResultVariant.h"

#include "mozilla/ThreadSafeWeakPtr.h"

#include "nsTArray.h"

#include <thread>

#include <atomic>

#include <chrono>

#include <utility>

namespace mozilla {

const uint32_t MAX_OUTPUT_CHANNELS = 2;

const uint32_t MAX_INPUT_CHANNELS = 2;

struct cubeb_ops {

  int (*init)(cubeb** context, char const* context_name);

  char const* (*get_backend_id)(cubeb* context);

  int (*get_max_channel_count)(cubeb* context, uint32_t* max_channels);

  int (*get_min_latency)(cubeb* context, cubeb_stream_params params,

                         uint32_t* latency_ms);

  int (*get_preferred_sample_rate)(cubeb* context, uint32_t* rate);

  int (*get_supported_input_processing_params)(

      cubeb* context, cubeb_input_processing_params* params);

  int (*enumerate_devices)(cubeb* context, cubeb_device_type type,

                           cubeb_device_collection* collection);

  int (*device_collection_destroy)(cubeb* context,

                                   cubeb_device_collection* collection);

  void (*destroy)(cubeb* context);

  int (*stream_init)(cubeb* context, cubeb_stream** stream,

                     char const* stream_name, cubeb_devid input_device,

                     cubeb_stream_params* input_stream_params,

                     cubeb_devid output_device,

                     cubeb_stream_params* output_stream_params,

                     unsigned int latency, cubeb_data_callback data_callback,

                     cubeb_state_callback state_callback, void* user_ptr);

  void (*stream_destroy)(cubeb_stream* stream);

  int (*stream_start)(cubeb_stream* stream);

  int (*stream_stop)(cubeb_stream* stream);

  int (*stream_get_position)(cubeb_stream* stream, uint64_t* position);

  int (*stream_get_latency)(cubeb_stream* stream, uint32_t* latency);

  int (*stream_get_input_latency)(cubeb_stream* stream, uint32_t* latency);

  int (*stream_set_volume)(cubeb_stream* stream, float volumes);

  int (*stream_set_name)(cubeb_stream* stream, char const* stream_name);

  int (*stream_get_current_device)(cubeb_stream* stream,

                                   cubeb_device** const device);

  int (*stream_set_input_mute)(cubeb_stream* stream, int mute);

  int (*stream_set_input_processing_params)(

      cubeb_stream* stream, cubeb_input_processing_params params);

  int (*stream_device_destroy)(cubeb_stream* stream, cubeb_device* device);

  int (*stream_register_device_changed_callback)(

      cubeb_stream* stream,

      cubeb_device_changed_callback device_changed_callback);

  int (*register_device_collection_changed)(

      cubeb* context, cubeb_device_type devtype,

      cubeb_device_collection_changed_callback callback, void* user_ptr);

};

// Keep those and the struct definition in sync with cubeb.h and

// cubeb-internal.h

void cubeb_mock_destroy(cubeb* context);

static int cubeb_mock_get_supported_input_processing_params(

    cubeb* context, cubeb_input_processing_params* params);

static int cubeb_mock_enumerate_devices(cubeb* context, cubeb_device_type type,

                                        cubeb_device_collection* out);

static int cubeb_mock_device_collection_destroy(

    cubeb* context, cubeb_device_collection* collection);

static int cubeb_mock_register_device_collection_changed(

    cubeb* context, cubeb_device_type devtype,

    cubeb_device_collection_changed_callback callback, void* user_ptr);

static int cubeb_mock_stream_init(

    cubeb* context, cubeb_stream** stream, char const* stream_name,

    cubeb_devid input_device, cubeb_stream_params* input_stream_params,

    cubeb_devid output_device, cubeb_stream_params* output_stream_params,

    unsigned int latency, cubeb_data_callback data_callback,

    cubeb_state_callback state_callback, void* user_ptr);

static int cubeb_mock_stream_start(cubeb_stream* stream);

static int cubeb_mock_stream_stop(cubeb_stream* stream);

static int cubeb_mock_stream_get_position(cubeb_stream* stream,

                                          uint64_t* position);

static void cubeb_mock_stream_destroy(cubeb_stream* stream);

static char const* cubeb_mock_get_backend_id(cubeb* context);

static int cubeb_mock_stream_set_volume(cubeb_stream* stream, float volume);

static int cubeb_mock_stream_set_name(cubeb_stream* stream,

                                      char const* stream_name);

static int cubeb_mock_stream_set_input_processing_params(

    cubeb_stream* stream, cubeb_input_processing_params);

static int cubeb_mock_stream_register_device_changed_callback(

    cubeb_stream* stream,

    cubeb_device_changed_callback device_changed_callback);

static int cubeb_mock_get_min_latency(cubeb* context,

                                      cubeb_stream_params params,

                                      uint32_t* latency_ms);

static int cubeb_mock_get_preferred_sample_rate(cubeb* context, uint32_t* rate);

static int cubeb_mock_get_max_channel_count(cubeb* context,

                                            uint32_t* max_channels);

// Mock cubeb impl, only supports device enumeration for now.

cubeb_ops const mock_ops = {

    /*.init =*/NULL,

    /*.get_backend_id =*/cubeb_mock_get_backend_id,

    /*.get_max_channel_count =*/cubeb_mock_get_max_channel_count,

    /*.get_min_latency =*/cubeb_mock_get_min_latency,

    /*.get_preferred_sample_rate =*/cubeb_mock_get_preferred_sample_rate,

    /*.get_supported_input_processing_params =*/

    cubeb_mock_get_supported_input_processing_params,

    /*.enumerate_devices =*/cubeb_mock_enumerate_devices,

    /*.device_collection_destroy =*/cubeb_mock_device_collection_destroy,

    /*.destroy =*/cubeb_mock_destroy,

    /*.stream_init =*/cubeb_mock_stream_init,

    /*.stream_destroy =*/cubeb_mock_stream_destroy,

    /*.stream_start =*/cubeb_mock_stream_start,

    /*.stream_stop =*/cubeb_mock_stream_stop,

    /*.stream_get_position =*/cubeb_mock_stream_get_position,

    /*.stream_get_latency =*/NULL,

    /*.stream_get_input_latency =*/NULL,

    /*.stream_set_volume =*/cubeb_mock_stream_set_volume,

    /*.stream_set_name =*/cubeb_mock_stream_set_name,

    /*.stream_get_current_device =*/NULL,

    /*.stream_set_input_mute =*/NULL,

    /*.stream_set_input_processing_params =*/

    cubeb_mock_stream_set_input_processing_params,

    /*.stream_device_destroy =*/NULL,

    /*.stream_register_device_changed_callback =*/

    cubeb_mock_stream_register_device_changed_callback,

    /*.register_device_collection_changed =*/

    cubeb_mock_register_device_collection_changed};

class SmartMockCubebStream;

// Represents the fake cubeb_stream. The context instance is needed to

// provide access on cubeb_ops struct.

class MockCubebStream {

  friend class MockCubeb;

  // These members need to have the exact same memory layout as a real

  // cubeb_stream, so that AsMock() returns a pointer to this that can be used

  // as a cubeb_stream.

  cubeb* context;

  void* mUserPtr;

 public:

  enum class KeepProcessing { No, Yes, InvalidState };

  enum class RunningMode { Automatic, Manual };

  MockCubebStream(cubeb* aContext, char const* aStreamName,

                  cubeb_devid aInputDevice,

                  cubeb_stream_params* aInputStreamParams,

                  cubeb_devid aOutputDevice,

                  cubeb_stream_params* aOutputStreamParams,

                  cubeb_data_callback aDataCallback,

                  cubeb_state_callback aStateCallback, void* aUserPtr,

                  SmartMockCubebStream* aSelf, RunningMode aRunningMode,

                  bool aFrozenStart);

  ~MockCubebStream();

  int Start() MOZ_EXCLUDES(mMutex);

  int Stop() MOZ_EXCLUDES(mMutex);

  uint64_t Position() MOZ_EXCLUDES(mMutex);

  void Destroy() MOZ_EXCLUDES(mMutex);

  int SetName(char const* aName) MOZ_EXCLUDES(mMutex);

  int RegisterDeviceChangedCallback(

      cubeb_device_changed_callback aDeviceChangedCallback)

      MOZ_EXCLUDES(mMutex);

  int SetInputProcessingParams(cubeb_input_processing_params aParams);

  cubeb_stream* AsCubebStream() MOZ_EXCLUDES(mMutex);

  static MockCubebStream* AsMock(cubeb_stream* aStream);

  char const* StreamName() const MOZ_EXCLUDES(mMutex) {

    MutexAutoLock l(mMutex);

    return mName.get();

  cubeb_devid GetInputDeviceID() const;

  cubeb_devid GetOutputDeviceID() const;

  uint32_t InputChannels() const MOZ_EXCLUDES(mMutex);

  uint32_t OutputChannels() const MOZ_EXCLUDES(mMutex);

  uint32_t SampleRate() const MOZ_EXCLUDES(mMutex);

  uint32_t InputFrequency() const MOZ_EXCLUDES(mMutex);

  Maybe<cubeb_state> State() const MOZ_EXCLUDES(mMutex);

  void SetDriftFactor(float aDriftFactor) MOZ_EXCLUDES(mMutex);

  void ForceError() MOZ_EXCLUDES(mMutex);

  void ForceDeviceChanged() MOZ_EXCLUDES(mMutex);

  void Thaw() MOZ_EXCLUDES(mMutex);

  // For RunningMode::Manual, drive this MockCubebStream forward.

  KeepProcessing ManualDataCallback(long aNrFrames) MOZ_EXCLUDES(mMutex);

  // For RunningMode::Manual, notify the client of a DeviceChanged event

  // synchronously.

  void NotifyDeviceChangedNow() MOZ_EXCLUDES(mMutex);

  // Enable input recording for this driver. This is best called before

  // the thread is running, but is safe to call whenever.

  void SetOutputRecordingEnabled(bool aEnabled) MOZ_EXCLUDES(mMutex);

  // Enable input recording for this driver. This is best called before

  // the thread is running, but is safe to call whenever.

  void SetInputRecordingEnabled(bool aEnabled) MOZ_EXCLUDES(mMutex);

  // Get the recorded output from this stream. This doesn't copy, and therefore

  // only works once.

  nsTArray<AudioDataValue>&& TakeRecordedOutput() MOZ_EXCLUDES(mMutex);

  // Get the recorded input from this stream. This doesn't copy, and therefore

  // only works once.

  nsTArray<AudioDataValue>&& TakeRecordedInput() MOZ_EXCLUDES(mMutex);

  MediaEventSource<nsCString>& NameSetEvent();

  MediaEventSource<cubeb_state>& StateEvent();

  MediaEventSource<uint32_t>& FramesProcessedEvent();

  // Notified when frames are processed after first non-silent output

  MediaEventSource<uint32_t>& FramesVerifiedEvent();

  // Notified when the stream is Stop()ed

  MediaEventSource<std::tuple<uint64_t, float, uint32_t>>&

  OutputVerificationEvent();

  MediaEventSource<void>& ErrorForcedEvent();

  MediaEventSource<void>& DeviceChangeForcedEvent();

 private:

  cubeb_stream* AsCubebStreamLocked() MOZ_REQUIRES(mMutex);

  static MockCubebStream* AsMockLocked(cubeb_stream* aStream);

  uint32_t InputChannelsLocked() const MOZ_REQUIRES(mMutex);

  uint32_t OutputChannelsLocked() const MOZ_REQUIRES(mMutex);

  uint32_t SampleRateLocked() const MOZ_REQUIRES(mMutex);

  uint32_t InputFrequencyLocked() const MOZ_REQUIRES(mMutex);

  KeepProcessing Process(long aNrFrames) MOZ_REQUIRES(mMutex);

  KeepProcessing Process10Ms();

 public:

  const RunningMode mRunningMode;

  const bool mHasInput;

  const bool mHasOutput;

  SmartMockCubebStream* const mSelf;

 private:

  void NotifyState(cubeb_state aState) MOZ_REQUIRES(mMutex);

  void NotifyDeviceChanged() MOZ_EXCLUDES(mMutex);

  static constexpr long kMaxNrFrames = 1920;

  // Mutex guarding most members to ensure state is in sync.

  mutable Mutex mMutex{"MockCubebStream::mMutex"};

  // Monitor used to block start until mFrozenStart is false.

  Monitor mFrozenStartMonitor MOZ_ACQUIRED_BEFORE(mMutex);

  // Whether this stream should wait for an explicit start request before

  // starting.

  bool mFrozenStart MOZ_GUARDED_BY(mFrozenStartMonitor);

  // The stream's most recently issued state change, if any has occurred.

  // Used to abort a frozen start if cubeb_stream_start() is called currently

  // with a blocked cubeb_stream_start() call.

  Maybe<cubeb_state> mState MOZ_GUARDED_BY(mMutex);

  // Whether or not the output-side of this stream (what is written from the

  // callback output buffer) is recorded in an internal buffer. The data is then

  // available via `GetRecordedOutput`.

  bool mOutputRecordingEnabled MOZ_GUARDED_BY(mMutex) = false;

  // Whether or not the input-side of this stream (what is written from the

  // callback input buffer) is recorded in an internal buffer. The data is then

  // available via `TakeRecordedInput`.

  bool mInputRecordingEnabled MOZ_GUARDED_BY(mMutex) = false;

  // The audio buffer used on data callback.

  AudioDataValue mOutputBuffer[MAX_OUTPUT_CHANNELS *

                               kMaxNrFrames] MOZ_GUARDED_BY(mMutex) = {};

  AudioDataValue mInputBuffer[MAX_INPUT_CHANNELS * kMaxNrFrames] MOZ_GUARDED_BY(

      mMutex) = {};

  // The audio callback

  const cubeb_data_callback mDataCallback = nullptr;

  // The stream state callback

  const cubeb_state_callback mStateCallback = nullptr;

  // The device changed callback

  cubeb_device_changed_callback mDeviceChangedCallback MOZ_GUARDED_BY(mMutex) =

      nullptr;

  // A name for this stream

  nsCString mName MOZ_GUARDED_BY(mMutex);

  // The stream params

  cubeb_stream_params mOutputParams MOZ_GUARDED_BY(mMutex) = {};

  cubeb_stream_params mInputParams MOZ_GUARDED_BY(mMutex) = {};

  /* Device IDs */

  const cubeb_devid mInputDeviceID;

  const cubeb_devid mOutputDeviceID;

  float mDriftFactor MOZ_GUARDED_BY(mMutex) = 1.0;

  bool mFastMode MOZ_GUARDED_BY(mMutex) = false;

  bool mForceErrorState MOZ_GUARDED_BY(mMutex) = false;

  bool mForceDeviceChanged MOZ_GUARDED_BY(mMutex) = false;

  bool mDestroyed MOZ_GUARDED_BY(mMutex) = false;

  uint64_t mPosition MOZ_GUARDED_BY(mMutex) = 0;

  AudioGenerator<AudioDataValue> mAudioGenerator MOZ_GUARDED_BY(mMutex);

  AudioVerifier<AudioDataValue> mAudioVerifier MOZ_GUARDED_BY(mMutex);

  MediaEventProducer<nsCString> mNameSetEvent;

  MediaEventProducer<cubeb_state> mStateEvent;

  MediaEventProducer<uint32_t> mFramesProcessedEvent;

  MediaEventProducer<uint32_t> mFramesVerifiedEvent;

  MediaEventProducer<std::tuple<uint64_t, float, uint32_t>>

      mOutputVerificationEvent;

  MediaEventProducer<void> mErrorForcedEvent;

  MediaEventProducer<void> mDeviceChangedForcedEvent;

  // The recorded data, copied from the output_buffer of the callback.

  // Interleaved.

  nsTArray<AudioDataValue> mRecordedOutput MOZ_GUARDED_BY(mMutex);

  // The recorded data, copied from the input buffer of the callback.

  // Interleaved.

  nsTArray<AudioDataValue> mRecordedInput MOZ_GUARDED_BY(mMutex);

};

inline std::ostream& operator<<(std::ostream& aStream,

                                const MockCubebStream::KeepProcessing& aVal) {

  switch (aVal) {

    case MockCubebStream::KeepProcessing::Yes:

      aStream << "KeepProcessing::Yes";

      return aStream;

    case MockCubebStream::KeepProcessing::No:

      aStream << "KeepProcessing::No";

      return aStream;

    case MockCubebStream::KeepProcessing::InvalidState:

      aStream << "KeepProcessing::InvalidState";

      return aStream;

  aStream << "KeepProcessing(invalid " << static_cast<uint32_t>(aVal) << ")";

  return aStream;

class SmartMockCubebStream

    : public MockCubebStream,

      public SupportsThreadSafeWeakPtr<SmartMockCubebStream> {

 public:

  MOZ_DECLARE_REFCOUNTED_TYPENAME(SmartMockCubebStream)

  SmartMockCubebStream(cubeb* aContext, char const* aStreamName,

                       cubeb_devid aInputDevice,

                       cubeb_stream_params* aInputStreamParams,

                       cubeb_devid aOutputDevice,

                       cubeb_stream_params* aOutputStreamParams,

                       cubeb_data_callback aDataCallback,

                       cubeb_state_callback aStateCallback, void* aUserPtr,

                       RunningMode aRunningMode, bool aFrozenStart)

      : MockCubebStream(aContext, aStreamName, aInputDevice, aInputStreamParams,

                        aOutputDevice, aOutputStreamParams, aDataCallback,

                        aStateCallback, aUserPtr, this, aRunningMode,

                        aFrozenStart) {}

};

// This class has two facets: it is both a fake cubeb backend that is intended

// to be used for testing, and passed to Gecko code that expects a normal

// backend, but is also controllable by the test code to decide what the backend

// should do, depending on what is being tested.

class MockCubeb {

  // This needs to have the exact same memory layout as a real cubeb backend.

  // It's very important for the `ops` member to be the very first member of

  // the class, and for MockCubeb to not have any virtual members (to avoid

  // having a vtable), so that AsMock() returns a pointer to this that can be

  // used as a cubeb backend.

  const cubeb_ops* ops;

  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MockCubeb);

 public:

  using RunningMode = MockCubebStream::RunningMode;

  MockCubeb();

  explicit MockCubeb(RunningMode aRunningMode);

  // Cubeb backend implementation

  // This allows passing this class as a cubeb* instance.

  // cubeb_destroy(context) should eventually be called on the return value

  // iff this method is called.

  cubeb* AsCubebContext();

  static MockCubeb* AsMock(cubeb* aContext);

  void Destroy();

  // Fill in the collection parameter with all devices of aType.

  int EnumerateDevices(cubeb_device_type aType,

                       cubeb_device_collection* aCollection);

  // Clear the collection parameter and deallocate its related memory space.

  int DestroyDeviceCollection(cubeb_device_collection* aCollection);

  // For a given device type, add a callback, called with a user pointer, when

  // the device collection for this backend changes (i.e. a device has been

  // removed or added).

  int RegisterDeviceCollectionChangeCallback(

      cubeb_device_type aDevType,

      cubeb_device_collection_changed_callback aCallback, void* aUserPtr);

  Result<cubeb_input_processing_params, int> SupportedInputProcessingParams()

      const;

  void SetSupportedInputProcessingParams(cubeb_input_processing_params aParams,

                                         int aRv);

  // Set the rv to be returned when SetInputProcessingParams for any stream of

  // this context would apply the params to the stream, i.e. after passing the

  // supported-params check.

  void SetInputProcessingApplyRv(int aRv);

  int InputProcessingApplyRv() const;

  // Control API

  // Add an input or output device to this backend. This calls the device

  // collection invalidation callback if needed.

  void AddDevice(cubeb_device_info aDevice);

  // Remove a specific input or output device to this backend, returns true if

  // a device was removed. This calls the device collection invalidation

  // callback if needed.

  bool RemoveDevice(cubeb_devid aId);

  // Remove all input or output devices from this backend, without calling the

  // callback. This is meant to clean up in between tests.

  void ClearDevices(cubeb_device_type aType);

  // This allows simulating a backend that does not support setting a device

  // collection invalidation callback, to be able to test the fallback path.

  void SetSupportDeviceChangeCallback(bool aSupports);

  // This causes the next stream init with this context to return failure;

  void ForceStreamInitError();

  // Makes MockCubebStreams starting after this point wait for AllowStart().

  // Callers must ensure they get a hold of the stream through StreamInitEvent

  // to be able to start them.

  void SetStreamStartFreezeEnabled(bool aEnabled);

  // Helper class that automatically unforces a forced audio thread on release.

  class AudioThreadAutoUnforcer {

    NS_INLINE_DECL_THREADSAFE_REFCOUNTING(AudioThreadAutoUnforcer)

   public:

    explicit AudioThreadAutoUnforcer(MockCubeb* aContext)

        : mContext(aContext) {}

   protected:

    virtual ~AudioThreadAutoUnforcer() { mContext->UnforceAudioThread(); }

    MockCubeb* mContext;

};

  // Creates the audio thread if one is not available. The audio thread remains

  // forced until UnforceAudioThread is called. The returned promise is resolved

  // when the audio thread is running. With this, a test can ensure starting

  // audio streams is deterministically fast across platforms for more accurate

  // results.

  using ForcedAudioThreadPromise =

      MozPromise<RefPtr<AudioThreadAutoUnforcer>, nsresult, false>;

  RefPtr<ForcedAudioThreadPromise> ForceAudioThread();

  // Allows a forced audio thread to stop.

  void UnforceAudioThread();

  int StreamInit(cubeb* aContext, cubeb_stream** aStream,

                 char const* aStreamName, cubeb_devid aInputDevice,

                 cubeb_stream_params* aInputStreamParams,

                 cubeb_devid aOutputDevice,

                 cubeb_stream_params* aOutputStreamParams,

                 cubeb_data_callback aDataCallback,

                 cubeb_state_callback aStateCallback, void* aUserPtr);

  void StreamDestroy(MockCubebStream* aStream);

  void GoFaster();

  void DontGoFaster();

  MediaEventSource<RefPtr<SmartMockCubebStream>>& StreamInitEvent();

  MediaEventSource<RefPtr<SmartMockCubebStream>>& StreamDestroyEvent();

  // MockCubeb specific API

  void StartStream(MockCubebStream* aStream);

  void StopStream(MockCubebStream* aStream);

  // Simulates the audio thread. The thread is created at Start and destroyed

  // at Stop. At next StreamStart a new thread is created.

  static void ThreadFunction_s(MockCubeb* aContext) {

    aContext->ThreadFunction();

  void ThreadFunction();

 private:

  ~MockCubeb();

  // The callback to call when the device list has been changed.

  cubeb_device_collection_changed_callback

      mInputDeviceCollectionChangeCallback = nullptr;

  cubeb_device_collection_changed_callback

      mOutputDeviceCollectionChangeCallback = nullptr;

  // The pointer to pass in the callback.

  void* mInputDeviceCollectionChangeUserPtr = nullptr;

  void* mOutputDeviceCollectionChangeUserPtr = nullptr;

  void* mUserPtr = nullptr;

  // Whether or not this backend supports device collection change

  // notification via a system callback. If not, Gecko is expected to re-query

  // the list every time.

  bool mSupportsDeviceCollectionChangedCallback = true;

  std::pair<cubeb_input_processing_params, int>

      mSupportedInputProcessingParams = std::make_pair(

          CUBEB_INPUT_PROCESSING_PARAM_NONE, CUBEB_ERROR_NOT_SUPPORTED);

  int mInputProcessingParamsApplyRv = CUBEB_OK;

  const RunningMode mRunningMode;

  Atomic<bool> mStreamInitErrorState;

  // Whether new MockCubebStreams should be frozen on start.

  Atomic<bool> mStreamStartFreezeEnabled{false};

  // Whether the audio thread is forced, i.e., whether it remains active even

  // with no live streams.

  Atomic<bool> mForcedAudioThread{false};

  Atomic<bool> mHasCubebContext{false};

  Atomic<bool> mDestroyed{false};

  MozPromiseHolder<ForcedAudioThreadPromise> mForcedAudioThreadPromise;

  // Our input and output devices.

  nsTArray<cubeb_device_info> mInputDevices;

  nsTArray<cubeb_device_info> mOutputDevices;

  // The streams that are currently running.

  DataMutex<nsTArray<RefPtr<SmartMockCubebStream>>> mLiveStreams{

      "MockCubeb::mLiveStreams"};

  // Thread that simulates the audio thread, shared across MockCubebStreams to

  // avoid unintended drift. This is set together with mLiveStreams, under the

  // mLiveStreams DataMutex.

  UniquePtr<std::thread> mFakeAudioThread;

  // Whether to run the fake audio thread in fast mode, not caring about wall

  // clock time. false is default and means data is processed every 10ms. When

  // true we sleep(0) between iterations instead of 10ms.

  std::atomic<bool> mFastMode{false};

  MediaEventProducer<RefPtr<SmartMockCubebStream>> mStreamInitEvent;

  MediaEventProducer<RefPtr<SmartMockCubebStream>> mStreamDestroyEvent;

};

int cubeb_mock_enumerate_devices(cubeb* context, cubeb_device_type type,

                                 cubeb_device_collection* out) {

  return MockCubeb::AsMock(context)->EnumerateDevices(type, out);

int cubeb_mock_device_collection_destroy(cubeb* context,

                                         cubeb_device_collection* collection) {

  return MockCubeb::AsMock(context)->DestroyDeviceCollection(collection);

int cubeb_mock_register_device_collection_changed(

    cubeb* context, cubeb_device_type devtype,

    cubeb_device_collection_changed_callback callback, void* user_ptr) {

  return MockCubeb::AsMock(context)->RegisterDeviceCollectionChangeCallback(

      devtype, callback, user_ptr);

int cubeb_mock_get_supported_input_processing_params(

    cubeb* context, cubeb_input_processing_params* params) {

  Result<cubeb_input_processing_params, int> res =

      MockCubeb::AsMock(context)->SupportedInputProcessingParams();

  if (res.isErr()) {

    *params = CUBEB_INPUT_PROCESSING_PARAM_NONE;

    return res.unwrapErr();

  *params = res.unwrap();

  return CUBEB_OK;

int cubeb_mock_stream_init(

    cubeb* context, cubeb_stream** stream, char const* stream_name,

    cubeb_devid input_device, cubeb_stream_params* input_stream_params,

    cubeb_devid output_device, cubeb_stream_params* output_stream_params,

    unsigned int latency, cubeb_data_callback data_callback,

    cubeb_state_callback state_callback, void* user_ptr) {

  return MockCubeb::AsMock(context)->StreamInit(

      context, stream, stream_name, input_device, input_stream_params,

      output_device, output_stream_params, data_callback, state_callback,

      user_ptr);

int cubeb_mock_stream_start(cubeb_stream* stream) {

  return MockCubebStream::AsMock(stream)->Start();

int cubeb_mock_stream_stop(cubeb_stream* stream) {

  return MockCubebStream::AsMock(stream)->Stop();

int cubeb_mock_stream_get_position(cubeb_stream* stream, uint64_t* position) {

  *position = MockCubebStream::AsMock(stream)->Position();

  return CUBEB_OK;

void cubeb_mock_stream_destroy(cubeb_stream* stream) {

  MockCubebStream::AsMock(stream)->Destroy();

static char const* cubeb_mock_get_backend_id(cubeb* context) {

#if defined(XP_MACOSX)

  return "audiounit";

#elif defined(XP_WIN)

  return "wasapi";

#elif defined(ANDROID)

  return "opensl";

#elif defined(__OpenBSD__)

  return "sndio";

#else

  return "pulse";

#endif

static int cubeb_mock_stream_set_volume(cubeb_stream* stream, float volume) {

  return CUBEB_OK;

static int cubeb_mock_stream_set_name(cubeb_stream* stream,

                                      char const* stream_name) {

  return MockCubebStream::AsMock(stream)->SetName(stream_name);

  return CUBEB_OK;

int cubeb_mock_stream_register_device_changed_callback(

    cubeb_stream* stream,

    cubeb_device_changed_callback device_changed_callback) {

  return MockCubebStream::AsMock(stream)->RegisterDeviceChangedCallback(

      device_changed_callback);

static int cubeb_mock_stream_set_input_processing_params(

    cubeb_stream* stream, cubeb_input_processing_params params) {

  return MockCubebStream::AsMock(stream)->SetInputProcessingParams(params);

int cubeb_mock_get_min_latency(cubeb* context, cubeb_stream_params params,

                               uint32_t* latency_ms) {

  *latency_ms = 10;

  return CUBEB_OK;

int cubeb_mock_get_preferred_sample_rate(cubeb* context, uint32_t* rate) {

  *rate = 44100;

  return CUBEB_OK;

int cubeb_mock_get_max_channel_count(cubeb* context, uint32_t* max_channels) {

  *max_channels = MAX_OUTPUT_CHANNELS;

  return CUBEB_OK;

void PrintDevice(cubeb_device_info aInfo);

void PrintDevice(AudioDeviceInfo* aInfo);

cubeb_device_info DeviceTemplate(cubeb_devid aId, cubeb_device_type aType,

                                 const char* name);

cubeb_device_info DeviceTemplate(cubeb_devid aId, cubeb_device_type aType);

void AddDevices(MockCubeb* mock, uint32_t device_count,

                cubeb_device_type deviceType);

}  // namespace mozilla

#endif  // MOCKCUBEB_H_