Backed out changeset f594e6f00208 (bug 1940883) for causing crashes in bug 1941164.

[gecko.git] / dom / media / MediaDecoderStateMachine.cpp

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* 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/. */

#include "MediaDecoderStateMachine.h"

#include <algorithm>
#include <stdint.h>
#include <utility>

#include "AudioSegment.h"
#include "DOMMediaStream.h"
#include "ImageContainer.h"
#include "MediaDecoder.h"
#include "MediaShutdownManager.h"
#include "MediaTimer.h"
#include "MediaTrackGraph.h"
#include "PerformanceRecorder.h"
#include "ReaderProxy.h"
#include "TimeUnits.h"
#include "VideoSegment.h"
#include "VideoUtils.h"
#include "mediasink/AudioSink.h"
#include "mediasink/AudioSinkWrapper.h"
#include "mediasink/DecodedStream.h"
#include "mediasink/VideoSink.h"
#include "mozilla/Logging.h"
#include "mozilla/MathAlgorithms.h"
#include "mozilla/NotNull.h"
#include "mozilla/Preferences.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/ProfilerMarkerTypes.h"
#include "mozilla/ProfilerMarkers.h"
#include "mozilla/SharedThreadPool.h"
#include "mozilla/Sprintf.h"
#include "mozilla/StaticPrefs_media.h"
#include "mozilla/TaskQueue.h"
#include "mozilla/Telemetry.h"
#include "nsIMemoryReporter.h"
#include "nsPrintfCString.h"
#include "nsTArray.h"

