зеркало из https://github.com/mozilla/gecko-dev.git
193 строки
5.5 KiB
C++
193 строки
5.5 KiB
C++
/* -*- 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 "base/thread.h"
|
|
#include "MediaInfo.h"
|
|
#include "MediaPrefs.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(MediaDataDecoderCallback* aCallback)
|
|
: mActor(new VideoDecoderChild())
|
|
{
|
|
#ifdef DEBUG
|
|
mCallback = aCallback;
|
|
#endif
|
|
MOZ_ASSERT(mCallback->OnReaderTaskQueue());
|
|
}
|
|
|
|
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([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()
|
|
{
|
|
MOZ_ASSERT(mCallback->OnReaderTaskQueue());
|
|
return InvokeAsync(VideoDecoderManagerChild::GetManagerAbstractThread(),
|
|
this, __func__, &RemoteVideoDecoder::InitInternal);
|
|
}
|
|
|
|
RefPtr<MediaDataDecoder::InitPromise>
|
|
RemoteVideoDecoder::InitInternal()
|
|
{
|
|
MOZ_ASSERT(mActor);
|
|
MOZ_ASSERT(NS_GetCurrentThread() == VideoDecoderManagerChild::GetManagerThread());
|
|
return mActor->Init();
|
|
}
|
|
|
|
void
|
|
RemoteVideoDecoder::Input(MediaRawData* aSample)
|
|
{
|
|
MOZ_ASSERT(mCallback->OnReaderTaskQueue());
|
|
RefPtr<RemoteVideoDecoder> self = this;
|
|
RefPtr<MediaRawData> sample = aSample;
|
|
VideoDecoderManagerChild::GetManagerThread()->Dispatch(NS_NewRunnableFunction([self, sample]() {
|
|
MOZ_ASSERT(self->mActor);
|
|
self->mActor->Input(sample);
|
|
}), NS_DISPATCH_NORMAL);
|
|
}
|
|
|
|
void
|
|
RemoteVideoDecoder::Flush()
|
|
{
|
|
MOZ_ASSERT(mCallback->OnReaderTaskQueue());
|
|
SynchronousTask task("Decoder flush");
|
|
VideoDecoderManagerChild::GetManagerThread()->Dispatch(NS_NewRunnableFunction([&]() {
|
|
MOZ_ASSERT(this->mActor);
|
|
this->mActor->Flush(&task);
|
|
}), NS_DISPATCH_NORMAL);
|
|
task.Wait();
|
|
}
|
|
|
|
void
|
|
RemoteVideoDecoder::Drain()
|
|
{
|
|
MOZ_ASSERT(mCallback->OnReaderTaskQueue());
|
|
RefPtr<RemoteVideoDecoder> self = this;
|
|
VideoDecoderManagerChild::GetManagerThread()->Dispatch(NS_NewRunnableFunction([self]() {
|
|
MOZ_ASSERT(self->mActor);
|
|
self->mActor->Drain();
|
|
}), NS_DISPATCH_NORMAL);
|
|
}
|
|
|
|
void
|
|
RemoteVideoDecoder::Shutdown()
|
|
{
|
|
MOZ_ASSERT(mCallback->OnReaderTaskQueue());
|
|
SynchronousTask task("Shutdown");
|
|
RefPtr<RemoteVideoDecoder> self = this;
|
|
VideoDecoderManagerChild::GetManagerThread()->Dispatch(NS_NewRunnableFunction([&]() {
|
|
AutoCompleteTask complete(&task);
|
|
MOZ_ASSERT(self->mActor);
|
|
self->mActor->Shutdown();
|
|
}), NS_DISPATCH_NORMAL);
|
|
task.Wait();
|
|
}
|
|
|
|
bool
|
|
RemoteVideoDecoder::IsHardwareAccelerated(nsACString& aFailureReason) const
|
|
{
|
|
MOZ_ASSERT(mCallback->OnReaderTaskQueue());
|
|
return mActor->IsHardwareAccelerated(aFailureReason);
|
|
}
|
|
|
|
void
|
|
RemoteVideoDecoder::SetSeekThreshold(const media::TimeUnit& aTime)
|
|
{
|
|
MOZ_ASSERT(mCallback->OnReaderTaskQueue());
|
|
RefPtr<RemoteVideoDecoder> self = this;
|
|
media::TimeUnit time = aTime;
|
|
VideoDecoderManagerChild::GetManagerThread()->Dispatch(NS_NewRunnableFunction([=]() {
|
|
MOZ_ASSERT(self->mActor);
|
|
self->mActor->SetSeekThreshold(time);
|
|
}), NS_DISPATCH_NORMAL);
|
|
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
PlatformDecoderModule::ConversionRequired
|
|
RemoteDecoderModule::DecoderNeedsConversion(const TrackInfo& aConfig) const
|
|
{
|
|
return mWrapped->DecoderNeedsConversion(aConfig);
|
|
}
|
|
|
|
already_AddRefed<MediaDataDecoder>
|
|
RemoteDecoderModule::CreateVideoDecoder(const CreateDecoderParams& aParams)
|
|
{
|
|
if (!MediaPrefs::PDMUseGPUDecoder() ||
|
|
!aParams.mKnowsCompositor ||
|
|
aParams.mKnowsCompositor->GetTextureFactoryIdentifier().mParentProcessType != GeckoProcessType_GPU) {
|
|
return nullptr;
|
|
}
|
|
|
|
MediaDataDecoderCallback* callback = aParams.mCallback;
|
|
MOZ_ASSERT(callback->OnReaderTaskQueue());
|
|
RefPtr<RemoteVideoDecoder> object = new RemoteVideoDecoder(callback);
|
|
|
|
SynchronousTask task("InitIPDL");
|
|
bool success;
|
|
VideoDecoderManagerChild::GetManagerThread()->Dispatch(NS_NewRunnableFunction([&]() {
|
|
AutoCompleteTask complete(&task);
|
|
success = object->mActor->InitIPDL(callback,
|
|
aParams.VideoConfig(),
|
|
aParams.mKnowsCompositor->GetTextureFactoryIdentifier());
|
|
}), NS_DISPATCH_NORMAL);
|
|
task.Wait();
|
|
|
|
if (!success) {
|
|
return nullptr;
|
|
}
|
|
|
|
return object.forget();
|
|
}
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|