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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 ts=8 et ft=cpp : */
/* 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 mozilla_CamerasParent_h
#define mozilla_CamerasParent_h
#include "VideoEngine.h"
#include "mozilla/camera/PCamerasParent.h"
#include "mozilla/ipc/Shmem.h"
#include "mozilla/ShmemPool.h"
#include "mozilla/Atomics.h"
#include "api/video/video_sink_interface.h"
#include "common_video/include/incoming_video_stream.h"
#include "modules/video_capture/video_capture.h"
#include "modules/video_capture/video_capture_defines.h"
#include "CamerasChild.h"
#include "base/thread.h"
namespace mozilla::camera {
class CamerasParent;
class CallbackHelper : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
public:
CallbackHelper(CaptureEngine aCapEng, uint32_t aStreamId,
CamerasParent* aParent)
: mCapEngine(aCapEng),
mStreamId(aStreamId),
mTrackingId(CaptureEngineToTrackingSourceStr(aCapEng), aStreamId),
mParent(aParent){};
// These callbacks end up running on the VideoCapture thread.
// From VideoCaptureCallback
void OnFrame(const webrtc::VideoFrame& videoFrame) override;
friend CamerasParent;
private:
const CaptureEngine mCapEngine;
const uint32_t mStreamId;
const TrackingId mTrackingId;
CamerasParent* const mParent;
};
class InputObserver : public webrtc::VideoInputFeedBack {
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(InputObserver)
explicit InputObserver(CamerasParent* aParent) : mParent(aParent){};
virtual void OnDeviceChange() override;
friend CamerasParent;
private:
~InputObserver() = default;
const RefPtr<CamerasParent> mParent;
};
class DeliverFrameRunnable;
class CamerasParent final : public PCamerasParent,
public nsIAsyncShutdownBlocker {
NS_DECL_THREADSAFE_ISUPPORTS
public:
friend DeliverFrameRunnable;
static already_AddRefed<CamerasParent> Create();
// Messages received from the child. These run on the IPC/PBackground thread.
mozilla::ipc::IPCResult RecvPCamerasConstructor();
mozilla::ipc::IPCResult RecvAllocateCapture(
const CaptureEngine& aEngine, const nsACString& aUnique_idUTF8,
const uint64_t& aWindowID) override;
mozilla::ipc::IPCResult RecvReleaseCapture(const CaptureEngine&,
const int&) override;
mozilla::ipc::IPCResult RecvNumberOfCaptureDevices(
const CaptureEngine&) override;
mozilla::ipc::IPCResult RecvNumberOfCapabilities(const CaptureEngine&,
const nsACString&) override;
mozilla::ipc::IPCResult RecvGetCaptureCapability(const CaptureEngine&,
const nsACString&,
const int&) override;
mozilla::ipc::IPCResult RecvGetCaptureDevice(const CaptureEngine&,
const int&) override;
mozilla::ipc::IPCResult RecvStartCapture(
const CaptureEngine&, const int&, const VideoCaptureCapability&) override;
mozilla::ipc::IPCResult RecvFocusOnSelectedSource(const CaptureEngine&,
const int&) override;
mozilla::ipc::IPCResult RecvStopCapture(const CaptureEngine&,
const int&) override;
mozilla::ipc::IPCResult RecvReleaseFrame(mozilla::ipc::Shmem&&) override;
void ActorDestroy(ActorDestroyReason aWhy) override;
mozilla::ipc::IPCResult RecvEnsureInitialized(const CaptureEngine&) override;
nsIEventTarget* GetBackgroundEventTarget() {
return mPBackgroundEventTarget;
};
bool IsShuttingDown() {
// the first 2 are pBackground only, the last is atomic
MOZ_ASSERT(GetCurrentSerialEventTarget() == mPBackgroundEventTarget);
return !mChildIsAlive || mDestroyed || !mWebRTCAlive;
};
ShmemBuffer GetBuffer(size_t aSize);
// helper to forward to the PBackground thread
int DeliverFrameOverIPC(CaptureEngine capEng, uint32_t aStreamId,
const TrackingId& aTrackingId, ShmemBuffer buffer,
unsigned char* altbuffer,
const VideoFrameProperties& aProps);
CamerasParent();
protected:
virtual ~CamerasParent();
// We use these helpers for shutdown and for the respective IPC commands.
void StopCapture(const CaptureEngine& aCapEngine, int aCaptureId);
int ReleaseCapture(const CaptureEngine& aCapEngine, int aCaptureId);
bool SetupEngine(CaptureEngine aCapEngine);
VideoEngine* EnsureInitialized(int aEngine);
void CloseEngines();
void StopIPC();
void StopVideoCapture();
nsresult DispatchToVideoCaptureThread(RefPtr<Runnable> event);
NS_IMETHOD BlockShutdown(nsIAsyncShutdownClient*) override;
NS_IMETHOD GetName(nsAString& aName) override {
aName = mName;
return NS_OK;
}
NS_IMETHOD GetState(nsIPropertyBag**) override { return NS_OK; }
static nsString GetNewName();
// sEngines will be accessed by VideoCapture thread only
// sNumOfCamerasParents, sNumOfOpenCamerasParentEngines, and
// sVideoCaptureThread will be accessed by main thread / PBackground thread /
// VideoCapture thread
// sNumOfCamerasParents and sThreadMonitor create & delete are protected by
// sMutex
// sNumOfOpenCamerasParentEngines and sVideoCaptureThread are protected by
// sThreadMonitor
static StaticRefPtr<VideoEngine> sEngines[CaptureEngine::MaxEngine];
// Number of CamerasParents for which mWebRTCAlive is true.
static int32_t sNumOfOpenCamerasParentEngines;
static int32_t sNumOfCamerasParents;
static StaticMutex sMutex;
static Monitor* sThreadMonitor;
// video processing thread - where webrtc.org capturer code runs
static base::Thread* sVideoCaptureThread;
nsTArray<CallbackHelper*> mCallbacks;
nsString mName;
// image buffers
ShmemPool mShmemPool;
// PBackgroundParent thread
const nsCOMPtr<nsISerialEventTarget> mPBackgroundEventTarget;
// Shutdown handling
bool mChildIsAlive;
bool mDestroyed;
// Above 2 are PBackground only, but this is potentially
// read cross-thread.
Atomic<bool> mWebRTCAlive;
RefPtr<InputObserver> mCameraObserver;
std::map<nsCString, std::map<uint32_t, webrtc::VideoCaptureCapability>>
mAllCandidateCapabilities;
};
PCamerasParent* CreateCamerasParent();
} // namespace mozilla::camera
#endif // mozilla_CameraParent_h
|