namespace mozilla {

using namespace mozilla::media;

#define NS_DispatchToMainThread(...) \
  CompileError_UseAbstractThreadDispatchInstead

// avoid redefined macro in unified build
#undef FMT
#undef LOG
#undef LOGV
#undef LOGW
#undef LOGE
#undef SFMT
#undef SLOG
#undef SLOGW
#undef SLOGE

#define FMT(x, ...) "Decoder=%p " x, mDecoderID, ##__VA_ARGS__
#define LOG(x, ...)                                                         \
  DDMOZ_LOG(gMediaDecoderLog, LogLevel::Debug, "Decoder=%p " x, mDecoderID, \
            ##__VA_ARGS__)
#define LOGV(x, ...)                                                          \
  DDMOZ_LOG(gMediaDecoderLog, LogLevel::Verbose, "Decoder=%p " x, mDecoderID, \
            ##__VA_ARGS__)
#define LOGW(x, ...) NS_WARNING(nsPrintfCString(FMT(x, ##__VA_ARGS__)).get())
#define LOGE(x, ...)                                                   \
  NS_DebugBreak(NS_DEBUG_WARNING,                                      \
                nsPrintfCString(FMT(x, ##__VA_ARGS__)).get(), nullptr, \
                __FILE__, __LINE__)

// Used by StateObject and its sub-classes
#define SFMT(x, ...)                                                     \
  "Decoder=%p state=%s " x, mMaster->mDecoderID, ToStateStr(GetState()), \
      ##__VA_ARGS__
#define SLOG(x, ...)                                                     \
  DDMOZ_LOGEX(mMaster, gMediaDecoderLog, LogLevel::Debug, "state=%s " x, \
              ToStateStr(GetState()), ##__VA_ARGS__)
#define SLOGW(x, ...) NS_WARNING(nsPrintfCString(SFMT(x, ##__VA_ARGS__)).get())
#define SLOGE(x, ...)                                                   \
  NS_DebugBreak(NS_DEBUG_WARNING,                                       \
                nsPrintfCString(SFMT(x, ##__VA_ARGS__)).get(), nullptr, \
                __FILE__, __LINE__)

// Certain constants get stored as member variables and then adjusted by various
// scale factors on a per-decoder basis. We want to make sure to avoid using
// these constants directly, so we put them in a namespace.
namespace detail {

// Resume a suspended video decoder to the current playback position plus this
// time premium for compensating the seeking delay.
static constexpr auto RESUME_VIDEO_PREMIUM = TimeUnit::FromMicroseconds(125000);

static const int64_t AMPLE_AUDIO_USECS = 2000000;

// If more than this much decoded audio is queued, we'll hold off
// decoding more audio.
static constexpr auto AMPLE_AUDIO_THRESHOLD =
    TimeUnit::FromMicroseconds(AMPLE_AUDIO_USECS);

}  // namespace detail

// If we have fewer than LOW_VIDEO_FRAMES decoded frames, and
// we're not "prerolling video", we'll skip the video up to the next keyframe
// which is at or after the current playback position.
static const uint32_t LOW_VIDEO_FRAMES = 2;

// Arbitrary "frame duration" when playing only audio.
static const uint32_t AUDIO_DURATION_USECS = 40000;

namespace detail {

// If we have less than this much buffered data available, we'll consider
// ourselves to be running low on buffered data. We determine how much
// buffered data we have remaining using the reader's GetBuffered()
// implementation.
static const int64_t LOW_BUFFER_THRESHOLD_USECS = 5000000;

static constexpr auto LOW_BUFFER_THRESHOLD =
    TimeUnit::FromMicroseconds(LOW_BUFFER_THRESHOLD_USECS);

// LOW_BUFFER_THRESHOLD_USECS needs to be greater than AMPLE_AUDIO_USECS,
// otherwise the skip-to-keyframe logic can activate when we're running low on
// data.
static_assert(LOW_BUFFER_THRESHOLD_USECS > AMPLE_AUDIO_USECS,
              "LOW_BUFFER_THRESHOLD_USECS is too small");

}  // namespace detail

// Amount of excess data to add in to the "should we buffer" calculation.
static constexpr auto EXHAUSTED_DATA_MARGIN =
    TimeUnit::FromMicroseconds(100000);

static const uint32_t MIN_VIDEO_QUEUE_SIZE = 3;
static const uint32_t MAX_VIDEO_QUEUE_SIZE = 10;
#ifdef MOZ_APPLEMEDIA
static const uint32_t HW_VIDEO_QUEUE_SIZE = 10;
#else
static const uint32_t HW_VIDEO_QUEUE_SIZE = 3;
#endif
static const uint32_t VIDEO_QUEUE_SEND_TO_COMPOSITOR_SIZE = 9999;

static uint32_t sVideoQueueDefaultSize = MAX_VIDEO_QUEUE_SIZE;
static uint32_t sVideoQueueHWAccelSize = HW_VIDEO_QUEUE_SIZE;
static uint32_t sVideoQueueSendToCompositorSize =
    VIDEO_QUEUE_SEND_TO_COMPOSITOR_SIZE;

static void InitVideoQueuePrefs() {
  MOZ_ASSERT(NS_IsMainThread());
  static bool sPrefInit = false;
  if (!sPrefInit) {
    sPrefInit = true;
    sVideoQueueDefaultSize = Preferences::GetUint(
        "media.video-queue.default-size", MAX_VIDEO_QUEUE_SIZE);
    sVideoQueueHWAccelSize = Preferences::GetUint(
        "media.video-queue.hw-accel-size", HW_VIDEO_QUEUE_SIZE);
    sVideoQueueSendToCompositorSize =
        Preferences::GetUint("media.video-queue.send-to-compositor-size",
                             VIDEO_QUEUE_SEND_TO_COMPOSITOR_SIZE);
  }
}

template <typename Type, typename Function>
static void DiscardFramesFromTail(MediaQueue<Type>& aQueue,
                                  const Function&& aTest) {
  while (aQueue.GetSize()) {
    if (aTest(aQueue.PeekBack()->mTime.ToMicroseconds())) {
      RefPtr<Type> releaseMe = aQueue.PopBack();
      continue;
    }
    break;
  }
}

// Delay, in milliseconds, that tabs needs to be in background before video
// decoding is suspended.
static TimeDuration SuspendBackgroundVideoDelay() {
  return TimeDuration::FromMilliseconds(
      StaticPrefs::media_suspend_background_video_delay_ms());
}

class MediaDecoderStateMachine::StateObject {
 public:
  virtual ~StateObject() = default;
  virtual void Exit() {}  // Exit action.
  virtual void Step() {}  // Perform a 'cycle' of this state object.
  virtual State GetState() const = 0;

  // Event handlers for various events.
  virtual void HandleAudioCaptured() {}
  virtual void HandleAudioDecoded(AudioData* aAudio) {
    Crash("Unexpected event!", __func__);
  }
  virtual void HandleVideoDecoded(VideoData* aVideo) {
    Crash("Unexpected event!", __func__);
  }
  virtual void HandleAudioWaited(MediaData::Type aType) {
    Crash("Unexpected event!", __func__);
  }
  virtual void HandleVideoWaited(MediaData::Type aType) {
    Crash("Unexpected event!", __func__);
  }
  virtual void HandleWaitingForAudio() { Crash("Unexpected event!", __func__); }
  virtual void HandleAudioCanceled() { Crash("Unexpected event!", __func__); }
  virtual void HandleEndOfAudio() { Crash("Unexpected event!", __func__); }
  virtual void HandleWaitingForVideo() { Crash("Unexpected event!", __func__); }
  virtual void HandleVideoCanceled() { Crash("Unexpected event!", __func__); }
  virtual void HandleEndOfVideo() { Crash("Unexpected event!", __func__); }

  virtual RefPtr<MediaDecoder::SeekPromise> HandleSeek(
      const SeekTarget& aTarget);

  virtual RefPtr<ShutdownPromise> HandleShutdown();

  virtual void HandleVideoSuspendTimeout() = 0;

  virtual void HandleResumeVideoDecoding(const TimeUnit& aTarget);

  virtual void HandlePlayStateChanged(MediaDecoder::PlayState aPlayState) {}

  virtual void GetDebugInfo(
      dom::MediaDecoderStateMachineDecodingStateDebugInfo& aInfo) {}

  virtual void HandleLoopingChanged() {}

 private:
  template <class S, typename R, typename... As>
  auto ReturnTypeHelper(R (S::*)(As...)) -> R;

  void Crash(const char* aReason, const char* aSite) {
    char buf[1024];
    SprintfLiteral(buf, "%s state=%s callsite=%s", aReason,
                   ToStateStr(GetState()), aSite);
    MOZ_ReportAssertionFailure(buf, __FILE__, __LINE__);
    MOZ_CRASH();
  }

 protected:
  enum class EventVisibility : int8_t { Observable, Suppressed };

  using Master = MediaDecoderStateMachine;
  explicit StateObject(Master* aPtr) : mMaster(aPtr) {}
  TaskQueue* OwnerThread() const { return mMaster->mTaskQueue; }
  ReaderProxy* Reader() const { return mMaster->mReader; }
  const MediaInfo& Info() const { return mMaster->Info(); }
  MediaQueue<AudioData>& AudioQueue() const { return mMaster->mAudioQueue; }
  MediaQueue<VideoData>& VideoQueue() const { return mMaster->mVideoQueue; }

  template <class S, typename... Args, size_t... Indexes>
  auto CallEnterMemberFunction(S* aS, std::tuple<Args...>& aTuple,
                               std::index_sequence<Indexes...>)
      -> decltype(ReturnTypeHelper(&S::Enter)) {
    AUTO_PROFILER_LABEL("StateObject::CallEnterMemberFunction", MEDIA_PLAYBACK);
    return aS->Enter(std::move(std::get<Indexes>(aTuple))...);
  }

  // Note this function will delete the current state object.
  // Don't access members to avoid UAF after this call.
  template <class S, typename... Ts>
  auto SetState(Ts&&... aArgs) -> decltype(ReturnTypeHelper(&S::Enter)) {
    // |aArgs| must be passed by reference to avoid passing MOZ_NON_PARAM class
    // SeekJob by value.  See bug 1287006 and bug 1338374.  But we still *must*
    // copy the parameters, because |Exit()| can modify them.  See bug 1312321.
    // So we 1) pass the parameters by reference, but then 2) immediately copy
    // them into a Tuple to be safe against modification, and finally 3) move
    // the elements of the Tuple into the final function call.
    auto copiedArgs = std::make_tuple(std::forward<Ts>(aArgs)...);

    // Copy mMaster which will reset to null.
    auto* master = mMaster;

    auto* s = new S(master);

    // It's possible to seek again during seeking, otherwise the new state
    // should always be different from the original one.
    MOZ_ASSERT(GetState() != s->GetState() ||
               GetState() == DECODER_STATE_SEEKING_ACCURATE ||
               GetState() == DECODER_STATE_SEEKING_FROMDORMANT ||
               GetState() == DECODER_STATE_SEEKING_NEXTFRAMESEEKING ||
               GetState() == DECODER_STATE_SEEKING_VIDEOONLY);

    SLOG("change state to: %s", ToStateStr(s->GetState()));
    PROFILER_MARKER_TEXT("MDSM::StateChange", MEDIA_PLAYBACK, {},
                         nsPrintfCString("%s", ToStateStr(s->GetState())));

    Exit();

    // Delete the old state asynchronously to avoid UAF if the caller tries to
    // access its members after SetState() returns.
    master->OwnerThread()->DispatchDirectTask(
        NS_NewRunnableFunction("MDSM::StateObject::DeleteOldState",
                               [toDelete = std::move(master->mStateObj)]() {}));
    // Also reset mMaster to catch potentail UAF.
    mMaster = nullptr;

    master->mStateObj.reset(s);
    return CallEnterMemberFunction(s, copiedArgs,
                                   std::index_sequence_for<Ts...>{});
  }

  RefPtr<MediaDecoder::SeekPromise> SetSeekingState(
      SeekJob&& aSeekJob, EventVisibility aVisibility);

  void SetDecodingState();

  // Take a raw pointer in order not to change the life cycle of MDSM.
  // It is guaranteed to be valid by MDSM.
  Master* mMaster;
};

/**
 * Purpose: decode metadata like duration and dimensions of the media resource.
 *
 * Transition to other states when decoding metadata is done:
 *   SHUTDOWN if failing to decode metadata.
 *   DECODING_FIRSTFRAME otherwise.
 */
class MediaDecoderStateMachine::DecodeMetadataState
    : public MediaDecoderStateMachine::StateObject {
 public:
  explicit DecodeMetadataState(Master* aPtr) : StateObject(aPtr) {}

  void Enter() {
    MOZ_ASSERT(!mMaster->mVideoDecodeSuspended);
    MOZ_ASSERT(!mMetadataRequest.Exists());
    SLOG("Dispatching AsyncReadMetadata");

    // We disconnect mMetadataRequest in Exit() so it is fine to capture
    // a raw pointer here.
    Reader()
        ->ReadMetadata()
        ->Then(
            OwnerThread(), __func__,
            [this](MetadataHolder&& aMetadata) {
              OnMetadataRead(std::move(aMetadata));
            },
            [this](const MediaResult& aError) { OnMetadataNotRead(aError); })
        ->Track(mMetadataRequest);
  }

  void Exit() override { mMetadataRequest.DisconnectIfExists(); }

  State GetState() const override { return DECODER_STATE_DECODING_METADATA; }

  RefPtr<MediaDecoder::SeekPromise> HandleSeek(
      const SeekTarget& aTarget) override {
    MOZ_DIAGNOSTIC_CRASH("Can't seek while decoding metadata.");
    return MediaDecoder::SeekPromise::CreateAndReject(true, __func__);
  }

  void HandleVideoSuspendTimeout() override {
    // Do nothing since no decoders are created yet.
  }

  void HandleResumeVideoDecoding(const TimeUnit&) override {
    // We never suspend video decoding in this state.
    MOZ_ASSERT(false, "Shouldn't have suspended video decoding.");
  }

 private:
  void OnMetadataRead(MetadataHolder&& aMetadata);

  void OnMetadataNotRead(const MediaResult& aError) {
    AUTO_PROFILER_LABEL("DecodeMetadataState::OnMetadataNotRead",
                        MEDIA_PLAYBACK);

    mMetadataRequest.Complete();
    SLOGE("Decode metadata failed, shutting down decoder");
    mMaster->DecodeError(aError);
  }

  MozPromiseRequestHolder<MediaFormatReader::MetadataPromise> mMetadataRequest;
};

/**
 * Purpose: release decoder resources to save memory and hardware resources.
 *
 * Transition to:
 *   SEEKING if any seek request or play state changes to PLAYING.
 */
class MediaDecoderStateMachine::DormantState
    : public MediaDecoderStateMachine::StateObject {
 public:
  explicit DormantState(Master* aPtr) : StateObject(aPtr) {}

  void Enter() {
    if (mMaster->IsPlaying()) {
      mMaster->StopPlayback();
    }

    // Calculate the position to seek to when exiting dormant.
    auto t = mMaster->mMediaSink->IsStarted() ? mMaster->GetClock()
                                              : mMaster->GetMediaTime();
    mMaster->AdjustByLooping(t);
    mPendingSeek.mTarget.emplace(t, SeekTarget::Accurate);
    // SeekJob asserts |mTarget.IsValid() == !mPromise.IsEmpty()| so we
    // need to create the promise even it is not used at all.
    // The promise may be used when coming out of DormantState into
    // SeekingState.
    RefPtr<MediaDecoder::SeekPromise> x =
        mPendingSeek.mPromise.Ensure(__func__);

    // Reset the decoding state to ensure that any queued video frames are
    // released and don't consume video memory.
    mMaster->ResetDecode();

    // No need to call StopMediaSink() here.
    // We will do it during seeking when exiting dormant.

    // Ignore WAIT_FOR_DATA since we won't decode in dormant.
    mMaster->mAudioWaitRequest.DisconnectIfExists();
    mMaster->mVideoWaitRequest.DisconnectIfExists();

    MaybeReleaseResources();
  }

  void Exit() override {
    // mPendingSeek is either moved when exiting dormant or
    // should be rejected here before transition to SHUTDOWN.
    mPendingSeek.RejectIfExists(__func__);
  }

  State GetState() const override { return DECODER_STATE_DORMANT; }

  RefPtr<MediaDecoder::SeekPromise> HandleSeek(
      const SeekTarget& aTarget) override;

  void HandleVideoSuspendTimeout() override {
    // Do nothing since we've released decoders in Enter().
  }

  void HandleResumeVideoDecoding(const TimeUnit&) override {
    // Do nothing since we won't resume decoding until exiting dormant.
  }

  void HandlePlayStateChanged(MediaDecoder::PlayState aPlayState) override;

  void HandleAudioDecoded(AudioData*) override { MaybeReleaseResources(); }
  void HandleVideoDecoded(VideoData*) override { MaybeReleaseResources(); }
  void HandleWaitingForAudio() override { MaybeReleaseResources(); }
  void HandleWaitingForVideo() override { MaybeReleaseResources(); }
  void HandleAudioCanceled() override { MaybeReleaseResources(); }
  void HandleVideoCanceled() override { MaybeReleaseResources(); }
  void HandleEndOfAudio() override { MaybeReleaseResources(); }
  void HandleEndOfVideo() override { MaybeReleaseResources(); }

 private:
  void MaybeReleaseResources() {
    if (!mMaster->mAudioDataRequest.Exists() &&
        !mMaster->mVideoDataRequest.Exists()) {
      // Release decoders only when they are idle. Otherwise it might cause
      // decode error later when resetting decoders during seeking.
      mMaster->mReader->ReleaseResources();
    }
  }

  SeekJob mPendingSeek;
};

/**
 * Purpose: decode the 1st audio and video frames to fire the 'loadeddata'
 * event.
 *
 * Transition to:
 *   SHUTDOWN if any decode error.
 *   SEEKING if any seek request.
 *   DECODING/LOOPING_DECODING when the 'loadeddata' event is fired.
 */
class MediaDecoderStateMachine::DecodingFirstFrameState
    : public MediaDecoderStateMachine::StateObject {
 public:
  explicit DecodingFirstFrameState(Master* aPtr) : StateObject(aPtr) {}

  void Enter();

  void Exit() override {
    // mPendingSeek is either moved in MaybeFinishDecodeFirstFrame()
    // or should be rejected here before transition to SHUTDOWN.
    mPendingSeek.RejectIfExists(__func__);
  }

  State GetState() const override { return DECODER_STATE_DECODING_FIRSTFRAME; }

  void HandleAudioDecoded(AudioData* aAudio) override {
    mMaster->PushAudio(aAudio);
    MaybeFinishDecodeFirstFrame();
  }

  void HandleVideoDecoded(VideoData* aVideo) override {
    mMaster->PushVideo(aVideo);
    MaybeFinishDecodeFirstFrame();
  }

  void HandleWaitingForAudio() override {
    mMaster->WaitForData(MediaData::Type::AUDIO_DATA);
  }

  void HandleAudioCanceled() override { mMaster->RequestAudioData(); }

  void HandleEndOfAudio() override {
    AudioQueue().Finish();
    MaybeFinishDecodeFirstFrame();
  }

  void HandleWaitingForVideo() override {
    mMaster->WaitForData(MediaData::Type::VIDEO_DATA);
  }

  void HandleVideoCanceled() override {
    mMaster->RequestVideoData(media::TimeUnit());
  }

  void HandleEndOfVideo() override {
    VideoQueue().Finish();
    MaybeFinishDecodeFirstFrame();
  }

  void HandleAudioWaited(MediaData::Type aType) override {
    mMaster->RequestAudioData();
  }

  void HandleVideoWaited(MediaData::Type aType) override {
    mMaster->RequestVideoData(media::TimeUnit());
  }

  void HandleVideoSuspendTimeout() override {
    // Do nothing for we need to decode the 1st video frame to get the
    // dimensions.
  }

  void HandleResumeVideoDecoding(const TimeUnit&) override {
    // We never suspend video decoding in this state.
    MOZ_ASSERT(false, "Shouldn't have suspended video decoding.");
  }

  RefPtr<MediaDecoder::SeekPromise> HandleSeek(
      const SeekTarget& aTarget) override {
    if (mMaster->mIsMSE) {
      return StateObject::HandleSeek(aTarget);
    }
    // Delay seek request until decoding first frames for non-MSE media.
    SLOG("Not Enough Data to seek at this stage, queuing seek");
    mPendingSeek.RejectIfExists(__func__);
    mPendingSeek.mTarget.emplace(aTarget);
    return mPendingSeek.mPromise.Ensure(__func__);
  }

 private:
  // Notify FirstFrameLoaded if having decoded first frames and
  // transition to SEEKING if there is any pending seek, or DECODING otherwise.
  void MaybeFinishDecodeFirstFrame();

  SeekJob mPendingSeek;
};

/**
 * Purpose: decode audio/video data for playback.
 *
 * Transition to:
 *   DORMANT if playback is paused for a while.
 *   SEEKING if any seek request.
 *   SHUTDOWN if any decode error.
 *   BUFFERING if playback can't continue due to lack of decoded data.
 *   COMPLETED when having decoded all audio/video data.
 *   LOOPING_DECODING when media start seamless looping
 */
class MediaDecoderStateMachine::DecodingState
    : public MediaDecoderStateMachine::StateObject {
 public:
  explicit DecodingState(Master* aPtr)
      : StateObject(aPtr), mDormantTimer(OwnerThread()) {}

  void Enter();

  void Exit() override {
    if (!mDecodeStartTime.IsNull()) {
      TimeDuration decodeDuration = TimeStamp::Now() - mDecodeStartTime;
      SLOG("Exiting DECODING, decoded for %.3lfs", decodeDuration.ToSeconds());
    }
    mDormantTimer.Reset();
    mOnAudioPopped.DisconnectIfExists();
    mOnVideoPopped.DisconnectIfExists();
  }

  void Step() override;

  State GetState() const override { return DECODER_STATE_DECODING; }

  void HandleAudioDecoded(AudioData* aAudio) override {
    mMaster->PushAudio(aAudio);
    DispatchDecodeTasksIfNeeded();
    MaybeStopPrerolling();
  }

  void HandleVideoDecoded(VideoData* aVideo) override {
    // We only do this check when we're not looping, which can be known by
    // checking the queue's offset.
    const auto currentTime = mMaster->GetMediaTime();
    if (aVideo->GetEndTime() < currentTime &&
        VideoQueue().GetOffset() == media::TimeUnit::Zero()) {
      if (!mVideoFirstLateTime) {
        mVideoFirstLateTime = Some(TimeStamp::Now());
      }
      PROFILER_MARKER("Video falling behind", MEDIA_PLAYBACK, {},
                      VideoFallingBehindMarker, aVideo->mTime.ToMicroseconds(),
                      currentTime.ToMicroseconds());
      SLOG("video %" PRId64 " starts being late (current=%" PRId64 ")",
           aVideo->mTime.ToMicroseconds(), currentTime.ToMicroseconds());
    } else {
      mVideoFirstLateTime.reset();
    }
    mMaster->PushVideo(aVideo);
    DispatchDecodeTasksIfNeeded();
    MaybeStopPrerolling();
  }

  void HandleAudioCanceled() override { mMaster->RequestAudioData(); }

  void HandleVideoCanceled() override {
    mMaster->RequestVideoData(mMaster->GetMediaTime(),
                              ShouldRequestNextKeyFrame());
  }

  void HandleEndOfAudio() override;
  void HandleEndOfVideo() override;

  void HandleWaitingForAudio() override {
    mMaster->WaitForData(MediaData::Type::AUDIO_DATA);
    MaybeStopPrerolling();
  }

  void HandleWaitingForVideo() override {
    mMaster->WaitForData(MediaData::Type::VIDEO_DATA);
    MaybeStopPrerolling();
  }

  void HandleAudioWaited(MediaData::Type aType) override {
    mMaster->RequestAudioData();
  }

  void HandleVideoWaited(MediaData::Type aType) override {
    mMaster->RequestVideoData(mMaster->GetMediaTime(),
                              ShouldRequestNextKeyFrame());
  }

  void HandleAudioCaptured() override {
    MaybeStopPrerolling();
    // MediaSink is changed. Schedule Step() to check if we can start playback.
    mMaster->ScheduleStateMachine();
  }

  void HandleVideoSuspendTimeout() override {
    // No video, so nothing to suspend.
    if (!mMaster->HasVideo()) {
      return;
    }

    PROFILER_MARKER_UNTYPED("MDSM::EnterVideoSuspend", MEDIA_PLAYBACK);
    mMaster->mVideoDecodeSuspended = true;
    mMaster->mOnPlaybackEvent.Notify(MediaPlaybackEvent::EnterVideoSuspend);
    Reader()->SetVideoBlankDecode(true);
  }

  void HandlePlayStateChanged(MediaDecoder::PlayState aPlayState) override {
    // Schedule Step() to check if we can start or stop playback.
    mMaster->ScheduleStateMachine();
    if (aPlayState == MediaDecoder::PLAY_STATE_PLAYING) {
      // Try to dispatch decoding tasks for mMinimizePreroll might be reset.
      DispatchDecodeTasksIfNeeded();
    }

    if (aPlayState == MediaDecoder::PLAY_STATE_PAUSED) {
      StartDormantTimer();
      mVideoFirstLateTime.reset();
    } else {
      mDormantTimer.Reset();
    }
  }

  void GetDebugInfo(
      dom::MediaDecoderStateMachineDecodingStateDebugInfo& aInfo) override {
    aInfo.mIsPrerolling = mIsPrerolling;
  }

  void HandleLoopingChanged() override { SetDecodingState(); }

 protected:
  virtual void EnsureAudioDecodeTaskQueued();
  virtual void EnsureVideoDecodeTaskQueued();

  virtual bool ShouldStopPrerolling() const {
    return mIsPrerolling &&
           (DonePrerollingAudio() ||
            IsWaitingData(MediaData::Type::AUDIO_DATA)) &&
           (DonePrerollingVideo() ||
            IsWaitingData(MediaData::Type::VIDEO_DATA));
  }

  virtual bool IsWaitingData(MediaData::Type aType) const {
    if (aType == MediaData::Type::AUDIO_DATA) {
      return mMaster->IsWaitingAudioData();
    }
    MOZ_ASSERT(aType == MediaData::Type::VIDEO_DATA);
    return mMaster->IsWaitingVideoData();
  }

  void MaybeStopPrerolling() {
    if (ShouldStopPrerolling()) {
      mIsPrerolling = false;
      // Check if we can start playback.
      mMaster->ScheduleStateMachine();
    }
  }

  bool ShouldRequestNextKeyFrame() const {
    if (!mVideoFirstLateTime) {
      return false;
    }
    const double elapsedTimeMs =
        (TimeStamp::Now() - *mVideoFirstLateTime).ToMilliseconds();
    const bool rv = elapsedTimeMs >=
                    StaticPrefs::media_decoder_skip_when_video_too_slow_ms();
    if (rv) {
      PROFILER_MARKER_UNTYPED("Skipping to next keyframe", MEDIA_PLAYBACK);
      SLOG(
          "video has been late behind media time for %f ms, should skip to "
          "next key frame",
          elapsedTimeMs);
    }
    return rv;
  }

  virtual bool IsBufferingAllowed() const { return true; }

 private:
  void DispatchDecodeTasksIfNeeded();
  void MaybeStartBuffering();

  // At the start of decoding we want to "preroll" the decode until we've
  // got a few frames decoded before we consider whether decode is falling
  // behind. Otherwise our "we're falling behind" logic will trigger
  // unnecessarily if we start playing as soon as the first sample is
  // decoded. These two fields store how many video frames and audio
  // samples we must consume before are considered to be finished prerolling.
  TimeUnit AudioPrerollThreshold() const {
    return (mMaster->mAmpleAudioThreshold / 2)
        .MultDouble(mMaster->mPlaybackRate);
  }

  uint32_t VideoPrerollFrames() const {
    return std::min(
        static_cast<uint32_t>(
            mMaster->GetAmpleVideoFrames() / 2. * mMaster->mPlaybackRate + 1),
        sVideoQueueDefaultSize);
  }

  bool DonePrerollingAudio() const {
    return !mMaster->IsAudioDecoding() ||
           mMaster->GetDecodedAudioDuration() >= AudioPrerollThreshold();
  }

  bool DonePrerollingVideo() const {
    return !mMaster->IsVideoDecoding() ||
           static_cast<uint32_t>(mMaster->VideoQueue().GetSize()) >=
               VideoPrerollFrames();
  }

  void StartDormantTimer() {
    if (!mMaster->mMediaSeekable) {
      // Don't enter dormant if the media is not seekable because we need to
      // seek when exiting dormant.
      return;
    }

    auto timeout = StaticPrefs::media_dormant_on_pause_timeout_ms();
    if (timeout < 0) {
      // Disabled when timeout is negative.
      return;
    }

    if (timeout == 0) {
      // Enter dormant immediately without scheduling a timer.
      SetState<DormantState>();
      return;
    }

    if (mMaster->mMinimizePreroll) {
      SetState<DormantState>();
      return;
    }

    TimeStamp target =
        TimeStamp::Now() + TimeDuration::FromMilliseconds(timeout);

    mDormantTimer.Ensure(
        target,
        [this]() {
          AUTO_PROFILER_LABEL("DecodingState::StartDormantTimer:SetDormant",
                              MEDIA_PLAYBACK);
          mDormantTimer.CompleteRequest();
          SetState<DormantState>();
        },
        [this]() { mDormantTimer.CompleteRequest(); });
  }

  // Time at which we started decoding.
  TimeStamp mDecodeStartTime;

  // When we start decoding (either for the first time, or after a pause)
  // we may be low on decoded data. We don't want our "low data" logic to
  // kick in and decide that we're low on decoded data because the download
  // can't keep up with the decode, and cause us to pause playback. So we
  // have a "preroll" stage, where we ignore the results of our "low data"
  // logic during the first few frames of our decode. This occurs during
  // playback.
  bool mIsPrerolling = true;

  // Fired when playback is paused for a while to enter dormant.
  DelayedScheduler<TimeStamp> mDormantTimer;

  MediaEventListener mOnAudioPopped;
  MediaEventListener mOnVideoPopped;

  // If video has been later than the media time, this will records when the
  // video started being late. It will be reset once video catches up with the
  // media time.
  Maybe<TimeStamp> mVideoFirstLateTime;
};

/**
 * Purpose: decode audio data for playback when media is in seamless
 * looping, we will adjust media time to make samples time monotonically
 * increasing. All its methods runs on its owner thread (MDSM thread).
 *
 * Transition to:
 *   DORMANT if playback is paused for a while.
 *   SEEKING if any seek request.
 *   SHUTDOWN if any decode error.
 *   BUFFERING if playback can't continue due to lack of decoded data.
 *   COMPLETED when the media resource is closed and no data is available
 *             anymore.
 *   DECODING when media stops seamless looping.
 */
class MediaDecoderStateMachine::LoopingDecodingState
    : public MediaDecoderStateMachine::DecodingState {
 public:
  explicit LoopingDecodingState(Master* aPtr)
      : DecodingState(aPtr),
        mIsReachingAudioEOS(!mMaster->IsAudioDecoding()),
        mIsReachingVideoEOS(!mMaster->IsVideoDecoding()),
        mAudioEndedBeforeEnteringStateWithoutDuration(false),
        mVideoEndedBeforeEnteringStateWithoutDuration(false) {
    MOZ_ASSERT(mMaster->mLooping);
    SLOG(
        "LoopingDecodingState ctor, mIsReachingAudioEOS=%d, "
        "mIsReachingVideoEOS=%d",
        mIsReachingAudioEOS, mIsReachingVideoEOS);
    // If the track has reached EOS and we already have its last data, then we
    // can know its duration. But if playback starts from EOS (due to seeking),
    // the decoded end time would be zero because none of data gets decoded yet.
    if (mIsReachingAudioEOS) {
      if (mMaster->HasLastDecodedData(MediaData::Type::AUDIO_DATA) &&
          !mMaster->mAudioTrackDecodedDuration) {
        mMaster->mAudioTrackDecodedDuration.emplace(
            mMaster->mDecodedAudioEndTime);
        SLOG("determine mAudioTrackDecodedDuration");
      } else {
        mAudioEndedBeforeEnteringStateWithoutDuration = true;
        SLOG("still don't know mAudioTrackDecodedDuration");
      }
    }

    if (mIsReachingVideoEOS) {
      if (mMaster->HasLastDecodedData(MediaData::Type::VIDEO_DATA) &&
          !mMaster->mVideoTrackDecodedDuration) {
        mMaster->mVideoTrackDecodedDuration.emplace(
            mMaster->mDecodedVideoEndTime);
        SLOG("determine mVideoTrackDecodedDuration");
      } else {
        mVideoEndedBeforeEnteringStateWithoutDuration = true;
        SLOG("still don't know mVideoTrackDecodedDuration");
      }
    }

    // We might be able to determine the duration already, let's check.
    if (mIsReachingAudioEOS || mIsReachingVideoEOS) {
      Unused << DetermineOriginalDecodedDurationIfNeeded();
    }

    // If we've looped at least once before, then we need to update queue offset
    // correctly to make the media data time and the clock time consistent.
    // Otherwise, it would cause a/v desync.
    if (mMaster->mOriginalDecodedDuration != media::TimeUnit::Zero()) {
      if (mIsReachingAudioEOS && mMaster->HasAudio()) {
        AudioQueue().SetOffset(AudioQueue().GetOffset() +
                               mMaster->mOriginalDecodedDuration);
      }
      if (mIsReachingVideoEOS && mMaster->HasVideo()) {
        VideoQueue().SetOffset(VideoQueue().GetOffset() +
                               mMaster->mOriginalDecodedDuration);
      }
    }
  }

  void Enter() {
    if (mMaster->HasAudio() && mIsReachingAudioEOS) {
      SLOG("audio has ended, request the data again.");
      RequestDataFromStartPosition(TrackInfo::TrackType::kAudioTrack);
    }
    if (mMaster->HasVideo() && mIsReachingVideoEOS) {
      SLOG("video has ended, request the data again.");
      RequestDataFromStartPosition(TrackInfo::TrackType::kVideoTrack);
    }
    DecodingState::Enter();
  }

  void Exit() override {
    MOZ_DIAGNOSTIC_ASSERT(mMaster->OnTaskQueue());
    SLOG("Leaving looping state, offset [a=%" PRId64 ",v=%" PRId64
         "], endtime [a=%" PRId64 ",v=%" PRId64 "], track duration [a=%" PRId64
         ",v=%" PRId64 "], waiting=%s",
         AudioQueue().GetOffset().ToMicroseconds(),
         VideoQueue().GetOffset().ToMicroseconds(),
         mMaster->mDecodedAudioEndTime.ToMicroseconds(),
         mMaster->mDecodedVideoEndTime.ToMicroseconds(),
         mMaster->mAudioTrackDecodedDuration
             ? mMaster->mAudioTrackDecodedDuration->ToMicroseconds()
             : 0,
         mMaster->mVideoTrackDecodedDuration
             ? mMaster->mVideoTrackDecodedDuration->ToMicroseconds()
             : 0,
         mDataWaitingTimestampAdjustment
             ? MediaData::EnumValueToString(
                   mDataWaitingTimestampAdjustment->mType)
             : "none");
    if (ShouldDiscardLoopedData(MediaData::Type::AUDIO_DATA)) {
      DiscardLoopedData(MediaData::Type::AUDIO_DATA);
    }
    if (ShouldDiscardLoopedData(MediaData::Type::VIDEO_DATA)) {
      DiscardLoopedData(MediaData::Type::VIDEO_DATA);
    }

    if (mMaster->HasAudio() && HasDecodedLastAudioFrame()) {
      SLOG("Mark audio queue as finished");
      mMaster->mAudioDataRequest.DisconnectIfExists();
      mMaster->mAudioWaitRequest.DisconnectIfExists();
      AudioQueue().Finish();
    }
    if (mMaster->HasVideo() && HasDecodedLastVideoFrame()) {
      SLOG("Mark video queue as finished");
      mMaster->mVideoDataRequest.DisconnectIfExists();
      mMaster->mVideoWaitRequest.DisconnectIfExists();
      VideoQueue().Finish();
    }

    // Clear waiting data should be done after marking queue as finished.
    mDataWaitingTimestampAdjustment = nullptr;

    mAudioDataRequest.DisconnectIfExists();
    mVideoDataRequest.DisconnectIfExists();
    mAudioSeekRequest.DisconnectIfExists();
    mVideoSeekRequest.DisconnectIfExists();
    DecodingState::Exit();
  }

  ~LoopingDecodingState() {
    MOZ_DIAGNOSTIC_ASSERT(!mAudioDataRequest.Exists());
    MOZ_DIAGNOSTIC_ASSERT(!mVideoDataRequest.Exists());
    MOZ_DIAGNOSTIC_ASSERT(!mAudioSeekRequest.Exists());
    MOZ_DIAGNOSTIC_ASSERT(!mVideoSeekRequest.Exists());
  }

  State GetState() const override { return DECODER_STATE_LOOPING_DECODING; }

  void HandleAudioDecoded(AudioData* aAudio) override {
    // TODO : check if we need to update mOriginalDecodedDuration

    // After pushing data to the queue, timestamp might be adjusted.
    DecodingState::HandleAudioDecoded(aAudio);
    mMaster->mDecodedAudioEndTime =
        std::max(aAudio->GetEndTime(), mMaster->mDecodedAudioEndTime);
    SLOG("audio sample after time-adjustment [%" PRId64 ",%" PRId64 "]",
         aAudio->mTime.ToMicroseconds(), aAudio->GetEndTime().ToMicroseconds());
  }

  void HandleVideoDecoded(VideoData* aVideo) override {
    // TODO : check if we need to update mOriginalDecodedDuration

    // Here sample still keeps its original timestamp.

    // This indicates there is a shorter audio track, and it's the first time in
    // the looping (audio ends but video is playing) so that we haven't been
    // able to determine the decoded duration. Therefore, we fill the gap
    // between two tracks before video ends. Afterward, this adjustment will be
    // done in `HandleEndOfAudio()`.
    if (mMaster->mOriginalDecodedDuration == media::TimeUnit::Zero() &&
        mMaster->mAudioTrackDecodedDuration &&
        aVideo->GetEndTime() > *mMaster->mAudioTrackDecodedDuration) {
      media::TimeUnit gap;
      // First time we fill gap between the video frame to the last audio.
      if (auto prevVideo = VideoQueue().PeekBack();
          prevVideo &&
          prevVideo->GetEndTime() < *mMaster->mAudioTrackDecodedDuration) {
        gap =
            aVideo->GetEndTime().ToBase(*mMaster->mAudioTrackDecodedDuration) -
            *mMaster->mAudioTrackDecodedDuration;
      }
      // Then fill the gap for all following videos.
      else {
        gap = aVideo->mDuration.ToBase(*mMaster->mAudioTrackDecodedDuration);
      }
      SLOG("Longer video %" PRId64 "%s (audio-durtaion=%" PRId64
           "%s), insert silence to fill the gap %" PRId64 "%s",
           aVideo->GetEndTime().ToMicroseconds(),
           aVideo->GetEndTime().ToString().get(),
           mMaster->mAudioTrackDecodedDuration->ToMicroseconds(),
           mMaster->mAudioTrackDecodedDuration->ToString().get(),
           gap.ToMicroseconds(), gap.ToString().get());
      PushFakeAudioDataIfNeeded(gap);
    }

    // After pushing data to the queue, timestamp might be adjusted.
    DecodingState::HandleVideoDecoded(aVideo);
    mMaster->mDecodedVideoEndTime =
        std::max(aVideo->GetEndTime(), mMaster->mDecodedVideoEndTime);
    SLOG("video sample after time-adjustment [%" PRId64 ",%" PRId64 "]",
         aVideo->mTime.ToMicroseconds(), aVideo->GetEndTime().ToMicroseconds());
  }

  void HandleEndOfAudio() override {
    mIsReachingAudioEOS = true;
    if (!mMaster->mAudioTrackDecodedDuration &&
        mMaster->HasLastDecodedData(MediaData::Type::AUDIO_DATA)) {
      mMaster->mAudioTrackDecodedDuration.emplace(
          mMaster->mDecodedAudioEndTime);
    }
    if (DetermineOriginalDecodedDurationIfNeeded()) {
      AudioQueue().SetOffset(AudioQueue().GetOffset() +
                             mMaster->mOriginalDecodedDuration);
    }

    // This indicates that the audio track is shorter than the video track, so
    // we need to add some silence to fill the gap.
    if (mMaster->mAudioTrackDecodedDuration &&
        mMaster->mOriginalDecodedDuration >
            *mMaster->mAudioTrackDecodedDuration) {
      MOZ_ASSERT(mMaster->HasVideo());
      MOZ_ASSERT(mMaster->mVideoTrackDecodedDuration);
      MOZ_ASSERT(mMaster->mOriginalDecodedDuration ==
                 *mMaster->mVideoTrackDecodedDuration);
      auto gap = mMaster->mOriginalDecodedDuration.ToBase(
                     *mMaster->mAudioTrackDecodedDuration) -
                 *mMaster->mAudioTrackDecodedDuration;
      SLOG(
          "Audio track is shorter than the original decoded duration "
          "(a=%" PRId64 "%s, t=%" PRId64
          "%s), insert silence to fill the gap %" PRId64 "%s",
          mMaster->mAudioTrackDecodedDuration->ToMicroseconds(),
          mMaster->mAudioTrackDecodedDuration->ToString().get(),
          mMaster->mOriginalDecodedDuration.ToMicroseconds(),
          mMaster->mOriginalDecodedDuration.ToString().get(),
          gap.ToMicroseconds(), gap.ToString().get());
      PushFakeAudioDataIfNeeded(gap);
    }

    SLOG(
        "received audio EOS when seamless looping, starts seeking, "
        "audioLoopingOffset=[%" PRId64 "], mAudioTrackDecodedDuration=[%" PRId64
        "]",
        AudioQueue().GetOffset().ToMicroseconds(),
        mMaster->mAudioTrackDecodedDuration->ToMicroseconds());
    if (!IsRequestingDataFromStartPosition(MediaData::Type::AUDIO_DATA)) {
      RequestDataFromStartPosition(TrackInfo::TrackType::kAudioTrack);
    }
    ProcessSamplesWaitingAdjustmentIfAny();
  }

  void HandleEndOfVideo() override {
    mIsReachingVideoEOS = true;
    if (!mMaster->mVideoTrackDecodedDuration &&
        mMaster->HasLastDecodedData(MediaData::Type::VIDEO_DATA)) {
      mMaster->mVideoTrackDecodedDuration.emplace(
          mMaster->mDecodedVideoEndTime);
    }
    if (DetermineOriginalDecodedDurationIfNeeded()) {
      VideoQueue().SetOffset(VideoQueue().GetOffset() +
                             mMaster->mOriginalDecodedDuration);
    }

    SLOG(
        "received video EOS when seamless looping, starts seeking, "
        "videoLoopingOffset=[%" PRId64 "], mVideoTrackDecodedDuration=[%" PRId64
        "]",
        VideoQueue().GetOffset().ToMicroseconds(),
        mMaster->mVideoTrackDecodedDuration->ToMicroseconds());
    if (!IsRequestingDataFromStartPosition(MediaData::Type::VIDEO_DATA)) {
      RequestDataFromStartPosition(TrackInfo::TrackType::kVideoTrack);
    }
    ProcessSamplesWaitingAdjustmentIfAny();
  }

 private:
  void RequestDataFromStartPosition(TrackInfo::TrackType aType) {
    MOZ_DIAGNOSTIC_ASSERT(aType == TrackInfo::TrackType::kAudioTrack ||
                          aType == TrackInfo::TrackType::kVideoTrack);

    const bool isAudio = aType == TrackInfo::TrackType::kAudioTrack;
    MOZ_ASSERT_IF(isAudio, mMaster->HasAudio());
    MOZ_ASSERT_IF(!isAudio, mMaster->HasVideo());

    if (IsReaderSeeking()) {
      MOZ_ASSERT(!mPendingSeekingType);
      mPendingSeekingType = Some(aType);
      SLOG("Delay %s seeking until the reader finishes current seeking",
           isAudio ? "audio" : "video");
      return;
    }

    auto& seekRequest = isAudio ? mAudioSeekRequest : mVideoSeekRequest;
    Reader()->ResetDecode(aType);
    Reader()
        ->Seek(SeekTarget(media::TimeUnit::Zero(), SeekTarget::Type::Accurate,
                          isAudio ? SeekTarget::Track::AudioOnly
                                  : SeekTarget::Track::VideoOnly))
        ->Then(
            OwnerThread(), __func__,
            [this, isAudio, master = RefPtr{mMaster}]() mutable -> void {
              AUTO_PROFILER_LABEL(
                  nsPrintfCString(
                      "LoopingDecodingState::RequestDataFromStartPosition(%s)::"
                      "SeekResolved",
                      isAudio ? "audio" : "video")
                      .get(),
                  MEDIA_PLAYBACK);
              if (auto& state = master->mStateObj;
                  state &&
                  state->GetState() != DECODER_STATE_LOOPING_DECODING) {
                MOZ_RELEASE_ASSERT(false, "This shouldn't happen!");
                return;
              }
              if (isAudio) {
                mAudioSeekRequest.Complete();
              } else {
                mVideoSeekRequest.Complete();
              }
              SLOG(
                  "seeking completed, start to request first %s sample "
                  "(queued=%zu, decoder-queued=%zu)",
                  isAudio ? "audio" : "video",
                  isAudio ? AudioQueue().GetSize() : VideoQueue().GetSize(),
                  isAudio ? Reader()->SizeOfAudioQueueInFrames()
                          : Reader()->SizeOfVideoQueueInFrames());
              if (isAudio) {
                RequestAudioDataFromReaderAfterEOS();
              } else {
                RequestVideoDataFromReaderAfterEOS();
              }
              if (mPendingSeekingType) {
                auto seekingType = *mPendingSeekingType;
                mPendingSeekingType.reset();
                SLOG("Perform pending %s seeking", TrackTypeToStr(seekingType));
                RequestDataFromStartPosition(seekingType);
              }
            },
            [this, isAudio, master = RefPtr{mMaster}](
                const SeekRejectValue& aReject) mutable -> void {
              AUTO_PROFILER_LABEL(
                  nsPrintfCString("LoopingDecodingState::"
                                  "RequestDataFromStartPosition(%s)::"
                                  "SeekRejected",
                                  isAudio ? "audio" : "video")
                      .get(),
                  MEDIA_PLAYBACK);
              if (auto& state = master->mStateObj;
                  state &&
                  state->GetState() != DECODER_STATE_LOOPING_DECODING) {
                MOZ_RELEASE_ASSERT(false, "This shouldn't happen!");
                return;
              }
              if (isAudio) {
                mAudioSeekRequest.Complete();
              } else {
                mVideoSeekRequest.Complete();
              }
              HandleError(aReject.mError, isAudio);
            })
        ->Track(seekRequest);
  }

  void RequestAudioDataFromReaderAfterEOS() {
    MOZ_ASSERT(mMaster->HasAudio());
    Reader()
        ->RequestAudioData()
        ->Then(
            OwnerThread(), __func__,
            [this, master = RefPtr{mMaster}](const RefPtr<AudioData>& aAudio) {
              AUTO_PROFILER_LABEL(
                  "LoopingDecodingState::"
                  "RequestAudioDataFromReader::"
                  "RequestDataResolved",
                  MEDIA_PLAYBACK);
              if (auto& state = master->mStateObj;
                  state &&
                  state->GetState() != DECODER_STATE_LOOPING_DECODING) {
                MOZ_RELEASE_ASSERT(false, "This shouldn't happen!");
                return;
              }
              mIsReachingAudioEOS = false;
              mAudioDataRequest.Complete();
              SLOG(
                  "got audio decoded sample "
                  "[%" PRId64 ",%" PRId64 "]",
                  aAudio->mTime.ToMicroseconds(),
                  aAudio->GetEndTime().ToMicroseconds());
              if (ShouldPutDataOnWaiting(MediaData::Type::AUDIO_DATA)) {
                SLOG(
                    "decoded audio sample needs to wait for timestamp "
                    "adjustment after EOS");
                PutDataOnWaiting(aAudio);
                return;
              }
              HandleAudioDecoded(aAudio);
              ProcessSamplesWaitingAdjustmentIfAny();
            },
            [this, master = RefPtr{mMaster}](const MediaResult& aError) {
              AUTO_PROFILER_LABEL(
                  "LoopingDecodingState::"
                  "RequestAudioDataFromReader::"
                  "RequestDataRejected",
                  MEDIA_PLAYBACK);
              if (auto& state = master->mStateObj;
                  state &&
                  state->GetState() != DECODER_STATE_LOOPING_DECODING) {
                MOZ_RELEASE_ASSERT(false, "This shouldn't happen!");
                return;
              }
              mAudioDataRequest.Complete();
              HandleError(aError, true /* isAudio */);
            })
        ->Track(mAudioDataRequest);
  }

  void RequestVideoDataFromReaderAfterEOS() {
    MOZ_ASSERT(mMaster->HasVideo());
    Reader()
        ->RequestVideoData(media::TimeUnit(),
                           false /* aRequestNextVideoKeyFrame */)
        ->Then(
            OwnerThread(), __func__,
            [this, master = RefPtr{mMaster}](const RefPtr<VideoData>& aVideo) {
              AUTO_PROFILER_LABEL(
                  "LoopingDecodingState::"
                  "RequestVideoDataFromReaderAfterEOS()::"
                  "RequestDataResolved",
                  MEDIA_PLAYBACK);
              if (auto& state = master->mStateObj;
                  state &&
                  state->GetState() != DECODER_STATE_LOOPING_DECODING) {
                MOZ_RELEASE_ASSERT(false, "This shouldn't happen!");
                return;
              }
              mIsReachingVideoEOS = false;
              mVideoDataRequest.Complete();
              SLOG(
                  "got video decoded sample "
                  "[%" PRId64 ",%" PRId64 "]",
                  aVideo->mTime.ToMicroseconds(),
                  aVideo->GetEndTime().ToMicroseconds());
              if (ShouldPutDataOnWaiting(MediaData::Type::VIDEO_DATA)) {
                SLOG(
                    "decoded video sample needs to wait for timestamp "
                    "adjustment after EOS");
                PutDataOnWaiting(aVideo);
                return;
              }
              mMaster->mBypassingSkipToNextKeyFrameCheck = true;
              HandleVideoDecoded(aVideo);
              ProcessSamplesWaitingAdjustmentIfAny();
            },
            [this, master = RefPtr{mMaster}](const MediaResult& aError) {
              AUTO_PROFILER_LABEL(
                  "LoopingDecodingState::"
                  "RequestVideoDataFromReaderAfterEOS()::"
                  "RequestDataRejected",
                  MEDIA_PLAYBACK);
              if (auto& state = master->mStateObj;
                  state &&
                  state->GetState() != DECODER_STATE_LOOPING_DECODING) {
                MOZ_RELEASE_ASSERT(false, "This shouldn't happen!");
                return;
              }
              mVideoDataRequest.Complete();
              HandleError(aError, false /* isAudio */);
            })
        ->Track(mVideoDataRequest);
  }

  void HandleError(const MediaResult& aError, bool aIsAudio);

  bool ShouldRequestData(MediaData::Type aType) const {
    MOZ_DIAGNOSTIC_ASSERT(aType == MediaData::Type::AUDIO_DATA ||
                          aType == MediaData::Type::VIDEO_DATA);

    if (aType == MediaData::Type::AUDIO_DATA &&
        (mAudioSeekRequest.Exists() || mAudioDataRequest.Exists() ||
         IsDataWaitingForTimestampAdjustment(MediaData::Type::AUDIO_DATA) ||
         mMaster->IsWaitingAudioData())) {
      return false;
    }
    if (aType == MediaData::Type::VIDEO_DATA &&
        (mVideoSeekRequest.Exists() || mVideoDataRequest.Exists() ||
         IsDataWaitingForTimestampAdjustment(MediaData::Type::VIDEO_DATA) ||
         mMaster->IsWaitingVideoData())) {
      return false;
    }
    return true;
  }

  void HandleAudioCanceled() override {
    if (ShouldRequestData(MediaData::Type::AUDIO_DATA)) {
      mMaster->RequestAudioData();
    }
  }

  void HandleAudioWaited(MediaData::Type aType) override {
    if (ShouldRequestData(MediaData::Type::AUDIO_DATA)) {
      mMaster->RequestAudioData();
    }
  }

  void HandleVideoCanceled() override {
    if (ShouldRequestData(MediaData::Type::VIDEO_DATA)) {
      mMaster->RequestVideoData(mMaster->GetMediaTime(),
                                ShouldRequestNextKeyFrame());
    };
  }

  void HandleVideoWaited(MediaData::Type aType) override {
    if (ShouldRequestData(MediaData::Type::VIDEO_DATA)) {
      mMaster->RequestVideoData(mMaster->GetMediaTime(),
                                ShouldRequestNextKeyFrame());
    };
  }

  void EnsureAudioDecodeTaskQueued() override {
    if (!ShouldRequestData(MediaData::Type::AUDIO_DATA)) {
      return;
    }
    DecodingState::EnsureAudioDecodeTaskQueued();
  }

  void EnsureVideoDecodeTaskQueued() override {
    if (!ShouldRequestData(MediaData::Type::VIDEO_DATA)) {
      return;
    }
    DecodingState::EnsureVideoDecodeTaskQueued();
  }

  bool DetermineOriginalDecodedDurationIfNeeded() {
    // Duration would only need to be set once, unless we get more data which is
    // larger than the duration. That can happen on MSE (reopen stream).
    if (mMaster->mOriginalDecodedDuration != media::TimeUnit::Zero()) {
      return true;
    }

    // Single track situations
    if (mMaster->HasAudio() && !mMaster->HasVideo() &&
        mMaster->mAudioTrackDecodedDuration) {
      mMaster->mOriginalDecodedDuration = *mMaster->mAudioTrackDecodedDuration;
      SLOG("audio only, duration=%" PRId64,
           mMaster->mOriginalDecodedDuration.ToMicroseconds());
      return true;
    }
    if (mMaster->HasVideo() && !mMaster->HasAudio() &&
        mMaster->mVideoTrackDecodedDuration) {
      mMaster->mOriginalDecodedDuration = *mMaster->mVideoTrackDecodedDuration;
      SLOG("video only, duration=%" PRId64,
           mMaster->mOriginalDecodedDuration.ToMicroseconds());
      return true;
    }
    // Two tracks situation
    if (mMaster->HasAudio() && mMaster->HasVideo()) {
      // Both tracks have ended so that we can check which track is longer.
      if (mMaster->mAudioTrackDecodedDuration &&
          mMaster->mVideoTrackDecodedDuration) {
        mMaster->mOriginalDecodedDuration =
            std::max(*mMaster->mVideoTrackDecodedDuration,
                     *mMaster->mAudioTrackDecodedDuration);
        SLOG("Both tracks ended, original duration=%" PRId64 " (a=%" PRId64
             ", v=%" PRId64 ")",
             mMaster->mOriginalDecodedDuration.ToMicroseconds(),
             mMaster->mAudioTrackDecodedDuration->ToMicroseconds(),
             mMaster->mVideoTrackDecodedDuration->ToMicroseconds());
        return true;
      }
      // When entering the state, video has ended but audio hasn't, which means
      // audio is longer.
      if (mMaster->mAudioTrackDecodedDuration &&
          mVideoEndedBeforeEnteringStateWithoutDuration) {
        mMaster->mOriginalDecodedDuration =
            *mMaster->mAudioTrackDecodedDuration;
        mVideoEndedBeforeEnteringStateWithoutDuration = false;
        SLOG("audio is longer, duration=%" PRId64,
             mMaster->mOriginalDecodedDuration.ToMicroseconds());
        return true;
      }
      // When entering the state, audio has ended but video hasn't, which means
      // video is longer.
      if (mMaster->mVideoTrackDecodedDuration &&
          mAudioEndedBeforeEnteringStateWithoutDuration) {
        mMaster->mOriginalDecodedDuration =
            *mMaster->mVideoTrackDecodedDuration;
        mAudioEndedBeforeEnteringStateWithoutDuration = false;
        SLOG("video is longer, duration=%" PRId64,
             mMaster->mOriginalDecodedDuration.ToMicroseconds());
        return true;
      }
      SLOG("Still waiting for another track ends...");
      MOZ_ASSERT(!mMaster->mAudioTrackDecodedDuration ||
                 !mMaster->mVideoTrackDecodedDuration);
    }
    SLOG("can't determine the original decoded duration yet");
    MOZ_ASSERT(mMaster->mOriginalDecodedDuration == media::TimeUnit::Zero());
    return false;
  }

  void ProcessSamplesWaitingAdjustmentIfAny() {
    if (!mDataWaitingTimestampAdjustment) {
      return;
    }

    RefPtr<MediaData> data = mDataWaitingTimestampAdjustment;
    mDataWaitingTimestampAdjustment = nullptr;
    const bool isAudio = data->mType == MediaData::Type::AUDIO_DATA;
    SLOG("process %s sample waiting for timestamp adjustment",
         isAudio ? "audio" : "video");
    if (isAudio) {
      // Waiting sample is for next round of looping, so the queue offset
      // shouldn't be zero. This happens when the track has reached EOS before
      // entering the state (and looping never happens before). Same for below
      // video case.
      if (AudioQueue().GetOffset() == media::TimeUnit::Zero()) {
        AudioQueue().SetOffset(mMaster->mOriginalDecodedDuration);
      }
      HandleAudioDecoded(data->As<AudioData>());
    } else {
      MOZ_DIAGNOSTIC_ASSERT(data->mType == MediaData::Type::VIDEO_DATA);
      if (VideoQueue().GetOffset() == media::TimeUnit::Zero()) {
        VideoQueue().SetOffset(mMaster->mOriginalDecodedDuration);
      }
      HandleVideoDecoded(data->As<VideoData>());
    }
  }

  bool IsDataWaitingForTimestampAdjustment(MediaData::Type aType) const {
    return mDataWaitingTimestampAdjustment &&
           mDataWaitingTimestampAdjustment->mType == aType;
  }

  bool ShouldPutDataOnWaiting(MediaData::Type aType) const {
    // If another track is already waiting, this track shouldn't be waiting.
    // This case only happens when both tracks reached EOS before entering the
    // looping decoding state, so we don't know the decoded duration yet (used
    // to adjust timestamp) But this is fine, because both tracks will start
    // from 0 so we don't need to adjust them now.
    if (mDataWaitingTimestampAdjustment &&
        !IsDataWaitingForTimestampAdjustment(aType)) {
      return false;
    }

    // Only have one track, no need to wait.
    if ((aType == MediaData::Type::AUDIO_DATA && !mMaster->HasVideo()) ||
        (aType == MediaData::Type::VIDEO_DATA && !mMaster->HasAudio())) {
      return false;
    }

    // We don't know the duration yet, so we can't calculate the looping offset.
    return mMaster->mOriginalDecodedDuration == media::TimeUnit::Zero();
  }

  void PutDataOnWaiting(MediaData* aData) {
    MOZ_ASSERT(!mDataWaitingTimestampAdjustment);
    mDataWaitingTimestampAdjustment = aData;
    SLOG("put %s [%" PRId64 ",%" PRId64 "] on waiting",
         MediaData::EnumValueToString(aData->mType),
         aData->mTime.ToMicroseconds(), aData->GetEndTime().ToMicroseconds());
    MaybeStopPrerolling();
  }

  bool ShouldDiscardLoopedData(MediaData::Type aType) const {
    if (!mMaster->mMediaSink->IsStarted()) {
      return false;
    }

    MOZ_DIAGNOSTIC_ASSERT(aType == MediaData::Type::AUDIO_DATA ||
                          aType == MediaData::Type::VIDEO_DATA);
    const bool isAudio = aType == MediaData::Type::AUDIO_DATA;
    if (isAudio && !mMaster->HasAudio()) {
      return false;
    }
    if (!isAudio && !mMaster->HasVideo()) {
      return false;
    }

    /**
     * If media cancels looping, we should check whether there is media data
     * whose time is later than EOS. If so, we should discard them because we
     * won't have a chance to play them.
     *
     *    playback                     last decoded
     *    position          EOS        data time
     *   ----|---------------|------------|---------> (Increasing timeline)
     *    mCurrent         looping      mMaster's
     *    ClockTime        offset      mDecodedXXXEndTime
     *
     */
    const auto offset =
        isAudio ? AudioQueue().GetOffset() : VideoQueue().GetOffset();
    const auto endTime =
        isAudio ? mMaster->mDecodedAudioEndTime : mMaster->mDecodedVideoEndTime;
    const auto clockTime = mMaster->GetClock();
    return (offset != media::TimeUnit::Zero() && clockTime < offset &&
            offset < endTime);
  }

  void DiscardLoopedData(MediaData::Type aType) {
    MOZ_DIAGNOSTIC_ASSERT(aType == MediaData::Type::AUDIO_DATA ||
                          aType == MediaData::Type::VIDEO_DATA);
    const bool isAudio = aType == MediaData::Type::AUDIO_DATA;
    const auto offset =
        isAudio ? AudioQueue().GetOffset() : VideoQueue().GetOffset();
    if (offset == media::TimeUnit::Zero()) {
      return;
    }

    SLOG("Discard %s frames after the time=%" PRId64,
         isAudio ? "audio" : "video", offset.ToMicroseconds());
    if (isAudio) {
      DiscardFramesFromTail(AudioQueue(), [&](int64_t aSampleTime) {
        return aSampleTime > offset.ToMicroseconds();
      });
    } else {
      DiscardFramesFromTail(VideoQueue(), [&](int64_t aSampleTime) {
        return aSampleTime > offset.ToMicroseconds();
      });
    }
  }

  void PushFakeAudioDataIfNeeded(const media::TimeUnit& aDuration) {
    MOZ_ASSERT(Info().HasAudio());

    const auto& audioInfo = Info().mAudio;
    CheckedInt64 frames = aDuration.ToTicksAtRate(audioInfo.mRate);
    if (!frames.isValid() || !audioInfo.mChannels || !audioInfo.mRate) {
      NS_WARNING("Can't create fake audio, invalid frames/channel/rate?");
      return;
    }

    if (!frames.value()) {
      NS_WARNING(nsPrintfCString("Duration (%s) too short, no frame needed",
                                 aDuration.ToString().get())
                     .get());
      return;
    }

    // If we can get the last sample, use its frame. Otherwise, use common 1024.
    int64_t typicalPacketFrameCount = 1024;
    if (RefPtr<AudioData> audio = AudioQueue().PeekBack()) {
      typicalPacketFrameCount = audio->Frames();
    }

    media::TimeUnit totalDuration = TimeUnit::Zero(audioInfo.mRate);
    // Generate fake audio in a smaller size of audio chunk.
    while (frames.value()) {
      int64_t packetFrameCount =
          std::min(frames.value(), typicalPacketFrameCount);
      frames -= packetFrameCount;
      AlignedAudioBuffer samples(packetFrameCount * audioInfo.mChannels);
      if (!samples) {
        NS_WARNING("Can't create audio buffer, OOM?");
        return;
      }
      // `mDecodedAudioEndTime` is adjusted time, and we want unadjusted time
      // otherwise the time would be adjusted twice when pushing sample into the
      // media queue.
      media::TimeUnit startTime = mMaster->mDecodedAudioEndTime;
      if (AudioQueue().GetOffset() != media::TimeUnit::Zero()) {
        startTime -= AudioQueue().GetOffset();
      }
      RefPtr<AudioData> data(new AudioData(0, startTime, std::move(samples),
                                           audioInfo.mChannels,
                                           audioInfo.mRate));
      SLOG("Created fake audio data (duration=%s, frame-left=%" PRId64 ")",
           data->mDuration.ToString().get(), frames.value());
      totalDuration += data->mDuration;
      HandleAudioDecoded(data);
    }
    SLOG("Pushed fake silence audio data in total duration=%" PRId64 "%s",
         totalDuration.ToMicroseconds(), totalDuration.ToString().get());
  }

  bool HasDecodedLastAudioFrame() const {
    // when we're going to leave looping state and have got EOS before, we
    // should mark audio queue as ended because we have got all data we need.
    return mAudioDataRequest.Exists() || mAudioSeekRequest.Exists() ||
           ShouldDiscardLoopedData(MediaData::Type::AUDIO_DATA) ||
           IsDataWaitingForTimestampAdjustment(MediaData::Type::AUDIO_DATA) ||
           mIsReachingAudioEOS;
  }

  bool HasDecodedLastVideoFrame() const {
    // when we're going to leave looping state and have got EOS before, we
    // should mark video queue as ended because we have got all data we need.
    return mVideoDataRequest.Exists() || mVideoSeekRequest.Exists() ||
           ShouldDiscardLoopedData(MediaData::Type::VIDEO_DATA) ||
           IsDataWaitingForTimestampAdjustment(MediaData::Type::VIDEO_DATA) ||
           mIsReachingVideoEOS;
  }

  bool ShouldStopPrerolling() const override {
    // These checks is used to handle the media queue aren't opened correctly
    // because they've been close before entering the looping state. Therefore,
    // we need to preroll data in order to let new data to reopen the queue
    // automatically. Otherwise, playback can't start successfully.
    bool isWaitingForNewData = false;
    if (mMaster->HasAudio()) {
      isWaitingForNewData |= (mIsReachingAudioEOS && AudioQueue().IsFinished());
    }
    if (mMaster->HasVideo()) {
      isWaitingForNewData |= (mIsReachingVideoEOS && VideoQueue().IsFinished());
    }
    return !isWaitingForNewData && DecodingState::ShouldStopPrerolling();
  }

  bool IsReaderSeeking() const {
    return mAudioSeekRequest.Exists() || mVideoSeekRequest.Exists();
  }

  bool IsWaitingData(MediaData::Type aType) const override {
    if (aType == MediaData::Type::AUDIO_DATA) {
      return mMaster->IsWaitingAudioData() ||
             IsDataWaitingForTimestampAdjustment(MediaData::Type::AUDIO_DATA);
    }
    MOZ_DIAGNOSTIC_ASSERT(aType == MediaData::Type::VIDEO_DATA);
    return mMaster->IsWaitingVideoData() ||
           IsDataWaitingForTimestampAdjustment(MediaData::Type::VIDEO_DATA);
  }

  bool IsRequestingDataFromStartPosition(MediaData::Type aType) const {
    MOZ_DIAGNOSTIC_ASSERT(aType == MediaData::Type::AUDIO_DATA ||
                          aType == MediaData::Type::VIDEO_DATA);
    if (aType == MediaData::Type::AUDIO_DATA) {
      return mAudioSeekRequest.Exists() || mAudioDataRequest.Exists();
    }
    return mVideoSeekRequest.Exists() || mVideoDataRequest.Exists();
  }

  bool IsBufferingAllowed() const override {
    return !mIsReachingAudioEOS && !mIsReachingVideoEOS;
  }

  bool mIsReachingAudioEOS;
  bool mIsReachingVideoEOS;

  /**
   * If we have both tracks which have different length, when one track ends
   * first, we can't adjust new data from that track if another longer track
   * hasn't ended yet. The adjusted timestamp needs to be based off the longer
   * track's last data's timestamp, because otherwise it would cause a deviation
   * and eventually a/v unsync. Those sample needs to be stored and we will
   * adjust their timestamp later.
   *
   * Following graph explains the situation in details.
   * o : decoded data with timestamp adjusted or no adjustment (not looping yet)
   * x : decoded data without timestamp adjustment.
   * - : stop decoding and nothing happens
   * EOS : the track reaches to the end. We now know the offset of the track.
   *
   * Timeline ----------------------------------->
   * Track1 :  o EOS x  -  -  o
   * Track2 :  o  o  o EOS o  o
   *
   * Before reaching track2's EOS, we can't adjust samples from track1 because
   * track2 might have longer duration than track1. The sample X would be
   * stored in `mDataWaitingTimestampAdjustment` and we would also stop decoding
   * for track1.
   *
   * After reaching track2's EOS, now we know another track's offset, and the
   * larger one would be used for `mOriginalDecodedDuration`. Once that duration
   * has been determined, we will no longer need to put samples on waiting
   * because we already know how to adjust timestamp.
   */
  RefPtr<MediaData> mDataWaitingTimestampAdjustment;

  MozPromiseRequestHolder<MediaFormatReader::SeekPromise> mAudioSeekRequest;
  MozPromiseRequestHolder<MediaFormatReader::SeekPromise> mVideoSeekRequest;
  MozPromiseRequestHolder<AudioDataPromise> mAudioDataRequest;
  MozPromiseRequestHolder<VideoDataPromise> mVideoDataRequest;

  // The media format reader only allows seeking a track at a time, if we're
  // already in seeking, then delay the new seek until the current one finishes.
  Maybe<TrackInfo::TrackType> mPendingSeekingType;

  // These are used to track a special case where the playback starts from EOS
  // position via seeking. So even if EOS has reached, none of data has been
  // decoded yet. They will be reset when `mOriginalDecodedDuration` is
  // determined.
  bool mAudioEndedBeforeEnteringStateWithoutDuration;
  bool mVideoEndedBeforeEnteringStateWithoutDuration;
};

/**
 * Purpose: seek to a particular new playback position.
 *
 * Transition to:
 *   SEEKING if any new seek request.
 *   SHUTDOWN if seek failed.
 *   COMPLETED if the new playback position is the end of the media resource.
 *   NextFrameSeekingState if completing a NextFrameSeekingFromDormantState.
 *   DECODING/LOOPING_DECODING otherwise.
 */
class MediaDecoderStateMachine::SeekingState
    : public MediaDecoderStateMachine::StateObject {
 public:
  explicit SeekingState(Master* aPtr)
      : StateObject(aPtr), mVisibility(static_cast<EventVisibility>(0)) {}

  RefPtr<MediaDecoder::SeekPromise> Enter(SeekJob&& aSeekJob,
                                          EventVisibility aVisibility) {
    mSeekJob = std::move(aSeekJob);
    mVisibility = aVisibility;

    // Suppressed visibility comes from two cases: (1) leaving dormant state,
    // and (2) resuming suspended video decoder. We want both cases to be
    // transparent to the user. So we only notify the change when the seek
    // request is from the user.
    if (mVisibility == EventVisibility::Observable) {
      // Don't stop playback for a video-only seek since we want to keep playing
      // audio and we don't need to stop playback while leaving dormant for the
      // playback should has been stopped.
      mMaster->StopPlayback();
      mMaster->UpdatePlaybackPositionInternal(mSeekJob.mTarget->GetTime());
      mMaster->mOnPlaybackEvent.Notify(MediaPlaybackEvent::SeekStarted);
      mMaster->mOnNextFrameStatus.Notify(
          MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE_SEEKING);
    }

    RefPtr<MediaDecoder::SeekPromise> p = mSeekJob.mPromise.Ensure(__func__);

    DoSeek();

    return p;
  }

  virtual void Exit() override = 0;

  State GetState() const override = 0;

  void HandleAudioDecoded(AudioData* aAudio) override = 0;
  void HandleVideoDecoded(VideoData* aVideo) override = 0;
  void HandleAudioWaited(MediaData::Type aType) override = 0;
  void HandleVideoWaited(MediaData::Type aType) override = 0;

  void HandleVideoSuspendTimeout() override {
    // Do nothing since we want a valid video frame to show when seek is done.
  }

  void HandleResumeVideoDecoding(const TimeUnit&) override {
    // Do nothing. We will resume video decoding in the decoding state.
  }

  // We specially handle next frame seeks by ignoring them if we're already
  // seeking.
  RefPtr<MediaDecoder::SeekPromise> HandleSeek(
      const SeekTarget& aTarget) override {
    if (aTarget.IsNextFrame()) {
      // We ignore next frame seeks if we already have a seek pending
      SLOG("Already SEEKING, ignoring seekToNextFrame");
      MOZ_ASSERT(!mSeekJob.mPromise.IsEmpty(), "Seek shouldn't be finished");
      return MediaDecoder::SeekPromise::CreateAndReject(
          /* aRejectValue = */ true, __func__);
    }

    return StateObject::HandleSeek(aTarget);
  }

 protected:
  SeekJob mSeekJob;
  EventVisibility mVisibility;

  virtual void DoSeek() = 0;
  // Transition to the next state (defined by the subclass) when seek is
  // completed.
  virtual void GoToNextState() { SetDecodingState(); }
  void SeekCompleted();
  virtual TimeUnit CalculateNewCurrentTime() const = 0;
};

class MediaDecoderStateMachine::AccurateSeekingState
    : public MediaDecoderStateMachine::SeekingState {
 public:
  explicit AccurateSeekingState(Master* aPtr) : SeekingState(aPtr) {}

  State GetState() const override { return DECODER_STATE_SEEKING_ACCURATE; }

  RefPtr<MediaDecoder::SeekPromise> Enter(SeekJob&& aSeekJob,
                                          EventVisibility aVisibility) {
    MOZ_ASSERT(aSeekJob.mTarget->IsAccurate() || aSeekJob.mTarget->IsFast());
    mCurrentTimeBeforeSeek = mMaster->GetMediaTime();
    return SeekingState::Enter(std::move(aSeekJob), aVisibility);
  }

  void Exit() override {
    // Disconnect MediaDecoder.
    mSeekJob.RejectIfExists(__func__);

    // Disconnect ReaderProxy.
    mSeekRequest.DisconnectIfExists();

    mWaitRequest.DisconnectIfExists();
  }

  void HandleAudioDecoded(AudioData* aAudio) override {
    MOZ_ASSERT(!mDoneAudioSeeking || !mDoneVideoSeeking,
               "Seek shouldn't be finished");
    MOZ_ASSERT(aAudio);

    AdjustFastSeekIfNeeded(aAudio);

    if (mSeekJob.mTarget->IsFast()) {
      // Non-precise seek; we can stop the seek at the first sample.
      mMaster->PushAudio(aAudio);
      mDoneAudioSeeking = true;
    } else {
      nsresult rv = DropAudioUpToSeekTarget(aAudio);
      if (NS_FAILED(rv)) {
        mMaster->DecodeError(rv);
        return;
      }
    }

    if (!mDoneAudioSeeking) {
      RequestAudioData();
      return;
    }
    MaybeFinishSeek();
  }

  void HandleVideoDecoded(VideoData* aVideo) override {
    MOZ_ASSERT(!mDoneAudioSeeking || !mDoneVideoSeeking,
               "Seek shouldn't be finished");
    MOZ_ASSERT(aVideo);

    AdjustFastSeekIfNeeded(aVideo);

    if (mSeekJob.mTarget->IsFast()) {
      // Non-precise seek. We can stop the seek at the first sample.
      mMaster->PushVideo(aVideo);
      mDoneVideoSeeking = true;
    } else {
      nsresult rv = DropVideoUpToSeekTarget(aVideo);
      if (NS_FAILED(rv)) {
        mMaster->DecodeError(rv);
        return;
      }
    }

    if (!mDoneVideoSeeking) {
      RequestVideoData();
      return;
    }
    MaybeFinishSeek();
  }

  void HandleWaitingForAudio() override {
    MOZ_ASSERT(!mDoneAudioSeeking);
    mMaster->WaitForData(MediaData::Type::AUDIO_DATA);
  }

  void HandleAudioCanceled() override {
    MOZ_ASSERT(!mDoneAudioSeeking);
    RequestAudioData();
  }

  void HandleEndOfAudio() override {
    HandleEndOfAudioInternal();
    MaybeFinishSeek();
  }

  void HandleWaitingForVideo() override {
    MOZ_ASSERT(!mDoneVideoSeeking);
    mMaster->WaitForData(MediaData::Type::VIDEO_DATA);
  }

  void HandleVideoCanceled() override {
    MOZ_ASSERT(!mDoneVideoSeeking);
    RequestVideoData();
  }

  void HandleEndOfVideo() override {
    HandleEndOfVideoInternal();
    MaybeFinishSeek();
  }

  void HandleAudioWaited(MediaData::Type aType) override {
    MOZ_ASSERT(!mDoneAudioSeeking || !mDoneVideoSeeking,
               "Seek shouldn't be finished");

    RequestAudioData();
  }

  void HandleVideoWaited(MediaData::Type aType) override {
    MOZ_ASSERT(!mDoneAudioSeeking || !mDoneVideoSeeking,
               "Seek shouldn't be finished");

    RequestVideoData();
  }

  void DoSeek() override {
    mDoneAudioSeeking = !Info().HasAudio();
    mDoneVideoSeeking = !Info().HasVideo();

    // Resetting decode should be called after stopping media sink, which can
    // ensure that we have an empty media queue before seeking the demuxer.
    mMaster->StopMediaSink();
    mMaster->ResetDecode();

    DemuxerSeek();
  }

  TimeUnit CalculateNewCurrentTime() const override {
    const auto seekTime = mSeekJob.mTarget->GetTime();

    // For the accurate seek, we always set the newCurrentTime = seekTime so
    // that the updated HTMLMediaElement.currentTime will always be the seek
    // target; we rely on the MediaSink to handles the gap between the
    // newCurrentTime and the real decoded samples' start time.
    if (mSeekJob.mTarget->IsAccurate()) {
      return seekTime;
    }

    // For the fast seek, we update the newCurrentTime with the decoded audio
    // and video samples, set it to be the one which is closet to the seekTime.
    if (mSeekJob.mTarget->IsFast()) {
      RefPtr<AudioData> audio = AudioQueue().PeekFront();
      RefPtr<VideoData> video = VideoQueue().PeekFront();

      // A situation that both audio and video approaches the end.
      if (!audio && !video) {
        return seekTime;
      }

      const int64_t audioStart =
          audio ? audio->mTime.ToMicroseconds() : INT64_MAX;
      const int64_t videoStart =
          video ? video->mTime.ToMicroseconds() : INT64_MAX;
      const int64_t audioGap = std::abs(audioStart - seekTime.ToMicroseconds());
      const int64_t videoGap = std::abs(videoStart - seekTime.ToMicroseconds());
      return TimeUnit::FromMicroseconds(audioGap <= videoGap ? audioStart
                                                             : videoStart);
    }

    MOZ_ASSERT(false, "AccurateSeekTask doesn't handle other seek types.");
    return TimeUnit::Zero();
  }

 protected:
  void DemuxerSeek() {
    // Request the demuxer to perform seek.
    Reader()
        ->Seek(mSeekJob.mTarget.ref())
        ->Then(
            OwnerThread(), __func__,
            [this](const media::TimeUnit& aUnit) { OnSeekResolved(aUnit); },
            [this](const SeekRejectValue& aReject) { OnSeekRejected(aReject); })
        ->Track(mSeekRequest);
  }

  void OnSeekResolved(media::TimeUnit) {
    AUTO_PROFILER_LABEL("AccurateSeekingState::OnSeekResolved", MEDIA_PLAYBACK);
    mSeekRequest.Complete();

    // We must decode the first samples of active streams, so we can determine
    // the new stream time. So dispatch tasks to do that.
    if (!mDoneVideoSeeking) {
      RequestVideoData();
    }
    if (!mDoneAudioSeeking) {
      RequestAudioData();
    }
  }

  void OnSeekRejected(const SeekRejectValue& aReject) {
    AUTO_PROFILER_LABEL("AccurateSeekingState::OnSeekRejected", MEDIA_PLAYBACK);
    mSeekRequest.Complete();

    if (aReject.mError == NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA) {
      SLOG("OnSeekRejected reason=WAITING_FOR_DATA type=%s",
           MediaData::EnumValueToString(aReject.mType));
      MOZ_ASSERT_IF(aReject.mType == MediaData::Type::AUDIO_DATA,
                    !mMaster->IsRequestingAudioData());
      MOZ_ASSERT_IF(aReject.mType == MediaData::Type::VIDEO_DATA,
                    !mMaster->IsRequestingVideoData());
      MOZ_ASSERT_IF(aReject.mType == MediaData::Type::AUDIO_DATA,
                    !mMaster->IsWaitingAudioData());
      MOZ_ASSERT_IF(aReject.mType == MediaData::Type::VIDEO_DATA,
                    !mMaster->IsWaitingVideoData());

      // Fire 'waiting' to notify the player that we are waiting for data.
      mMaster->mOnNextFrameStatus.Notify(
          MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE_SEEKING);

      Reader()
          ->WaitForData(aReject.mType)
          ->Then(
              OwnerThread(), __func__,
              [this](MediaData::Type aType) {
                AUTO_PROFILER_LABEL(
                    "AccurateSeekingState::OnSeekRejected:WaitDataResolved",
                    MEDIA_PLAYBACK);
                SLOG("OnSeekRejected wait promise resolved");
                mWaitRequest.Complete();
                DemuxerSeek();
              },
              [this](const WaitForDataRejectValue& aRejection) {
                AUTO_PROFILER_LABEL(
                    "AccurateSeekingState::OnSeekRejected:WaitDataRejected",
                    MEDIA_PLAYBACK);
                SLOG("OnSeekRejected wait promise rejected");
                mWaitRequest.Complete();
                mMaster->DecodeError(NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA);
              })
          ->Track(mWaitRequest);
      return;
    }

    if (aReject.mError == NS_ERROR_DOM_MEDIA_END_OF_STREAM) {
      if (!mDoneAudioSeeking) {
        HandleEndOfAudioInternal();
      }
      if (!mDoneVideoSeeking) {
        HandleEndOfVideoInternal();
      }
      MaybeFinishSeek();
      return;
    }

    MOZ_ASSERT(NS_FAILED(aReject.mError),
               "Cancels should also disconnect mSeekRequest");
    mMaster->DecodeError(aReject.mError);
  }

  void RequestAudioData() {
    MOZ_ASSERT(!mDoneAudioSeeking);
    mMaster->RequestAudioData();
  }

  virtual void RequestVideoData() {
    MOZ_ASSERT(!mDoneVideoSeeking);
    mMaster->RequestVideoData(media::TimeUnit());
  }

  void AdjustFastSeekIfNeeded(MediaData* aSample) {
    if (mSeekJob.mTarget->IsFast() &&
        mSeekJob.mTarget->GetTime() > mCurrentTimeBeforeSeek &&
        aSample->mTime < mCurrentTimeBeforeSeek) {
      // We are doing a fastSeek, but we ended up *before* the previous
      // playback position. This is surprising UX, so switch to an accurate
      // seek and decode to the seek target. This is not conformant to the
      // spec, fastSeek should always be fast, but until we get the time to
      // change all Readers to seek to the keyframe after the currentTime
      // in this case, we'll just decode forward. Bug 1026330.
      mSeekJob.mTarget->SetType(SeekTarget::Accurate);
    }
  }

  nsresult DropAudioUpToSeekTarget(AudioData* aAudio) {
    MOZ_ASSERT(aAudio && mSeekJob.mTarget->IsAccurate());

    if (mSeekJob.mTarget->GetTime() >= aAudio->GetEndTime()) {
      // Our seek target lies after the frames in this AudioData. Don't
      // push it onto the audio queue, and keep decoding forwards.
      return NS_OK;
    }

    if (aAudio->mTime > mSeekJob.mTarget->GetTime()) {
      // The seek target doesn't lie in the audio block just after the last
      // audio frames we've seen which were before the seek target. This
      // could have been the first audio data we've seen after seek, i.e. the
      // seek terminated after the seek target in the audio stream. Just
      // abort the audio decode-to-target, the state machine will play
      // silence to cover the gap. Typically this happens in poorly muxed
      // files.
      SLOGW("Audio not synced after seek, maybe a poorly muxed file?");
      mMaster->PushAudio(aAudio);
      mDoneAudioSeeking = true;
      return NS_OK;
    }

    bool ok = aAudio->SetTrimWindow(
        {mSeekJob.mTarget->GetTime().ToBase(aAudio->mTime),
         aAudio->GetEndTime()});
    if (!ok) {
      return NS_ERROR_DOM_MEDIA_OVERFLOW_ERR;
    }

    MOZ_ASSERT(AudioQueue().GetSize() == 0,
               "Should be the 1st sample after seeking");
    mMaster->PushAudio(aAudio);
    mDoneAudioSeeking = true;

    return NS_OK;
  }

  nsresult DropVideoUpToSeekTarget(VideoData* aVideo) {
    MOZ_ASSERT(aVideo);
    SLOG("DropVideoUpToSeekTarget() frame [%" PRId64 ", %" PRId64 "]",
         aVideo->mTime.ToMicroseconds(), aVideo->GetEndTime().ToMicroseconds());
    const auto target = GetSeekTarget();

    // If the frame end time is less than the seek target, we won't want
    // to display this frame after the seek, so discard it.
    if (target >= aVideo->GetEndTime()) {
      SLOG("DropVideoUpToSeekTarget() pop video frame [%" PRId64 ", %" PRId64
           "] target=%" PRId64,
           aVideo->mTime.ToMicroseconds(),
           aVideo->GetEndTime().ToMicroseconds(), target.ToMicroseconds());
      PROFILER_MARKER_UNTYPED("MDSM::DropVideoUpToSeekTarget", MEDIA_PLAYBACK);
      mFirstVideoFrameAfterSeek = aVideo;
    } else {
      if (target >= aVideo->mTime && aVideo->GetEndTime() >= target) {
        // The seek target lies inside this frame's time slice. Adjust the
        // frame's start time to match the seek target.
        aVideo->UpdateTimestamp(target);
      }
      mFirstVideoFrameAfterSeek = nullptr;

      SLOG("DropVideoUpToSeekTarget() found video frame [%" PRId64 ", %" PRId64
           "] containing target=%" PRId64,
           aVideo->mTime.ToMicroseconds(),
           aVideo->GetEndTime().ToMicroseconds(), target.ToMicroseconds());

      MOZ_ASSERT(VideoQueue().GetSize() == 0,
                 "Should be the 1st sample after seeking");
      mMaster->PushVideo(aVideo);
      mDoneVideoSeeking = true;
    }

    return NS_OK;
  }

  void HandleEndOfAudioInternal() {
    MOZ_ASSERT(!mDoneAudioSeeking);
    AudioQueue().Finish();
    mDoneAudioSeeking = true;
  }

  void HandleEndOfVideoInternal() {
    MOZ_ASSERT(!mDoneVideoSeeking);
    if (mFirstVideoFrameAfterSeek) {
      // Hit the end of stream. Move mFirstVideoFrameAfterSeek into
      // mSeekedVideoData so we have something to display after seeking.
      mMaster->PushVideo(mFirstVideoFrameAfterSeek);
    }
    VideoQueue().Finish();
    mDoneVideoSeeking = true;
  }

  void MaybeFinishSeek() {
    if (mDoneAudioSeeking && mDoneVideoSeeking) {
      SeekCompleted();
    }
  }

  /*
   * Track the current seek promise made by the reader.
   */
  MozPromiseRequestHolder<MediaFormatReader::SeekPromise> mSeekRequest;

  /*
   * Internal state.
   */
  media::TimeUnit mCurrentTimeBeforeSeek;
  bool mDoneAudioSeeking = false;
  bool mDoneVideoSeeking = false;
  MozPromiseRequestHolder<WaitForDataPromise> mWaitRequest;

  // This temporarily stores the first frame we decode after we seek.
  // This is so that if we hit end of stream while we're decoding to reach
  // the seek target, we will still have a frame that we can display as the
  // last frame in the media.
  RefPtr<VideoData> mFirstVideoFrameAfterSeek;

 private:
  virtual media::TimeUnit GetSeekTarget() const {
    return mSeekJob.mTarget->GetTime();
  }
};

/*
 * Remove samples from the queue until aCompare() returns false.
 * aCompare A function object with the signature bool(int64_t) which returns
 *          true for samples that should be removed.
 */
template <typename Type, typename Function>
static void DiscardFrames(MediaQueue<Type>& aQueue, const Function& aCompare) {
  while (aQueue.GetSize() > 0) {
    if (aCompare(aQueue.PeekFront()->mTime.ToMicroseconds())) {
      RefPtr<Type> releaseMe = aQueue.PopFront();
      continue;
    }
    break;
  }
}

class MediaDecoderStateMachine::NextFrameSeekingState
    : public MediaDecoderStateMachine::SeekingState {
 public:
  explicit NextFrameSeekingState(Master* aPtr) : SeekingState(aPtr) {}

  State GetState() const override {
    return DECODER_STATE_SEEKING_NEXTFRAMESEEKING;
  }

  RefPtr<MediaDecoder::SeekPromise> Enter(SeekJob&& aSeekJob,
                                          EventVisibility aVisibility) {
    MOZ_ASSERT(aSeekJob.mTarget->IsNextFrame());
    mCurrentTime = mMaster->GetMediaTime();
    mDuration = mMaster->Duration();
    return SeekingState::Enter(std::move(aSeekJob), aVisibility);
  }

  void Exit() override {
    // Disconnect my async seek operation.
    if (mAsyncSeekTask) {
      mAsyncSeekTask->Cancel();
    }

    // Disconnect MediaDecoder.
    mSeekJob.RejectIfExists(__func__);
  }

  void HandleAudioDecoded(AudioData* aAudio) override {
    mMaster->PushAudio(aAudio);
  }

  void HandleVideoDecoded(VideoData* aVideo) override {
    MOZ_ASSERT(aVideo);
    MOZ_ASSERT(!mSeekJob.mPromise.IsEmpty(), "Seek shouldn't be finished");
    MOZ_ASSERT(NeedMoreVideo());

    if (aVideo->mTime > mCurrentTime) {
      mMaster->PushVideo(aVideo);
      FinishSeek();
    } else {
      RequestVideoData();
    }
  }

  void HandleWaitingForAudio() override {
    MOZ_ASSERT(!mSeekJob.mPromise.IsEmpty(), "Seek shouldn't be finished");
    // We don't care about audio decode errors in this state which will be
    // handled by other states after seeking.
  }

  void HandleAudioCanceled() override {
    MOZ_ASSERT(!mSeekJob.mPromise.IsEmpty(), "Seek shouldn't be finished");
    // We don't care about audio decode errors in this state which will be
    // handled by other states after seeking.
  }

  void HandleEndOfAudio() override {
    MOZ_ASSERT(!mSeekJob.mPromise.IsEmpty(), "Seek shouldn't be finished");
    // We don't care about audio decode errors in this state which will be
    // handled by other states after seeking.
  }

  void HandleWaitingForVideo() override {
    MOZ_ASSERT(!mSeekJob.mPromise.IsEmpty(), "Seek shouldn't be finished");
    MOZ_ASSERT(NeedMoreVideo());
    mMaster->WaitForData(MediaData::Type::VIDEO_DATA);
  }

  void HandleVideoCanceled() override {
    MOZ_ASSERT(!mSeekJob.mPromise.IsEmpty(), "Seek shouldn't be finished");
    MOZ_ASSERT(NeedMoreVideo());
    RequestVideoData();
  }

  void HandleEndOfVideo() override {
    MOZ_ASSERT(!mSeekJob.mPromise.IsEmpty(), "Seek shouldn't be finished");
    MOZ_ASSERT(NeedMoreVideo());
    VideoQueue().Finish();
    FinishSeek();
  }

  void HandleAudioWaited(MediaData::Type aType) override {
    // We don't care about audio in this state.
  }

  void HandleVideoWaited(MediaData::Type aType) override {
    MOZ_ASSERT(!mSeekJob.mPromise.IsEmpty(), "Seek shouldn't be finished");
    MOZ_ASSERT(NeedMoreVideo());
    RequestVideoData();
  }

  TimeUnit CalculateNewCurrentTime() const override {
    // The HTMLMediaElement.currentTime should be updated to the seek target
    // which has been updated to the next frame's time.
    return mSeekJob.mTarget->GetTime();
  }

  void DoSeek() override {
    mMaster->StopMediaSink();

    auto currentTime = mCurrentTime;
    DiscardFrames(VideoQueue(), [currentTime](int64_t aSampleTime) {
      return aSampleTime <= currentTime.ToMicroseconds();
    });

    // If there is a pending video request, finish the seeking if we don't need
    // more data, or wait for HandleVideoDecoded() to finish seeking.
    if (mMaster->IsRequestingVideoData()) {
      if (!NeedMoreVideo()) {
        FinishSeek();
      }
      return;
    }

    // Otherwise, we need to do the seek operation asynchronously for a special
    // case (video with no data)which has no data at all, the 1st
    // seekToNextFrame() operation reaches the end of the media. If we did the
    // seek operation synchronously, we immediately resolve the SeekPromise in
    // mSeekJob and then switch to the CompletedState which dispatches an
    // "ended" event. However, the ThenValue of the SeekPromise has not yet been
    // set, so the promise resolving is postponed and then the JS developer
    // receives the "ended" event before the seek promise is resolved. An
    // asynchronous seek operation helps to solve this issue since while the
    // seek is actually performed, the ThenValue of SeekPromise has already been
    // set so that it won't be postponed.
    RefPtr<Runnable> r = mAsyncSeekTask = new AysncNextFrameSeekTask(this);
    nsresult rv = OwnerThread()->Dispatch(r.forget());
    MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));
    Unused << rv;
  }

 private:
  void DoSeekInternal() {
    // We don't need to discard frames to the mCurrentTime here because we have
    // done it at DoSeek() and any video data received in between either
    // finishes the seek operation or be discarded, see HandleVideoDecoded().

    if (!NeedMoreVideo()) {
      FinishSeek();
    } else if (!mMaster->IsTrackingVideoData()) {
      RequestVideoData();
    }
  }

  class AysncNextFrameSeekTask : public Runnable {
   public:
    explicit AysncNextFrameSeekTask(NextFrameSeekingState* aStateObject)
        : Runnable(
              "MediaDecoderStateMachine::NextFrameSeekingState::"
              "AysncNextFrameSeekTask"),
          mStateObj(aStateObject) {}

    void Cancel() { mStateObj = nullptr; }

    NS_IMETHOD Run() override {
      if (mStateObj) {
        AUTO_PROFILER_LABEL("AysncNextFrameSeekTask::Run", MEDIA_PLAYBACK);
        mStateObj->DoSeekInternal();
      }
      return NS_OK;
    }

   private:
    NextFrameSeekingState* mStateObj;
  };

  void RequestVideoData() { mMaster->RequestVideoData(media::TimeUnit()); }

  bool NeedMoreVideo() const {
    // Need to request video when we have none and video queue is not finished.
    return VideoQueue().GetSize() == 0 && !VideoQueue().IsFinished();
  }

  // Update the seek target's time before resolving this seek task, the updated
  // time will be used in the MDSM::SeekCompleted() to update the MDSM's
  // position.
  void UpdateSeekTargetTime() {
    RefPtr<VideoData> data = VideoQueue().PeekFront();
    if (data) {
      mSeekJob.mTarget->SetTime(data->mTime);
    } else {
      MOZ_ASSERT(VideoQueue().AtEndOfStream());
      mSeekJob.mTarget->SetTime(mDuration);
    }
  }

  void FinishSeek() {
    MOZ_ASSERT(!NeedMoreVideo());
    UpdateSeekTargetTime();
    auto time = mSeekJob.mTarget->GetTime().ToMicroseconds();
    DiscardFrames(AudioQueue(),
                  [time](int64_t aSampleTime) { return aSampleTime < time; });
    SeekCompleted();
  }

  /*
   * Internal state.
   */
  TimeUnit mCurrentTime;
  TimeUnit mDuration;
  RefPtr<AysncNextFrameSeekTask> mAsyncSeekTask;
};

class MediaDecoderStateMachine::NextFrameSeekingFromDormantState
    : public MediaDecoderStateMachine::AccurateSeekingState {
 public:
  explicit NextFrameSeekingFromDormantState(Master* aPtr)
      : AccurateSeekingState(aPtr) {}

  State GetState() const override { return DECODER_STATE_SEEKING_FROMDORMANT; }

  RefPtr<MediaDecoder::SeekPromise> Enter(SeekJob&& aCurrentSeekJob,
                                          SeekJob&& aFutureSeekJob) {
    mFutureSeekJob = std::move(aFutureSeekJob);

    AccurateSeekingState::Enter(std::move(aCurrentSeekJob),
                                EventVisibility::Suppressed);

    // Once seekToNextFrame() is called, we assume the user is likely to keep
    // calling seekToNextFrame() repeatedly, and so, we should prevent the MDSM
    // from getting into Dormant state.
    mMaster->mMinimizePreroll = false;

    return mFutureSeekJob.mPromise.Ensure(__func__);
  }

  void Exit() override {
    mFutureSeekJob.RejectIfExists(__func__);
    AccurateSeekingState::Exit();
  }

 private:
  SeekJob mFutureSeekJob;

  // We don't want to transition to DecodingState once this seek completes,
  // instead, we transition to NextFrameSeekingState.
  void GoToNextState() override {
    SetState<NextFrameSeekingState>(std::move(mFutureSeekJob),
                                    EventVisibility::Observable);
  }
};

class MediaDecoderStateMachine::VideoOnlySeekingState
    : public MediaDecoderStateMachine::AccurateSeekingState {
 public:
  explicit VideoOnlySeekingState(Master* aPtr) : AccurateSeekingState(aPtr) {}

  State GetState() const override { return DECODER_STATE_SEEKING_VIDEOONLY; }

  RefPtr<MediaDecoder::SeekPromise> Enter(SeekJob&& aSeekJob,
                                          EventVisibility aVisibility) {
    MOZ_ASSERT(aSeekJob.mTarget->IsVideoOnly());
    MOZ_ASSERT(aVisibility == EventVisibility::Suppressed);

    RefPtr<MediaDecoder::SeekPromise> p =
        AccurateSeekingState::Enter(std::move(aSeekJob), aVisibility);

    // Dispatch a mozvideoonlyseekbegin event to indicate UI for corresponding
    // changes.
    mMaster->mOnPlaybackEvent.Notify(MediaPlaybackEvent::VideoOnlySeekBegin);

    return p;
  }

  void Exit() override {
    // We are completing or discarding this video-only seek operation now,
    // dispatch an event so that the UI can change in response to the end
    // of video-only seek.
    mMaster->mOnPlaybackEvent.Notify(
        MediaPlaybackEvent::VideoOnlySeekCompleted);

    AccurateSeekingState::Exit();
  }

  void HandleAudioDecoded(AudioData* aAudio) override {
    MOZ_ASSERT(mDoneAudioSeeking && !mDoneVideoSeeking,
               "Seek shouldn't be finished");
    MOZ_ASSERT(aAudio);

    // Video-only seek doesn't reset audio decoder. There might be pending audio
    // requests when AccurateSeekTask::Seek() begins. We will just store the
    // data without checking |mDiscontinuity| or calling
    // DropAudioUpToSeekTarget().
    mMaster->PushAudio(aAudio);
  }

  void HandleWaitingForAudio() override {}

  void HandleAudioCanceled() override {}

  void HandleEndOfAudio() override {}

  void HandleAudioWaited(MediaData::Type aType) override {
    MOZ_ASSERT(!mDoneAudioSeeking || !mDoneVideoSeeking,
               "Seek shouldn't be finished");

    // Ignore pending requests from video-only seek.
  }

  void DoSeek() override {
    // TODO: keep decoding audio.
    mDoneAudioSeeking = true;
    mDoneVideoSeeking = !Info().HasVideo();

    const auto offset = VideoQueue().GetOffset();
    mMaster->ResetDecode(TrackInfo::kVideoTrack);

    // Entering video-only state and we've looped at least once before, so we
    // need to set offset in order to let new video frames catch up with the
    // clock time.
    if (offset != media::TimeUnit::Zero()) {
      VideoQueue().SetOffset(offset);
    }

    DemuxerSeek();
  }

 protected:
  // Allow skip-to-next-key-frame to kick in if we fall behind the current
  // playback position so decoding has a better chance to catch up.
  void RequestVideoData() override {
    MOZ_ASSERT(!mDoneVideoSeeking);

    auto clock = mMaster->mMediaSink->IsStarted() ? mMaster->GetClock()
                                                  : mMaster->GetMediaTime();
    mMaster->AdjustByLooping(clock);
    const auto& nextKeyFrameTime = GetNextKeyFrameTime();

    auto threshold = clock;

    if (nextKeyFrameTime.IsValid() &&
        clock >= (nextKeyFrameTime - sSkipToNextKeyFrameThreshold)) {
      threshold = nextKeyFrameTime;
    }

    mMaster->RequestVideoData(threshold);
  }

 private:
  // Trigger skip to next key frame if the current playback position is very
  // close the next key frame's time.
  static constexpr TimeUnit sSkipToNextKeyFrameThreshold =
      TimeUnit::FromMicroseconds(5000);

  // If the media is playing, drop video until catch up playback position.
  media::TimeUnit GetSeekTarget() const override {
    auto target = mMaster->mMediaSink->IsStarted()
                      ? mMaster->GetClock()
                      : mSeekJob.mTarget->GetTime();
    mMaster->AdjustByLooping(target);
    return target;
  }

  media::TimeUnit GetNextKeyFrameTime() const {
    // We only call this method in RequestVideoData() and we only request video
    // data if we haven't done video seeking.
    MOZ_DIAGNOSTIC_ASSERT(!mDoneVideoSeeking);
    MOZ_DIAGNOSTIC_ASSERT(mMaster->VideoQueue().GetSize() == 0);

    if (mFirstVideoFrameAfterSeek) {
      return mFirstVideoFrameAfterSeek->NextKeyFrameTime();
    }

    return TimeUnit::Invalid();
  }
};

constexpr TimeUnit MediaDecoderStateMachine::VideoOnlySeekingState::
    sSkipToNextKeyFrameThreshold;

RefPtr<MediaDecoder::SeekPromise>
MediaDecoderStateMachine::DormantState::HandleSeek(const SeekTarget& aTarget) {
  if (aTarget.IsNextFrame()) {
    // NextFrameSeekingState doesn't reset the decoder unlike
    // AccurateSeekingState. So we first must come out of dormant by seeking to
    // mPendingSeek and continue later with the NextFrameSeek
    SLOG("Changed state to SEEKING (to %" PRId64 ")",
         aTarget.GetTime().ToMicroseconds());
    SeekJob seekJob;
    seekJob.mTarget = Some(aTarget);
    return StateObject::SetState<NextFrameSeekingFromDormantState>(
        std::move(mPendingSeek), std::move(seekJob));
  }

  return StateObject::HandleSeek(aTarget);
}

/**
 * Purpose: stop playback until enough data is decoded to continue playback.
 *
 * Transition to:
 *   SEEKING if any seek request.
 *   SHUTDOWN if any decode error.
 *   COMPLETED when having decoded all audio/video data.
 *   DECODING/LOOPING_DECODING when having decoded enough data to continue
 * playback.
 */
class MediaDecoderStateMachine::BufferingState
    : public MediaDecoderStateMachine::StateObject {
 public:
  explicit BufferingState(Master* aPtr) : StateObject(aPtr) {}

  void Enter() {
    if (mMaster->IsPlaying()) {
      mMaster->StopPlayback();
    }

    mBufferingStart = TimeStamp::Now();
    // Playback is now stopped, so there is no need to connect to the queues'
    // PopFrontEvent()s, but frames may have been recently popped before the
    // transition from DECODING.
    if (mMaster->IsAudioDecoding() && !mMaster->HaveEnoughDecodedAudio() &&
        !mMaster->IsTrackingAudioData()) {
      mMaster->RequestAudioData();
    }
    if (mMaster->IsVideoDecoding() && !mMaster->HaveEnoughDecodedVideo() &&
        !mMaster->IsTrackingVideoData()) {
      mMaster->RequestVideoData(TimeUnit());
    }

    mMaster->ScheduleStateMachineIn(TimeUnit::FromMicroseconds(USECS_PER_S));
    mMaster->mOnNextFrameStatus.Notify(
        MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE_BUFFERING);
  }

  void Step() override;

  State GetState() const override { return DECODER_STATE_BUFFERING; }

  void HandleAudioDecoded(AudioData* aAudio) override {
    mMaster->PushAudio(aAudio);
    if (!mMaster->HaveEnoughDecodedAudio()) {
      mMaster->RequestAudioData();
    }
    // This might be the sample we need to exit buffering.
    // Schedule Step() to check it.
    mMaster->ScheduleStateMachine();
  }

  void HandleVideoDecoded(VideoData* aVideo) override {
    mMaster->PushVideo(aVideo);
    if (!mMaster->HaveEnoughDecodedVideo()) {
      mMaster->RequestVideoData(media::TimeUnit());
    }
    // This might be the sample we need to exit buffering.
    // Schedule Step() to check it.
    mMaster->ScheduleStateMachine();
  }

  void HandleAudioCanceled() override { mMaster->RequestAudioData(); }

  void HandleVideoCanceled() override {
    mMaster->RequestVideoData(media::TimeUnit());
  }

  void HandleWaitingForAudio() override {
    mMaster->WaitForData(MediaData::Type::AUDIO_DATA);
  }

  void HandleWaitingForVideo() override {
    mMaster->WaitForData(MediaData::Type::VIDEO_DATA);
  }

  void HandleAudioWaited(MediaData::Type aType) override {
    mMaster->RequestAudioData();
  }

  void HandleVideoWaited(MediaData::Type aType) override {
    mMaster->RequestVideoData(media::TimeUnit());
  }

  void HandleEndOfAudio() override;
  void HandleEndOfVideo() override;

  void HandleVideoSuspendTimeout() override {
    // No video, so nothing to suspend.
    if (!mMaster->HasVideo()) {
      return;
    }

    mMaster->mVideoDecodeSuspended = true;
    mMaster->mOnPlaybackEvent.Notify(MediaPlaybackEvent::EnterVideoSuspend);
    Reader()->SetVideoBlankDecode(true);
  }

 private:
  TimeStamp mBufferingStart;

  // The maximum number of second we spend buffering when we are short on
  // unbuffered data.
  const uint32_t mBufferingWait = 15;
};

/**
 * Purpose: play all the decoded data and fire the 'ended' event.
 *
 * Transition to:
 *   SEEKING if any seek request.
 *   LOOPING_DECODING if MDSM enable looping.
 */
class MediaDecoderStateMachine::CompletedState
    : public MediaDecoderStateMachine::StateObject {
 public:
  explicit CompletedState(Master* aPtr) : StateObject(aPtr) {}

  void Enter() {
    // On Android, the life cycle of graphic buffer is equal to Android's codec,
    // we couldn't release it if we still need to render the frame.
#ifndef MOZ_WIDGET_ANDROID
    if (!mMaster->mLooping) {
      // We've decoded all samples.
      // We don't need decoders anymore if not looping.
      Reader()->ReleaseResources();
    }
#endif
    bool hasNextFrame = (!mMaster->HasAudio() || !mMaster->mAudioCompleted) &&
                        (!mMaster->HasVideo() || !mMaster->mVideoCompleted);

    mMaster->mOnNextFrameStatus.Notify(
        hasNextFrame ? MediaDecoderOwner::NEXT_FRAME_AVAILABLE
                     : MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE);

    Step();
  }

  void Exit() override { mSentPlaybackEndedEvent = false; }

  void Step() override {
    if (mMaster->mPlayState != MediaDecoder::PLAY_STATE_PLAYING &&
        mMaster->IsPlaying()) {
      mMaster->StopPlayback();
    }

    // Play the remaining media. We want to run AdvanceFrame() at least
    // once to ensure the current playback position is advanced to the
    // end of the media, and so that we update the readyState.
    if ((mMaster->HasVideo() && !mMaster->mVideoCompleted) ||
        (mMaster->HasAudio() && !mMaster->mAudioCompleted)) {
      // Start playback if necessary to play the remaining media.
      mMaster->MaybeStartPlayback();
      mMaster->UpdatePlaybackPositionPeriodically();
      MOZ_ASSERT(!mMaster->IsPlaying() || mMaster->IsStateMachineScheduled(),
                 "Must have timer scheduled");
      return;
    }

    // StopPlayback in order to reset the IsPlaying() state so audio
    // is restarted correctly.
    mMaster->StopPlayback();

    if (!mSentPlaybackEndedEvent) {
      auto clockTime =
          std::max(mMaster->AudioEndTime(), mMaster->VideoEndTime());
      // Correct the time over the end once looping was turned on.
      mMaster->AdjustByLooping(clockTime);
      if (mMaster->mDuration.Ref()->IsInfinite()) {
        // We have a finite duration when playback reaches the end.
        mMaster->mDuration = Some(clockTime);
        DDLOGEX(mMaster, DDLogCategory::Property, "duration_us",
                mMaster->mDuration.Ref()->ToMicroseconds());
      }
      mMaster->UpdatePlaybackPosition(clockTime);

      // Ensure readyState is updated before firing the 'ended' event.
      mMaster->mOnNextFrameStatus.Notify(
          MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE);

      mMaster->mOnPlaybackEvent.Notify(MediaPlaybackEvent::PlaybackEnded);

      mSentPlaybackEndedEvent = true;

      // MediaSink::GetEndTime() must be called before stopping playback.
      mMaster->StopMediaSink();
    }
  }

  State GetState() const override { return DECODER_STATE_COMPLETED; }

  void HandleLoopingChanged() override {
    if (mMaster->mLooping) {
      SetDecodingState();
    }
  }

  void HandleAudioCaptured() override {
    // MediaSink is changed. Schedule Step() to check if we can start playback.
    mMaster->ScheduleStateMachine();
  }

  void HandleVideoSuspendTimeout() override {
    // Do nothing since no decoding is going on.
  }

  void HandleResumeVideoDecoding(const TimeUnit&) override {
    // Resume the video decoder and seek to the last video frame.
    // This triggers a video-only seek which won't update the playback position.
    auto target = mMaster->mDecodedVideoEndTime;
    mMaster->AdjustByLooping(target);
    StateObject::HandleResumeVideoDecoding(target);
  }

  void HandlePlayStateChanged(MediaDecoder::PlayState aPlayState) override {
    if (aPlayState == MediaDecoder::PLAY_STATE_PLAYING) {
      // Schedule Step() to check if we can start playback.
      mMaster->ScheduleStateMachine();
    }
  }

 private:
  bool mSentPlaybackEndedEvent = false;
};

/**
 * Purpose: release all resources allocated by MDSM.
 *
 * Transition to:
 *   None since this is the final state.
 *
 * Transition from:
 *   Any states other than SHUTDOWN.
 */
class MediaDecoderStateMachine::ShutdownState
    : public MediaDecoderStateMachine::StateObject {
 public:
  explicit ShutdownState(Master* aPtr) : StateObject(aPtr) {}

  RefPtr<ShutdownPromise> Enter();

  void Exit() override {
    MOZ_DIAGNOSTIC_CRASH("Shouldn't escape the SHUTDOWN state.");
  }

  State GetState() const override { return DECODER_STATE_SHUTDOWN; }

  RefPtr<MediaDecoder::SeekPromise> HandleSeek(
      const SeekTarget& aTarget) override {
    MOZ_DIAGNOSTIC_CRASH("Can't seek in shutdown state.");
    return MediaDecoder::SeekPromise::CreateAndReject(true, __func__);
  }

  RefPtr<ShutdownPromise> HandleShutdown() override {
    MOZ_DIAGNOSTIC_CRASH("Already shutting down.");
    return nullptr;
  }

  void HandleVideoSuspendTimeout() override {
    MOZ_DIAGNOSTIC_CRASH("Already shutting down.");
  }

  void HandleResumeVideoDecoding(const TimeUnit&) override {
    MOZ_DIAGNOSTIC_CRASH("Already shutting down.");
  }
};

RefPtr<MediaDecoder::SeekPromise>
MediaDecoderStateMachine::StateObject::HandleSeek(const SeekTarget& aTarget) {
  SLOG("Changed state to SEEKING (to %" PRId64 ")",
       aTarget.GetTime().ToMicroseconds());
  SeekJob seekJob;
  seekJob.mTarget = Some(aTarget);
  return SetSeekingState(std::move(seekJob), EventVisibility::Observable);
}

RefPtr<ShutdownPromise>
MediaDecoderStateMachine::StateObject::HandleShutdown() {
  return SetState<ShutdownState>();
}

void MediaDecoderStateMachine::StateObject::HandleResumeVideoDecoding(
    const TimeUnit& aTarget) {
  MOZ_ASSERT(mMaster->mVideoDecodeSuspended);

  mMaster->mVideoDecodeSuspended = false;
  mMaster->mOnPlaybackEvent.Notify(MediaPlaybackEvent::ExitVideoSuspend);
  Reader()->SetVideoBlankDecode(false);

  // Start video-only seek to the current time.
  SeekJob seekJob;

  // We use fastseek to optimize the resuming time.
  // FastSeek is only used for video-only media since we don't need to worry
  // about A/V sync.
  // Don't use fastSeek if we want to seek to the end because it might seek to a
  // keyframe before the last frame (if the last frame itself is not a keyframe)
  // and we always want to present the final frame to the user when seeking to
  // the end.
  const auto type = mMaster->HasAudio() || aTarget == mMaster->Duration()
                        ? SeekTarget::Type::Accurate
                        : SeekTarget::Type::PrevSyncPoint;

  seekJob.mTarget.emplace(aTarget, type, SeekTarget::Track::VideoOnly);
  SLOG("video-only seek target=%" PRId64 ", current time=%" PRId64,
       aTarget.ToMicroseconds(), mMaster->GetMediaTime().ToMicroseconds());

  SetSeekingState(std::move(seekJob), EventVisibility::Suppressed);
}

RefPtr<MediaDecoder::SeekPromise>
MediaDecoderStateMachine::StateObject::SetSeekingState(
    SeekJob&& aSeekJob, EventVisibility aVisibility) {
  if (aSeekJob.mTarget->IsAccurate() || aSeekJob.mTarget->IsFast()) {
    if (aSeekJob.mTarget->IsVideoOnly()) {
      return SetState<VideoOnlySeekingState>(std::move(aSeekJob), aVisibility);
    }
    return SetState<AccurateSeekingState>(std::move(aSeekJob), aVisibility);
  }

  if (aSeekJob.mTarget->IsNextFrame()) {
    return SetState<NextFrameSeekingState>(std::move(aSeekJob), aVisibility);
  }

  MOZ_ASSERT_UNREACHABLE("Unknown SeekTarget::Type.");
  return nullptr;
}

void MediaDecoderStateMachine::StateObject::SetDecodingState() {
  if (mMaster->IsInSeamlessLooping()) {
    SetState<LoopingDecodingState>();
    return;
  }
  SetState<DecodingState>();
}

void MediaDecoderStateMachine::DecodeMetadataState::OnMetadataRead(
    MetadataHolder&& aMetadata) {
  mMetadataRequest.Complete();

  AUTO_PROFILER_LABEL("DecodeMetadataState::OnMetadataRead", MEDIA_PLAYBACK);
  mMaster->mInfo.emplace(*aMetadata.mInfo);
  mMaster->mMediaSeekable = Info().mMediaSeekable;
  mMaster->mMediaSeekableOnlyInBufferedRanges =
      Info().mMediaSeekableOnlyInBufferedRanges;

  if (Info().mMetadataDuration.isSome()) {
    mMaster->mDuration = Info().mMetadataDuration;
  } else if (Info().mUnadjustedMetadataEndTime.isSome()) {
    const TimeUnit unadjusted = Info().mUnadjustedMetadataEndTime.ref();
    const TimeUnit adjustment = Info().mStartTime;
    SLOG("No metadata duration, calculate one. unadjusted=%" PRId64
         ", adjustment=%" PRId64,
         unadjusted.ToMicroseconds(), adjustment.ToMicroseconds());
    mMaster->mInfo->mMetadataDuration.emplace(unadjusted - adjustment);
    mMaster->mDuration = Info().mMetadataDuration;
  }

  // If we don't know the duration by this point, we assume infinity, per spec.
  if (mMaster->mDuration.Ref().isNothing()) {
    mMaster->mDuration = Some(TimeUnit::FromInfinity());
  }

  DDLOGEX(mMaster, DDLogCategory::Property, "duration_us",
          mMaster->mDuration.Ref()->ToMicroseconds());

  if (mMaster->HasVideo()) {
    SLOG("Video decode HWAccel=%d videoQueueSize=%d",
         Reader()->VideoIsHardwareAccelerated(),
         mMaster->GetAmpleVideoFrames());
  }

  MOZ_ASSERT(mMaster->mDuration.Ref().isSome());
  SLOG("OnMetadataRead, duration=%" PRId64,
       mMaster->mDuration.Ref()->ToMicroseconds());

  mMaster->mMetadataLoadedEvent.Notify(std::move(aMetadata.mInfo),
                                       std::move(aMetadata.mTags),
                                       MediaDecoderEventVisibility::Observable);

  // Check whether the media satisfies the requirement of seamless looping.
  // TODO : after we ensure video seamless looping is stable enough, then we can
  // remove this to make the condition always true.
  mMaster->mSeamlessLoopingAllowed = StaticPrefs::media_seamless_looping();
  if (mMaster->HasVideo()) {
    mMaster->mSeamlessLoopingAllowed =
        StaticPrefs::media_seamless_looping_video();
  }

  SetState<DecodingFirstFrameState>();
}

void MediaDecoderStateMachine::DormantState::HandlePlayStateChanged(
    MediaDecoder::PlayState aPlayState) {
  if (aPlayState == MediaDecoder::PLAY_STATE_PLAYING) {
    // Exit dormant when the user wants to play.
    MOZ_ASSERT(mMaster->mSentFirstFrameLoadedEvent);
    SetSeekingState(std::move(mPendingSeek), EventVisibility::Suppressed);
  }
}

void MediaDecoderStateMachine::DecodingFirstFrameState::Enter() {
  // Transition to DECODING if we've decoded first frames.
  if (mMaster->mSentFirstFrameLoadedEvent) {
    SetDecodingState();
    return;
  }

  MOZ_ASSERT(!mMaster->mVideoDecodeSuspended);

  // Dispatch tasks to decode first frames.
  if (mMaster->HasAudio()) {
    mMaster->RequestAudioData();
  }
  if (mMaster->HasVideo()) {
    mMaster->RequestVideoData(media::TimeUnit());
  }
}

void MediaDecoderStateMachine::DecodingFirstFrameState::
    MaybeFinishDecodeFirstFrame() {
  MOZ_ASSERT(!mMaster->mSentFirstFrameLoadedEvent);

  if ((mMaster->IsAudioDecoding() && AudioQueue().GetSize() == 0) ||
      (mMaster->IsVideoDecoding() && VideoQueue().GetSize() == 0)) {
    return;
  }

  mMaster->FinishDecodeFirstFrame();
  if (mPendingSeek.Exists()) {
    SetSeekingState(std::move(mPendingSeek), EventVisibility::Observable);
  } else {
    SetDecodingState();
  }
}

void MediaDecoderStateMachine::DecodingState::Enter() {
  MOZ_ASSERT(mMaster->mSentFirstFrameLoadedEvent);

  if (mMaster->mVideoDecodeSuspended &&
      mMaster->mVideoDecodeMode == VideoDecodeMode::Normal) {
    StateObject::HandleResumeVideoDecoding(mMaster->GetMediaTime());
    return;
  }

  if (mMaster->mVideoDecodeMode == VideoDecodeMode::Suspend &&
      !mMaster->mVideoDecodeSuspendTimer.IsScheduled() &&
      !mMaster->mVideoDecodeSuspended) {
    // If the VideoDecodeMode is Suspend and the timer is not schedule, it means
    // the timer has timed out and we should suspend video decoding now if
    // necessary.
    HandleVideoSuspendTimeout();
  }

  // If we're in the normal decoding mode and the decoding has finished, then we
  // should go to `completed` state because we don't need to decode anything
  // later. However, if we're in the saemless decoding mode, we will restart
  // decoding ASAP so we can still stay in `decoding` state.
  if (!mMaster->IsVideoDecoding() && !mMaster->IsAudioDecoding() &&
      !mMaster->IsInSeamlessLooping()) {
    SetState<CompletedState>();
    return;
  }

  mOnAudioPopped =
      AudioQueue().PopFrontEvent().Connect(OwnerThread(), [this]() {
        AUTO_PROFILER_LABEL("MediaDecoderStateMachine::OnAudioPopped",
                            MEDIA_PLAYBACK);
        if (mMaster->IsAudioDecoding() && !mMaster->HaveEnoughDecodedAudio()) {
          EnsureAudioDecodeTaskQueued();
        }
      });
  mOnVideoPopped =
      VideoQueue().PopFrontEvent().Connect(OwnerThread(), [this]() {
        AUTO_PROFILER_LABEL("MediaDecoderStateMachine::OnVideoPopped",
                            MEDIA_PLAYBACK);
        if (mMaster->IsVideoDecoding() && !mMaster->HaveEnoughDecodedVideo()) {
          EnsureVideoDecodeTaskQueued();
        }
      });

  mMaster->mOnNextFrameStatus.Notify(MediaDecoderOwner::NEXT_FRAME_AVAILABLE);

  mDecodeStartTime = TimeStamp::Now();

  MaybeStopPrerolling();

  // Ensure that we've got tasks enqueued to decode data if we need to.
  DispatchDecodeTasksIfNeeded();

  mMaster->ScheduleStateMachine();

  // Will enter dormant when playback is paused for a while.
  if (mMaster->mPlayState == MediaDecoder::PLAY_STATE_PAUSED) {
    StartDormantTimer();
  }
}

void MediaDecoderStateMachine::DecodingState::Step() {
  if (mMaster->mPlayState != MediaDecoder::PLAY_STATE_PLAYING &&
      mMaster->IsPlaying()) {
    // We're playing, but the element/decoder is in paused state. Stop
    // playing!
    mMaster->StopPlayback();
  }

  // Start playback if necessary so that the clock can be properly queried.
  if (!mIsPrerolling) {
    mMaster->MaybeStartPlayback();
  }

  mMaster->UpdatePlaybackPositionPeriodically();
  MOZ_ASSERT(!mMaster->IsPlaying() || mMaster->IsStateMachineScheduled(),
             "Must have timer scheduled");
  if (IsBufferingAllowed()) {
    MaybeStartBuffering();
  }
}

void MediaDecoderStateMachine::DecodingState::HandleEndOfAudio() {
  AudioQueue().Finish();
  if (!mMaster->IsVideoDecoding()) {
    SetState<CompletedState>();
  } else {
    MaybeStopPrerolling();
  }
}

void MediaDecoderStateMachine::DecodingState::HandleEndOfVideo() {
  VideoQueue().Finish();
  if (!mMaster->IsAudioDecoding()) {
    SetState<CompletedState>();
  } else {
    MaybeStopPrerolling();
  }
}

void MediaDecoderStateMachine::DecodingState::DispatchDecodeTasksIfNeeded() {
  if (mMaster->IsAudioDecoding() && !mMaster->mMinimizePreroll &&
      !mMaster->HaveEnoughDecodedAudio()) {
    EnsureAudioDecodeTaskQueued();
  }

  if (mMaster->IsVideoDecoding() && !mMaster->mMinimizePreroll &&
      !mMaster->HaveEnoughDecodedVideo()) {
    EnsureVideoDecodeTaskQueued();
  }
}

void MediaDecoderStateMachine::DecodingState::EnsureAudioDecodeTaskQueued() {
  if (!mMaster->IsAudioDecoding() || mMaster->IsTrackingAudioData()) {
    return;
  }
  mMaster->RequestAudioData();
}

void MediaDecoderStateMachine::DecodingState::EnsureVideoDecodeTaskQueued() {
  if (!mMaster->IsVideoDecoding() || mMaster->IsTrackingVideoData()) {
    return;
  }
  mMaster->RequestVideoData(mMaster->GetMediaTime(),
                            ShouldRequestNextKeyFrame());
}

void MediaDecoderStateMachine::DecodingState::MaybeStartBuffering() {
  // Buffering makes senses only after decoding first frames.
  MOZ_ASSERT(mMaster->mSentFirstFrameLoadedEvent);

  // Don't enter buffering when MediaDecoder is not playing.
  if (mMaster->mPlayState != MediaDecoder::PLAY_STATE_PLAYING) {
    return;
  }

  // Don't enter buffering while prerolling so that the decoder has a chance to
  // enqueue some decoded data before we give up and start buffering.
  if (!mMaster->IsPlaying()) {
    return;
  }

  // Note we could have a wait promise pending when playing non-MSE EME.
  if (mMaster->OutOfDecodedAudio() && mMaster->IsWaitingAudioData()) {
    PROFILER_MARKER_TEXT("MDSM::StartBuffering", MEDIA_PLAYBACK, {},
                         "OutOfDecodedAudio");
    SLOG("Enter buffering due to out of decoded audio");
    SetState<BufferingState>();
    return;
  }
  if (mMaster->OutOfDecodedVideo() && mMaster->IsWaitingVideoData()) {
    PROFILER_MARKER_TEXT("MDSM::StartBuffering", MEDIA_PLAYBACK, {},
                         "OutOfDecodedVideo");
    SLOG("Enter buffering due to out of decoded video");
    SetState<BufferingState>();
    return;
  }

  if (Reader()->UseBufferingHeuristics() && mMaster->HasLowDecodedData() &&
      mMaster->HasLowBufferedData() && !mMaster->mCanPlayThrough) {
    PROFILER_MARKER_TEXT("MDSM::StartBuffering", MEDIA_PLAYBACK, {},
                         "BufferingHeuristics");
    SLOG("Enter buffering due to buffering heruistics");
    SetState<BufferingState>();
  }
}

void MediaDecoderStateMachine::LoopingDecodingState::HandleError(
    const MediaResult& aError, bool aIsAudio) {
  SLOG("%s looping failed, aError=%s", aIsAudio ? "audio" : "video",
       aError.ErrorName().get());
  switch (aError.Code()) {
    case NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA:
      if (aIsAudio) {
        HandleWaitingForAudio();
      } else {
        HandleWaitingForVideo();
      }
      [[fallthrough]];
    case NS_ERROR_DOM_MEDIA_END_OF_STREAM:
      // This could happen after either the resource has been close, or the data
      // hasn't been appended in MSE, so that we won't be able to get any
      // sample and need to fallback to normal looping.
      if (mIsReachingAudioEOS && mIsReachingVideoEOS) {
        SetState<CompletedState>();
      }
      break;
    default:
      mMaster->DecodeError(aError);
      break;
  }
}

void MediaDecoderStateMachine::SeekingState::SeekCompleted() {
  const auto newCurrentTime = CalculateNewCurrentTime();

  if ((newCurrentTime == mMaster->Duration() ||
       newCurrentTime.EqualsAtLowestResolution(
           mMaster->Duration().ToBase(USECS_PER_S))) &&
      !mMaster->IsLiveStream()) {
    SLOG("Seek completed, seeked to end: %s", newCurrentTime.ToString().get());
    // will transition to COMPLETED immediately. Note we don't do
    // this when playing a live stream, since the end of media will advance
    // once we download more data!
    AudioQueue().Finish();
    VideoQueue().Finish();

    // We won't start MediaSink when paused. m{Audio,Video}Completed will
    // remain false and 'playbackEnded' won't be notified. Therefore we
    // need to set these flags explicitly when seeking to the end.
    mMaster->mAudioCompleted = true;
    mMaster->mVideoCompleted = true;

    // There might still be a pending audio request when doing video-only or
    // next-frame seek. Discard it so we won't break the invariants of the
    // COMPLETED state by adding audio samples to a finished queue.
    mMaster->mAudioDataRequest.DisconnectIfExists();
  }

  // We want to resolve the seek request prior finishing the first frame
  // to ensure that the seeked event is fired prior loadeded.
  // Note: SeekJob.Resolve() resets SeekJob.mTarget. Don't use mSeekJob anymore
  //       hereafter.
  mSeekJob.Resolve(__func__);

  // Notify FirstFrameLoaded now if we haven't since we've decoded some data
  // for readyState to transition to HAVE_CURRENT_DATA and fire 'loadeddata'.
  if (!mMaster->mSentFirstFrameLoadedEvent) {
    mMaster->FinishDecodeFirstFrame();
  }

  // Ensure timestamps are up to date.
  // Suppressed visibility comes from two cases: (1) leaving dormant state,
  // and (2) resuming suspended video decoder. We want both cases to be
  // transparent to the user. So we only notify the change when the seek
  // request is from the user.
  if (mVisibility == EventVisibility::Observable) {
    // Don't update playback position for video-only seek.
    // Otherwise we might have |newCurrentTime > mMediaSink->GetPosition()|
    // and fail the assertion in GetClock() since we didn't stop MediaSink.
    mMaster->UpdatePlaybackPositionInternal(newCurrentTime);
  }

  // Try to decode another frame to detect if we're at the end...
  SLOG("Seek completed, mCurrentPosition=%" PRId64,
       mMaster->mCurrentPosition.Ref().ToMicroseconds());

  if (mMaster->VideoQueue().PeekFront()) {
    mMaster->mMediaSink->Redraw(Info().mVideo);
    mMaster->mOnPlaybackEvent.Notify(MediaPlaybackEvent::Invalidate);
  }

  GoToNextState();
}

void MediaDecoderStateMachine::BufferingState::Step() {
  TimeStamp now = TimeStamp::Now();
  MOZ_ASSERT(!mBufferingStart.IsNull(), "Must know buffering start time.");

  if (Reader()->UseBufferingHeuristics()) {
    if (mMaster->IsWaitingAudioData() || mMaster->IsWaitingVideoData()) {
      // Can't exit buffering when we are still waiting for data.
      // Note we don't schedule next loop for we will do that when the wait
      // promise is resolved.
      return;
    }
    // With buffering heuristics, we exit buffering state when we:
    // 1. can play through or
    // 2. time out (specified by mBufferingWait) or
    // 3. have enough buffered data.
    TimeDuration elapsed = now - mBufferingStart;
    TimeDuration timeout =
        TimeDuration::FromSeconds(mBufferingWait * mMaster->mPlaybackRate);
    bool stopBuffering =
        mMaster->mCanPlayThrough || elapsed >= timeout ||
        !mMaster->HasLowBufferedData(TimeUnit::FromSeconds(mBufferingWait));
    if (!stopBuffering) {
      SLOG("Buffering: wait %ds, timeout in %.3lfs", mBufferingWait,
           mBufferingWait - elapsed.ToSeconds());
      mMaster->ScheduleStateMachineIn(TimeUnit::FromMicroseconds(USECS_PER_S));
      return;
    }
  } else if (mMaster->OutOfDecodedAudio() || mMaster->OutOfDecodedVideo()) {
    MOZ_ASSERT(!mMaster->OutOfDecodedAudio() || mMaster->IsTrackingAudioData());
    MOZ_ASSERT(!mMaster->OutOfDecodedVideo() || mMaster->IsTrackingVideoData());
    SLOG(
        "In buffering mode, waiting to be notified: outOfAudio: %d, "
        "mAudioStatus: %s, outOfVideo: %d, mVideoStatus: %s",
        mMaster->OutOfDecodedAudio(), mMaster->AudioRequestStatus(),
        mMaster->OutOfDecodedVideo(), mMaster->VideoRequestStatus());
    return;
  }

  SLOG("Buffered for %.3lfs", (now - mBufferingStart).ToSeconds());
  mMaster->mTotalBufferingDuration += (now - mBufferingStart);
  SetDecodingState();
}

void MediaDecoderStateMachine::BufferingState::HandleEndOfAudio() {
  AudioQueue().Finish();
  if (!mMaster->IsVideoDecoding()) {
    SetState<CompletedState>();
  } else {
    // Check if we can exit buffering.
    mMaster->ScheduleStateMachine();
  }
}

void MediaDecoderStateMachine::BufferingState::HandleEndOfVideo() {
  VideoQueue().Finish();
  if (!mMaster->IsAudioDecoding()) {
    SetState<CompletedState>();
  } else {
    // Check if we can exit buffering.
    mMaster->ScheduleStateMachine();
  }
}

RefPtr<ShutdownPromise> MediaDecoderStateMachine::ShutdownState::Enter() {
  auto* master = mMaster;

  master->mDelayedScheduler.Reset();

  // Shutdown happens while decode timer is active, we need to disconnect and
  // dispose of the timer.
  master->CancelSuspendTimer();

  if (master->IsPlaying()) {
    master->StopPlayback();
  }

  master->mAudioDataRequest.DisconnectIfExists();
  master->mVideoDataRequest.DisconnectIfExists();
  master->mAudioWaitRequest.DisconnectIfExists();
  master->mVideoWaitRequest.DisconnectIfExists();

  // Resetting decode should be called after stopping media sink, which can
  // ensure that we have an empty media queue before seeking the demuxer.
  master->StopMediaSink();
  master->ResetDecode();
  master->mMediaSink->Shutdown();

  // Prevent dangling pointers by disconnecting the listeners.
  master->mAudioQueueListener.Disconnect();
  master->mVideoQueueListener.Disconnect();
  master->mMetadataManager.Disconnect();
  master->mOnMediaNotSeekable.Disconnect();
  master->mAudibleListener.DisconnectIfExists();

  // Disconnect canonicals and mirrors before shutting down our task queue.
  master->mStreamName.DisconnectIfConnected();
  master->mSinkDevice.DisconnectIfConnected();
  master->mOutputCaptureState.DisconnectIfConnected();
  master->mOutputDummyTrack.DisconnectIfConnected();
  master->mOutputTracks.DisconnectIfConnected();
  master->mOutputPrincipal.DisconnectIfConnected();

  master->mDuration.DisconnectAll();
  master->mCurrentPosition.DisconnectAll();
  master->mIsAudioDataAudible.DisconnectAll();

  // Shut down the watch manager to stop further notifications.
  master->mWatchManager.Shutdown();

  return Reader()->Shutdown()->Then(OwnerThread(), __func__, master,
                                    &MediaDecoderStateMachine::FinishShutdown,
                                    &MediaDecoderStateMachine::FinishShutdown);
}

#define INIT_WATCHABLE(name, val) name(val, "MediaDecoderStateMachine::" #name)
#define INIT_MIRROR(name, val) \
  name(mTaskQueue, val, "MediaDecoderStateMachine::" #name " (Mirror)")
#define INIT_CANONICAL(name, val) \
  name(mTaskQueue, val, "MediaDecoderStateMachine::" #name " (Canonical)")

MediaDecoderStateMachine::MediaDecoderStateMachine(MediaDecoder* aDecoder,
                                                   MediaFormatReader* aReader)
    : MediaDecoderStateMachineBase(aDecoder, aReader),
      mWatchManager(this, mTaskQueue),
      mDispatchedStateMachine(false),
      mDelayedScheduler(mTaskQueue, true /*aFuzzy*/),
      mCurrentFrameID(0),
      mAmpleAudioThreshold(detail::AMPLE_AUDIO_THRESHOLD),
      mVideoDecodeSuspended(false),
      mVideoDecodeSuspendTimer(mTaskQueue),
      mVideoDecodeMode(VideoDecodeMode::Normal),
      mIsMSE(aDecoder->IsMSE()),
      mShouldResistFingerprinting(aDecoder->ShouldResistFingerprinting()),
      mSeamlessLoopingAllowed(false),
      mTotalBufferingDuration(TimeDuration::Zero()),
      INIT_MIRROR(mStreamName, nsAutoString()),
      INIT_MIRROR(mSinkDevice, nullptr),
      INIT_MIRROR(mOutputCaptureState, MediaDecoder::OutputCaptureState::None),
      INIT_MIRROR(mOutputDummyTrack, nullptr),
      INIT_MIRROR(mOutputTracks, nsTArray<RefPtr<ProcessedMediaTrack>>()),
      INIT_MIRROR(mOutputPrincipal, PRINCIPAL_HANDLE_NONE),
      INIT_CANONICAL(mCanonicalOutputPrincipal, PRINCIPAL_HANDLE_NONE),
      mShuttingDown(false),
      mInitialized(false) {
  MOZ_COUNT_CTOR(MediaDecoderStateMachine);
  NS_ASSERTION(NS_IsMainThread(), "Should be on main thread.");

  InitVideoQueuePrefs();

  DDLINKCHILD("reader", aReader);
}

#undef INIT_WATCHABLE
#undef INIT_MIRROR
#undef INIT_CANONICAL

MediaDecoderStateMachine::~MediaDecoderStateMachine() {
  MOZ_ASSERT(NS_IsMainThread(), "Should be on main thread.");
  MOZ_COUNT_DTOR(MediaDecoderStateMachine);
}

void MediaDecoderStateMachine::InitializationTask(MediaDecoder* aDecoder) {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::InitializationTask",
                      MEDIA_PLAYBACK);
  MOZ_ASSERT(OnTaskQueue());

  MediaDecoderStateMachineBase::InitializationTask(aDecoder);

  // Initialize watchers.
  mWatchManager.Watch(mStreamName,
                      &MediaDecoderStateMachine::StreamNameChanged);
  mWatchManager.Watch(mOutputCaptureState,
                      &MediaDecoderStateMachine::UpdateOutputCaptured);
  mWatchManager.Watch(mOutputDummyTrack,
                      &MediaDecoderStateMachine::UpdateOutputCaptured);
  mWatchManager.Watch(mOutputTracks,
                      &MediaDecoderStateMachine::UpdateOutputCaptured);
  mWatchManager.Watch(mOutputPrincipal,
                      &MediaDecoderStateMachine::OutputPrincipalChanged);

  mMediaSink = CreateMediaSink();
  mInitialized = true;

  MOZ_ASSERT(!mStateObj);
  auto* s = new DecodeMetadataState(this);
  mStateObj.reset(s);
  s->Enter();
}

void MediaDecoderStateMachine::AudioAudibleChanged(bool aAudible) {
  mIsAudioDataAudible = aAudible;
}

MediaSink* MediaDecoderStateMachine::CreateAudioSink() {
  if (mOutputCaptureState != MediaDecoder::OutputCaptureState::None) {
    DecodedStream* stream = new DecodedStream(
        this,
        mOutputCaptureState == MediaDecoder::OutputCaptureState::Capture
            ? mOutputDummyTrack.Ref()
            : nullptr,
        mOutputTracks, mVolume, mPlaybackRate, mPreservesPitch, mAudioQueue,
        mVideoQueue, mSinkDevice.Ref());
    mAudibleListener.DisconnectIfExists();
    mAudibleListener = stream->AudibleEvent().Connect(
        OwnerThread(), this, &MediaDecoderStateMachine::AudioAudibleChanged);
    return stream;
  }

  auto audioSinkCreator = [s = RefPtr<MediaDecoderStateMachine>(this), this]() {
    MOZ_ASSERT(OnTaskQueue());
    UniquePtr<AudioSink> audioSink{new AudioSink(
        mTaskQueue, mAudioQueue, Info().mAudio, mShouldResistFingerprinting)};
    mAudibleListener.DisconnectIfExists();
    mAudibleListener = audioSink->AudibleEvent().Connect(
        mTaskQueue, this, &MediaDecoderStateMachine::AudioAudibleChanged);
    return audioSink;
  };
  return new AudioSinkWrapper(
      mTaskQueue, mAudioQueue, std::move(audioSinkCreator), mVolume,
      mPlaybackRate, mPreservesPitch, mSinkDevice.Ref());
}

already_AddRefed<MediaSink> MediaDecoderStateMachine::CreateMediaSink() {
  MOZ_ASSERT(OnTaskQueue());
  RefPtr<MediaSink> audioSink = CreateAudioSink();
  RefPtr<MediaSink> mediaSink =
      new VideoSink(mTaskQueue, audioSink, mVideoQueue, mVideoFrameContainer,
                    *mFrameStats, sVideoQueueSendToCompositorSize);
  if (mSecondaryVideoContainer.Ref()) {
    mediaSink->SetSecondaryVideoContainer(mSecondaryVideoContainer.Ref());
  }
  return mediaSink.forget();
}

TimeUnit MediaDecoderStateMachine::GetDecodedAudioDuration() const {
  MOZ_ASSERT(OnTaskQueue());
  if (mMediaSink->IsStarted()) {
    return mMediaSink->UnplayedDuration(TrackInfo::kAudioTrack) +
           TimeUnit::FromMicroseconds(AudioQueue().Duration());
  }
  // MediaSink not started. All audio samples are in the queue.
  return TimeUnit::FromMicroseconds(AudioQueue().Duration());
}

bool MediaDecoderStateMachine::HaveEnoughDecodedAudio() const {
  MOZ_ASSERT(OnTaskQueue());
  auto ampleAudio = mAmpleAudioThreshold.MultDouble(mPlaybackRate);
  return AudioQueue().GetSize() > 0 && GetDecodedAudioDuration() >= ampleAudio;
}

bool MediaDecoderStateMachine::HaveEnoughDecodedVideo() const {
  MOZ_ASSERT(OnTaskQueue());
  return static_cast<double>(VideoQueue().GetSize()) >=
             GetAmpleVideoFrames() * mPlaybackRate + 1 &&
         IsVideoDataEnoughComparedWithAudio();
}

bool MediaDecoderStateMachine::IsVideoDataEnoughComparedWithAudio() const {
  // HW decoding is usually fast enough and we don't need to worry about its
  // speed.
  // TODO : we can consider whether we need to enable this on other HW decoding
  // except VAAPI. When enabling VAAPI on Linux, ffmpeg is not able to store too
  // many frames because it has a limitation of amount of stored video frames.
  // See bug1716638 and 1718309.
  if (mReader->VideoIsHardwareAccelerated()) {
    return true;
  }
  // In extreme situations (e.g. 4k+ video without hardware acceleration), the
  // video decoding will be much slower than audio. So for 4K+ video, we want to
  // consider audio decoding speed as well in order to reduce frame drops. This
  // check tries to keep the decoded video buffered as much as audio.
  if (HasAudio() && Info().mVideo.mImage.width >= 3840 &&
      Info().mVideo.mImage.height >= 2160) {
    return VideoQueue().Duration() >= AudioQueue().Duration();
  }
  // For non-4k video, the video decoding is usually really fast so we won't
  // need to consider audio decoding speed to store extra frames.
  return true;
}

void MediaDecoderStateMachine::PushAudio(AudioData* aSample) {
  MOZ_ASSERT(OnTaskQueue());
  MOZ_ASSERT(aSample);
  AudioQueue().Push(aSample);
  PROFILER_MARKER("MDSM::PushAudio", MEDIA_PLAYBACK, {}, MediaSampleMarker,
                  aSample->mTime.ToMicroseconds(),
                  aSample->GetEndTime().ToMicroseconds(),
                  AudioQueue().GetSize());
}

void MediaDecoderStateMachine::PushVideo(VideoData* aSample) {
  MOZ_ASSERT(OnTaskQueue());
  MOZ_ASSERT(aSample);
  aSample->mFrameID = ++mCurrentFrameID;
  VideoQueue().Push(aSample);
  PROFILER_MARKER("MDSM::PushVideo", MEDIA_PLAYBACK, {}, MediaSampleMarker,
                  aSample->mTime.ToMicroseconds(),
                  aSample->GetEndTime().ToMicroseconds(),
                  VideoQueue().GetSize());
}

void MediaDecoderStateMachine::OnAudioPopped(const RefPtr<AudioData>& aSample) {
  MOZ_ASSERT(OnTaskQueue());
  mPlaybackOffset = std::max(mPlaybackOffset, aSample->mOffset);
}

void MediaDecoderStateMachine::OnVideoPopped(const RefPtr<VideoData>& aSample) {
  MOZ_ASSERT(OnTaskQueue());
  mPlaybackOffset = std::max(mPlaybackOffset, aSample->mOffset);
}

bool MediaDecoderStateMachine::IsAudioDecoding() {
  MOZ_ASSERT(OnTaskQueue());
  return HasAudio() && !AudioQueue().IsFinished();
}

bool MediaDecoderStateMachine::IsVideoDecoding() {
  MOZ_ASSERT(OnTaskQueue());
  return HasVideo() && !VideoQueue().IsFinished();
}

bool MediaDecoderStateMachine::IsPlaying() const {
  MOZ_ASSERT(OnTaskQueue());
  return mMediaSink->IsPlaying();
}

void MediaDecoderStateMachine::SetMediaNotSeekable() { mMediaSeekable = false; }

nsresult MediaDecoderStateMachine::Init(MediaDecoder* aDecoder) {
  MOZ_ASSERT(NS_IsMainThread());

  nsresult rv = MediaDecoderStateMachineBase::Init(aDecoder);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }

  // Connect mirrors.
  aDecoder->CanonicalStreamName().ConnectMirror(&mStreamName);
  aDecoder->CanonicalSinkDevice().ConnectMirror(&mSinkDevice);
  aDecoder->CanonicalOutputCaptureState().ConnectMirror(&mOutputCaptureState);
  aDecoder->CanonicalOutputDummyTrack().ConnectMirror(&mOutputDummyTrack);
  aDecoder->CanonicalOutputTracks().ConnectMirror(&mOutputTracks);
  aDecoder->CanonicalOutputPrincipal().ConnectMirror(&mOutputPrincipal);

  mAudioQueueListener = AudioQueue().PopFrontEvent().Connect(
      mTaskQueue, this, &MediaDecoderStateMachine::OnAudioPopped);
  mVideoQueueListener = VideoQueue().PopFrontEvent().Connect(
      mTaskQueue, this, &MediaDecoderStateMachine::OnVideoPopped);
  mOnMediaNotSeekable = mReader->OnMediaNotSeekable().Connect(
      OwnerThread(), this, &MediaDecoderStateMachine::SetMediaNotSeekable);

  return NS_OK;
}

void MediaDecoderStateMachine::StopPlayback() {
  MOZ_ASSERT(OnTaskQueue());
  LOG("StopPlayback()");

  if (IsPlaying()) {
    mOnPlaybackEvent.Notify(MediaPlaybackEvent{
        MediaPlaybackEvent::PlaybackStopped, mPlaybackOffset});
    mMediaSink->SetPlaying(false);
    MOZ_ASSERT(!IsPlaying());
  }
}

void MediaDecoderStateMachine::MaybeStartPlayback() {
  MOZ_ASSERT(OnTaskQueue());
  // Should try to start playback only after decoding first frames.
  if (!mSentFirstFrameLoadedEvent) {
    LOG("MaybeStartPlayback: Not starting playback before loading first frame");
    return;
  }

  if (IsPlaying()) {
    // Logging this case is really spammy - don't do it.
    return;
  }

  if (mIsMediaSinkSuspended) {
    LOG("MaybeStartPlayback: Not starting playback when sink is suspended");
    return;
  }

  if (mPlayState != MediaDecoder::PLAY_STATE_PLAYING) {
    LOG("MaybeStartPlayback: Not starting playback [mPlayState=%d]",
        mPlayState.Ref());
    return;
  }

  LOG("MaybeStartPlayback() starting playback");
  StartMediaSink();

  if (!IsPlaying()) {
    mMediaSink->SetPlaying(true);
    MOZ_ASSERT(IsPlaying());
  }

  mOnPlaybackEvent.Notify(
      MediaPlaybackEvent{MediaPlaybackEvent::PlaybackStarted, mPlaybackOffset});
}

void MediaDecoderStateMachine::UpdatePlaybackPositionInternal(
    const TimeUnit& aTime) {
  MOZ_ASSERT(OnTaskQueue());
  LOGV("UpdatePlaybackPositionInternal(%" PRId64 ")", aTime.ToMicroseconds());

  // Ensure the position has a precision that matches other TimeUnit such as
  // buffering ranges and duration.
  mCurrentPosition = aTime.ToBase(1000000);
  NS_ASSERTION(mCurrentPosition.Ref() >= TimeUnit::Zero(),
               "CurrentTime should be positive!");
  if (mDuration.Ref().ref() < mCurrentPosition.Ref()) {
    mDuration = Some(mCurrentPosition.Ref());
    DDLOG(DDLogCategory::Property, "duration_us",
          mDuration.Ref()->ToMicroseconds());
  }
}

void MediaDecoderStateMachine::UpdatePlaybackPosition(const TimeUnit& aTime) {
  MOZ_ASSERT(OnTaskQueue());
  UpdatePlaybackPositionInternal(aTime);

  bool fragmentEnded =
      mFragmentEndTime.IsValid() && GetMediaTime() >= mFragmentEndTime;
  mMetadataManager.DispatchMetadataIfNeeded(aTime);

  if (fragmentEnded) {
    StopPlayback();
  }
}

/* static */ const char* MediaDecoderStateMachine::ToStateStr(State aState) {
  switch (aState) {
    case DECODER_STATE_DECODING_METADATA:
      return "DECODING_METADATA";
    case DECODER_STATE_DORMANT:
      return "DORMANT";
    case DECODER_STATE_DECODING_FIRSTFRAME:
      return "DECODING_FIRSTFRAME";
    case DECODER_STATE_DECODING:
      return "DECODING";
    case DECODER_STATE_SEEKING_ACCURATE:
      return "SEEKING_ACCURATE";
    case DECODER_STATE_SEEKING_FROMDORMANT:
      return "SEEKING_FROMDORMANT";
    case DECODER_STATE_SEEKING_NEXTFRAMESEEKING:
      return "DECODER_STATE_SEEKING_NEXTFRAMESEEKING";
    case DECODER_STATE_SEEKING_VIDEOONLY:
      return "SEEKING_VIDEOONLY";
    case DECODER_STATE_BUFFERING:
      return "BUFFERING";
    case DECODER_STATE_COMPLETED:
      return "COMPLETED";
    case DECODER_STATE_SHUTDOWN:
      return "SHUTDOWN";
    case DECODER_STATE_LOOPING_DECODING:
      return "LOOPING_DECODING";
    default:
      MOZ_ASSERT_UNREACHABLE("Invalid state.");
  }
  return "UNKNOWN";
}

const char* MediaDecoderStateMachine::ToStateStr() {
  MOZ_ASSERT(OnTaskQueue());
  return ToStateStr(mStateObj->GetState());
}

void MediaDecoderStateMachine::VolumeChanged() {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::VolumeChanged",
                      MEDIA_PLAYBACK);
  PROFILER_MARKER_TEXT("MDSM::VolumeChanged", MEDIA_PLAYBACK, {},
                       nsPrintfCString("%f", mVolume.Ref()));
  MOZ_ASSERT(OnTaskQueue());
  mMediaSink->SetVolume(mVolume);
}

RefPtr<ShutdownPromise> MediaDecoderStateMachine::Shutdown() {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::Shutdown", MEDIA_PLAYBACK);
  PROFILER_MARKER_UNTYPED("MDSM::Shutdown", MEDIA_PLAYBACK);
  MOZ_ASSERT(OnTaskQueue());
  mShuttingDown = true;
  return mStateObj->HandleShutdown();
}

void MediaDecoderStateMachine::PlayStateChanged() {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::PlayStateChanged",
                      MEDIA_PLAYBACK);
  PROFILER_MARKER_TEXT(
      "MDSM::PlayStateChanged", MEDIA_PLAYBACK, {},
      nsPrintfCString("%s", MediaDecoder::EnumValueToString(mPlayState.Ref())));
  MOZ_ASSERT(OnTaskQueue());

  if (mPlayState != MediaDecoder::PLAY_STATE_PLAYING) {
    CancelSuspendTimer();
  } else if (mMinimizePreroll) {
    // Once we start playing, we don't want to minimize our prerolling, as we
    // assume the user is likely to want to keep playing in future. This needs
    // to happen before we invoke StartDecoding().
    mMinimizePreroll = false;
  }

  mStateObj->HandlePlayStateChanged(mPlayState);
}

void MediaDecoderStateMachine::SetVideoDecodeMode(VideoDecodeMode aMode) {
  MOZ_ASSERT(NS_IsMainThread());
  nsCOMPtr<nsIRunnable> r = NewRunnableMethod<VideoDecodeMode>(
      "MediaDecoderStateMachine::SetVideoDecodeModeInternal", this,
      &MediaDecoderStateMachine::SetVideoDecodeModeInternal, aMode);
  OwnerThread()->DispatchStateChange(r.forget());
}

void MediaDecoderStateMachine::SetVideoDecodeModeInternal(
    VideoDecodeMode aMode) {
  MOZ_ASSERT(OnTaskQueue());

  LOG("SetVideoDecodeModeInternal(), VideoDecodeMode=(%s->%s), "
      "mVideoDecodeSuspended=%c",
      mVideoDecodeMode == VideoDecodeMode::Normal ? "Normal" : "Suspend",
      aMode == VideoDecodeMode::Normal ? "Normal" : "Suspend",
      mVideoDecodeSuspended ? 'T' : 'F');

  // Should not suspend decoding if we don't turn on the pref.
  if (!StaticPrefs::media_suspend_background_video_enabled() &&
      aMode == VideoDecodeMode::Suspend) {
    LOG("SetVideoDecodeModeInternal(), early return because preference off and "
        "set to Suspend");
    return;
  }

  if (aMode == mVideoDecodeMode) {
    LOG("SetVideoDecodeModeInternal(), early return because the mode does not "
        "change");
    return;
  }

  // Set new video decode mode.
  mVideoDecodeMode = aMode;

  // Start timer to trigger suspended video decoding.
  if (mVideoDecodeMode == VideoDecodeMode::Suspend) {
    TimeStamp target = TimeStamp::Now() + SuspendBackgroundVideoDelay();

    RefPtr<MediaDecoderStateMachine> self = this;
    mVideoDecodeSuspendTimer.Ensure(
        target, [=]() { self->OnSuspendTimerResolved(); },
        []() { MOZ_DIAGNOSTIC_CRASH("SetVideoDecodeModeInternal reject"); });
    mOnPlaybackEvent.Notify(MediaPlaybackEvent::StartVideoSuspendTimer);
    return;
  }

  // Resuming from suspended decoding

  // If suspend timer exists, destroy it.
  CancelSuspendTimer();

  if (mVideoDecodeSuspended) {
    auto target = mMediaSink->IsStarted() ? GetClock() : GetMediaTime();
    AdjustByLooping(target);
    mStateObj->HandleResumeVideoDecoding(target + detail::RESUME_VIDEO_PREMIUM);
  }
}

void MediaDecoderStateMachine::BufferedRangeUpdated() {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::BufferedRangeUpdated",
                      MEDIA_PLAYBACK);
  MOZ_ASSERT(OnTaskQueue());

  // While playing an unseekable stream of unknown duration, mDuration
  // is updated as we play. But if data is being downloaded
  // faster than played, mDuration won't reflect the end of playable data
  // since we haven't played the frame at the end of buffered data. So update
  // mDuration here as new data is downloaded to prevent such a lag.
  if (mBuffered.Ref().IsInvalid()) {
    return;
  }

  bool exists;
  media::TimeUnit end{mBuffered.Ref().GetEnd(&exists)};
  if (!exists) {
    return;
  }

  // Use estimated duration from buffer ranges when mDuration is unknown or
  // the estimated duration is larger.
  if ((mDuration.Ref().isNothing() || mDuration.Ref()->IsInfinite() ||
       end > mDuration.Ref().ref()) &&
      end.IsPositiveOrZero()) {
    nsPrintfCString msg{
        "duration:%" PRId64 "->%" PRId64,
        mDuration.Ref().isNothing() ? 0 : mDuration.Ref()->ToMicroseconds(),
        end.ToMicroseconds()};
    PROFILER_MARKER_TEXT("MDSM::BufferedRangeUpdated", MEDIA_PLAYBACK, {}, msg);
    LOG("%s", msg.get());
    mDuration = Some(end);
    DDLOG(DDLogCategory::Property, "duration_us",
          mDuration.Ref()->ToMicroseconds());
  }
}

RefPtr<MediaDecoder::SeekPromise> MediaDecoderStateMachine::Seek(
    const SeekTarget& aTarget) {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::Seek", MEDIA_PLAYBACK);
  PROFILER_MARKER_UNTYPED("MDSM::Seek", MEDIA_PLAYBACK);
  MOZ_ASSERT(OnTaskQueue());

  // We need to be able to seek in some way
  if (!mMediaSeekable && !mMediaSeekableOnlyInBufferedRanges) {
    LOGW("Seek() should not be called on a non-seekable media");
    return MediaDecoder::SeekPromise::CreateAndReject(/* aRejectValue = */ true,
                                                      __func__);
  }

  if (aTarget.IsNextFrame() && !HasVideo()) {
    LOGW("Ignore a NextFrameSeekTask on a media file without video track.");
    return MediaDecoder::SeekPromise::CreateAndReject(/* aRejectValue = */ true,
                                                      __func__);
  }

  MOZ_ASSERT(mDuration.Ref().isSome(), "We should have got duration already");

  return mStateObj->HandleSeek(aTarget);
}

void MediaDecoderStateMachine::StopMediaSink() {
  MOZ_ASSERT(OnTaskQueue());
  if (mMediaSink->IsStarted()) {
    LOG("Stop MediaSink");
    mMediaSink->Stop();
    mMediaSinkAudioEndedPromise.DisconnectIfExists();
    mMediaSinkVideoEndedPromise.DisconnectIfExists();
  }
}

void MediaDecoderStateMachine::RequestAudioData() {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::RequestAudioData",
                      MEDIA_PLAYBACK);
  MOZ_ASSERT(OnTaskQueue());
  MOZ_ASSERT(IsAudioDecoding());
  MOZ_ASSERT(!IsRequestingAudioData());
  MOZ_ASSERT(!IsWaitingAudioData());
  LOGV("Queueing audio task - queued=%zu, decoder-queued=%zu",
       AudioQueue().GetSize(), mReader->SizeOfAudioQueueInFrames());

  PerformanceRecorder<PlaybackStage> perfRecorder(MediaStage::RequestData);
  RefPtr<MediaDecoderStateMachine> self = this;
  mReader->RequestAudioData()
      ->Then(
          OwnerThread(), __func__,
          [this, self, perfRecorder(std::move(perfRecorder))](
              const RefPtr<AudioData>& aAudio) mutable {
            perfRecorder.Record();
            AUTO_PROFILER_LABEL(
                "MediaDecoderStateMachine::RequestAudioData:Resolved",
                MEDIA_PLAYBACK);
            MOZ_ASSERT(aAudio);
            mAudioDataRequest.Complete();
            // audio->GetEndTime() is not always mono-increasing in chained
            // ogg.
            mDecodedAudioEndTime =
                std::max(aAudio->GetEndTime(), mDecodedAudioEndTime);
            LOGV("OnAudioDecoded [%" PRId64 ",%" PRId64 "]",
                 aAudio->mTime.ToMicroseconds(),
                 aAudio->GetEndTime().ToMicroseconds());
            mStateObj->HandleAudioDecoded(aAudio);
          },
          [this, self](const MediaResult& aError) {
            AUTO_PROFILER_LABEL(
                "MediaDecoderStateMachine::RequestAudioData:Rejected",
                MEDIA_PLAYBACK);
            LOGV("OnAudioNotDecoded ErrorName=%s Message=%s",
                 aError.ErrorName().get(), aError.Message().get());
            mAudioDataRequest.Complete();
            switch (aError.Code()) {
              case NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA:
                mStateObj->HandleWaitingForAudio();
                break;
              case NS_ERROR_DOM_MEDIA_CANCELED:
                mStateObj->HandleAudioCanceled();
                break;
              case NS_ERROR_DOM_MEDIA_END_OF_STREAM:
                mStateObj->HandleEndOfAudio();
                break;
              default:
                DecodeError(aError);
            }
          })
      ->Track(mAudioDataRequest);
}

void MediaDecoderStateMachine::RequestVideoData(
    const media::TimeUnit& aCurrentTime, bool aRequestNextKeyFrame) {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::RequestVideoData",
                      MEDIA_PLAYBACK);
  MOZ_ASSERT(OnTaskQueue());
  MOZ_ASSERT(IsVideoDecoding());
  MOZ_ASSERT(!IsRequestingVideoData());
  MOZ_ASSERT(!IsWaitingVideoData());
  LOGV(
      "Queueing video task - queued=%zu, decoder-queued=%zo"
      ", stime=%" PRId64 ", by-pass-skip=%d",
      VideoQueue().GetSize(), mReader->SizeOfVideoQueueInFrames(),
      aCurrentTime.ToMicroseconds(), mBypassingSkipToNextKeyFrameCheck);

  PerformanceRecorder<PlaybackStage> perfRecorder(MediaStage::RequestData,
                                                  Info().mVideo.mImage.height);
  RefPtr<MediaDecoderStateMachine> self = this;
  mReader
      ->RequestVideoData(
          mBypassingSkipToNextKeyFrameCheck ? media::TimeUnit() : aCurrentTime,
          mBypassingSkipToNextKeyFrameCheck ? false : aRequestNextKeyFrame)
      ->Then(
          OwnerThread(), __func__,
          [this, self, perfRecorder(std::move(perfRecorder))](
              const RefPtr<VideoData>& aVideo) mutable {
            perfRecorder.Record();
            AUTO_PROFILER_LABEL(
                "MediaDecoderStateMachine::RequestVideoData:Resolved",
                MEDIA_PLAYBACK);
            MOZ_ASSERT(aVideo);
            mVideoDataRequest.Complete();
            // Handle abnormal or negative timestamps.
            mDecodedVideoEndTime =
                std::max(mDecodedVideoEndTime, aVideo->GetEndTime());
            LOGV("OnVideoDecoded [%" PRId64 ",%" PRId64 "]",
                 aVideo->mTime.ToMicroseconds(),
                 aVideo->GetEndTime().ToMicroseconds());
            mStateObj->HandleVideoDecoded(aVideo);
          },
          [this, self](const MediaResult& aError) {
            AUTO_PROFILER_LABEL(
                "MediaDecoderStateMachine::RequestVideoData:Rejected",
                MEDIA_PLAYBACK);
            LOGV("OnVideoNotDecoded ErrorName=%s Message=%s",
                 aError.ErrorName().get(), aError.Message().get());
            mVideoDataRequest.Complete();
            switch (aError.Code()) {
              case NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA:
                mStateObj->HandleWaitingForVideo();
                break;
              case NS_ERROR_DOM_MEDIA_CANCELED:
                mStateObj->HandleVideoCanceled();
                break;
              case NS_ERROR_DOM_MEDIA_END_OF_STREAM:
                mStateObj->HandleEndOfVideo();
                break;
              default:
                DecodeError(aError);
            }
          })
      ->Track(mVideoDataRequest);
}

void MediaDecoderStateMachine::WaitForData(MediaData::Type aType) {
  MOZ_ASSERT(OnTaskQueue());
  MOZ_ASSERT(aType == MediaData::Type::AUDIO_DATA ||
             aType == MediaData::Type::VIDEO_DATA);
  LOG("%s: %s", __func__, MediaData::EnumValueToString(aType));
  RefPtr<MediaDecoderStateMachine> self = this;
  if (aType == MediaData::Type::AUDIO_DATA) {
    mReader->WaitForData(MediaData::Type::AUDIO_DATA)
        ->Then(
            OwnerThread(), __func__,
            [self](MediaData::Type aType) {
              AUTO_PROFILER_LABEL(
                  "MediaDecoderStateMachine::WaitForData:AudioResolved",
                  MEDIA_PLAYBACK);
              self->mAudioWaitRequest.Complete();
              MOZ_ASSERT(aType == MediaData::Type::AUDIO_DATA);
              self->mStateObj->HandleAudioWaited(aType);
            },
            [self](const WaitForDataRejectValue& aRejection) {
              AUTO_PROFILER_LABEL(
                  "MediaDecoderStateMachine::WaitForData:AudioRejected",
                  MEDIA_PLAYBACK);
              self->mAudioWaitRequest.Complete();
              self->DecodeError(NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA);
            })
        ->Track(mAudioWaitRequest);
  } else {
    mReader->WaitForData(MediaData::Type::VIDEO_DATA)
        ->Then(
            OwnerThread(), __func__,
            [self, this](MediaData::Type aType) {
              AUTO_PROFILER_LABEL(
                  "MediaDecoderStateMachine::WaitForData:VideoResolved",
                  MEDIA_PLAYBACK);
              self->mVideoWaitRequest.Complete();
              MOZ_ASSERT(aType == MediaData::Type::VIDEO_DATA);
              LOG("WaitForData::VideoResolved");
              self->mStateObj->HandleVideoWaited(aType);
            },
            [self, this](const WaitForDataRejectValue& aRejection) {
              AUTO_PROFILER_LABEL(
                  "MediaDecoderStateMachine::WaitForData:VideoRejected",
                  MEDIA_PLAYBACK);
              self->mVideoWaitRequest.Complete();
              LOG("WaitForData::VideoRejected");
              self->DecodeError(NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA);
            })
        ->Track(mVideoWaitRequest);
  }
}

nsresult MediaDecoderStateMachine::StartMediaSink() {
  MOZ_ASSERT(OnTaskQueue());

  if (mMediaSink->IsStarted()) {
    return NS_OK;
  }

  mAudioCompleted = false;
  const auto startTime = GetMediaTime();
  LOG("StartMediaSink, mediaTime=%" PRId64, startTime.ToMicroseconds());
  nsresult rv = mMediaSink->Start(startTime, Info());
  StreamNameChanged();

  auto videoPromise = mMediaSink->OnEnded(TrackInfo::kVideoTrack);
  auto audioPromise = mMediaSink->OnEnded(TrackInfo::kAudioTrack);

  if (audioPromise) {
    audioPromise
        ->Then(OwnerThread(), __func__, this,
               &MediaDecoderStateMachine::OnMediaSinkAudioComplete,
               &MediaDecoderStateMachine::OnMediaSinkAudioError)
        ->Track(mMediaSinkAudioEndedPromise);
  }
  if (videoPromise) {
    videoPromise
        ->Then(OwnerThread(), __func__, this,
               &MediaDecoderStateMachine::OnMediaSinkVideoComplete,
               &MediaDecoderStateMachine::OnMediaSinkVideoError)
        ->Track(mMediaSinkVideoEndedPromise);
  }
  // Remember the initial offset when playback starts. This will be used
  // to calculate the rate at which bytes are consumed as playback moves on.
  RefPtr<MediaData> sample = mAudioQueue.PeekFront();
  mPlaybackOffset = sample ? sample->mOffset : 0;
  sample = mVideoQueue.PeekFront();
  if (sample && sample->mOffset > mPlaybackOffset) {
    mPlaybackOffset = sample->mOffset;
  }
  return rv;
}

bool MediaDecoderStateMachine::HasLowDecodedAudio() {
  MOZ_ASSERT(OnTaskQueue());
  return IsAudioDecoding() &&
         GetDecodedAudioDuration() <
             EXHAUSTED_DATA_MARGIN.MultDouble(mPlaybackRate);
}

bool MediaDecoderStateMachine::HasLowDecodedVideo() {
  MOZ_ASSERT(OnTaskQueue());
  return IsVideoDecoding() &&
         VideoQueue().GetSize() <
             static_cast<size_t>(floorl(LOW_VIDEO_FRAMES * mPlaybackRate));
}

bool MediaDecoderStateMachine::HasLowDecodedData() {
  MOZ_ASSERT(OnTaskQueue());
  MOZ_ASSERT(mReader->UseBufferingHeuristics());
  return HasLowDecodedAudio() || HasLowDecodedVideo();
}

bool MediaDecoderStateMachine::OutOfDecodedAudio() {
  MOZ_ASSERT(OnTaskQueue());
  return IsAudioDecoding() && !AudioQueue().IsFinished() &&
         AudioQueue().GetSize() == 0 &&
         !mMediaSink->HasUnplayedFrames(TrackInfo::kAudioTrack);
}

bool MediaDecoderStateMachine::HasLowBufferedData() {
  MOZ_ASSERT(OnTaskQueue());
  return HasLowBufferedData(detail::LOW_BUFFER_THRESHOLD);
}

bool MediaDecoderStateMachine::HasLowBufferedData(const TimeUnit& aThreshold) {
  MOZ_ASSERT(OnTaskQueue());

  // If we don't have a duration, mBuffered is probably not going to have
  // a useful buffered range. Return false here so that we don't get stuck in
  // buffering mode for live streams.
  if (Duration().IsInfinite()) {
    return false;
  }

  if (mBuffered.Ref().IsInvalid()) {
    return false;
  }

  // We are never low in decoded data when we don't have audio/video or have
  // decoded all audio/video samples.
  TimeUnit endOfDecodedVideo = (HasVideo() && !VideoQueue().IsFinished())
                                   ? mDecodedVideoEndTime
                                   : TimeUnit::FromNegativeInfinity();
  TimeUnit endOfDecodedAudio = (HasAudio() && !AudioQueue().IsFinished())
                                   ? mDecodedAudioEndTime
                                   : TimeUnit::FromNegativeInfinity();

  auto endOfDecodedData = std::max(endOfDecodedVideo, endOfDecodedAudio);
  if (Duration() < endOfDecodedData) {
    // Our duration is not up to date. No point buffering.
    return false;
  }

  if (endOfDecodedData.IsInfinite()) {
    // Have decoded all samples. No point buffering.
    return false;
  }

  auto start = endOfDecodedData;
  auto end = std::min(GetMediaTime() + aThreshold, Duration());
  if (start >= end) {
    // Duration of decoded samples is greater than our threshold.
    return false;
  }
  media::TimeInterval interval(start, end);
  return !mBuffered.Ref().Contains(interval);
}

void MediaDecoderStateMachine::EnqueueFirstFrameLoadedEvent() {
  MOZ_ASSERT(OnTaskQueue());
  // Track value of mSentFirstFrameLoadedEvent from before updating it
  bool firstFrameBeenLoaded = mSentFirstFrameLoadedEvent;
  mSentFirstFrameLoadedEvent = true;
  MediaDecoderEventVisibility visibility =
      firstFrameBeenLoaded ? MediaDecoderEventVisibility::Suppressed
                           : MediaDecoderEventVisibility::Observable;
  mFirstFrameLoadedEvent.Notify(UniquePtr<MediaInfo>(new MediaInfo(Info())),
                                visibility);
}

void MediaDecoderStateMachine::FinishDecodeFirstFrame() {
  MOZ_ASSERT(OnTaskQueue());
  MOZ_ASSERT(!mSentFirstFrameLoadedEvent);
  LOG("FinishDecodeFirstFrame");

  mMediaSink->Redraw(Info().mVideo);

  LOG("Media duration %" PRId64 ", mediaSeekable=%d",
      Duration().ToMicroseconds(), mMediaSeekable);

  // Get potentially updated metadata
  mReader->ReadUpdatedMetadata(mInfo.ptr());

  EnqueueFirstFrameLoadedEvent();
}

RefPtr<ShutdownPromise> MediaDecoderStateMachine::FinishShutdown() {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::FinishShutdown",
                      MEDIA_PLAYBACK);
  MOZ_ASSERT(OnTaskQueue());
  LOG("Shutting down state machine task queue");
  return OwnerThread()->BeginShutdown();
}

