gecko-dev/dom/media/ipc/RemoteVideoDecoder.cpp

/* -*- 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 "RemoteVideoDecoder.h"
#include "VideoDecoderChild.h"
#include "VideoDecoderManagerChild.h"
#include "mozilla/layers/TextureClient.h"
#include "mozilla/StaticPrefs.h"
#include "base/thread.h"
#include "MediaInfo.h"
#include "ImageContainer.h"
#include "mozilla/layers/SynchronousTask.h"

namespace mozilla {
namespace dom {

using base::Thread;
using namespace ipc;
using namespace layers;
using namespace gfx;

RemoteVideoDecoder::RemoteVideoDecoder()
  : mActor(new VideoDecoderChild())
  , mDescription("RemoteVideoDecoder")
  , mIsHardwareAccelerated(false)
  , mConversion(MediaDataDecoder::ConversionRequired::kNeedNone)
{
}

RemoteVideoDecoder::~RemoteVideoDecoder()
{
  // We're about to be destroyed and drop our ref to
  // VideoDecoderChild. Make sure we put a ref into the
  // task queue for the VideoDecoderChild thread to keep
  // it alive until we send the delete message.
  RefPtr<VideoDecoderChild> actor = mActor;

  RefPtr<Runnable> task = NS_NewRunnableFunction(
    "dom::RemoteVideoDecoder::~RemoteVideoDecoder", [actor]() {
      MOZ_ASSERT(actor);
      actor->DestroyIPDL();
    });

  // Drop out references to the actor so that the last ref
  // always gets released on the manager thread.
  actor = nullptr;
  mActor = nullptr;

  VideoDecoderManagerChild::GetManagerThread()->Dispatch(task.forget(),
                                                         NS_DISPATCH_NORMAL);
}

RefPtr<MediaDataDecoder::InitPromise>
RemoteVideoDecoder::Init()
{
  RefPtr<RemoteVideoDecoder> self = this;
  return InvokeAsync(VideoDecoderManagerChild::GetManagerAbstractThread(),
                     __func__,
                     [self]() { return self->mActor->Init(); })
    ->Then(VideoDecoderManagerChild::GetManagerAbstractThread(),
           __func__,
           [self, this](TrackType aTrack) {
             mDescription =
               mActor->GetDescriptionName() + NS_LITERAL_CSTRING(" (remote)");
             mIsHardwareAccelerated =
               mActor->IsHardwareAccelerated(mHardwareAcceleratedReason);
             mConversion = mActor->NeedsConversion();
             return InitPromise::CreateAndResolve(aTrack, __func__);
           },
           [self](const MediaResult& aError) {
             return InitPromise::CreateAndReject(aError, __func__);
           });
}

RefPtr<MediaDataDecoder::DecodePromise>
RemoteVideoDecoder::Decode(MediaRawData* aSample)
{
  RefPtr<RemoteVideoDecoder> self = this;
  RefPtr<MediaRawData> sample = aSample;
  return InvokeAsync(VideoDecoderManagerChild::GetManagerAbstractThread(),
                     __func__,
                     [self, sample]() { return self->mActor->Decode(sample); });
}

RefPtr<MediaDataDecoder::FlushPromise>
RemoteVideoDecoder::Flush()
{
  RefPtr<RemoteVideoDecoder> self = this;
  return InvokeAsync(VideoDecoderManagerChild::GetManagerAbstractThread(),
                     __func__, [self]() { return self->mActor->Flush(); });
}

RefPtr<MediaDataDecoder::DecodePromise>
RemoteVideoDecoder::Drain()
{
  RefPtr<RemoteVideoDecoder> self = this;
  return InvokeAsync(VideoDecoderManagerChild::GetManagerAbstractThread(),
                     __func__, [self]() { return self->mActor->Drain(); });
}

RefPtr<ShutdownPromise>
RemoteVideoDecoder::Shutdown()
{
  RefPtr<RemoteVideoDecoder> self = this;
  return InvokeAsync(VideoDecoderManagerChild::GetManagerAbstractThread(),
                     __func__, [self]() {
                       self->mActor->Shutdown();
                       return ShutdownPromise::CreateAndResolve(true, __func__);
                     });
}

bool
RemoteVideoDecoder::IsHardwareAccelerated(nsACString& aFailureReason) const
{
  aFailureReason = mHardwareAcceleratedReason;
  return mIsHardwareAccelerated;
}

void
RemoteVideoDecoder::SetSeekThreshold(const media::TimeUnit& aTime)
{
  RefPtr<RemoteVideoDecoder> self = this;
  media::TimeUnit time = aTime;
  VideoDecoderManagerChild::GetManagerThread()->Dispatch(
    NS_NewRunnableFunction("dom::RemoteVideoDecoder::SetSeekThreshold",
                           [=]() {
                             MOZ_ASSERT(self->mActor);
                             self->mActor->SetSeekThreshold(time);
                           }),
    NS_DISPATCH_NORMAL);
}

MediaDataDecoder::ConversionRequired
RemoteVideoDecoder::NeedsConversion() const
{
  return mConversion;
}

nsresult
RemoteDecoderModule::Startup()
{
  if (!VideoDecoderManagerChild::GetManagerThread()) {
    return NS_ERROR_FAILURE;
  }
  return mWrapped->Startup();
}

bool
RemoteDecoderModule::SupportsMimeType(const nsACString& aMimeType,
                                      DecoderDoctorDiagnostics* aDiagnostics) const
{
  return mWrapped->SupportsMimeType(aMimeType, aDiagnostics);
}

bool
RemoteDecoderModule::Supports(const TrackInfo& aTrackInfo,
                              DecoderDoctorDiagnostics* aDiagnostics) const
{
  return mWrapped->Supports(aTrackInfo, aDiagnostics);
}

static inline bool
IsRemoteAcceleratedCompositor(KnowsCompositor* aKnows)
{
  TextureFactoryIdentifier ident = aKnows->GetTextureFactoryIdentifier();
  return ident.mParentBackend != LayersBackend::LAYERS_BASIC &&
         ident.mParentProcessType == GeckoProcessType_GPU;
}

already_AddRefed<MediaDataDecoder>
RemoteDecoderModule::CreateVideoDecoder(const CreateDecoderParams& aParams)
{
  if (!StaticPrefs::MediaGpuProcessDecoder() ||
      !aParams.mKnowsCompositor ||
      !IsRemoteAcceleratedCompositor(aParams.mKnowsCompositor))
  {
    return mWrapped->CreateVideoDecoder(aParams);
  }

  RefPtr<RemoteVideoDecoder> object = new RemoteVideoDecoder();

  SynchronousTask task("InitIPDL");
  MediaResult result(NS_OK);
  VideoDecoderManagerChild::GetManagerThread()->Dispatch(
    NS_NewRunnableFunction(
      "dom::RemoteDecoderModule::CreateVideoDecoder",
      [&]() {
        AutoCompleteTask complete(&task);
        result = object->mActor->InitIPDL(
          aParams.VideoConfig(),
          aParams.mRate.mValue,
          aParams.mKnowsCompositor->GetTextureFactoryIdentifier());
      }),
    NS_DISPATCH_NORMAL);
  task.Wait();

  if (NS_FAILED(result)) {
    if (aParams.mError) {
      *aParams.mError = result;
    }
    return nullptr;
  }

  return object.forget();
}

nsCString
RemoteVideoDecoder::GetDescriptionName() const
{
  return mDescription;
}

} // namespace dom
} // namespace mozilla