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 input parameters and audio | |
23 // hardware configuration. | |
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_bufffer_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 hadrware 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_bufffer_size = | |
43 hardware_params.frames_per_buffer(); | |
44 } | |
45 #endif | |
46 | |
47 int output_buffer_size = 0; | |
48 | |
49 switch (latency) { | |
50 case media::AudioLatency::LATENCY_INTERACTIVE: | |
51 // WebAudio should provide correct callback size in frames; it does not | |
52 // depend on the sample rate. | |
53 output_buffer_size = media::AudioLatency::GetInteractiveBufferSize( | |
54 hardware_params.frames_per_buffer()); | |
55 break; | |
56 case media::AudioLatency::LATENCY_RTC: | |
57 // adjust output buffer size according to the latency requirement. | |
58 output_buffer_size = media::AudioLatency::GetRtcBufferSize( | |
59 output_sample_rate, valid_not_fake_hardware_params | |
60 ? hardware_params.frames_per_buffer() | |
61 : 0); | |
62 break; | |
63 case media::AudioLatency::LATENCY_PLAYBACK: | |
64 // adjust output buffer size according to the latency requirement. | |
65 output_buffer_size = media::AudioLatency::GetHighLatencyBufferSize( | |
66 output_sample_rate, preferred_high_latency_output_bufffer_size); | |
67 break; | |
68 case media::AudioLatency::LATENCY_EXACT_MS: | |
69 // TODO(olka): add support when WebAudio requires it. | |
70 default: | |
71 NOTREACHED(); | |
72 } | |
73 DCHECK(output_buffer_size); | |
74 | |
75 // Force to 16-bit output for now since we know that works everywhere; | |
76 // ChromeOS does not support other bit depths. | |
77 return media::AudioParameters(input_params.format(), | |
78 input_params.channel_layout(), | |
79 output_sample_rate, 16, output_buffer_size); | |
80 } | |
81 | |
82 const std::string GetMixerUmaHistogramName( | |
83 media::AudioLatency::LatencyType latency) { | |
84 switch (latency) { | |
85 case media::AudioLatency::LATENCY_EXACT_MS: | |
86 return "Media.Audio.Render.AudioInputsPerMixer.LatencyExact"; | |
87 case media::AudioLatency::LATENCY_INTERACTIVE: | |
88 return "Media.Audio.Render.AudioInputsPerMixer.LatencyInteractive"; | |
89 case media::AudioLatency::LATENCY_RTC: | |
90 return "Media.Audio.Render.AudioInputsPerMixer.LatencyRtc"; | |
91 case media::AudioLatency::LATENCY_PLAYBACK: | |
92 return "Media.Audio.Render.AudioInputsPerMixer.LatencyPlayback"; | |
93 default: | |
94 NOTREACHED(); | |
95 } | |
96 } | |
97 } // namespace | |
98 | |
19 namespace content { | 99 namespace content { |
20 | 100 |
21 AudioRendererMixerManager::AudioRendererMixerManager( | 101 AudioRendererMixerManager::AudioRendererMixerManager( |
22 std::unique_ptr<AudioRendererSinkCache> sink_cache) | 102 std::unique_ptr<AudioRendererSinkCache> sink_cache) |
23 : sink_cache_(std::move(sink_cache)) { | 103 : sink_cache_(std::move(sink_cache)) { |
24 DCHECK(sink_cache_); | 104 DCHECK(sink_cache_); |
25 } | 105 } |
26 | 106 |
27 AudioRendererMixerManager::~AudioRendererMixerManager() { | 107 AudioRendererMixerManager::~AudioRendererMixerManager() { |
28 // References to AudioRendererMixers may be owned by garbage collected | 108 // References to AudioRendererMixers may be owned by garbage collected |
29 // objects. During process shutdown they may be leaked, so, transitively, | 109 // 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. | 110 // |mixers_| may leak (i.e., may be non-empty at this time) as well. |
o1ka
2016/06/28 15:51:28
This means mixer destructor is never called and we
| |
111 | |
112 if (std::size_t subset_value = latency_map_.to_ulong()) { | |
113 LOCAL_HISTOGRAM_CUSTOM_COUNTS("Media.Audio.Render.AudioMixing.LatencyMap", | |
o1ka
2016/06/28 15:51:28
The problem is that the destructor for RendererThr
o1ka
2016/06/28 16:05:32
Looks like we need to send updates to the browser
o1ka
2016/06/28 17:16:08
Another option is to log the values each time they
| |
114 subset_value, 1, 0xff, 0xff); | |
115 } | |
31 } | 116 } |
32 | 117 |
33 // static | 118 // static |
34 std::unique_ptr<AudioRendererMixerManager> AudioRendererMixerManager::Create() { | 119 std::unique_ptr<AudioRendererMixerManager> AudioRendererMixerManager::Create() { |
35 return base::WrapUnique( | 120 return base::WrapUnique( |
36 new AudioRendererMixerManager(AudioRendererSinkCache::Create())); | 121 new AudioRendererMixerManager(AudioRendererSinkCache::Create())); |
37 } | 122 } |
38 | 123 |
39 media::AudioRendererMixerInput* AudioRendererMixerManager::CreateInput( | 124 media::AudioRendererMixerInput* AudioRendererMixerManager::CreateInput( |
40 int source_render_frame_id, | 125 int source_render_frame_id, |
41 int session_id, | 126 int session_id, |
42 const std::string& device_id, | 127 const std::string& device_id, |
43 const url::Origin& security_origin) { | 128 const url::Origin& security_origin, |
129 media::AudioLatency::LatencyType latency) { | |
44 // AudioRendererMixerManager lives on the renderer thread and is destroyed on | 130 // 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 | 131 // renderer thread destruction, so it's safe to pass its pointer to a mixer |
46 // input. | 132 // input. |
47 return new media::AudioRendererMixerInput( | 133 return new media::AudioRendererMixerInput( |
48 this, source_render_frame_id, | 134 this, source_render_frame_id, |
49 media::AudioDeviceDescription::UseSessionIdToSelectDevice(session_id, | 135 media::AudioDeviceDescription::UseSessionIdToSelectDevice(session_id, |
50 device_id) | 136 device_id) |
51 ? GetOutputDeviceInfo(source_render_frame_id, session_id, device_id, | 137 ? GetOutputDeviceInfo(source_render_frame_id, session_id, device_id, |
52 security_origin) | 138 security_origin) |
53 .device_id() | 139 .device_id() |
54 : device_id, | 140 : device_id, |
55 security_origin); | 141 security_origin, latency); |
56 } | 142 } |
57 | 143 |
58 media::AudioRendererMixer* AudioRendererMixerManager::GetMixer( | 144 media::AudioRendererMixer* AudioRendererMixerManager::GetMixer( |
59 int source_render_frame_id, | 145 int source_render_frame_id, |
60 const media::AudioParameters& params, | 146 const media::AudioParameters& input_params, |
147 media::AudioLatency::LatencyType latency, | |
61 const std::string& device_id, | 148 const std::string& device_id, |
62 const url::Origin& security_origin, | 149 const url::Origin& security_origin, |
63 media::OutputDeviceStatus* device_status) { | 150 media::OutputDeviceStatus* device_status) { |
64 // Effects are not passed through to output creation, so ensure none are set. | 151 // Effects are not passed through to output creation, so ensure none are set. |
65 DCHECK_EQ(params.effects(), media::AudioParameters::NO_EFFECTS); | 152 DCHECK_EQ(input_params.effects(), media::AudioParameters::NO_EFFECTS); |
66 | 153 |
67 const MixerKey key(source_render_frame_id, params, device_id, | 154 const MixerKey key(source_render_frame_id, input_params, latency, device_id, |
68 security_origin); | 155 security_origin); |
69 base::AutoLock auto_lock(mixers_lock_); | 156 base::AutoLock auto_lock(mixers_lock_); |
70 | 157 |
158 // Update latency map when the mixer is requested, i.e. there is an attempt to | |
159 // mix and output audio with a given latency. This is opposite to | |
160 // CreateInput() which creates a sink which is probably never used for output. | |
161 latency_map_[latency] = 1; | |
162 | |
71 AudioRendererMixerMap::iterator it = mixers_.find(key); | 163 AudioRendererMixerMap::iterator it = mixers_.find(key); |
72 if (it != mixers_.end()) { | 164 if (it != mixers_.end()) { |
73 if (device_status) | 165 if (device_status) |
74 *device_status = media::OUTPUT_DEVICE_STATUS_OK; | 166 *device_status = media::OUTPUT_DEVICE_STATUS_OK; |
75 | 167 |
76 it->second.ref_count++; | 168 it->second.ref_count++; |
169 DVLOG(1) << "Reusing mixer: " << it->second.mixer; | |
77 return it->second.mixer; | 170 return it->second.mixer; |
78 } | 171 } |
79 | 172 |
80 scoped_refptr<media::AudioRendererSink> sink = | 173 scoped_refptr<media::AudioRendererSink> sink = |
81 sink_cache_->GetSink(source_render_frame_id, device_id, security_origin); | 174 sink_cache_->GetSink(source_render_frame_id, device_id, security_origin); |
82 | 175 |
83 const media::OutputDeviceInfo& device_info = sink->GetOutputDeviceInfo(); | 176 const media::OutputDeviceInfo& device_info = sink->GetOutputDeviceInfo(); |
84 if (device_status) | 177 if (device_status) |
85 *device_status = device_info.device_status(); | 178 *device_status = device_info.device_status(); |
86 if (device_info.device_status() != media::OUTPUT_DEVICE_STATUS_OK) { | 179 if (device_info.device_status() != media::OUTPUT_DEVICE_STATUS_OK) { |
87 sink_cache_->ReleaseSink(sink.get()); | 180 sink_cache_->ReleaseSink(sink.get()); |
88 sink->Stop(); | 181 sink->Stop(); |
89 return nullptr; | 182 return nullptr; |
90 } | 183 } |
91 | 184 |
92 // On ChromeOS as well as when a fake device is used, we can rely on the | 185 const media::AudioParameters& mixer_output_params = |
93 // playback device to handle resampling, so don't waste cycles on it here. | 186 GetMixerOutputParams(input_params, device_info.output_params(), latency); |
94 int sample_rate = params.sample_rate(); | 187 media::AudioRendererMixer* mixer = new media::AudioRendererMixer( |
95 int buffer_size = | 188 mixer_output_params, sink, GetMixerUmaHistogramName(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()}; | 189 AudioRendererMixerReference mixer_reference = {mixer, 1, sink.get()}; |
122 mixers_[key] = mixer_reference; | 190 mixers_[key] = mixer_reference; |
191 DVLOG(1) << __FUNCTION__ << " mixer: " << mixer << " latency: " << latency | |
192 << "\n input: " << input_params.AsHumanReadableString() | |
193 << "\noutput: " << mixer_output_params.AsHumanReadableString(); | |
123 return mixer; | 194 return mixer; |
124 } | 195 } |
125 | 196 |
126 void AudioRendererMixerManager::ReturnMixer( | 197 void AudioRendererMixerManager::ReturnMixer( |
127 int source_render_frame_id, | 198 const media::AudioRendererMixer* mixer) { |
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_); | 199 base::AutoLock auto_lock(mixers_lock_); |
134 | 200 AudioRendererMixerMap::iterator it = std::find_if( |
135 AudioRendererMixerMap::iterator it = mixers_.find(key); | 201 mixers_.begin(), mixers_.end(), |
202 [mixer](const std::pair<MixerKey, AudioRendererMixerReference>& val) { | |
203 return val.second.mixer == mixer; | |
204 }); | |
136 DCHECK(it != mixers_.end()); | 205 DCHECK(it != mixers_.end()); |
137 | 206 |
138 // Only remove the mixer if AudioRendererMixerManager is the last owner. | 207 // Only remove the mixer if AudioRendererMixerManager is the last owner. |
139 it->second.ref_count--; | 208 it->second.ref_count--; |
140 if (it->second.ref_count == 0) { | 209 if (it->second.ref_count == 0) { |
141 // The mixer will be deleted now, so release the sink. | 210 // The mixer will be deleted now, so release the sink. |
142 sink_cache_->ReleaseSink(it->second.sink_ptr); | 211 sink_cache_->ReleaseSink(it->second.sink_ptr); |
143 delete it->second.mixer; | 212 delete it->second.mixer; |
144 mixers_.erase(it); | 213 mixers_.erase(it); |
145 } | 214 } |
146 } | 215 } |
147 | 216 |
148 media::OutputDeviceInfo AudioRendererMixerManager::GetOutputDeviceInfo( | 217 media::OutputDeviceInfo AudioRendererMixerManager::GetOutputDeviceInfo( |
149 int source_render_frame_id, | 218 int source_render_frame_id, |
150 int session_id, | 219 int session_id, |
151 const std::string& device_id, | 220 const std::string& device_id, |
152 const url::Origin& security_origin) { | 221 const url::Origin& security_origin) { |
153 return sink_cache_->GetSinkInfo(source_render_frame_id, session_id, device_id, | 222 return sink_cache_->GetSinkInfo(source_render_frame_id, session_id, device_id, |
154 security_origin); | 223 security_origin); |
155 } | 224 } |
156 | 225 |
157 AudioRendererMixerManager::MixerKey::MixerKey( | 226 AudioRendererMixerManager::MixerKey::MixerKey( |
158 int source_render_frame_id, | 227 int source_render_frame_id, |
159 const media::AudioParameters& params, | 228 const media::AudioParameters& params, |
229 media::AudioLatency::LatencyType latency, | |
160 const std::string& device_id, | 230 const std::string& device_id, |
161 const url::Origin& security_origin) | 231 const url::Origin& security_origin) |
162 : source_render_frame_id(source_render_frame_id), | 232 : source_render_frame_id(source_render_frame_id), |
163 params(params), | 233 params(params), |
234 latency(latency), | |
164 device_id(device_id), | 235 device_id(device_id), |
165 security_origin(security_origin) {} | 236 security_origin(security_origin) {} |
166 | 237 |
167 AudioRendererMixerManager::MixerKey::MixerKey(const MixerKey& other) = default; | 238 AudioRendererMixerManager::MixerKey::MixerKey(const MixerKey& other) = default; |
168 | 239 |
169 } // namespace content | 240 } // namespace content |
OLD | NEW |