void MediaDecoderStateMachine::RunStateMachine() {
  MOZ_ASSERT(OnTaskQueue());
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::RunStateMachine",
                      MEDIA_PLAYBACK);
  mDelayedScheduler.Reset();  // Must happen on state machine task queue.
  mDispatchedStateMachine = false;
  mStateObj->Step();
}

void MediaDecoderStateMachine::ResetDecode(const TrackSet& aTracks) {
  MOZ_ASSERT(OnTaskQueue());
  LOG("MediaDecoderStateMachine::Reset");

  // Assert that aTracks specifies to reset the video track because we
  // don't currently support resetting just the audio track.
  MOZ_ASSERT(aTracks.contains(TrackInfo::kVideoTrack));

  if (aTracks.contains(TrackInfo::kVideoTrack)) {
    mDecodedVideoEndTime = TimeUnit::Zero();
    mVideoCompleted = false;
    VideoQueue().Reset();
    mVideoDataRequest.DisconnectIfExists();
    mVideoWaitRequest.DisconnectIfExists();
  }

  if (aTracks.contains(TrackInfo::kAudioTrack)) {
    mDecodedAudioEndTime = TimeUnit::Zero();
    mAudioCompleted = false;
    AudioQueue().Reset();
    mAudioDataRequest.DisconnectIfExists();
    mAudioWaitRequest.DisconnectIfExists();
  }

  mReader->ResetDecode(aTracks);
}

