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
|
// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/modules/mediastream/local_video_capturer_source.h"
#include <utility>
#include "base/functional/callback_helpers.h"
#include "base/task/bind_post_task.h"
#include "base/task/single_thread_task_runner.h"
#include "base/token.h"
#include "media/capture/mojom/video_capture_types.mojom-blink.h"
#include "media/capture/video_capture_types.h"
#include "third_party/blink/public/platform/modules/video_capture/web_video_capture_impl_manager.h"
#include "third_party/blink/public/platform/platform.h"
#include "third_party/blink/public/platform/web_string.h"
#include "third_party/blink/public/web/modules/mediastream/media_stream_video_source.h"
#include "third_party/blink/renderer/core/frame/local_frame.h"
#include "third_party/blink/renderer/platform/wtf/cross_thread_copier_base.h"
#include "third_party/blink/renderer/platform/wtf/cross_thread_functional.h"
namespace blink {
LocalVideoCapturerSource::LocalVideoCapturerSource(
scoped_refptr<base::SingleThreadTaskRunner> task_runner,
LocalFrame* frame,
const base::UnguessableToken& session_id)
: session_id_(session_id),
manager_(Platform::Current()->GetVideoCaptureImplManager()),
frame_token_(frame->GetLocalFrameToken()),
release_device_cb_(
manager_->UseDevice(session_id_, frame->GetBrowserInterfaceBroker())),
task_runner_(std::move(task_runner)) {}
LocalVideoCapturerSource::~LocalVideoCapturerSource() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
std::move(release_device_cb_).Run();
}
media::VideoCaptureFormats LocalVideoCapturerSource::GetPreferredFormats() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
return media::VideoCaptureFormats();
}
void LocalVideoCapturerSource::StartCapture(
const media::VideoCaptureParams& params,
VideoCaptureCallbacks video_capture_callbacks,
VideoCaptureRunningCallbackCB running_callback) {
DCHECK(params.requested_format.IsValid());
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
running_callback_ = std::move(running_callback);
// Combine all callbacks into MediaStreamVideoSourceCallbacks structure
VideoCaptureCallbacks new_video_capture_callbacks;
new_video_capture_callbacks.state_update_cb = base::BindPostTask(
task_runner_, ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
&LocalVideoCapturerSource::OnStateUpdate,
weak_factory_.GetWeakPtr())));
new_video_capture_callbacks.deliver_frame_cb =
std::move(video_capture_callbacks.deliver_frame_cb);
new_video_capture_callbacks.sub_capture_target_version_cb =
std::move(video_capture_callbacks.sub_capture_target_version_cb);
new_video_capture_callbacks.frame_dropped_cb =
std::move(video_capture_callbacks.frame_dropped_cb);
stop_capture_cb_ = manager_->StartCapture(
session_id_, params, std::move(new_video_capture_callbacks));
}
media::VideoCaptureFeedbackCB LocalVideoCapturerSource::GetFeedbackCallback()
const {
return manager_->GetFeedbackCallback(session_id_);
}
void LocalVideoCapturerSource::RequestRefreshFrame() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
if (!stop_capture_cb_)
return; // Do not request frames if the source is stopped.
manager_->RequestRefreshFrame(session_id_);
}
void LocalVideoCapturerSource::MaybeSuspend() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
manager_->Suspend(session_id_);
}
void LocalVideoCapturerSource::Resume() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
manager_->Resume(session_id_);
}
void LocalVideoCapturerSource::StopCapture() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
// Immediately make sure we don't provide more frames.
if (stop_capture_cb_)
std::move(stop_capture_cb_).Run();
}
void LocalVideoCapturerSource::OnLog(const std::string& message) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
manager_->OnLog(session_id_, WebString::FromUTF8(message));
}
void LocalVideoCapturerSource::OnStateUpdate(blink::VideoCaptureState state) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
if (running_callback_.is_null()) {
OnLog("LocalVideoCapturerSource::OnStateUpdate discarding state update.");
return;
}
VideoCaptureRunState run_state;
switch (state) {
case VIDEO_CAPTURE_STATE_ERROR_SYSTEM_PERMISSIONS_DENIED:
run_state = VideoCaptureRunState::kSystemPermissionsError;
break;
case VIDEO_CAPTURE_STATE_ERROR_CAMERA_BUSY:
run_state = VideoCaptureRunState::kCameraBusyError;
break;
case VIDEO_CAPTURE_STATE_ERROR_START_TIMEOUT:
run_state = VideoCaptureRunState::kStartTimeoutError;
break;
default:
run_state = VideoCaptureRunState::kStopped;
}
auto* frame = LocalFrame::FromFrameToken(frame_token_);
switch (state) {
case VIDEO_CAPTURE_STATE_STARTED:
OnLog(
"LocalVideoCapturerSource::OnStateUpdate signaling to "
"consumer that source is now running.");
running_callback_.Run(VideoCaptureRunState::kRunning);
break;
case VIDEO_CAPTURE_STATE_STOPPING:
case VIDEO_CAPTURE_STATE_STOPPED:
case VIDEO_CAPTURE_STATE_ERROR:
case VIDEO_CAPTURE_STATE_ERROR_SYSTEM_PERMISSIONS_DENIED:
case VIDEO_CAPTURE_STATE_ERROR_CAMERA_BUSY:
case VIDEO_CAPTURE_STATE_ENDED:
case VIDEO_CAPTURE_STATE_ERROR_START_TIMEOUT:
std::move(release_device_cb_).Run();
release_device_cb_ =
frame && frame->Client()
? manager_->UseDevice(session_id_,
frame->GetBrowserInterfaceBroker())
: base::DoNothing();
OnLog(
"LocalVideoCapturerSource::OnStateUpdate signaling to "
"consumer that source is no longer running.");
running_callback_.Run(run_state);
break;
case VIDEO_CAPTURE_STATE_STARTING:
case VIDEO_CAPTURE_STATE_PAUSED:
case VIDEO_CAPTURE_STATE_RESUMED:
// Not applicable to reporting on device starts or errors.
break;
}
}
// static
std::unique_ptr<VideoCapturerSource> LocalVideoCapturerSource::Create(
scoped_refptr<base::SingleThreadTaskRunner> task_runner,
LocalFrame* frame,
const base::UnguessableToken& session_id) {
return std::make_unique<LocalVideoCapturerSource>(std::move(task_runner),
frame, session_id);
}
} // namespace blink
|
