1 /*
2 * Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "modules/desktop_capture/fallback_desktop_capturer_wrapper.h"
12
13 #include <stddef.h>
14
15 #include <utility>
16
17 #include "rtc_base/checks.h"
18 #include "rtc_base/thread_checker.h"
19 #include "system_wrappers/include/metrics.h"
20
21 namespace webrtc {
22
23 namespace {
24
25 // Implementation to share a SharedMemoryFactory between DesktopCapturer
26 // instances. This class is designed for synchronized DesktopCapturer
27 // implementations only.
28 class SharedMemoryFactoryProxy : public SharedMemoryFactory {
29 public:
30 // Users should maintain the lifetime of |factory| to ensure it overlives
31 // current instance.
32 static std::unique_ptr<SharedMemoryFactory> Create(
33 SharedMemoryFactory* factory);
34 ~SharedMemoryFactoryProxy() override;
35
36 // Forwards CreateSharedMemory() calls to |factory_|. Users should always call
37 // this function in one thread. Users should not call this function after the
38 // SharedMemoryFactory which current instance created from has been destroyed.
39 std::unique_ptr<SharedMemory> CreateSharedMemory(size_t size) override;
40
41 private:
42 explicit SharedMemoryFactoryProxy(SharedMemoryFactory* factory);
43
44 SharedMemoryFactory* factory_ = nullptr;
45 rtc::ThreadChecker thread_checker_;
46 };
47
48 } // namespace
49
SharedMemoryFactoryProxy(SharedMemoryFactory * factory)50 SharedMemoryFactoryProxy::SharedMemoryFactoryProxy(
51 SharedMemoryFactory* factory) {
52 RTC_DCHECK(factory);
53 factory_ = factory;
54 }
55
56 // static
Create(SharedMemoryFactory * factory)57 std::unique_ptr<SharedMemoryFactory> SharedMemoryFactoryProxy::Create(
58 SharedMemoryFactory* factory) {
59 return std::unique_ptr<SharedMemoryFactory>(
60 new SharedMemoryFactoryProxy(factory));
61 }
62
63 SharedMemoryFactoryProxy::~SharedMemoryFactoryProxy() = default;
64
CreateSharedMemory(size_t size)65 std::unique_ptr<SharedMemory> SharedMemoryFactoryProxy::CreateSharedMemory(
66 size_t size) {
67 RTC_DCHECK(thread_checker_.IsCurrent());
68 return factory_->CreateSharedMemory(size);
69 }
70
FallbackDesktopCapturerWrapper(std::unique_ptr<DesktopCapturer> main_capturer,std::unique_ptr<DesktopCapturer> secondary_capturer)71 FallbackDesktopCapturerWrapper::FallbackDesktopCapturerWrapper(
72 std::unique_ptr<DesktopCapturer> main_capturer,
73 std::unique_ptr<DesktopCapturer> secondary_capturer)
74 : main_capturer_(std::move(main_capturer)),
75 secondary_capturer_(std::move(secondary_capturer)) {
76 RTC_DCHECK(main_capturer_);
77 RTC_DCHECK(secondary_capturer_);
78 }
79
80 FallbackDesktopCapturerWrapper::~FallbackDesktopCapturerWrapper() = default;
81
Start(DesktopCapturer::Callback * callback)82 void FallbackDesktopCapturerWrapper::Start(
83 DesktopCapturer::Callback* callback) {
84 callback_ = callback;
85 // FallbackDesktopCapturerWrapper catchs the callback of the main capturer,
86 // and checks its return value to decide whether the secondary capturer should
87 // be involved.
88 main_capturer_->Start(this);
89 // For the secondary capturer, we do not have a backup plan anymore, so
90 // FallbackDesktopCapturerWrapper won't check its return value any more. It
91 // will directly return to the input |callback|.
92 secondary_capturer_->Start(callback);
93 }
94
SetSharedMemoryFactory(std::unique_ptr<SharedMemoryFactory> shared_memory_factory)95 void FallbackDesktopCapturerWrapper::SetSharedMemoryFactory(
96 std::unique_ptr<SharedMemoryFactory> shared_memory_factory) {
97 shared_memory_factory_ = std::move(shared_memory_factory);
98 if (shared_memory_factory_) {
99 main_capturer_->SetSharedMemoryFactory(
100 SharedMemoryFactoryProxy::Create(shared_memory_factory_.get()));
101 secondary_capturer_->SetSharedMemoryFactory(
102 SharedMemoryFactoryProxy::Create(shared_memory_factory_.get()));
103 } else {
104 main_capturer_->SetSharedMemoryFactory(
105 std::unique_ptr<SharedMemoryFactory>());
106 secondary_capturer_->SetSharedMemoryFactory(
107 std::unique_ptr<SharedMemoryFactory>());
108 }
109 }
110
CaptureFrame()111 void FallbackDesktopCapturerWrapper::CaptureFrame() {
112 RTC_DCHECK(callback_);
113 if (main_capturer_permanent_error_) {
114 secondary_capturer_->CaptureFrame();
115 } else {
116 main_capturer_->CaptureFrame();
117 }
118 }
119
SetExcludedWindow(WindowId window)120 void FallbackDesktopCapturerWrapper::SetExcludedWindow(WindowId window) {
121 main_capturer_->SetExcludedWindow(window);
122 secondary_capturer_->SetExcludedWindow(window);
123 }
124
GetSourceList(SourceList * sources)125 bool FallbackDesktopCapturerWrapper::GetSourceList(SourceList* sources) {
126 if (main_capturer_permanent_error_) {
127 return secondary_capturer_->GetSourceList(sources);
128 }
129 return main_capturer_->GetSourceList(sources);
130 }
131
SelectSource(SourceId id)132 bool FallbackDesktopCapturerWrapper::SelectSource(SourceId id) {
133 if (main_capturer_permanent_error_) {
134 return secondary_capturer_->SelectSource(id);
135 }
136 const bool main_capturer_result = main_capturer_->SelectSource(id);
137 RTC_HISTOGRAM_BOOLEAN(
138 "WebRTC.DesktopCapture.PrimaryCapturerSelectSourceError",
139 main_capturer_result);
140 if (!main_capturer_result) {
141 main_capturer_permanent_error_ = true;
142 }
143
144 return secondary_capturer_->SelectSource(id);
145 }
146
FocusOnSelectedSource()147 bool FallbackDesktopCapturerWrapper::FocusOnSelectedSource() {
148 if (main_capturer_permanent_error_) {
149 return secondary_capturer_->FocusOnSelectedSource();
150 }
151 return main_capturer_->FocusOnSelectedSource() ||
152 secondary_capturer_->FocusOnSelectedSource();
153 }
154
IsOccluded(const DesktopVector & pos)155 bool FallbackDesktopCapturerWrapper::IsOccluded(const DesktopVector& pos) {
156 // Returns true if either capturer returns true.
157 if (main_capturer_permanent_error_) {
158 return secondary_capturer_->IsOccluded(pos);
159 }
160 return main_capturer_->IsOccluded(pos) ||
161 secondary_capturer_->IsOccluded(pos);
162 }
163
OnCaptureResult(Result result,std::unique_ptr<DesktopFrame> frame)164 void FallbackDesktopCapturerWrapper::OnCaptureResult(
165 Result result,
166 std::unique_ptr<DesktopFrame> frame) {
167 RTC_DCHECK(callback_);
168 RTC_HISTOGRAM_BOOLEAN("WebRTC.DesktopCapture.PrimaryCapturerError",
169 result != Result::SUCCESS);
170 RTC_HISTOGRAM_BOOLEAN("WebRTC.DesktopCapture.PrimaryCapturerPermanentError",
171 result == Result::ERROR_PERMANENT);
172 if (result == Result::SUCCESS) {
173 callback_->OnCaptureResult(result, std::move(frame));
174 return;
175 }
176
177 if (result == Result::ERROR_PERMANENT) {
178 main_capturer_permanent_error_ = true;
179 }
180 secondary_capturer_->CaptureFrame();
181 }
182
183 } // namespace webrtc
184