media::TimeUnit MediaDecoderStateMachine::GetClock(
    TimeStamp* aTimeStamp) const {
  MOZ_ASSERT(OnTaskQueue());
  auto clockTime = mMediaSink->GetPosition(aTimeStamp);
  // This fails on Windows some times, see 1765563
#if defined(XP_WIN)
  NS_ASSERTION(GetMediaTime() <= clockTime, "Clock should go forwards.");
#else
  MOZ_ASSERT(GetMediaTime() <= clockTime, "Clock should go forwards.");
#endif
  return clockTime;
}

void MediaDecoderStateMachine::UpdatePlaybackPositionPeriodically() {
  MOZ_ASSERT(OnTaskQueue());

  if (!IsPlaying()) {
    return;
  }

  // Cap the current time to the larger of the audio and video end time.
  // This ensures that if we're running off the system clock, we don't
  // advance the clock to after the media end time.
  if (VideoEndTime() > TimeUnit::Zero() || AudioEndTime() > TimeUnit::Zero()) {
    auto clockTime = GetClock();
    // Once looping was turned on, the time is probably larger than the duration
    // of the media track, so the time over the end should be corrected.
    AdjustByLooping(clockTime);
    bool loopback = clockTime < GetMediaTime() && mLooping;
    if (loopback && mBypassingSkipToNextKeyFrameCheck) {
      LOG("media has looped back, no longer bypassing skip-to-next-key-frame");
      mBypassingSkipToNextKeyFrameCheck = false;
    }

    // Skip frames up to the frame at the playback position, and figure out
    // the time remaining until it's time to display the next frame and drop
    // the current frame.
    NS_ASSERTION(clockTime >= TimeUnit::Zero(),
                 "Should have positive clock time.");

    // These will be non -1 if we've displayed a video frame, or played an audio
    // frame.
    auto maxEndTime = std::max(VideoEndTime(), AudioEndTime());
    auto t = std::min(clockTime, maxEndTime);
    // FIXME: Bug 1091422 - chained ogg files hit this assertion.
    // MOZ_ASSERT(t >= GetMediaTime());
    if (loopback || t > GetMediaTime()) {
      UpdatePlaybackPosition(t);
    }
  }
  // Note we have to update playback position before releasing the monitor.
  // Otherwise, MediaDecoder::AddOutputTrack could kick in when we are outside
  // the monitor and get a staled value from GetCurrentTimeUs() which hits the
  // assertion in GetClock().

  int64_t delay = std::max<int64_t>(
      1, static_cast<int64_t>(AUDIO_DURATION_USECS / mPlaybackRate));
  ScheduleStateMachineIn(TimeUnit::FromMicroseconds(delay));

  // Notify the listener as we progress in the playback offset. Note it would
  // be too intensive to send notifications for each popped audio/video sample.
  // It is good enough to send 'PlaybackProgressed' events every 40us (defined
  // by AUDIO_DURATION_USECS), and we ensure 'PlaybackProgressed' events are
  // always sent after 'PlaybackStarted' and before 'PlaybackStopped'.
  mOnPlaybackEvent.Notify(MediaPlaybackEvent{
      MediaPlaybackEvent::PlaybackProgressed, mPlaybackOffset});
}

