/* 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 "mozilla/EnumeratedArray.h"
#include "mozilla/PRemoteDecoderChild.h"
#include "mozilla/RemoteMediaManagerChild.h"
#include "mozilla/ShmemRecycleAllocator.h"

namespace mozilla {

class RemoteMediaManagerChild;
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(RemoteMediaIn 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;
  using DecodeProperties =
      EnumeratedArray<MediaDataDecoder::PropertyName,
                      Maybe<MediaDataDecoder::PropertyValue>,
                      MediaDataDecoder::sPropertyNameCount>;
  const DecodeProperties& GetDecodeProperties() const {
    return mDecodeProperties;
  }

  void DestroyIPDL();

  // Called from IPDL when our actor has been destroyed
  void IPDLActorDestroyed();

  RemoteMediaManagerChild* 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 RemoteMediaIn 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;

  nsCString mHardwareAcceleratedReason;
  nsCString mDescription;
  nsCString mProcessName;
  nsCString mCodecName;
  bool mIsHardwareAccelerated = false;
  bool mRemoteDecoderCrashed = false;
  MediaDataDecoder::ConversionRequired mConversion =
      MediaDataDecoder::ConversionRequired::kNeedNone;
  bool mShouldDecoderAlwaysBeRecycled = false;
  DecodeProperties mDecodeProperties;
};

}  // namespace mozilla

#endif  // include_dom_media_ipc_RemoteDecoderChild_h