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

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

/* 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 "VideoDecoderChild.h"

#include "VideoDecoderManagerChild.h"

#include "mozilla/layers/TextureClient.h"

#include "mozilla/Telemetry.h"

#include "base/thread.h"

#include "MediaInfo.h"

#include "ImageContainer.h"

#include "GPUVideoImage.h"

namespace mozilla {

namespace dom {

using base::Thread;

using namespace ipc;

using namespace layers;

using namespace gfx;

#ifdef XP_WIN

static void

ReportUnblacklistingTelemetry(bool isGPUProcessCrashed,

                              const nsCString& aD3D11BlacklistedDriver,

                              const nsCString& aD3D9BlacklistedDriver)

{

  const nsCString& blacklistedDLL = !aD3D11BlacklistedDriver.IsEmpty()

                                    ? aD3D11BlacklistedDriver

                                    : aD3D9BlacklistedDriver;

  if (!blacklistedDLL.IsEmpty()) {

    Telemetry::Accumulate(Telemetry::VIDEO_UNBLACKINGLISTING_DXVA_DRIVER_RUNTIME_STATUS,

                          blacklistedDLL,

                          isGPUProcessCrashed ? 1 : 0);

  }

}

#endif // XP_WIN

VideoDecoderChild::VideoDecoderChild()

  : mThread(VideoDecoderManagerChild::GetManagerThread())

  , mCanSend(false)

  , mInitialized(false)

  , mIsHardwareAccelerated(false)

  , mConversion(MediaDataDecoder::ConversionRequired::kNeedNone)

  , mNeedNewDecoder(false)

{

}

VideoDecoderChild::~VideoDecoderChild()

{

  AssertOnManagerThread();

  mInitPromise.RejectIfExists(NS_ERROR_DOM_MEDIA_CANCELED, __func__);

}

mozilla::ipc::IPCResult

VideoDecoderChild::RecvOutput(const VideoDataIPDL& aData)

{

  AssertOnManagerThread();

  // The Image here creates a TextureData object that takes ownership

  // of the SurfaceDescriptor, and is responsible for making sure that

  // it gets deallocated.

  RefPtr<Image> image = new GPUVideoImage(GetManager(), aData.sd(), aData.frameSize());

  RefPtr<VideoData> video = VideoData::CreateFromImage(

    aData.display(),

    aData.base().offset(),

    media::TimeUnit::FromMicroseconds(aData.base().time()),

    media::TimeUnit::FromMicroseconds(aData.base().duration()),

    image,

    aData.base().keyframe(),

    media::TimeUnit::FromMicroseconds(aData.base().timecode()));

  mDecodedData.AppendElement(std::move(video));

  return IPC_OK();

}

mozilla::ipc::IPCResult

VideoDecoderChild::RecvInputExhausted()

{

  AssertOnManagerThread();

  mDecodePromise.ResolveIfExists(mDecodedData, __func__);

  mDecodedData.Clear();

  return IPC_OK();

}

mozilla::ipc::IPCResult

VideoDecoderChild::RecvDrainComplete()

{

  AssertOnManagerThread();

  mDrainPromise.ResolveIfExists(mDecodedData, __func__);

  mDecodedData.Clear();

  return IPC_OK();

}

mozilla::ipc::IPCResult

VideoDecoderChild::RecvError(const nsresult& aError)

{

  AssertOnManagerThread();

  mDecodedData.Clear();

  mDecodePromise.RejectIfExists(aError, __func__);

  mDrainPromise.RejectIfExists(aError, __func__);

  mFlushPromise.RejectIfExists(aError, __func__);

  return IPC_OK();

}

mozilla::ipc::IPCResult

VideoDecoderChild::RecvInitComplete(const nsCString& aDecoderDescription,

                                    const bool& aHardware,

                                    const nsCString& aHardwareReason,

                                    const uint32_t& aConversion)

{

  AssertOnManagerThread();

  mInitPromise.ResolveIfExists(TrackInfo::kVideoTrack, __func__);

  mInitialized = true;

  mDescription = aDecoderDescription;

  mIsHardwareAccelerated = aHardware;

  mHardwareAcceleratedReason = aHardwareReason;

  mConversion = static_cast<MediaDataDecoder::ConversionRequired>(aConversion);

  return IPC_OK();

}

mozilla::ipc::IPCResult

VideoDecoderChild::RecvInitFailed(const nsresult& aReason)

{

  AssertOnManagerThread();

  mInitPromise.RejectIfExists(aReason, __func__);

  return IPC_OK();

}

mozilla::ipc::IPCResult

VideoDecoderChild::RecvFlushComplete()

{

  AssertOnManagerThread();

  mFlushPromise.ResolveIfExists(true, __func__);

  return IPC_OK();

}

void

VideoDecoderChild::ActorDestroy(ActorDestroyReason aWhy)

{

  if (aWhy == AbnormalShutdown) {

    // GPU process crashed, record the time and send back to MFR for telemetry.

    mGPUCrashTime = TimeStamp::Now();

    // Defer reporting an error until we've recreated the manager so that

    // it'll be safe for MediaFormatReader to recreate decoders

    RefPtr<VideoDecoderChild> ref = this;

    GetManager()->RunWhenRecreated(

      NS_NewRunnableFunction("dom::VideoDecoderChild::ActorDestroy", [=]() {

        MediaResult error(NS_ERROR_DOM_MEDIA_NEED_NEW_DECODER);

        error.SetGPUCrashTimeStamp(ref->mGPUCrashTime);

        if (ref->mInitialized) {

          mDecodedData.Clear();

          mDecodePromise.RejectIfExists(error, __func__);

          mDrainPromise.RejectIfExists(error, __func__);

          mFlushPromise.RejectIfExists(error, __func__);

          // Make sure the next request will be rejected accordingly if ever

          // called.

          mNeedNewDecoder = true;

        } else {

          ref->mInitPromise.RejectIfExists(error, __func__);

        }

      }));

  }

  mCanSend = false;

#ifdef XP_WIN

  ReportUnblacklistingTelemetry(aWhy == AbnormalShutdown,

                                mBlacklistedD3D11Driver,

                                mBlacklistedD3D9Driver);

#endif // XP_WIN

}

MediaResult

VideoDecoderChild::InitIPDL(const VideoInfo& aVideoInfo,

                            float aFramerate,

                            const layers::TextureFactoryIdentifier& aIdentifier)

{

  RefPtr<VideoDecoderManagerChild> manager =

    VideoDecoderManagerChild::GetSingleton();

  // The manager isn't available because VideoDecoderManagerChild has been

  // initialized with null end points and we don't want to decode video on GPU

  // process anymore. Return false here so that we can fallback to other PDMs.

  if (!manager) {

    return MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,

                       RESULT_DETAIL("VideoDecoderManager is not available."));

  }

  // The manager doesn't support sending messages because we've just crashed

  // and are working on reinitialization. Don't initialize mIPDLSelfRef and

  // leave us in an error state. We'll then immediately reject the promise when

  // Init() is called and the caller can try again. Hopefully by then the new

  // manager is ready, or we've notified the caller of it being no longer

  // available. If not, then the cycle repeats until we're ready.

  if (!manager->CanSend()) {

    return NS_OK;

  }

  mIPDLSelfRef = this;

  bool success = false;

  nsCString errorDescription;

  if (manager->SendPVideoDecoderConstructor(this,

                                            aVideoInfo,

                                            aFramerate,

                                            aIdentifier,

                                            &success,

                                            &mBlacklistedD3D11Driver,

                                            &mBlacklistedD3D9Driver,

                                            &errorDescription)) {

    mCanSend = true;

  }

  return success ? MediaResult(NS_OK) :

                   MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR, errorDescription);

}

void

VideoDecoderChild::DestroyIPDL()

{

  if (mCanSend) {

    PVideoDecoderChild::Send__delete__(this);

  }

}

void

VideoDecoderChild::IPDLActorDestroyed()

{

  mIPDLSelfRef = nullptr;

}

// MediaDataDecoder methods

RefPtr<MediaDataDecoder::InitPromise>

VideoDecoderChild::Init()

{

  AssertOnManagerThread();

  if (!mIPDLSelfRef) {

    return MediaDataDecoder::InitPromise::CreateAndReject(

      NS_ERROR_DOM_MEDIA_DECODE_ERR, __func__);

  }

  // If we failed to send this, then we'll still resolve the Init promise

  // as ActorDestroy handles it.

  if (mCanSend) {

    SendInit();

  }

  return mInitPromise.Ensure(__func__);

}

RefPtr<MediaDataDecoder::DecodePromise>

VideoDecoderChild::Decode(MediaRawData* aSample)

{

  AssertOnManagerThread();

  if (mNeedNewDecoder) {

    MediaResult error(NS_ERROR_DOM_MEDIA_NEED_NEW_DECODER);

    error.SetGPUCrashTimeStamp(mGPUCrashTime);

    return MediaDataDecoder::DecodePromise::CreateAndReject(error, __func__);

  }

  if (!mCanSend) {

    // We're here if the IPC channel has died but we're still waiting for the

    // RunWhenRecreated task to complete. The decode promise will be rejected

    // when that task is run.

    return mDecodePromise.Ensure(__func__);

  }

  // TODO: It would be nice to add an allocator method to

  // MediaDataDecoder so that the demuxer could write directly

  // into shmem rather than requiring a copy here.

  Shmem buffer;

  if (!AllocShmem(aSample->Size(), Shmem::SharedMemory::TYPE_BASIC, &buffer)) {

    return MediaDataDecoder::DecodePromise::CreateAndReject(

      NS_ERROR_DOM_MEDIA_DECODE_ERR, __func__);

  }

  memcpy(buffer.get<uint8_t>(), aSample->Data(), aSample->Size());

  MediaRawDataIPDL sample(MediaDataIPDL(aSample->mOffset,

                                        aSample->mTime.ToMicroseconds(),

                                        aSample->mTimecode.ToMicroseconds(),

                                        aSample->mDuration.ToMicroseconds(),

                                        aSample->mFrames,

                                        aSample->mKeyframe),

                          buffer);

  SendInput(sample);

  return mDecodePromise.Ensure(__func__);

}

RefPtr<MediaDataDecoder::FlushPromise>

VideoDecoderChild::Flush()

{

  AssertOnManagerThread();

  mDecodePromise.RejectIfExists(NS_ERROR_DOM_MEDIA_CANCELED, __func__);

  mDrainPromise.RejectIfExists(NS_ERROR_DOM_MEDIA_CANCELED, __func__);

  if (mNeedNewDecoder) {

    MediaResult error(NS_ERROR_DOM_MEDIA_NEED_NEW_DECODER);

    error.SetGPUCrashTimeStamp(mGPUCrashTime);

    return MediaDataDecoder::FlushPromise::CreateAndReject(error, __func__);

  }

  if (mCanSend) {

    SendFlush();

  }

  return mFlushPromise.Ensure(__func__);

}

RefPtr<MediaDataDecoder::DecodePromise>

VideoDecoderChild::Drain()

{

  AssertOnManagerThread();

  if (mNeedNewDecoder) {

    MediaResult error(NS_ERROR_DOM_MEDIA_NEED_NEW_DECODER);

    error.SetGPUCrashTimeStamp(mGPUCrashTime);

    return MediaDataDecoder::DecodePromise::CreateAndReject(error, __func__);

  }

  if (mCanSend) {

    SendDrain();

  }

  return mDrainPromise.Ensure(__func__);

}

void

VideoDecoderChild::Shutdown()

{

  AssertOnManagerThread();

  mInitPromise.RejectIfExists(NS_ERROR_DOM_MEDIA_CANCELED, __func__);

  if (mCanSend) {

    SendShutdown();

  }

  mInitialized = false;

}

bool

VideoDecoderChild::IsHardwareAccelerated(nsACString& aFailureReason) const

{

  AssertOnManagerThread();

  aFailureReason = mHardwareAcceleratedReason;

  return mIsHardwareAccelerated;

}

nsCString

VideoDecoderChild::GetDescriptionName() const

{

  AssertOnManagerThread();

  return mDescription;

}

void

VideoDecoderChild::SetSeekThreshold(const media::TimeUnit& aTime)

{

  AssertOnManagerThread();

  if (mCanSend) {

    SendSetSeekThreshold(aTime.ToMicroseconds());

  }

}

MediaDataDecoder::ConversionRequired

VideoDecoderChild::NeedsConversion() const

{

  AssertOnManagerThread();

  return mConversion;

}

void

VideoDecoderChild::AssertOnManagerThread() const

{

  MOZ_ASSERT(NS_GetCurrentThread() == mThread);

}

VideoDecoderManagerChild*

VideoDecoderChild::GetManager()

{

  if (!mCanSend) {

    return nullptr;

  }

  return static_cast<VideoDecoderManagerChild*>(Manager());

}

} // namespace dom

} // namespace mozilla