OLD | NEW |
---|---|
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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/audio_renderer_mixer_manager.h" | 5 #include "content/renderer/media/audio_renderer_mixer_manager.h" |
6 | 6 |
7 #include <algorithm> | |
7 #include <string> | 8 #include <string> |
8 | 9 |
9 #include "base/bind.h" | 10 #include "base/bind.h" |
10 #include "base/bind_helpers.h" | 11 #include "base/bind_helpers.h" |
11 #include "base/memory/ptr_util.h" | 12 #include "base/memory/ptr_util.h" |
13 #include "base/metrics/histogram_macros.h" | |
12 #include "build/build_config.h" | 14 #include "build/build_config.h" |
13 #include "content/renderer/media/audio_renderer_sink_cache.h" | 15 #include "content/renderer/media/audio_renderer_sink_cache.h" |
14 #include "media/audio/audio_device_description.h" | 16 #include "media/audio/audio_device_description.h" |
15 #include "media/base/audio_hardware_config.h" | 17 #include "media/base/audio_hardware_config.h" |
16 #include "media/base/audio_renderer_mixer.h" | 18 #include "media/base/audio_renderer_mixer.h" |
17 #include "media/base/audio_renderer_mixer_input.h" | 19 #include "media/base/audio_renderer_mixer_input.h" |
18 | 20 |
21 namespace { | |
22 // Calculate mixer output parameters based on mixer input parameters and | |
23 // hardware parameters for audio output. | |
24 media::AudioParameters GetMixerOutputParams( | |
25 const media::AudioParameters& input_params, | |
26 const media::AudioParameters& hardware_params, | |
27 media::AudioLatency::LatencyType latency) { | |
28 int output_sample_rate = input_params.sample_rate(); | |
29 bool valid_not_fake_hardware_params = | |
30 hardware_params.format() != media::AudioParameters::AUDIO_FAKE && | |
31 hardware_params.IsValid(); | |
32 int preferred_high_latency_output_buffer_size = 0; | |
33 | |
34 #if !defined(OS_CHROMEOS) | |
35 // On ChromeOS as well as when a fake device is used, we can rely on the | |
36 // playback device to handle resampling, so don't waste cycles on it here. | |
37 // On other systems if hardware parameters are valid and the device is not | |
38 // fake, resample to hardware sample rate. Otherwise, pass the input one and | |
39 // let the browser side handle automatic fallback. | |
40 if (valid_not_fake_hardware_params) { | |
41 output_sample_rate = hardware_params.sample_rate(); | |
42 preferred_high_latency_output_buffer_size = | |
43 hardware_params.frames_per_buffer(); | |
44 } | |
45 #endif | |
46 | |
47 int output_buffer_size = 0; | |
48 | |
49 // Adjust output buffer size according to the latency requirement. | |
50 switch (latency) { | |
51 case media::AudioLatency::LATENCY_INTERACTIVE: | |
52 output_buffer_size = media::AudioLatency::GetInteractiveBufferSize( | |
53 hardware_params.frames_per_buffer()); | |
54 break; | |
55 case media::AudioLatency::LATENCY_RTC: | |
56 output_buffer_size = media::AudioLatency::GetRtcBufferSize( | |
57 output_sample_rate, valid_not_fake_hardware_params | |
58 ? hardware_params.frames_per_buffer() | |
59 : 0); | |
60 break; | |
61 case media::AudioLatency::LATENCY_PLAYBACK: | |
62 output_buffer_size = media::AudioLatency::GetHighLatencyBufferSize( | |
63 output_sample_rate, preferred_high_latency_output_buffer_size); | |
64 break; | |
65 case media::AudioLatency::LATENCY_EXACT_MS: | |
66 // TODO(olka): add support when WebAudio requires it. | |
67 default: | |
68 NOTREACHED(); | |
69 } | |
70 | |
71 DCHECK_NE(output_buffer_size, 0); | |
72 | |
73 // Force to 16-bit output for now since we know that works everywhere; | |
74 // ChromeOS does not support other bit depths. | |
75 return media::AudioParameters(input_params.format(), | |
76 input_params.channel_layout(), | |
77 output_sample_rate, 16, output_buffer_size); | |
78 } | |
79 | |
80 void LogMixerUmaHistogram(media::AudioLatency::LatencyType latency, int value) { | |
81 switch (latency) { | |
82 case media::AudioLatency::LATENCY_EXACT_MS: | |
83 UMA_HISTOGRAM_CUSTOM_COUNTS( | |
84 "Media.Audio.Render.AudioInputsPerMixer.LatencyExact", value, 1, 20, | |
85 20); | |
Steven Holte
2016/06/29 18:34:25
If you want exact numbers below 20, you probably w
| |
86 return; | |
87 case media::AudioLatency::LATENCY_INTERACTIVE: | |
88 UMA_HISTOGRAM_CUSTOM_COUNTS( | |
89 "Media.Audio.Render.AudioInputsPerMixer.LatencyInteractive", value, 1, | |
90 20, 20); | |
91 return; | |
92 case media::AudioLatency::LATENCY_RTC: | |
93 UMA_HISTOGRAM_CUSTOM_COUNTS( | |
94 "Media.Audio.Render.AudioInputsPerMixer.LatencyRtc", value, 1, 20, | |
95 20); | |
96 return; | |
97 case media::AudioLatency::LATENCY_PLAYBACK: | |
98 UMA_HISTOGRAM_CUSTOM_COUNTS( | |
99 "Media.Audio.Render.AudioInputsPerMixer.LatencyPlayback", value, 1, | |
100 20, 20); | |
101 return; | |
102 default: | |
103 NOTREACHED(); | |
104 } | |
105 } | |
106 | |
107 } // namespace | |
108 | |
19 namespace content { | 109 namespace content { |
20 | 110 |
21 AudioRendererMixerManager::AudioRendererMixerManager( | 111 AudioRendererMixerManager::AudioRendererMixerManager( |
22 std::unique_ptr<AudioRendererSinkCache> sink_cache) | 112 std::unique_ptr<AudioRendererSinkCache> sink_cache) |
23 : sink_cache_(std::move(sink_cache)) { | 113 : sink_cache_(std::move(sink_cache)) { |
24 DCHECK(sink_cache_); | 114 DCHECK(sink_cache_); |
25 } | 115 } |
26 | 116 |
27 AudioRendererMixerManager::~AudioRendererMixerManager() { | 117 AudioRendererMixerManager::~AudioRendererMixerManager() { |
28 // References to AudioRendererMixers may be owned by garbage collected | 118 // References to AudioRendererMixers may be owned by garbage collected |
29 // objects. During process shutdown they may be leaked, so, transitively, | 119 // objects. During process shutdown they may be leaked, so, transitively, |
30 // |mixers_| may leak (i.e., may be non-empty at this time) as well. | 120 // |mixers_| may leak (i.e., may be non-empty at this time) as well. |
31 } | 121 } |
32 | 122 |
33 // static | 123 // static |
34 std::unique_ptr<AudioRendererMixerManager> AudioRendererMixerManager::Create() { | 124 std::unique_ptr<AudioRendererMixerManager> AudioRendererMixerManager::Create() { |
35 return base::WrapUnique( | 125 return base::WrapUnique( |
36 new AudioRendererMixerManager(AudioRendererSinkCache::Create())); | 126 new AudioRendererMixerManager(AudioRendererSinkCache::Create())); |
37 } | 127 } |
38 | 128 |
39 media::AudioRendererMixerInput* AudioRendererMixerManager::CreateInput( | 129 media::AudioRendererMixerInput* AudioRendererMixerManager::CreateInput( |
40 int source_render_frame_id, | 130 int source_render_frame_id, |
41 int session_id, | 131 int session_id, |
42 const std::string& device_id, | 132 const std::string& device_id, |
43 const url::Origin& security_origin) { | 133 const url::Origin& security_origin, |
134 media::AudioLatency::LatencyType latency) { | |
44 // AudioRendererMixerManager lives on the renderer thread and is destroyed on | 135 // AudioRendererMixerManager lives on the renderer thread and is destroyed on |
45 // renderer thread destruction, so it's safe to pass its pointer to a mixer | 136 // renderer thread destruction, so it's safe to pass its pointer to a mixer |
46 // input. | 137 // input. |
47 return new media::AudioRendererMixerInput( | 138 return new media::AudioRendererMixerInput( |
48 this, source_render_frame_id, | 139 this, source_render_frame_id, |
49 media::AudioDeviceDescription::UseSessionIdToSelectDevice(session_id, | 140 media::AudioDeviceDescription::UseSessionIdToSelectDevice(session_id, |
50 device_id) | 141 device_id) |
51 ? GetOutputDeviceInfo(source_render_frame_id, session_id, device_id, | 142 ? GetOutputDeviceInfo(source_render_frame_id, session_id, device_id, |
52 security_origin) | 143 security_origin) |
53 .device_id() | 144 .device_id() |
54 : device_id, | 145 : device_id, |
55 security_origin); | 146 security_origin, latency); |
56 } | 147 } |
57 | 148 |
58 media::AudioRendererMixer* AudioRendererMixerManager::GetMixer( | 149 media::AudioRendererMixer* AudioRendererMixerManager::GetMixer( |
59 int source_render_frame_id, | 150 int source_render_frame_id, |
60 const media::AudioParameters& params, | 151 const media::AudioParameters& input_params, |
152 media::AudioLatency::LatencyType latency, | |
61 const std::string& device_id, | 153 const std::string& device_id, |
62 const url::Origin& security_origin, | 154 const url::Origin& security_origin, |
63 media::OutputDeviceStatus* device_status) { | 155 media::OutputDeviceStatus* device_status) { |
64 // Effects are not passed through to output creation, so ensure none are set. | 156 // Effects are not passed through to output creation, so ensure none are set. |
65 DCHECK_EQ(params.effects(), media::AudioParameters::NO_EFFECTS); | 157 DCHECK_EQ(input_params.effects(), media::AudioParameters::NO_EFFECTS); |
66 | 158 |
67 const MixerKey key(source_render_frame_id, params, device_id, | 159 const MixerKey key(source_render_frame_id, input_params, latency, device_id, |
68 security_origin); | 160 security_origin); |
69 base::AutoLock auto_lock(mixers_lock_); | 161 base::AutoLock auto_lock(mixers_lock_); |
70 | 162 |
163 // Update latency map when the mixer is requested, i.e. there is an attempt to | |
164 // mix and output audio with a given latency. This is opposite to | |
165 // CreateInput() which creates a sink which is probably never used for output. | |
166 if (!latency_map_[latency]) { | |
167 latency_map_[latency] = 1; | |
168 // Log the updated latency map. This can't be done once in the end of the | |
169 // renderer lifetime, because the destructor is usually not called. So, | |
170 // we'll have a sort of exponential scale here, with a smaller subset | |
171 // logged both on its own and as a part of any larger subset. | |
172 UMA_HISTOGRAM_CUSTOM_COUNTS("Media.Audio.Render.AudioMixing.LatencyMap", | |
173 latency_map_.to_ulong(), 1, 0xff, 0xff); | |
Steven Holte
2016/06/29 18:34:25
Similarly here, though you might consider using UM
| |
174 } | |
175 | |
71 AudioRendererMixerMap::iterator it = mixers_.find(key); | 176 AudioRendererMixerMap::iterator it = mixers_.find(key); |
72 if (it != mixers_.end()) { | 177 if (it != mixers_.end()) { |
73 if (device_status) | 178 if (device_status) |
74 *device_status = media::OUTPUT_DEVICE_STATUS_OK; | 179 *device_status = media::OUTPUT_DEVICE_STATUS_OK; |
75 | 180 |
76 it->second.ref_count++; | 181 it->second.ref_count++; |
182 DVLOG(1) << "Reusing mixer: " << it->second.mixer; | |
77 return it->second.mixer; | 183 return it->second.mixer; |
78 } | 184 } |
79 | 185 |
80 scoped_refptr<media::AudioRendererSink> sink = | 186 scoped_refptr<media::AudioRendererSink> sink = |
81 sink_cache_->GetSink(source_render_frame_id, device_id, security_origin); | 187 sink_cache_->GetSink(source_render_frame_id, device_id, security_origin); |
82 | 188 |
83 const media::OutputDeviceInfo& device_info = sink->GetOutputDeviceInfo(); | 189 const media::OutputDeviceInfo& device_info = sink->GetOutputDeviceInfo(); |
84 if (device_status) | 190 if (device_status) |
85 *device_status = device_info.device_status(); | 191 *device_status = device_info.device_status(); |
86 if (device_info.device_status() != media::OUTPUT_DEVICE_STATUS_OK) { | 192 if (device_info.device_status() != media::OUTPUT_DEVICE_STATUS_OK) { |
87 sink_cache_->ReleaseSink(sink.get()); | 193 sink_cache_->ReleaseSink(sink.get()); |
88 sink->Stop(); | 194 sink->Stop(); |
89 return nullptr; | 195 return nullptr; |
90 } | 196 } |
91 | 197 |
92 // On ChromeOS as well as when a fake device is used, we can rely on the | 198 const media::AudioParameters& mixer_output_params = |
93 // playback device to handle resampling, so don't waste cycles on it here. | 199 GetMixerOutputParams(input_params, device_info.output_params(), latency); |
94 int sample_rate = params.sample_rate(); | 200 media::AudioRendererMixer* mixer = new media::AudioRendererMixer( |
95 int buffer_size = | 201 mixer_output_params, sink, base::Bind(LogMixerUmaHistogram, latency)); |
96 media::AudioHardwareConfig::GetHighLatencyBufferSize(sample_rate, 0); | |
97 | |
98 #if !defined(OS_CHROMEOS) | |
99 const media::AudioParameters& hardware_params = device_info.output_params(); | |
100 | |
101 // If we have valid, non-fake hardware parameters, use them. Otherwise, pass | |
102 // on the input params and let the browser side handle automatic fallback. | |
103 if (hardware_params.format() != media::AudioParameters::AUDIO_FAKE && | |
104 hardware_params.IsValid()) { | |
105 sample_rate = hardware_params.sample_rate(); | |
106 buffer_size = media::AudioHardwareConfig::GetHighLatencyBufferSize( | |
107 sample_rate, hardware_params.frames_per_buffer()); | |
108 } | |
109 #endif | |
110 | |
111 // Create output parameters based on the audio hardware configuration for | |
112 // passing on to the output sink. Force to 16-bit output for now since we | |
113 // know that works everywhere; ChromeOS does not support other bit depths. | |
114 media::AudioParameters output_params( | |
115 media::AudioParameters::AUDIO_PCM_LOW_LATENCY, params.channel_layout(), | |
116 sample_rate, 16, buffer_size); | |
117 DCHECK(output_params.IsValid()); | |
118 | |
119 media::AudioRendererMixer* mixer = | |
120 new media::AudioRendererMixer(output_params, sink); | |
121 AudioRendererMixerReference mixer_reference = {mixer, 1, sink.get()}; | 202 AudioRendererMixerReference mixer_reference = {mixer, 1, sink.get()}; |
122 mixers_[key] = mixer_reference; | 203 mixers_[key] = mixer_reference; |
204 DVLOG(1) << __FUNCTION__ << " mixer: " << mixer << " latency: " << latency | |
205 << "\n input: " << input_params.AsHumanReadableString() | |
206 << "\noutput: " << mixer_output_params.AsHumanReadableString(); | |
123 return mixer; | 207 return mixer; |
124 } | 208 } |
125 | 209 |
126 void AudioRendererMixerManager::ReturnMixer( | 210 void AudioRendererMixerManager::ReturnMixer(media::AudioRendererMixer* mixer) { |
127 int source_render_frame_id, | |
128 const media::AudioParameters& params, | |
129 const std::string& device_id, | |
130 const url::Origin& security_origin) { | |
131 const MixerKey key(source_render_frame_id, params, device_id, | |
132 security_origin); | |
133 base::AutoLock auto_lock(mixers_lock_); | 211 base::AutoLock auto_lock(mixers_lock_); |
134 | 212 AudioRendererMixerMap::iterator it = std::find_if( |
135 AudioRendererMixerMap::iterator it = mixers_.find(key); | 213 mixers_.begin(), mixers_.end(), |
214 [mixer](const std::pair<MixerKey, AudioRendererMixerReference>& val) { | |
215 return val.second.mixer == mixer; | |
216 }); | |
136 DCHECK(it != mixers_.end()); | 217 DCHECK(it != mixers_.end()); |
137 | 218 |
138 // Only remove the mixer if AudioRendererMixerManager is the last owner. | 219 // Only remove the mixer if AudioRendererMixerManager is the last owner. |
139 it->second.ref_count--; | 220 it->second.ref_count--; |
140 if (it->second.ref_count == 0) { | 221 if (it->second.ref_count == 0) { |
141 // The mixer will be deleted now, so release the sink. | 222 // The mixer will be deleted now, so release the sink. |
142 sink_cache_->ReleaseSink(it->second.sink_ptr); | 223 sink_cache_->ReleaseSink(it->second.sink_ptr); |
143 delete it->second.mixer; | 224 delete it->second.mixer; |
144 mixers_.erase(it); | 225 mixers_.erase(it); |
145 } | 226 } |
146 } | 227 } |
147 | 228 |
148 media::OutputDeviceInfo AudioRendererMixerManager::GetOutputDeviceInfo( | 229 media::OutputDeviceInfo AudioRendererMixerManager::GetOutputDeviceInfo( |
149 int source_render_frame_id, | 230 int source_render_frame_id, |
150 int session_id, | 231 int session_id, |
151 const std::string& device_id, | 232 const std::string& device_id, |
152 const url::Origin& security_origin) { | 233 const url::Origin& security_origin) { |
153 return sink_cache_->GetSinkInfo(source_render_frame_id, session_id, device_id, | 234 return sink_cache_->GetSinkInfo(source_render_frame_id, session_id, device_id, |
154 security_origin); | 235 security_origin); |
155 } | 236 } |
156 | 237 |
157 AudioRendererMixerManager::MixerKey::MixerKey( | 238 AudioRendererMixerManager::MixerKey::MixerKey( |
158 int source_render_frame_id, | 239 int source_render_frame_id, |
159 const media::AudioParameters& params, | 240 const media::AudioParameters& params, |
241 media::AudioLatency::LatencyType latency, | |
160 const std::string& device_id, | 242 const std::string& device_id, |
161 const url::Origin& security_origin) | 243 const url::Origin& security_origin) |
162 : source_render_frame_id(source_render_frame_id), | 244 : source_render_frame_id(source_render_frame_id), |
163 params(params), | 245 params(params), |
246 latency(latency), | |
164 device_id(device_id), | 247 device_id(device_id), |
165 security_origin(security_origin) {} | 248 security_origin(security_origin) {} |
166 | 249 |
167 AudioRendererMixerManager::MixerKey::MixerKey(const MixerKey& other) = default; | 250 AudioRendererMixerManager::MixerKey::MixerKey(const MixerKey& other) = default; |
168 | 251 |
169 } // namespace content | 252 } // namespace content |
OLD | NEW |