OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2017 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "content/renderer/media/webrtc/webrtc_media_stream_track_adapter.h" | |
6 | |
7 #include "content/renderer/media/media_stream_audio_track.h" | |
8 #include "content/renderer/media/webrtc/media_stream_video_webrtc_sink.h" | |
9 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h" | |
10 #include "content/renderer/media/webrtc/processed_local_audio_source.h" | |
11 | |
12 namespace content { | |
13 | |
14 scoped_refptr<WebRtcMediaStreamTrackAdapter> | |
Guido Urdaneta
2017/05/22 14:26:38
static methods usually have a "// static" comment,
hbos_chromium
2017/05/29 11:24:17
Done.
| |
15 WebRtcMediaStreamTrackAdapter::CreateLocalTrackAdapter( | |
16 PeerConnectionDependencyFactory* factory, | |
17 const scoped_refptr<base::SingleThreadTaskRunner>& main_thread, | |
18 const blink::WebMediaStreamTrack& web_track) { | |
19 DCHECK(main_thread->BelongsToCurrentThread()); | |
20 DCHECK(!web_track.Source().Remote()); | |
21 scoped_refptr<WebRtcMediaStreamTrackAdapter> local_track_adapter( | |
22 new WebRtcMediaStreamTrackAdapter(factory, main_thread)); | |
23 if (web_track.Source().GetType() == blink::WebMediaStreamSource::kTypeAudio) { | |
24 local_track_adapter->InitializeLocalAudioTrack(web_track); | |
25 } else { | |
26 DCHECK_EQ(web_track.Source().GetType(), | |
27 blink::WebMediaStreamSource::kTypeVideo); | |
28 local_track_adapter->InitializeLocalVideoTrack(web_track); | |
29 } | |
30 return local_track_adapter; | |
31 } | |
32 | |
33 scoped_refptr<WebRtcMediaStreamTrackAdapter> | |
34 WebRtcMediaStreamTrackAdapter::CreateRemoteTrackAdapter( | |
35 PeerConnectionDependencyFactory* factory, | |
36 const scoped_refptr<base::SingleThreadTaskRunner>& main_thread, | |
37 webrtc::MediaStreamTrackInterface* webrtc_track) { | |
38 DCHECK(factory->GetWebRtcSignalingThread()->BelongsToCurrentThread()); | |
39 DCHECK(webrtc_track); | |
40 scoped_refptr<WebRtcMediaStreamTrackAdapter> remote_track_adapter( | |
41 new WebRtcMediaStreamTrackAdapter(factory, main_thread)); | |
42 if (webrtc_track->kind() == webrtc::MediaStreamTrackInterface::kAudioKind) { | |
43 remote_track_adapter->InitializeRemoteAudioTrack( | |
44 static_cast<webrtc::AudioTrackInterface*>(webrtc_track)); | |
45 } else { | |
46 DCHECK_EQ(webrtc_track->kind(), | |
47 webrtc::MediaStreamTrackInterface::kVideoKind); | |
48 remote_track_adapter->InitializeRemoteVideoTrack( | |
49 static_cast<webrtc::VideoTrackInterface*>(webrtc_track)); | |
50 } | |
51 return remote_track_adapter; | |
52 } | |
53 | |
54 WebRtcMediaStreamTrackAdapter::WebRtcMediaStreamTrackAdapter( | |
55 PeerConnectionDependencyFactory* factory, | |
56 const scoped_refptr<base::SingleThreadTaskRunner>& main_thread) | |
57 : factory_(factory), main_thread_(main_thread), is_initialized_(false) { | |
58 DCHECK(factory_); | |
59 DCHECK(main_thread_); | |
60 } | |
61 | |
62 WebRtcMediaStreamTrackAdapter::~WebRtcMediaStreamTrackAdapter() { | |
63 DCHECK(main_thread_->BelongsToCurrentThread()); | |
64 DCHECK(!is_initialized_); | |
65 } | |
66 | |
67 void WebRtcMediaStreamTrackAdapter::Uninitialize() { | |
68 DCHECK(main_thread_->BelongsToCurrentThread()); | |
69 DCHECK(is_initialized_); | |
70 if (!web_track_.Source().Remote()) { | |
71 if (web_track_.Source().GetType() == | |
72 blink::WebMediaStreamSource::kTypeAudio) { | |
73 UninitializeLocalAudioTrack(); | |
74 } else { | |
75 DCHECK_EQ(web_track_.Source().GetType(), | |
76 blink::WebMediaStreamSource::kTypeVideo); | |
77 UninitializeLocalVideoTrack(); | |
78 } | |
79 } else { | |
80 if (web_track_.Source().GetType() == | |
81 blink::WebMediaStreamSource::kTypeAudio) { | |
82 UninitializeRemoteAudioTrack(); | |
83 } else { | |
84 DCHECK_EQ(web_track_.Source().GetType(), | |
85 blink::WebMediaStreamSource::kTypeVideo); | |
86 UninitializeRemoteVideoTrack(); | |
87 } | |
88 } | |
89 } | |
90 | |
91 bool WebRtcMediaStreamTrackAdapter::is_initialized() const { | |
92 return is_initialized_; | |
93 } | |
94 | |
95 const blink::WebMediaStreamTrack& WebRtcMediaStreamTrackAdapter::web_track() | |
96 const { | |
97 DCHECK(is_initialized_); | |
98 DCHECK(!web_track_.IsNull()); | |
99 return web_track_; | |
100 } | |
101 | |
102 webrtc::MediaStreamTrackInterface* WebRtcMediaStreamTrackAdapter::webrtc_track() | |
103 const { | |
104 DCHECK(is_initialized_); | |
105 DCHECK(webrtc_track_); | |
106 return webrtc_track_.get(); | |
107 } | |
108 | |
109 bool WebRtcMediaStreamTrackAdapter::IsEqual( | |
110 const blink::WebMediaStreamTrack& web_track) const { | |
111 DCHECK(is_initialized_); | |
112 return web_track_.GetTrackData() == web_track.GetTrackData(); | |
113 } | |
114 | |
115 void WebRtcMediaStreamTrackAdapter::InitializeLocalAudioTrack( | |
116 const blink::WebMediaStreamTrack& web_track) { | |
hbos_chromium
2017/05/18 11:41:51
This code is based on WebRtcMediaStreamAdapter::Ad
Guido Urdaneta
2017/05/22 14:26:38
Can you add a TODO for this in WebRtcMediaStreamAd
hbos_chromium
2017/05/29 11:24:17
Done.
| |
117 DCHECK(main_thread_->BelongsToCurrentThread()); | |
118 DCHECK(!is_initialized_); | |
119 DCHECK(!web_track.IsNull()); | |
120 DCHECK(!web_track.Source().Remote()); | |
121 DCHECK_EQ(web_track.Source().GetType(), | |
122 blink::WebMediaStreamSource::kTypeAudio); | |
123 web_track_ = web_track; | |
124 MediaStreamAudioTrack* native_track = MediaStreamAudioTrack::From(web_track_); | |
125 DCHECK(native_track); | |
126 | |
127 // Non-WebRtc remote sources and local sources do not provide an instance of | |
128 // the webrtc::AudioSourceInterface, and also do not need references to the | |
129 // audio level calculator or audio processor passed to the sink. | |
130 webrtc::AudioSourceInterface* source_interface = nullptr; | |
131 local_audio_sink_.reset( | |
132 new WebRtcAudioSink(web_track_.Id().Utf8(), source_interface, | |
133 factory_->GetWebRtcSignalingThread())); | |
134 | |
135 if (auto* media_stream_source = ProcessedLocalAudioSource::From( | |
136 MediaStreamAudioSource::From(web_track_.Source()))) { | |
137 local_audio_sink_->SetLevel(media_stream_source->audio_level()); | |
138 // The sink only grabs stats from the audio processor. Stats are only | |
139 // available if audio processing is turned on. Therefore, only provide the | |
140 // sink a reference to the processor if audio processing is turned on. | |
141 if (auto processor = media_stream_source->audio_processor()) { | |
142 if (processor && processor->has_audio_processing()) | |
Guido Urdaneta
2017/05/22 14:26:38
The if (processor) part is redundant since that wa
hbos_chromium
2017/05/29 11:24:17
Done.
| |
143 local_audio_sink_->SetAudioProcessor(processor); | |
144 } | |
145 } | |
146 native_track->AddSink(local_audio_sink_.get()); | |
147 webrtc_track_ = local_audio_sink_->webrtc_audio_track(); | |
148 DCHECK(webrtc_track_); | |
149 is_initialized_ = true; | |
150 } | |
151 | |
152 void WebRtcMediaStreamTrackAdapter::InitializeLocalVideoTrack( | |
153 const blink::WebMediaStreamTrack& web_track) { | |
hbos_chromium
2017/05/18 11:41:51
This code is based on WebRtcMediaStreamAdapter::Ad
Guido Urdaneta
2017/05/22 14:26:38
Ditto.
hbos_chromium
2017/05/29 11:24:17
Donno.
| |
154 DCHECK(main_thread_->BelongsToCurrentThread()); | |
155 DCHECK(!is_initialized_); | |
156 DCHECK(!web_track.IsNull()); | |
157 DCHECK(!web_track.Source().Remote()); | |
158 DCHECK_EQ(web_track.Source().GetType(), | |
159 blink::WebMediaStreamSource::kTypeVideo); | |
160 web_track_ = web_track; | |
161 local_video_sink_.reset(new MediaStreamVideoWebRtcSink(web_track_, factory_)); | |
162 webrtc_track_ = local_video_sink_->webrtc_video_track(); | |
163 DCHECK(webrtc_track_); | |
164 is_initialized_ = true; | |
165 } | |
166 | |
167 void WebRtcMediaStreamTrackAdapter::InitializeRemoteAudioTrack( | |
168 webrtc::AudioTrackInterface* webrtc_audio_track) { | |
169 DCHECK(factory_->GetWebRtcSignalingThread()->BelongsToCurrentThread()); | |
170 DCHECK(!is_initialized_); | |
171 DCHECK(webrtc_audio_track); | |
172 DCHECK_EQ(webrtc_audio_track->kind(), | |
173 webrtc::MediaStreamTrackInterface::kAudioKind); | |
174 remote_audio_track_adapter_ = | |
175 new RemoteAudioTrackAdapter(main_thread_, webrtc_audio_track); | |
176 webrtc_track_ = webrtc_audio_track; | |
177 main_thread_->PostTask( | |
178 FROM_HERE, base::Bind(&WebRtcMediaStreamTrackAdapter:: | |
179 FinalizeRemoteTrackInitializationOnMainThread, | |
180 this)); | |
181 } | |
182 | |
183 void WebRtcMediaStreamTrackAdapter::InitializeRemoteVideoTrack( | |
184 webrtc::VideoTrackInterface* webrtc_video_track) { | |
185 DCHECK(factory_->GetWebRtcSignalingThread()->BelongsToCurrentThread()); | |
186 DCHECK(!is_initialized_); | |
187 DCHECK(webrtc_video_track); | |
188 DCHECK_EQ(webrtc_video_track->kind(), | |
189 webrtc::MediaStreamTrackInterface::kVideoKind); | |
190 remote_video_track_adapter_ = | |
191 new RemoteVideoTrackAdapter(main_thread_, webrtc_video_track); | |
192 webrtc_track_ = webrtc_video_track; | |
193 main_thread_->PostTask( | |
194 FROM_HERE, base::Bind(&WebRtcMediaStreamTrackAdapter:: | |
195 FinalizeRemoteTrackInitializationOnMainThread, | |
196 this)); | |
197 } | |
198 | |
199 void WebRtcMediaStreamTrackAdapter:: | |
200 FinalizeRemoteTrackInitializationOnMainThread() { | |
201 DCHECK(main_thread_->BelongsToCurrentThread()); | |
202 DCHECK(remote_audio_track_adapter_ || remote_video_track_adapter_); | |
203 if (remote_audio_track_adapter_) { | |
204 remote_audio_track_adapter_->Initialize(); | |
205 web_track_ = *remote_audio_track_adapter_->webkit_track(); | |
206 } else { | |
207 remote_video_track_adapter_->Initialize(); | |
208 web_track_ = *remote_video_track_adapter_->webkit_track(); | |
209 } | |
210 is_initialized_ = true; | |
211 } | |
212 | |
213 void WebRtcMediaStreamTrackAdapter::UninitializeLocalAudioTrack() { | |
214 DCHECK(main_thread_->BelongsToCurrentThread()); | |
215 DCHECK(is_initialized_); | |
216 DCHECK(!web_track_.Source().Remote()); | |
217 DCHECK_EQ(web_track_.Source().GetType(), | |
218 blink::WebMediaStreamSource::kTypeAudio); | |
219 MediaStreamAudioTrack* audio_track = MediaStreamAudioTrack::From(web_track_); | |
220 DCHECK(audio_track); | |
221 DCHECK(local_audio_sink_); | |
222 audio_track->RemoveSink(local_audio_sink_.get()); | |
223 local_audio_sink_.reset(); | |
224 webrtc_track_ = nullptr; | |
225 web_track_.Reset(); | |
226 is_initialized_ = false; | |
227 } | |
228 | |
229 void WebRtcMediaStreamTrackAdapter::UninitializeLocalVideoTrack() { | |
230 DCHECK(main_thread_->BelongsToCurrentThread()); | |
231 DCHECK(is_initialized_); | |
232 DCHECK(!web_track_.Source().Remote()); | |
233 DCHECK_EQ(web_track_.Source().GetType(), | |
234 blink::WebMediaStreamSource::kTypeVideo); | |
235 local_video_sink_.reset(); | |
236 webrtc_track_ = nullptr; | |
237 web_track_.Reset(); | |
238 is_initialized_ = false; | |
239 } | |
240 | |
241 void WebRtcMediaStreamTrackAdapter::UninitializeRemoteAudioTrack() { | |
242 DCHECK(main_thread_->BelongsToCurrentThread()); | |
243 DCHECK(is_initialized_); | |
244 DCHECK(web_track_.Source().Remote()); | |
245 DCHECK_EQ(web_track_.Source().GetType(), | |
246 blink::WebMediaStreamSource::kTypeAudio); | |
247 factory_->GetWebRtcSignalingThread()->PostTask( | |
248 FROM_HERE, | |
249 base::Bind(&WebRtcMediaStreamTrackAdapter:: | |
250 UnregisterRemoteAudioTrackAdapterOnSignalingThread, | |
251 this)); | |
252 } | |
253 | |
254 void WebRtcMediaStreamTrackAdapter::UninitializeRemoteVideoTrack() { | |
255 DCHECK(main_thread_->BelongsToCurrentThread()); | |
256 DCHECK(is_initialized_); | |
257 DCHECK(web_track_.Source().Remote()); | |
258 DCHECK_EQ(web_track_.Source().GetType(), | |
259 blink::WebMediaStreamSource::kTypeVideo); | |
260 FinalizeRemoteTrackUninitalizationOnMainThread(); | |
261 } | |
262 | |
263 void WebRtcMediaStreamTrackAdapter:: | |
264 UnregisterRemoteAudioTrackAdapterOnSignalingThread() { | |
265 DCHECK(factory_->GetWebRtcSignalingThread()->BelongsToCurrentThread()); | |
266 DCHECK(remote_audio_track_adapter_); | |
267 remote_audio_track_adapter_->Unregister(); | |
268 main_thread_->PostTask( | |
269 FROM_HERE, base::Bind(&WebRtcMediaStreamTrackAdapter:: | |
270 FinalizeRemoteTrackUninitalizationOnMainThread, | |
271 this)); | |
272 } | |
273 | |
274 void WebRtcMediaStreamTrackAdapter:: | |
275 FinalizeRemoteTrackUninitalizationOnMainThread() { | |
276 DCHECK(main_thread_->BelongsToCurrentThread()); | |
277 DCHECK(is_initialized_); | |
278 remote_audio_track_adapter_ = nullptr; | |
279 remote_video_track_adapter_ = nullptr; | |
280 webrtc_track_ = nullptr; | |
281 web_track_.Reset(); | |
282 is_initialized_ = false; | |
283 } | |
284 | |
285 } // namespace content | |
OLD | NEW |