void MediaDecoderStateMachine::ScheduleStateMachine() {
  MOZ_ASSERT(OnTaskQueue());
  if (mDispatchedStateMachine) {
    return;
  }
  mDispatchedStateMachine = true;

  nsresult rv = OwnerThread()->Dispatch(
      NewRunnableMethod("MediaDecoderStateMachine::RunStateMachine", this,
                        &MediaDecoderStateMachine::RunStateMachine));
  MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));
  Unused << rv;
}

void MediaDecoderStateMachine::ScheduleStateMachineIn(const TimeUnit& aTime) {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::ScheduleStateMachineIn",
                      MEDIA_PLAYBACK);
  MOZ_ASSERT(OnTaskQueue());  // mDelayedScheduler.Ensure() may Disconnect()
                              // the promise, which must happen on the state
                              // machine task queue.
  MOZ_ASSERT(aTime > TimeUnit::Zero());
  if (mDispatchedStateMachine) {
    return;
  }

  TimeStamp target = TimeStamp::Now() + aTime.ToTimeDuration();

  // It is OK to capture 'this' without causing UAF because the callback
  // always happens before shutdown.
  RefPtr<MediaDecoderStateMachine> self = this;
  mDelayedScheduler.Ensure(
      target,
      [self]() {
        self->mDelayedScheduler.CompleteRequest();
        self->RunStateMachine();
      },
      []() { MOZ_DIAGNOSTIC_CRASH("ScheduleStateMachineIn reject"); });
}

