AudioSinkWrapper.h

Enable keyboard shortcuts

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

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* 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 AudioSinkWrapper_h_

#define AudioSinkWrapper_h_

#include "mozilla/AbstractThread.h"

#include "mozilla/EventTargetCapability.h"

#include "mozilla/RefPtr.h"

#include "mozilla/TimeStamp.h"

#include "mozilla/UniquePtr.h"

#include "AudioSink.h"

#include "MediaSink.h"

namespace mozilla {

class MediaData;

template <class T>

class MediaQueue;

/**

 * A wrapper around AudioSink to provide the interface of MediaSink.

*/

class AudioSinkWrapper : public MediaSink {

  using PlaybackParams = AudioSink::PlaybackParams;

  using SinkCreator = std::function<UniquePtr<AudioSink>()>;

 public:

  AudioSinkWrapper(AbstractThread* aOwnerThread,

                   MediaQueue<AudioData>& aAudioQueue, SinkCreator aFunc,

                   double aVolume, double aPlaybackRate, bool aPreservesPitch,

                   RefPtr<AudioDeviceInfo> aAudioDevice)

      : mOwnerThread(aOwnerThread),

        mAsyncInitTaskQueue(CreateAsyncInitTaskQueue()),

        mSinkCreator(std::move(aFunc)),

        mAudioDevice(std::move(aAudioDevice)),

        mParams(aVolume, aPlaybackRate, aPreservesPitch),

        mAudioQueue(aAudioQueue),

        mRetrySinkTime(TimeStamp::Now()) {

    MOZ_ASSERT(mAsyncInitTaskQueue);

  RefPtr<EndedPromise> OnEnded(TrackType aType) override;

  media::TimeUnit GetEndTime(TrackType aType) const override;

  media::TimeUnit GetPosition(TimeStamp* aTimeStamp = nullptr) override;

  bool HasUnplayedFrames(TrackType aType) const override;

  media::TimeUnit UnplayedDuration(TrackType aType) const override;

  void DropAudioPacketsIfNeeded(const media::TimeUnit& aMediaPosition);

  void SetVolume(double aVolume) override;

  void SetStreamName(const nsAString& aStreamName) override;

  void SetPlaybackRate(double aPlaybackRate) override;

  void SetPreservesPitch(bool aPreservesPitch) override;

  void SetPlaying(bool aPlaying) override;

  RefPtr<GenericPromise> SetAudioDevice(

      RefPtr<AudioDeviceInfo> aDevice) override;

  double PlaybackRate() const override;

  nsresult Start(const media::TimeUnit& aStartTime,

                 const MediaInfo& aInfo) override;

  void Stop() override;

  bool IsStarted() const override;

  bool IsPlaying() const override;

  void Shutdown() override;

  void GetDebugInfo(dom::MediaSinkDebugInfo& aInfo) override;

 private:

  // The clock that was in use for the previous position query, allowing to

  // detect clock switches.

  enum class ClockSource {

    // The clock comes from an underlying system-level audio stream.

    AudioStream,

    // The clock comes from the system clock.

    SystemClock,

    // The stream is paused, a constant time is reported.

    Paused

  } mLastClockSource = ClockSource::Paused;

  static already_AddRefed<TaskQueue> CreateAsyncInitTaskQueue();

  bool IsMuted() const;

  void OnMuted(bool aMuted);

  virtual ~AudioSinkWrapper();

  void AssertOwnerThread() const MOZ_ASSERT_CAPABILITY(mOwnerThread) {

    mOwnerThread.AssertOnCurrentThread();

  bool NeedAudioSink();

  void StartAudioSink(UniquePtr<AudioSink> aAudioSink,

                      const media::TimeUnit& aStartTime);

  void ShutDownAudioSink();

  // Create and start mAudioSink.

  // An AudioSink can be started synchronously from the MDSM thread, or

  // asynchronously.

  // In synchronous mode, the clock doesn't advance until the sink has been

  // created, initialized and started. This is useful for the initial startup,

  // and when seeking.

  // In asynchronous mode, the clock will keep going forward (using the system

  // clock) until the AudioSink is started, at which point the clock will use

  // the AudioSink clock. This is used when unmuting a media element or

  // switching audio output devices. The promise is resolved when the

  // previous device is no longer in use and an attempt to open the new device

  // completes (successfully or not) or is deemed unnecessary because the

  // device is not required for output at this time.

  nsresult SyncCreateAudioSink(const media::TimeUnit& aStartTime);

  RefPtr<GenericPromise> MaybeAsyncCreateAudioSink(

      RefPtr<AudioDeviceInfo> aDevice);

  void ScheduleRetrySink();

  // Get the current media position using the system clock. This is used when

  // the audio is muted, or when the media has no audio track. Otherwise, the

  // media's position is based on the clock of the AudioStream.

  media::TimeUnit GetSystemClockPosition(TimeStamp aNow) const;

  bool CheckIfEnded() const;

  void OnAudioEnded(const EndedPromise::ResolveOrRejectValue& aValue);

  bool IsAudioSourceEnded(const MediaInfo& aInfo) const;

  const EventTargetCapability<AbstractThread> mOwnerThread;

  const RefPtr<TaskQueue> mAsyncInitTaskQueue;

  SinkCreator mSinkCreator;

  UniquePtr<AudioSink> mAudioSink;

  // The output device this AudioSink is playing data to. The system's default

  // device is used if this is null.

  RefPtr<AudioDeviceInfo> mAudioDevice;

  // Will only exist when media has an audio track.

  RefPtr<EndedPromise> mEndedPromise;

  MozPromiseHolder<EndedPromise> mEndedPromiseHolder;

  // true between Start() and Stop()

  bool mIsStarted = false;

  PlaybackParams MOZ_GUARDED_BY(mOwnerThread) mParams;

  // mClockStartTime is null before Start(), after Stop(), and between

  // SetPlaying(false) and SetPlaying(true).  When the system time is used for

  // the clock, this is the time corresponding to mPositionAtClockStart.  When

  // an AudioStream is used for the clock, non-null values don't have specific

  // meaning beyond indicating that the clock is advancing.

  TimeStamp mClockStartTime;

  // The media position at the clock datum.  If the clock is not advancing,

  // then this is the media position from which to resume playback.  The value

  // is Invalid() before Start() to facilitate debug.

  media::TimeUnit mPositionAtClockStart = media::TimeUnit::Invalid();

  // End time of last packet played or dropped.

  // Only up-to-date when there is no AudioSink.

  media::TimeUnit mLastPacketEndTime;

  bool mAudioEnded = true;

  // mAudioSinkEndedRequest is connected when and only when mAudioSink is set

  // and not ended.

  MozPromiseRequestHolder<EndedPromise> mAudioSinkEndedRequest;

  MediaQueue<AudioData>& mAudioQueue;

  // Time when next to re-try AudioSink creation.

  // Set to a useful value only when another sink is needed.  At other times

  // it needs to be non-null for a comparison where the result will be

  // irrelevant.

  // This is checked in GetPosition() which is triggered periodically during

  // playback by MediaDecoderStateMachine::UpdatePlaybackPositionPeriodically()

  TimeStamp mRetrySinkTime;

  // Number of async AudioSink creation tasks in flight

  uint32_t mAsyncCreateCount = 0;

};

}  // namespace mozilla

#endif  // AudioSinkWrapper_h_