1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
/* -*- 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_RemoteDecoderManagerChild_h
#define include_dom_media_ipc_RemoteDecoderManagerChild_h
#include "GPUVideoImage.h"
#include "ipc/EnumSerializer.h"
#include "mozilla/EnumTypeTraits.h"
#include "mozilla/PRemoteDecoderManagerChild.h"
#include "mozilla/layers/VideoBridgeUtils.h"
namespace mozilla {
class RemoteDecoderChild;
enum class RemoteDecodeIn {
Unspecified,
RddProcess,
GpuProcess,
SENTINEL,
};
class RemoteDecoderManagerChild final
: public PRemoteDecoderManagerChild,
public mozilla::ipc::IShmemAllocator,
public mozilla::layers::IGPUVideoSurfaceManager {
friend class PRemoteDecoderManagerChild;
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RemoteDecoderManagerChild, override)
// Can only be called from the manager thread
static RemoteDecoderManagerChild* GetSingleton(RemoteDecodeIn aLocation);
static void Init();
static void SetSupported(RemoteDecodeIn aLocation,
const PDMFactory::MediaCodecsSupported& aSupported);
// Can be called from any thread.
static bool Supports(RemoteDecodeIn aLocation,
const SupportDecoderParams& aParams,
DecoderDoctorDiagnostics* aDiagnostics);
static RefPtr<PlatformDecoderModule::CreateDecoderPromise> CreateAudioDecoder(
const CreateDecoderParams& aParams);
static RefPtr<PlatformDecoderModule::CreateDecoderPromise> CreateVideoDecoder(
const CreateDecoderParams& aParams, RemoteDecodeIn aLocation);
// Can be called from any thread.
static nsISerialEventTarget* GetManagerThread();
// Can be called from any thread, dispatches the request to the IPDL thread
// internally and will be ignored if the IPDL actor has been destroyed.
already_AddRefed<gfx::SourceSurface> Readback(
const SurfaceDescriptorGPUVideo& aSD) override;
void DeallocateSurfaceDescriptor(
const SurfaceDescriptorGPUVideo& aSD) override;
bool AllocShmem(size_t aSize,
mozilla::ipc::SharedMemory::SharedMemoryType aShmType,
mozilla::ipc::Shmem* aShmem) override {
return PRemoteDecoderManagerChild::AllocShmem(aSize, aShmType, aShmem);
}
bool AllocUnsafeShmem(size_t aSize,
mozilla::ipc::SharedMemory::SharedMemoryType aShmType,
mozilla::ipc::Shmem* aShmem) override {
return PRemoteDecoderManagerChild::AllocUnsafeShmem(aSize, aShmType,
aShmem);
}
// Can be called from any thread, dispatches the request to the IPDL thread
// internally and will be ignored if the IPDL actor has been destroyed.
bool DeallocShmem(mozilla::ipc::Shmem& aShmem) override;
// Main thread only
static void InitForGPUProcess(
Endpoint<PRemoteDecoderManagerChild>&& aVideoManager);
static void Shutdown();
// Run aTask (on the manager thread) when we next attempt to create a new
// manager (even if creation fails). Intended to be called from ActorDestroy
// when we get notified that the old manager is being destroyed. Can only be
// called from the manager thread.
void RunWhenGPUProcessRecreated(already_AddRefed<Runnable> aTask);
RemoteDecodeIn Location() const { return mLocation; }
layers::VideoBridgeSource GetSource() const;
protected:
void InitIPDL();
void ActorDealloc() override;
void HandleFatalError(const char* aMsg) const override;
PRemoteDecoderChild* AllocPRemoteDecoderChild(
const RemoteDecoderInfoIPDL& aRemoteDecoderInfo,
const CreateDecoderParams::OptionSet& aOptions,
const Maybe<layers::TextureFactoryIdentifier>& aIdentifier);
bool DeallocPRemoteDecoderChild(PRemoteDecoderChild* actor);
private:
explicit RemoteDecoderManagerChild(RemoteDecodeIn aLocation);
~RemoteDecoderManagerChild() = default;
static RefPtr<PlatformDecoderModule::CreateDecoderPromise> Construct(
RefPtr<RemoteDecoderChild>&& aChild);
static void OpenForRDDProcess(
Endpoint<PRemoteDecoderManagerChild>&& aEndpoint);
static void OpenForGPUProcess(
Endpoint<PRemoteDecoderManagerChild>&& aEndpoint);
static RefPtr<GenericNonExclusivePromise> LaunchRDDProcessIfNeeded();
RefPtr<RemoteDecoderManagerChild> mIPDLSelfRef;
// The location for decoding, Rdd or Gpu process.
const RemoteDecodeIn mLocation;
};
} // namespace mozilla
namespace IPC {
template <>
struct ParamTraits<mozilla::RemoteDecodeIn>
: public ContiguousEnumSerializer<mozilla::RemoteDecodeIn,
mozilla::RemoteDecodeIn::Unspecified,
mozilla::RemoteDecodeIn::SENTINEL> {};
} // namespace IPC
#endif // include_dom_media_ipc_RemoteDecoderManagerChild_h
|