bool MediaDecoderStateMachine::IsStateMachineScheduled() const {
  MOZ_ASSERT(OnTaskQueue());
  return mDispatchedStateMachine || mDelayedScheduler.IsScheduled();
}

void MediaDecoderStateMachine::SetPlaybackRate(double aPlaybackRate) {
  MOZ_ASSERT(OnTaskQueue());
  MOZ_ASSERT(aPlaybackRate != 0, "Should be handled by MediaDecoder::Pause()");
  PROFILER_MARKER_TEXT("MDSM::SetPlaybackRate", MEDIA_PLAYBACK, {},
                       nsPrintfCString("PlaybackRate:%f", aPlaybackRate));
  mPlaybackRate = aPlaybackRate;
  mMediaSink->SetPlaybackRate(mPlaybackRate);

  // Schedule next cycle to check if we can stop prerolling.
  ScheduleStateMachine();
}

void MediaDecoderStateMachine::PreservesPitchChanged() {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::PreservesPitchChanged",
                      MEDIA_PLAYBACK);
  PROFILER_MARKER_TEXT(
      "MDSM::PreservesPitchChanged", MEDIA_PLAYBACK, {},
      nsPrintfCString("PreservesPitch:%d", mPreservesPitch.Ref()));
  MOZ_ASSERT(OnTaskQueue());
  mMediaSink->SetPreservesPitch(mPreservesPitch);
}

