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