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_device_factory.h" | 5 #include "content/renderer/media/audio_device_factory.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 | 8 |
9 #include "base/logging.h" | 9 #include "base/logging.h" |
10 #include "content/common/content_constants_internal.h" | 10 #include "content/common/content_constants_internal.h" |
11 #include "content/renderer/media/audio_input_message_filter.h" | 11 #include "content/renderer/media/audio_input_message_filter.h" |
12 #include "content/renderer/media/audio_message_filter.h" | 12 #include "content/renderer/media/audio_message_filter.h" |
13 #include "content/renderer/media/audio_renderer_mixer_manager.h" | 13 #include "content/renderer/media/audio_renderer_mixer_manager.h" |
14 #include "content/renderer/render_thread_impl.h" | 14 #include "content/renderer/render_thread_impl.h" |
15 #include "media/audio/audio_input_device.h" | 15 #include "media/audio/audio_input_device.h" |
16 #include "media/audio/audio_output_device.h" | 16 #include "media/audio/audio_output_device.h" |
17 #include "media/base/audio_latency.h" | |
17 #include "media/base/audio_renderer_mixer_input.h" | 18 #include "media/base/audio_renderer_mixer_input.h" |
18 #include "url/origin.h" | 19 #include "url/origin.h" |
19 | 20 |
20 namespace content { | 21 namespace content { |
21 | 22 |
22 // static | 23 // static |
23 AudioDeviceFactory* AudioDeviceFactory::factory_ = NULL; | 24 AudioDeviceFactory* AudioDeviceFactory::factory_ = NULL; |
24 | 25 |
25 namespace { | 26 namespace { |
26 const int64_t kMaxAuthorizationTimeoutMs = 4000; | 27 const int64_t kMaxAuthorizationTimeoutMs = 4000; |
27 | 28 |
29 media::AudioLatency::LatencyType GetSourceLatencyType( | |
30 AudioDeviceFactory::SourceType source) { | |
31 switch (source) { | |
32 case AudioDeviceFactory::kSourceWebAudioInteractive: | |
33 return media::AudioLatency::LATENCY_INTERACTIVE; | |
34 case AudioDeviceFactory::kSourceNone: | |
35 case AudioDeviceFactory::kSourceWebRtc: | |
36 case AudioDeviceFactory::kSourceNonRtcAudioTrack: | |
37 case AudioDeviceFactory::kSourceWebAudioBalanced: | |
38 return media::AudioLatency::LATENCY_RTC; | |
39 case AudioDeviceFactory::kSourceMediaElement: | |
40 case AudioDeviceFactory::kSourceWebAudioPlayback: | |
41 return media::AudioLatency::LATENCY_PLAYBACK; | |
42 case AudioDeviceFactory::kSourceWebAudioExact: | |
43 return media::AudioLatency::LATENCY_EXACT_MS; | |
44 } | |
45 NOTREACHED(); | |
tommi (sloooow) - chröme
2016/06/28 14:14:54
does this compile on all platforms?
| |
46 } | |
47 | |
28 scoped_refptr<media::AudioOutputDevice> NewOutputDevice( | 48 scoped_refptr<media::AudioOutputDevice> NewOutputDevice( |
29 int render_frame_id, | 49 int render_frame_id, |
30 int session_id, | 50 int session_id, |
31 const std::string& device_id, | 51 const std::string& device_id, |
32 const url::Origin& security_origin) { | 52 const url::Origin& security_origin) { |
33 AudioMessageFilter* const filter = AudioMessageFilter::Get(); | 53 AudioMessageFilter* const filter = AudioMessageFilter::Get(); |
34 scoped_refptr<media::AudioOutputDevice> device(new media::AudioOutputDevice( | 54 scoped_refptr<media::AudioOutputDevice> device(new media::AudioOutputDevice( |
35 filter->CreateAudioOutputIPC(render_frame_id), filter->io_task_runner(), | 55 filter->CreateAudioOutputIPC(render_frame_id), filter->io_task_runner(), |
36 session_id, device_id, security_origin, | 56 session_id, device_id, security_origin, |
37 // Set authorization request timeout at 80% of renderer hung timeout, but | 57 // Set authorization request timeout at 80% of renderer hung timeout, but |
38 // no more than kMaxAuthorizationTimeout. | 58 // no more than kMaxAuthorizationTimeout. |
39 base::TimeDelta::FromMilliseconds(std::min(kHungRendererDelayMs * 8 / 10, | 59 base::TimeDelta::FromMilliseconds(std::min(kHungRendererDelayMs * 8 / 10, |
40 kMaxAuthorizationTimeoutMs)))); | 60 kMaxAuthorizationTimeoutMs)))); |
41 device->RequestDeviceAuthorization(); | 61 device->RequestDeviceAuthorization(); |
42 return device; | 62 return device; |
43 } | 63 } |
44 | 64 |
45 // This is where we decide which audio will go to mixers and which one to | 65 // This is where we decide which audio will go to mixers and which one to |
46 // AudioOutpuDevice directly. | 66 // AudioOutpuDevice directly. |
47 bool IsMixable(AudioDeviceFactory::SourceType source_type) { | 67 bool IsMixable(AudioDeviceFactory::SourceType source_type) { |
48 if (source_type == AudioDeviceFactory::kSourceMediaElement) | 68 if (source_type == AudioDeviceFactory::kSourceMediaElement) |
49 return true; // Must ALWAYS go through mixer. | 69 return true; // Must ALWAYS go through mixer. |
50 | 70 |
51 // TODO(olka): make a decision for the rest of the sources basing on OS | 71 // TODO(olka): make a decision for the rest of the sources basing on OS |
52 // type and configuration parameters. | 72 // type and configuration parameters. |
53 return false; | 73 return false; |
54 } | 74 } |
55 | 75 |
56 scoped_refptr<media::SwitchableAudioRendererSink> NewMixableSink( | 76 scoped_refptr<media::SwitchableAudioRendererSink> NewMixableSink( |
77 AudioDeviceFactory::SourceType source_type, | |
57 int render_frame_id, | 78 int render_frame_id, |
58 int session_id, | 79 int session_id, |
59 const std::string& device_id, | 80 const std::string& device_id, |
60 const url::Origin& security_origin) { | 81 const url::Origin& security_origin) { |
61 RenderThreadImpl* render_thread = RenderThreadImpl::current(); | 82 RenderThreadImpl* render_thread = RenderThreadImpl::current(); |
62 return scoped_refptr<media::AudioRendererMixerInput>( | 83 return scoped_refptr<media::AudioRendererMixerInput>( |
63 render_thread->GetAudioRendererMixerManager()->CreateInput( | 84 render_thread->GetAudioRendererMixerManager()->CreateInput( |
64 render_frame_id, session_id, device_id, security_origin)); | 85 render_frame_id, session_id, device_id, security_origin, |
86 GetSourceLatencyType(source_type))); | |
65 } | 87 } |
66 | 88 |
67 } // namespace | 89 } // namespace |
68 | 90 |
69 scoped_refptr<media::AudioRendererSink> | 91 scoped_refptr<media::AudioRendererSink> |
70 AudioDeviceFactory::NewAudioRendererMixerSink( | 92 AudioDeviceFactory::NewAudioRendererMixerSink( |
71 int render_frame_id, | 93 int render_frame_id, |
72 int session_id, | 94 int session_id, |
73 const std::string& device_id, | 95 const std::string& device_id, |
74 const url::Origin& security_origin) { | 96 const url::Origin& security_origin) { |
(...skipping 11 matching lines...) Expand all Loading... | |
86 if (factory_) { | 108 if (factory_) { |
87 scoped_refptr<media::AudioRendererSink> device = | 109 scoped_refptr<media::AudioRendererSink> device = |
88 factory_->CreateAudioRendererSink(source_type, render_frame_id, | 110 factory_->CreateAudioRendererSink(source_type, render_frame_id, |
89 session_id, device_id, | 111 session_id, device_id, |
90 security_origin); | 112 security_origin); |
91 if (device) | 113 if (device) |
92 return device; | 114 return device; |
93 } | 115 } |
94 | 116 |
95 if (IsMixable(source_type)) | 117 if (IsMixable(source_type)) |
96 return NewMixableSink(render_frame_id, session_id, device_id, | 118 return NewMixableSink(source_type, render_frame_id, session_id, device_id, |
97 security_origin); | 119 security_origin); |
98 | 120 |
99 return NewFinalAudioRendererSink(render_frame_id, session_id, device_id, | 121 return NewFinalAudioRendererSink(render_frame_id, session_id, device_id, |
100 security_origin); | 122 security_origin); |
101 } | 123 } |
102 | 124 |
103 // static | 125 // static |
104 scoped_refptr<media::SwitchableAudioRendererSink> | 126 scoped_refptr<media::SwitchableAudioRendererSink> |
105 AudioDeviceFactory::NewSwitchableAudioRendererSink( | 127 AudioDeviceFactory::NewSwitchableAudioRendererSink( |
106 SourceType source_type, | 128 SourceType source_type, |
107 int render_frame_id, | 129 int render_frame_id, |
108 int session_id, | 130 int session_id, |
109 const std::string& device_id, | 131 const std::string& device_id, |
110 const url::Origin& security_origin) { | 132 const url::Origin& security_origin) { |
111 if (factory_) { | 133 if (factory_) { |
112 scoped_refptr<media::SwitchableAudioRendererSink> sink = | 134 scoped_refptr<media::SwitchableAudioRendererSink> sink = |
113 factory_->CreateSwitchableAudioRendererSink(source_type, | 135 factory_->CreateSwitchableAudioRendererSink(source_type, |
114 render_frame_id, session_id, | 136 render_frame_id, session_id, |
115 device_id, security_origin); | 137 device_id, security_origin); |
116 if (sink) | 138 if (sink) |
117 return sink; | 139 return sink; |
118 } | 140 } |
119 | 141 |
120 if (IsMixable(source_type)) | 142 if (IsMixable(source_type)) |
121 return NewMixableSink(render_frame_id, session_id, device_id, | 143 return NewMixableSink(source_type, render_frame_id, session_id, device_id, |
122 security_origin); | 144 security_origin); |
123 | 145 |
124 // AudioOutputDevice is not RestartableAudioRendererSink, so we can't return | 146 // AudioOutputDevice is not RestartableAudioRendererSink, so we can't return |
125 // anything for those who wants to create an unmixable sink. | 147 // anything for those who wants to create an unmixable sink. |
126 NOTIMPLEMENTED(); | 148 NOTIMPLEMENTED(); |
127 return nullptr; | 149 return nullptr; |
128 } | 150 } |
129 | 151 |
130 // static | 152 // static |
131 scoped_refptr<media::AudioCapturerSource> | 153 scoped_refptr<media::AudioCapturerSource> |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
177 device_id, security_origin); | 199 device_id, security_origin); |
178 if (sink) | 200 if (sink) |
179 return sink; | 201 return sink; |
180 } | 202 } |
181 | 203 |
182 return NewOutputDevice(render_frame_id, session_id, device_id, | 204 return NewOutputDevice(render_frame_id, session_id, device_id, |
183 security_origin); | 205 security_origin); |
184 } | 206 } |
185 | 207 |
186 } // namespace content | 208 } // namespace content |
OLD | NEW |