void MediaDecoderStateMachine::LoopingChanged() {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::LoopingChanged",
                      MEDIA_PLAYBACK);
  MOZ_ASSERT(OnTaskQueue());
  LOGV("LoopingChanged, looping=%d", mLooping.Ref());
  PROFILER_MARKER_TEXT("MDSM::LoopingChanged", MEDIA_PLAYBACK, {},
                       mLooping ? "true"_ns : "false"_ns);
  if (mSeamlessLoopingAllowed) {
    mStateObj->HandleLoopingChanged();
  }
}

void MediaDecoderStateMachine::StreamNameChanged() {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::StreamNameChanged",
                      MEDIA_PLAYBACK);
  MOZ_ASSERT(OnTaskQueue());

  mMediaSink->SetStreamName(mStreamName);
}

void MediaDecoderStateMachine::UpdateOutputCaptured() {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::UpdateOutputCaptured",
                      MEDIA_PLAYBACK);
  MOZ_ASSERT(OnTaskQueue());
  MOZ_ASSERT_IF(
      mOutputCaptureState == MediaDecoder::OutputCaptureState::Capture,
      mOutputDummyTrack.Ref());

  // Reset these flags so they are consistent with the status of the sink.
  // TODO: Move these flags into MediaSink to improve cohesion so we don't need
  // to reset these flags when switching MediaSinks.
  mAudioCompleted = false;
  mVideoCompleted = false;

  // Don't create a new media sink if we're still suspending media sink.
  if (!mIsMediaSinkSuspended) {
    const bool wasPlaying = IsPlaying();
    // Stop and shut down the existing sink.
    StopMediaSink();
    mMediaSink->Shutdown();

    // Create a new sink according to whether output is captured.
    mMediaSink = CreateMediaSink();
    if (wasPlaying) {
      DebugOnly<nsresult> rv = StartMediaSink();
      MOZ_ASSERT(NS_SUCCEEDED(rv));
    }
  }

  // Don't buffer as much when audio is captured because we don't need to worry
  // about high latency audio devices.
  mAmpleAudioThreshold =
      mOutputCaptureState != MediaDecoder::OutputCaptureState::None
          ? detail::AMPLE_AUDIO_THRESHOLD / 2
          : detail::AMPLE_AUDIO_THRESHOLD;

  mStateObj->HandleAudioCaptured();
}

