OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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_audio_device_impl.h" | 5 #include "content/renderer/media/webrtc_audio_device_impl.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/metrics/histogram.h" | 8 #include "base/metrics/histogram.h" |
9 #include "base/strings/string_util.h" | 9 #include "base/strings/string_util.h" |
10 #include "base/win/windows_version.h" | 10 #include "base/win/windows_version.h" |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
44 } | 44 } |
45 | 45 |
46 int32_t WebRtcAudioDeviceImpl::Release() { | 46 int32_t WebRtcAudioDeviceImpl::Release() { |
47 DCHECK(thread_checker_.CalledOnValidThread()); | 47 DCHECK(thread_checker_.CalledOnValidThread()); |
48 int ret = base::subtle::Barrier_AtomicIncrement(&ref_count_, -1); | 48 int ret = base::subtle::Barrier_AtomicIncrement(&ref_count_, -1); |
49 if (ret == 0) { | 49 if (ret == 0) { |
50 delete this; | 50 delete this; |
51 } | 51 } |
52 return ret; | 52 return ret; |
53 } | 53 } |
| 54 |
54 int WebRtcAudioDeviceImpl::CaptureData(const std::vector<int>& channels, | 55 int WebRtcAudioDeviceImpl::CaptureData(const std::vector<int>& channels, |
55 const int16* audio_data, | 56 const int16* audio_data, |
56 int sample_rate, | 57 int sample_rate, |
57 int number_of_channels, | 58 int number_of_channels, |
58 int number_of_frames, | 59 int number_of_frames, |
59 int audio_delay_milliseconds, | 60 int audio_delay_milliseconds, |
60 int current_volume, | 61 int current_volume, |
61 bool need_audio_processing, | 62 bool need_audio_processing, |
62 bool key_pressed) { | 63 bool key_pressed) { |
63 int total_delay_ms = 0; | 64 int total_delay_ms = 0; |
64 { | 65 { |
65 base::AutoLock auto_lock(lock_); | 66 base::AutoLock auto_lock(lock_); |
66 // Return immediately when not recording or |channels| is empty. | 67 // Return immediately when not recording or |channels| is empty. |
67 // See crbug.com/274017: renderer crash dereferencing invalid channels[0]. | 68 // See crbug.com/274017: renderer crash dereferencing invalid channels[0]. |
68 if (!recording_ || channels.empty()) | 69 if (!recording_ || channels.empty()) |
69 return 0; | 70 return 0; |
70 | 71 |
71 // Store the reported audio delay locally. | 72 // Store the reported audio delay locally. |
72 input_delay_ms_ = audio_delay_milliseconds; | 73 input_delay_ms_ = audio_delay_milliseconds; |
73 total_delay_ms = input_delay_ms_ + output_delay_ms_; | 74 total_delay_ms = input_delay_ms_ + output_delay_ms_; |
74 DVLOG(2) << "total delay: " << input_delay_ms_ + output_delay_ms_; | 75 DVLOG(2) << "total delay: " << input_delay_ms_ + output_delay_ms_; |
75 } | 76 } |
76 | 77 |
77 // Write audio samples in blocks of 10 milliseconds to the registered | 78 // Deliver 10ms of recorded 16-bit linear PCM audio. |
78 // webrtc::AudioTransport sink. Keep writing until our internal byte | 79 return audio_transport_callback_->OnDataAvailable( |
79 // buffer is empty. | 80 &channels[0], channels.size(), audio_data, sample_rate, |
80 const int16* audio_buffer = audio_data; | 81 number_of_channels, number_of_frames, total_delay_ms, |
81 const int samples_per_10_msec = (sample_rate / 100); | 82 current_volume, key_pressed, need_audio_processing); |
82 int accumulated_audio_samples = 0; | |
83 uint32_t new_volume = 0; | |
84 while (accumulated_audio_samples < number_of_frames) { | |
85 // Deliver 10ms of recorded 16-bit linear PCM audio. | |
86 int new_mic_level = audio_transport_callback_->OnDataAvailable( | |
87 &channels[0], | |
88 channels.size(), | |
89 audio_buffer, | |
90 sample_rate, | |
91 number_of_channels, | |
92 samples_per_10_msec, | |
93 total_delay_ms, | |
94 current_volume, | |
95 key_pressed, | |
96 need_audio_processing); | |
97 | |
98 accumulated_audio_samples += samples_per_10_msec; | |
99 audio_buffer += samples_per_10_msec * number_of_channels; | |
100 | |
101 // The latest non-zero new microphone level will be returned. | |
102 if (new_mic_level) | |
103 new_volume = new_mic_level; | |
104 } | |
105 | |
106 return new_volume; | |
107 } | 83 } |
108 | 84 |
109 void WebRtcAudioDeviceImpl::SetCaptureFormat( | 85 void WebRtcAudioDeviceImpl::SetCaptureFormat( |
110 const media::AudioParameters& params) { | 86 const media::AudioParameters& params) { |
111 DVLOG(1) << "WebRtcAudioDeviceImpl::SetCaptureFormat()"; | 87 DVLOG(1) << "WebRtcAudioDeviceImpl::SetCaptureFormat()"; |
112 DCHECK(thread_checker_.CalledOnValidThread()); | 88 DCHECK(thread_checker_.CalledOnValidThread()); |
113 } | 89 } |
114 | 90 |
115 void WebRtcAudioDeviceImpl::RenderData(uint8* audio_data, | 91 void WebRtcAudioDeviceImpl::RenderData(uint8* audio_data, |
116 int number_of_channels, | 92 int number_of_channels, |
(...skipping 26 matching lines...) Expand all Loading... |
143 // Get 10ms and append output to temporary byte buffer. | 119 // Get 10ms and append output to temporary byte buffer. |
144 audio_transport_callback_->NeedMorePlayData(samples_per_10_msec, | 120 audio_transport_callback_->NeedMorePlayData(samples_per_10_msec, |
145 bytes_per_sample, | 121 bytes_per_sample, |
146 channels, | 122 channels, |
147 samples_per_sec, | 123 samples_per_sec, |
148 audio_data, | 124 audio_data, |
149 num_audio_samples); | 125 num_audio_samples); |
150 accumulated_audio_samples += num_audio_samples; | 126 accumulated_audio_samples += num_audio_samples; |
151 audio_data += bytes_per_10_msec; | 127 audio_data += bytes_per_10_msec; |
152 } | 128 } |
| 129 |
| 130 base::AutoLock auto_lock(lock_); |
| 131 for (RenderDataObservers::const_iterator iter = |
| 132 render_data_observers_.begin(); |
| 133 iter != render_data_observers_.end(); ++iter) { |
| 134 (*iter)->OnRenderData( |
| 135 reinterpret_cast<const int16*>(audio_data), |
| 136 samples_per_sec, |
| 137 number_of_channels, |
| 138 number_of_frames, |
| 139 audio_delay_milliseconds); |
| 140 } |
153 } | 141 } |
154 | 142 |
155 void WebRtcAudioDeviceImpl::SetRenderFormat(const AudioParameters& params) { | 143 void WebRtcAudioDeviceImpl::SetRenderFormat(const AudioParameters& params) { |
156 DCHECK(thread_checker_.CalledOnValidThread()); | 144 DCHECK(thread_checker_.CalledOnValidThread()); |
157 output_audio_parameters_ = params; | 145 output_audio_parameters_ = params; |
158 } | 146 } |
159 | 147 |
160 void WebRtcAudioDeviceImpl::RemoveAudioRenderer(WebRtcAudioRenderer* renderer) { | 148 void WebRtcAudioDeviceImpl::RemoveAudioRenderer(WebRtcAudioRenderer* renderer) { |
161 DCHECK(thread_checker_.CalledOnValidThread()); | 149 DCHECK(thread_checker_.CalledOnValidThread()); |
162 DCHECK_EQ(renderer, renderer_); | 150 DCHECK_EQ(renderer, renderer_); |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
195 return 0; | 183 return 0; |
196 | 184 |
197 StopRecording(); | 185 StopRecording(); |
198 StopPlayout(); | 186 StopPlayout(); |
199 | 187 |
200 DCHECK(!renderer_.get() || !renderer_->IsStarted()) | 188 DCHECK(!renderer_.get() || !renderer_->IsStarted()) |
201 << "The shared audio renderer shouldn't be running"; | 189 << "The shared audio renderer shouldn't be running"; |
202 | 190 |
203 capturers_.clear(); | 191 capturers_.clear(); |
204 | 192 |
| 193 // Notify all the remaining observers that the render object is going away. |
| 194 for (RenderDataObservers::const_iterator iter = |
| 195 render_data_observers_.begin(); |
| 196 iter != render_data_observers_.end(); ++iter) { |
| 197 (*iter)->OnRenderClosing(); |
| 198 } |
| 199 render_data_observers_.clear(); |
| 200 |
205 initialized_ = false; | 201 initialized_ = false; |
206 return 0; | 202 return 0; |
207 } | 203 } |
208 | 204 |
209 bool WebRtcAudioDeviceImpl::Initialized() const { | 205 bool WebRtcAudioDeviceImpl::Initialized() const { |
210 return initialized_; | 206 return initialized_; |
211 } | 207 } |
212 | 208 |
213 int32_t WebRtcAudioDeviceImpl::PlayoutIsAvailable(bool* available) { | 209 int32_t WebRtcAudioDeviceImpl::PlayoutIsAvailable(bool* available) { |
214 *available = initialized_; | 210 *available = initialized_; |
(...skipping 259 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
474 base::AutoLock auto_lock(lock_); | 470 base::AutoLock auto_lock(lock_); |
475 for (CapturerList::const_iterator iter = capturers_.begin(); | 471 for (CapturerList::const_iterator iter = capturers_.begin(); |
476 iter != capturers_.end(); ++iter) { | 472 iter != capturers_.end(); ++iter) { |
477 if (!(*iter)->device_id().empty()) | 473 if (!(*iter)->device_id().empty()) |
478 return *iter; | 474 return *iter; |
479 } | 475 } |
480 | 476 |
481 return NULL; | 477 return NULL; |
482 } | 478 } |
483 | 479 |
| 480 void WebRtcAudioDeviceImpl::AddRenderDataObserver( |
| 481 WebRtcAudioRenderDataObserver* observer) { |
| 482 DCHECK(observer); |
| 483 base::AutoLock auto_lock(lock_); |
| 484 DCHECK(std::find(render_data_observers_.begin(), |
| 485 render_data_observers_.end(), |
| 486 observer) == render_data_observers_.end()); |
| 487 render_data_observers_.push_back(observer); |
| 488 } |
| 489 |
| 490 void WebRtcAudioDeviceImpl::RemoveRenderDataObserver( |
| 491 WebRtcAudioRenderDataObserver* observer) { |
| 492 DCHECK(observer); |
| 493 base::AutoLock auto_lock(lock_); |
| 494 RenderDataObservers::iterator iter = std::find( |
| 495 render_data_observers_.begin(), render_data_observers_.end(), observer); |
| 496 // TODO(xians): why not DCHECK. |
| 497 if (iter == render_data_observers_.end()) |
| 498 return; |
| 499 |
| 500 render_data_observers_.erase(iter); |
| 501 } |
| 502 |
484 } // namespace content | 503 } // namespace content |
OLD | NEW |