OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/renderer/media/webrtc/webrtc_local_audio_track_adapter.h" | 5 #include "content/renderer/media/webrtc/webrtc_local_audio_track_adapter.h" |
6 | 6 |
7 #include "base/location.h" | 7 #include "base/location.h" |
8 #include "base/logging.h" | 8 #include "base/logging.h" |
9 #include "content/renderer/media/media_stream_audio_processor.h" | 9 #include "content/renderer/media/media_stream_audio_processor.h" |
10 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h" | 10 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h" |
11 #include "content/renderer/media/webrtc/webrtc_audio_sink_adapter.h" | 11 #include "content/renderer/media/webrtc/webrtc_audio_sink_adapter.h" |
12 #include "content/renderer/media/webrtc_local_audio_track.h" | 12 #include "content/renderer/media/webrtc_local_audio_track.h" |
13 #include "content/renderer/render_thread_impl.h" | 13 #include "content/renderer/render_thread_impl.h" |
14 #include "third_party/webrtc/api/mediastreaminterface.h" | 14 #include "third_party/webrtc/api/mediastreaminterface.h" |
15 | 15 |
16 namespace content { | 16 namespace content { |
17 | 17 |
18 static const char kAudioTrackKind[] = "audio"; | 18 static const char kAudioTrackKind[] = "audio"; |
19 | 19 |
20 scoped_refptr<WebRtcLocalAudioTrackAdapter> | 20 scoped_refptr<WebRtcLocalAudioTrackAdapter> |
21 WebRtcLocalAudioTrackAdapter::Create( | 21 WebRtcLocalAudioTrackAdapter::Create( |
22 const std::string& label, | 22 const std::string& label, |
23 webrtc::AudioSourceInterface* track_source) { | 23 webrtc::AudioSourceInterface* track_source) { |
24 // TODO(tommi): Change this so that the signaling thread is one of the | 24 // TODO(tommi): Change this so that the signaling thread is one of the |
25 // parameters to this method. | 25 // parameters to this method. |
26 scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner; | 26 scoped_refptr<base::SingleThreadTaskRunner> signaling_thread; |
27 RenderThreadImpl* current = RenderThreadImpl::current(); | 27 RenderThreadImpl* current = RenderThreadImpl::current(); |
28 if (current) { | 28 if (current) { |
29 PeerConnectionDependencyFactory* pc_factory = | 29 PeerConnectionDependencyFactory* pc_factory = |
30 current->GetPeerConnectionDependencyFactory(); | 30 current->GetPeerConnectionDependencyFactory(); |
31 signaling_task_runner = pc_factory->GetWebRtcSignalingThread(); | 31 signaling_thread = pc_factory->GetWebRtcSignalingThread(); |
32 CHECK(signaling_task_runner); | |
33 } else { | |
34 LOG(WARNING) << "Assuming single-threaded operation for unit test."; | |
35 } | 32 } |
36 | 33 |
| 34 LOG_IF(ERROR, !signaling_thread.get()) << "No signaling thread!"; |
| 35 |
37 rtc::RefCountedObject<WebRtcLocalAudioTrackAdapter>* adapter = | 36 rtc::RefCountedObject<WebRtcLocalAudioTrackAdapter>* adapter = |
38 new rtc::RefCountedObject<WebRtcLocalAudioTrackAdapter>( | 37 new rtc::RefCountedObject<WebRtcLocalAudioTrackAdapter>( |
39 label, track_source, std::move(signaling_task_runner)); | 38 label, track_source, signaling_thread); |
40 return adapter; | 39 return adapter; |
41 } | 40 } |
42 | 41 |
43 WebRtcLocalAudioTrackAdapter::WebRtcLocalAudioTrackAdapter( | 42 WebRtcLocalAudioTrackAdapter::WebRtcLocalAudioTrackAdapter( |
44 const std::string& label, | 43 const std::string& label, |
45 webrtc::AudioSourceInterface* track_source, | 44 webrtc::AudioSourceInterface* track_source, |
46 scoped_refptr<base::SingleThreadTaskRunner> signaling_task_runner) | 45 const scoped_refptr<base::SingleThreadTaskRunner>& signaling_thread) |
47 : webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>(label), | 46 : webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>(label), |
48 owner_(NULL), | 47 owner_(NULL), |
49 track_source_(track_source), | 48 track_source_(track_source), |
50 signaling_task_runner_(std::move(signaling_task_runner)) {} | 49 signaling_thread_(signaling_thread), |
| 50 signal_level_(0) { |
| 51 signaling_thread_checker_.DetachFromThread(); |
| 52 capture_thread_.DetachFromThread(); |
| 53 } |
51 | 54 |
52 WebRtcLocalAudioTrackAdapter::~WebRtcLocalAudioTrackAdapter() { | 55 WebRtcLocalAudioTrackAdapter::~WebRtcLocalAudioTrackAdapter() { |
53 } | 56 } |
54 | 57 |
55 void WebRtcLocalAudioTrackAdapter::Initialize(WebRtcLocalAudioTrack* owner) { | 58 void WebRtcLocalAudioTrackAdapter::Initialize(WebRtcLocalAudioTrack* owner) { |
56 DCHECK(!owner_); | 59 DCHECK(!owner_); |
57 DCHECK(owner); | 60 DCHECK(owner); |
58 owner_ = owner; | 61 owner_ = owner; |
59 } | 62 } |
60 | 63 |
61 void WebRtcLocalAudioTrackAdapter::SetAudioProcessor( | 64 void WebRtcLocalAudioTrackAdapter::SetAudioProcessor( |
62 scoped_refptr<MediaStreamAudioProcessor> processor) { | 65 const scoped_refptr<MediaStreamAudioProcessor>& processor) { |
63 DCHECK(processor.get()); | 66 // SetAudioProcessor will be called when a new capture thread has been |
64 DCHECK(!audio_processor_); | 67 // initialized, so we need to detach from any current capture thread we're |
65 audio_processor_ = std::move(processor); | 68 // checking and attach to the current one. |
66 } | 69 capture_thread_.DetachFromThread(); |
67 | 70 DCHECK(capture_thread_.CalledOnValidThread()); |
68 void WebRtcLocalAudioTrackAdapter::SetLevel( | 71 base::AutoLock auto_lock(lock_); |
69 scoped_refptr<MediaStreamAudioLevelCalculator::Level> level) { | 72 audio_processor_ = processor; |
70 DCHECK(level.get()); | |
71 DCHECK(!level_); | |
72 level_ = std::move(level); | |
73 } | 73 } |
74 | 74 |
75 std::string WebRtcLocalAudioTrackAdapter::kind() const { | 75 std::string WebRtcLocalAudioTrackAdapter::kind() const { |
76 return kAudioTrackKind; | 76 return kAudioTrackKind; |
77 } | 77 } |
78 | 78 |
79 bool WebRtcLocalAudioTrackAdapter::set_enabled(bool enable) { | 79 bool WebRtcLocalAudioTrackAdapter::set_enabled(bool enable) { |
80 // If we're not called on the signaling thread, we need to post a task to | 80 // If we're not called on the signaling thread, we need to post a task to |
81 // change the state on the correct thread. | 81 // change the state on the correct thread. |
82 if (signaling_task_runner_ && | 82 if (signaling_thread_.get() && !signaling_thread_->BelongsToCurrentThread()) { |
83 !signaling_task_runner_->BelongsToCurrentThread()) { | 83 signaling_thread_->PostTask(FROM_HERE, |
84 signaling_task_runner_->PostTask(FROM_HERE, | |
85 base::Bind( | 84 base::Bind( |
86 base::IgnoreResult(&WebRtcLocalAudioTrackAdapter::set_enabled), | 85 base::IgnoreResult(&WebRtcLocalAudioTrackAdapter::set_enabled), |
87 this, enable)); | 86 this, enable)); |
88 return true; | 87 return true; |
89 } | 88 } |
90 | 89 |
91 return webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>:: | 90 return webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>:: |
92 set_enabled(enable); | 91 set_enabled(enable); |
93 } | 92 } |
94 | 93 |
95 void WebRtcLocalAudioTrackAdapter::AddSink( | 94 void WebRtcLocalAudioTrackAdapter::AddSink( |
96 webrtc::AudioTrackSinkInterface* sink) { | 95 webrtc::AudioTrackSinkInterface* sink) { |
97 DCHECK(!signaling_task_runner_ || | 96 DCHECK(signaling_thread_checker_.CalledOnValidThread()); |
98 signaling_task_runner_->RunsTasksOnCurrentThread()); | |
99 DCHECK(sink); | 97 DCHECK(sink); |
100 #ifndef NDEBUG | 98 #ifndef NDEBUG |
101 // Verify that |sink| has not been added. | 99 // Verify that |sink| has not been added. |
102 for (ScopedVector<WebRtcAudioSinkAdapter>::const_iterator it = | 100 for (ScopedVector<WebRtcAudioSinkAdapter>::const_iterator it = |
103 sink_adapters_.begin(); | 101 sink_adapters_.begin(); |
104 it != sink_adapters_.end(); ++it) { | 102 it != sink_adapters_.end(); ++it) { |
105 DCHECK(!(*it)->IsEqual(sink)); | 103 DCHECK(!(*it)->IsEqual(sink)); |
106 } | 104 } |
107 #endif | 105 #endif |
108 | 106 |
109 scoped_ptr<WebRtcAudioSinkAdapter> adapter( | 107 scoped_ptr<WebRtcAudioSinkAdapter> adapter( |
110 new WebRtcAudioSinkAdapter(sink)); | 108 new WebRtcAudioSinkAdapter(sink)); |
111 owner_->AddSink(adapter.get()); | 109 owner_->AddSink(adapter.get()); |
112 sink_adapters_.push_back(adapter.release()); | 110 sink_adapters_.push_back(adapter.release()); |
113 } | 111 } |
114 | 112 |
115 void WebRtcLocalAudioTrackAdapter::RemoveSink( | 113 void WebRtcLocalAudioTrackAdapter::RemoveSink( |
116 webrtc::AudioTrackSinkInterface* sink) { | 114 webrtc::AudioTrackSinkInterface* sink) { |
117 DCHECK(!signaling_task_runner_ || | 115 DCHECK(signaling_thread_checker_.CalledOnValidThread()); |
118 signaling_task_runner_->RunsTasksOnCurrentThread()); | |
119 DCHECK(sink); | 116 DCHECK(sink); |
120 for (ScopedVector<WebRtcAudioSinkAdapter>::iterator it = | 117 for (ScopedVector<WebRtcAudioSinkAdapter>::iterator it = |
121 sink_adapters_.begin(); | 118 sink_adapters_.begin(); |
122 it != sink_adapters_.end(); ++it) { | 119 it != sink_adapters_.end(); ++it) { |
123 if ((*it)->IsEqual(sink)) { | 120 if ((*it)->IsEqual(sink)) { |
124 owner_->RemoveSink(*it); | 121 owner_->RemoveSink(*it); |
125 sink_adapters_.erase(it); | 122 sink_adapters_.erase(it); |
126 return; | 123 return; |
127 } | 124 } |
128 } | 125 } |
129 } | 126 } |
130 | 127 |
131 bool WebRtcLocalAudioTrackAdapter::GetSignalLevel(int* level) { | 128 bool WebRtcLocalAudioTrackAdapter::GetSignalLevel(int* level) { |
132 DCHECK(!signaling_task_runner_ || | 129 DCHECK(signaling_thread_checker_.CalledOnValidThread()); |
133 signaling_task_runner_->RunsTasksOnCurrentThread()); | |
134 | 130 |
135 // |level_| is only set once, so it's safe to read without first acquiring a | 131 base::AutoLock auto_lock(lock_); |
136 // mutex. | 132 *level = signal_level_; |
137 if (!level_) | |
138 return false; | |
139 const float signal_level = level_->GetCurrent(); | |
140 DCHECK_GE(signal_level, 0.0f); | |
141 DCHECK_LE(signal_level, 1.0f); | |
142 // Convert from float in range [0.0,1.0] to an int in range [0,32767]. | |
143 *level = static_cast<int>(signal_level * std::numeric_limits<int16_t>::max() + | |
144 0.5f /* rounding to nearest int */); | |
145 return true; | 133 return true; |
146 } | 134 } |
147 | 135 |
148 rtc::scoped_refptr<webrtc::AudioProcessorInterface> | 136 rtc::scoped_refptr<webrtc::AudioProcessorInterface> |
149 WebRtcLocalAudioTrackAdapter::GetAudioProcessor() { | 137 WebRtcLocalAudioTrackAdapter::GetAudioProcessor() { |
150 DCHECK(!signaling_task_runner_ || | 138 DCHECK(signaling_thread_checker_.CalledOnValidThread()); |
151 signaling_task_runner_->RunsTasksOnCurrentThread()); | 139 base::AutoLock auto_lock(lock_); |
152 return audio_processor_.get(); | 140 return audio_processor_.get(); |
153 } | 141 } |
154 | 142 |
| 143 void WebRtcLocalAudioTrackAdapter::SetSignalLevel(int signal_level) { |
| 144 DCHECK(capture_thread_.CalledOnValidThread()); |
| 145 base::AutoLock auto_lock(lock_); |
| 146 signal_level_ = signal_level; |
| 147 } |
| 148 |
155 webrtc::AudioSourceInterface* WebRtcLocalAudioTrackAdapter::GetSource() const { | 149 webrtc::AudioSourceInterface* WebRtcLocalAudioTrackAdapter::GetSource() const { |
156 DCHECK(!signaling_task_runner_ || | 150 DCHECK(signaling_thread_checker_.CalledOnValidThread()); |
157 signaling_task_runner_->RunsTasksOnCurrentThread()); | |
158 return track_source_; | 151 return track_source_; |
159 } | 152 } |
160 | 153 |
161 } // namespace content | 154 } // namespace content |
OLD | NEW |