void MediaDecoderStateMachine::OutputPrincipalChanged() {
  MOZ_ASSERT(OnTaskQueue());
  mCanonicalOutputPrincipal = mOutputPrincipal;
}

RefPtr<GenericPromise> MediaDecoderStateMachine::InvokeSetSink(
    const RefPtr<AudioDeviceInfo>& aSink) {
  MOZ_ASSERT(NS_IsMainThread());
  MOZ_ASSERT(aSink);

  return InvokeAsync(OwnerThread(), this, __func__,
                     &MediaDecoderStateMachine::SetSink, aSink);
}

RefPtr<GenericPromise> MediaDecoderStateMachine::SetSink(
    RefPtr<AudioDeviceInfo> aDevice) {
  MOZ_ASSERT(OnTaskQueue());
  if (mIsMediaSinkSuspended) {
    // Don't create a new media sink when suspended.
    return GenericPromise::CreateAndResolve(true, __func__);
  }

  return mMediaSink->SetAudioDevice(std::move(aDevice));
}

void MediaDecoderStateMachine::InvokeSuspendMediaSink() {
  MOZ_ASSERT(NS_IsMainThread());

  nsresult rv = OwnerThread()->Dispatch(
      NewRunnableMethod("MediaDecoderStateMachine::SuspendMediaSink", this,
                        &MediaDecoderStateMachine::SuspendMediaSink));
  MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));
  Unused << rv;
}

void MediaDecoderStateMachine::SuspendMediaSink() {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::SuspendMediaSink",
                      MEDIA_PLAYBACK);
  MOZ_ASSERT(OnTaskQueue());
  if (mIsMediaSinkSuspended) {
    return;
  }
  LOG("SuspendMediaSink");
  mIsMediaSinkSuspended = true;
  StopMediaSink();
  mMediaSink->Shutdown();
}

void MediaDecoderStateMachine::InvokeResumeMediaSink() {
  MOZ_ASSERT(NS_IsMainThread());

  nsresult rv = OwnerThread()->Dispatch(
      NewRunnableMethod("MediaDecoderStateMachine::ResumeMediaSink", this,
                        &MediaDecoderStateMachine::ResumeMediaSink));
  MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));
  Unused << rv;
}

void MediaDecoderStateMachine::ResumeMediaSink() {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::ResumeMediaSink",
                      MEDIA_PLAYBACK);
  MOZ_ASSERT(OnTaskQueue());
  if (!mIsMediaSinkSuspended) {
    return;
  }
  LOG("ResumeMediaSink");
  mIsMediaSinkSuspended = false;
  if (!mMediaSink->IsStarted()) {
    mMediaSink = CreateMediaSink();
    MaybeStartPlayback();
  }
}

void MediaDecoderStateMachine::UpdateSecondaryVideoContainer() {
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::UpdateSecondaryVideoContainer",
                      MEDIA_PLAYBACK);
  MOZ_ASSERT(OnTaskQueue());
  MOZ_DIAGNOSTIC_ASSERT(mMediaSink);
  mMediaSink->SetSecondaryVideoContainer(mSecondaryVideoContainer.Ref());
  mOnSecondaryVideoContainerInstalled.Notify(mSecondaryVideoContainer.Ref());
}

TimeUnit MediaDecoderStateMachine::AudioEndTime() const {
  MOZ_ASSERT(OnTaskQueue());
  if (mMediaSink->IsStarted()) {
    return mMediaSink->GetEndTime(TrackInfo::kAudioTrack);
  }
  return GetMediaTime();
}

TimeUnit MediaDecoderStateMachine::VideoEndTime() const {
  MOZ_ASSERT(OnTaskQueue());
  if (mMediaSink->IsStarted()) {
    return mMediaSink->GetEndTime(TrackInfo::kVideoTrack);
  }
  return GetMediaTime();
}

void MediaDecoderStateMachine::OnMediaSinkVideoComplete() {
  MOZ_ASSERT(OnTaskQueue());
  MOZ_ASSERT(HasVideo());
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::OnMediaSinkVideoComplete",
                      MEDIA_PLAYBACK);
  LOG("[%s]", __func__);

  mMediaSinkVideoEndedPromise.Complete();
  mVideoCompleted = true;
  ScheduleStateMachine();
}

void MediaDecoderStateMachine::OnMediaSinkVideoError() {
  MOZ_ASSERT(OnTaskQueue());
  MOZ_ASSERT(HasVideo());
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::OnMediaSinkVideoError",
                      MEDIA_PLAYBACK);
  LOGE("[%s]", __func__);

  mMediaSinkVideoEndedPromise.Complete();
  mVideoCompleted = true;
  if (HasAudio()) {
    return;
  }
  DecodeError(MediaResult(NS_ERROR_DOM_MEDIA_MEDIASINK_ERR, __func__));
}

void MediaDecoderStateMachine::OnMediaSinkAudioComplete() {
  MOZ_ASSERT(OnTaskQueue());
  MOZ_ASSERT(HasAudio());
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::OnMediaSinkAudioComplete",
                      MEDIA_PLAYBACK);
  LOG("[%s]", __func__);

  mMediaSinkAudioEndedPromise.Complete();
  mAudioCompleted = true;
  // To notify PlaybackEnded as soon as possible.
  ScheduleStateMachine();

  // Report OK to Decoder Doctor (to know if issue may have been resolved).
  mOnDecoderDoctorEvent.Notify(
      DecoderDoctorEvent{DecoderDoctorEvent::eAudioSinkStartup, NS_OK});
}

void MediaDecoderStateMachine::OnMediaSinkAudioError(nsresult aResult) {
  MOZ_ASSERT(OnTaskQueue());
  MOZ_ASSERT(HasAudio());
  AUTO_PROFILER_LABEL("MediaDecoderStateMachine::OnMediaSinkAudioError",
                      MEDIA_PLAYBACK);
  LOGE("[%s]", __func__);

  mMediaSinkAudioEndedPromise.Complete();
  mAudioCompleted = true;

  // Result should never be NS_OK in this *error* handler. Report to Dec-Doc.
  MOZ_ASSERT(NS_FAILED(aResult));
  mOnDecoderDoctorEvent.Notify(
      DecoderDoctorEvent{DecoderDoctorEvent::eAudioSinkStartup, aResult});

  // Make the best effort to continue playback when there is video.
  if (HasVideo()) {
    return;
  }

  // Otherwise notify media decoder/element about this error for it makes
  // no sense to play an audio-only file without sound output.
  DecodeError(MediaResult(NS_ERROR_DOM_MEDIA_MEDIASINK_ERR, __func__));
}

uint32_t MediaDecoderStateMachine::GetAmpleVideoFrames() const {
  MOZ_ASSERT(OnTaskQueue());
  return mReader->VideoIsHardwareAccelerated()
             ? std::max<uint32_t>(sVideoQueueHWAccelSize, MIN_VIDEO_QUEUE_SIZE)
             : std::max<uint32_t>(sVideoQueueDefaultSize, MIN_VIDEO_QUEUE_SIZE);
}

void MediaDecoderStateMachine::GetDebugInfo(
    dom::MediaDecoderStateMachineDebugInfo& aInfo) {
  MOZ_ASSERT(OnTaskQueue());
  aInfo.mDuration =
      mDuration.Ref() ? mDuration.Ref().ref().ToMicroseconds() : -1;
  aInfo.mMediaTime = GetMediaTime().ToMicroseconds();
  aInfo.mClock = mMediaSink->IsStarted() ? GetClock().ToMicroseconds() : -1;
  aInfo.mPlayState = int32_t(mPlayState.Ref());
  aInfo.mSentFirstFrameLoadedEvent = mSentFirstFrameLoadedEvent;
  aInfo.mIsPlaying = IsPlaying();
  CopyUTF8toUTF16(MakeStringSpan(AudioRequestStatus()),
                  aInfo.mAudioRequestStatus);
  CopyUTF8toUTF16(MakeStringSpan(VideoRequestStatus()),
                  aInfo.mVideoRequestStatus);
  aInfo.mDecodedAudioEndTime = mDecodedAudioEndTime.ToMicroseconds();
  aInfo.mDecodedVideoEndTime = mDecodedVideoEndTime.ToMicroseconds();
  aInfo.mAudioCompleted = mAudioCompleted;
  aInfo.mVideoCompleted = mVideoCompleted;
  mStateObj->GetDebugInfo(aInfo.mStateObj);
  mMediaSink->GetDebugInfo(aInfo.mMediaSink);
  aInfo.mTotalBufferingTimeMs = mTotalBufferingDuration.ToMilliseconds();
}

RefPtr<GenericPromise> MediaDecoderStateMachine::RequestDebugInfo(
    dom::MediaDecoderStateMachineDebugInfo& aInfo) {
  if (mShuttingDown) {
    return GenericPromise::CreateAndReject(NS_ERROR_FAILURE, __func__);
  }

  RefPtr<GenericPromise::Private> p = new GenericPromise::Private(__func__);
  RefPtr<MediaDecoderStateMachine> self = this;
  nsresult rv = OwnerThread()->Dispatch(
      NS_NewRunnableFunction("MediaDecoderStateMachine::RequestDebugInfo",
                             [self, p, &aInfo]() {
                               self->GetDebugInfo(aInfo);
                               p->Resolve(true, __func__);
                             }),
      AbstractThread::TailDispatch);
  MOZ_ASSERT(NS_SUCCEEDED(rv));
  Unused << rv;
  return p;
}

class VideoQueueMemoryFunctor : public nsDequeFunctor<VideoData> {
 public:
  VideoQueueMemoryFunctor() : mSize(0) {}

  MOZ_DEFINE_MALLOC_SIZE_OF(MallocSizeOf);

  virtual void operator()(VideoData* aObject) override {
    mSize += aObject->SizeOfIncludingThis(MallocSizeOf);
  }

  size_t mSize;
};

class AudioQueueMemoryFunctor : public nsDequeFunctor<AudioData> {
 public:
  AudioQueueMemoryFunctor() : mSize(0) {}

  MOZ_DEFINE_MALLOC_SIZE_OF(MallocSizeOf);

  virtual void operator()(AudioData* aObject) override {
    mSize += aObject->SizeOfIncludingThis(MallocSizeOf);
  }

  size_t mSize;
};

size_t MediaDecoderStateMachine::SizeOfVideoQueue() const {
  VideoQueueMemoryFunctor functor;
  mVideoQueue.LockedForEach(functor);
  return functor.mSize;
}

size_t MediaDecoderStateMachine::SizeOfAudioQueue() const {
  AudioQueueMemoryFunctor functor;
  mAudioQueue.LockedForEach(functor);
  return functor.mSize;
}

const char* MediaDecoderStateMachine::AudioRequestStatus() const {
  MOZ_ASSERT(OnTaskQueue());
  if (IsRequestingAudioData()) {
    MOZ_DIAGNOSTIC_ASSERT(!IsWaitingAudioData());
    return "pending";
  }

  if (IsWaitingAudioData()) {
    return "waiting";
  }
  return "idle";
}

const char* MediaDecoderStateMachine::VideoRequestStatus() const {
  MOZ_ASSERT(OnTaskQueue());
  if (IsRequestingVideoData()) {
    MOZ_DIAGNOSTIC_ASSERT(!IsWaitingVideoData());
    return "pending";
  }

  if (IsWaitingVideoData()) {
    return "waiting";
  }
  return "idle";
}

void MediaDecoderStateMachine::OnSuspendTimerResolved() {
  LOG("OnSuspendTimerResolved");
  mVideoDecodeSuspendTimer.CompleteRequest();
  mStateObj->HandleVideoSuspendTimeout();
}

void MediaDecoderStateMachine::CancelSuspendTimer() {
  LOG("CancelSuspendTimer: State: %s, Timer.IsScheduled: %c",
      ToStateStr(mStateObj->GetState()),
      mVideoDecodeSuspendTimer.IsScheduled() ? 'T' : 'F');
  MOZ_ASSERT(OnTaskQueue());
  if (mVideoDecodeSuspendTimer.IsScheduled()) {
    mOnPlaybackEvent.Notify(MediaPlaybackEvent::CancelVideoSuspendTimer);
  }
  mVideoDecodeSuspendTimer.Reset();
}

void MediaDecoderStateMachine::AdjustByLooping(media::TimeUnit& aTime) const {
  MOZ_ASSERT(OnTaskQueue());

  // No need to adjust time.
  if (mOriginalDecodedDuration == media::TimeUnit::Zero()) {
    return;
  }

  // There are situations where we need to perform subtraction instead of modulo
  // to accurately adjust the clock. When we are not in a state of seamless
  // looping, it is usually necessary to normalize the clock time within the
  // range of [0, duration]. However, if the current clock time is greater than
  // the duration (i.e., duration+1) and not in looping, we should not adjust it
  // to 1 as we are not looping back to the starting position. Instead, we
  // should leave the clock time unchanged and trim it later to match the
  // maximum duration time.
  if (mStateObj->GetState() != DECODER_STATE_LOOPING_DECODING) {
    // Use the smaller offset rather than the larger one, as the larger offset
    // indicates the next round of looping. For example, if the duration is X
    // and the playback is currently in the third round of looping, both
    // queues will have an offset of 3X. However, if the audio decoding is
    // faster and the fourth round of data has already been added to the audio
    // queue, the audio offset will become 4X. Since playback is still in the
    // third round, we should use the smaller offset of 3X to adjust the time.
    TimeUnit offset = TimeUnit::FromInfinity();
    if (HasAudio()) {
      offset = std::min(AudioQueue().GetOffset(), offset);
    }
    if (HasVideo()) {
      offset = std::min(VideoQueue().GetOffset(), offset);
    }
    if (aTime > offset) {
      aTime -= offset;
      return;
    }
  }

  // When seamless looping happens at least once, it doesn't matter if we're
  // looping or not.
  aTime = aTime % mOriginalDecodedDuration;
}

bool MediaDecoderStateMachine::IsInSeamlessLooping() const {
  return mLooping && mSeamlessLoopingAllowed;
}

bool MediaDecoderStateMachine::HasLastDecodedData(MediaData::Type aType) {
  MOZ_DIAGNOSTIC_ASSERT(aType == MediaData::Type::AUDIO_DATA ||
                        aType == MediaData::Type::VIDEO_DATA);
  if (aType == MediaData::Type::AUDIO_DATA) {
    return mDecodedAudioEndTime != TimeUnit::Zero();
  }
  return mDecodedVideoEndTime != TimeUnit::Zero();
}

bool MediaDecoderStateMachine::IsCDMProxySupported(CDMProxy* aProxy) {
#ifdef MOZ_WMF_CDM
  MOZ_ASSERT(aProxy);
  // This proxy only works with the external state machine.
  return !aProxy->AsWMFCDMProxy();
#else
  return true;
#endif
}

RefPtr<SetCDMPromise> MediaDecoderStateMachine::SetCDMProxy(CDMProxy* aProxy) {
  // Playback hasn't started yet.
  if (!mInitialized) {
    mReader->SetEncryptedCustomIdent();
  }
  return MediaDecoderStateMachineBase::SetCDMProxy(aProxy);
}

}  // namespace mozilla

// avoid redefined macro in unified build
#undef LOG
#undef LOGV
#undef LOGW
#undef LOGE
#undef SLOGW
#undef SLOGE
#undef NS_DispatchToMainThread