RemoteDecoderChild.h

Enable keyboard shortcuts

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

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

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

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

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

#ifndef include_dom_media_ipc_RemoteDecoderChild_h

#define include_dom_media_ipc_RemoteDecoderChild_h

#include <functional>

#include "mozilla/PRemoteDecoderChild.h"

#include "mozilla/RemoteDecoderManagerChild.h"

#include "mozilla/ShmemRecycleAllocator.h"

namespace mozilla {

class RemoteDecoderManagerChild;

using mozilla::MediaDataDecoder;

using mozilla::ipc::IPCResult;

class RemoteDecoderChild : public ShmemRecycleAllocator<RemoteDecoderChild>,

                           public PRemoteDecoderChild {

  friend class PRemoteDecoderChild;

 public:

  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RemoteDecoderChild);

  explicit RemoteDecoderChild(RemoteDecodeIn aLocation);

  void ActorDestroy(ActorDestroyReason aWhy) override;

  // This interface closely mirrors the MediaDataDecoder plus a bit

  // (DestroyIPDL) to allow proxying to a remote decoder in RemoteDecoderModule.

  RefPtr<MediaDataDecoder::InitPromise> Init();

  RefPtr<MediaDataDecoder::DecodePromise> Decode(

      const nsTArray<RefPtr<MediaRawData>>& aSamples);

  RefPtr<MediaDataDecoder::DecodePromise> Drain();

  RefPtr<MediaDataDecoder::FlushPromise> Flush();

  RefPtr<mozilla::ShutdownPromise> Shutdown();

  bool IsHardwareAccelerated(nsACString& aFailureReason) const;

  nsCString GetDescriptionName() const;

  nsCString GetProcessName() const;

  nsCString GetCodecName() const;

  void SetSeekThreshold(const media::TimeUnit& aTime);

  MediaDataDecoder::ConversionRequired NeedsConversion() const;

  bool ShouldDecoderAlwaysBeRecycled() const;

  void DestroyIPDL();

  // Called from IPDL when our actor has been destroyed

  void IPDLActorDestroyed();

  RemoteDecoderManagerChild* GetManager();

 protected:

  virtual ~RemoteDecoderChild();

  void AssertOnManagerThread() const;

  virtual MediaResult ProcessOutput(DecodedOutputIPDL&& aDecodedData) = 0;

  virtual void RecordShutdownTelemetry(bool aForAbnormalShutdown) {}

  RefPtr<RemoteDecoderChild> mIPDLSelfRef;

  MediaDataDecoder::DecodedData mDecodedData;

  const RemoteDecodeIn mLocation;

 private:

  const nsCOMPtr<nsISerialEventTarget> mThread;

  MozPromiseHolder<MediaDataDecoder::InitPromise> mInitPromise;

  MozPromiseRequestHolder<PRemoteDecoderChild::InitPromise> mInitPromiseRequest;

  MozPromiseHolder<MediaDataDecoder::DecodePromise> mDecodePromise;

  MozPromiseHolder<MediaDataDecoder::DecodePromise> mDrainPromise;

  MozPromiseHolder<MediaDataDecoder::FlushPromise> mFlushPromise;

  MozPromiseHolder<mozilla::ShutdownPromise> mShutdownPromise;

  void HandleRejectionError(

      const ipc::ResponseRejectReason& aReason,

      std::function<void(const MediaResult&)>&& aCallback);

  nsCString mHardwareAcceleratedReason;

  nsCString mDescription;

  nsCString mProcessName;

  nsCString mCodecName;

  bool mIsHardwareAccelerated = false;

  bool mRemoteDecoderCrashed = false;

  MediaDataDecoder::ConversionRequired mConversion =

      MediaDataDecoder::ConversionRequired::kNeedNone;

  bool mShouldDecoderAlwaysBeRecycled = false;

};

}  // namespace mozilla

#endif  // include_dom_media_ipc_RemoteDecoderChild_h