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 "base/logging.h" | 7 #include "base/logging.h" |
8 #include "content/renderer/media/audio_input_message_filter.h" | 8 #include "content/renderer/media/audio_input_message_filter.h" |
9 #include "content/renderer/media/audio_message_filter.h" | 9 #include "content/renderer/media/audio_message_filter.h" |
10 #include "content/renderer/media/audio_renderer_mixer_manager.h" | 10 #include "content/renderer/media/audio_renderer_mixer_manager.h" |
11 #include "content/renderer/render_thread_impl.h" | 11 #include "content/renderer/render_thread_impl.h" |
12 #include "media/audio/audio_input_device.h" | 12 #include "media/audio/audio_input_device.h" |
13 #include "media/audio/audio_output_device.h" | 13 #include "media/audio/audio_output_device.h" |
14 #include "media/base/audio_renderer_mixer_input.h" | 14 #include "media/base/audio_renderer_mixer_input.h" |
15 #include "url/origin.h" | 15 #include "url/origin.h" |
16 | 16 |
17 namespace content { | 17 namespace content { |
18 | 18 |
19 // static | 19 // static |
20 AudioDeviceFactory* AudioDeviceFactory::factory_ = NULL; | 20 AudioDeviceFactory* AudioDeviceFactory::factory_ = NULL; |
21 | 21 |
22 namespace { | 22 namespace { |
23 | 23 |
| 24 scoped_refptr<media::AudioOutputDevice> NewOutputDevice( |
| 25 int render_frame_id, |
| 26 int session_id, |
| 27 const std::string& device_id, |
| 28 const url::Origin& security_origin) { |
| 29 AudioMessageFilter* const filter = AudioMessageFilter::Get(); |
| 30 scoped_refptr<media::AudioOutputDevice> device(new media::AudioOutputDevice( |
| 31 filter->CreateAudioOutputIPC(render_frame_id), filter->io_task_runner(), |
| 32 session_id, device_id, security_origin)); |
| 33 device->RequestDeviceAuthorization(); |
| 34 return device; |
| 35 } |
| 36 |
24 // This is where we decide which audio will go to mixers and which one to | 37 // This is where we decide which audio will go to mixers and which one to |
25 // AudioOutpuDevice directly. | 38 // AudioOutpuDevice directly. |
26 bool IsMixable(AudioDeviceFactory::SourceType source_type) { | 39 bool IsMixable(AudioDeviceFactory::SourceType source_type) { |
27 if (source_type == AudioDeviceFactory::kSourceMediaElement) | 40 if (source_type == AudioDeviceFactory::kSourceMediaElement) |
28 return true; // Must ALWAYS go through mixer. | 41 return true; // Must ALWAYS go through mixer. |
29 | 42 |
30 // TODO(olka): make a decision for the rest of the sources basing on OS | 43 // TODO(olka): make a decision for the rest of the sources basing on OS |
31 // type and configuration parameters. | 44 // type and configuration parameters. |
32 return false; | 45 return false; |
33 } | 46 } |
34 | 47 |
35 scoped_refptr<media::RestartableAudioRendererSink> NewMixableSink( | 48 scoped_refptr<media::SwitchableAudioRendererSink> NewMixableSink( |
36 int render_frame_id, | 49 int render_frame_id, |
37 const std::string& device_id, | 50 const std::string& device_id, |
38 const url::Origin& security_origin) { | 51 const url::Origin& security_origin) { |
39 RenderThreadImpl* render_thread = RenderThreadImpl::current(); | 52 RenderThreadImpl* render_thread = RenderThreadImpl::current(); |
40 return scoped_refptr<media::AudioRendererMixerInput>( | 53 return scoped_refptr<media::AudioRendererMixerInput>( |
41 render_thread->GetAudioRendererMixerManager()->CreateInput( | 54 render_thread->GetAudioRendererMixerManager()->CreateInput( |
42 render_frame_id, device_id, security_origin)); | 55 render_frame_id, device_id, security_origin)); |
43 } | 56 } |
44 | 57 |
45 scoped_refptr<media::AudioRendererSink> NewUnmixableSink( | 58 scoped_refptr<media::AudioRendererSink> NewUnmixableSink( |
46 int render_frame_id, | 59 int render_frame_id, |
47 int session_id, | 60 int session_id, |
48 const std::string& device_id, | 61 const std::string& device_id, |
49 const url::Origin& security_origin) { | 62 const url::Origin& security_origin) { |
50 return AudioDeviceFactory::NewOutputDevice(render_frame_id, session_id, | 63 return NewOutputDevice(render_frame_id, session_id, device_id, |
51 device_id, security_origin); | 64 security_origin); |
52 } | 65 } |
53 | 66 |
54 } // namespace | 67 } // namespace |
55 | 68 |
56 // static | 69 scoped_refptr<media::AudioRendererSink> |
57 scoped_refptr<media::AudioOutputDevice> AudioDeviceFactory::NewOutputDevice( | 70 AudioDeviceFactory::NewAudioRendererMixerSink( |
58 int render_frame_id, | 71 int render_frame_id, |
59 int session_id, | 72 int session_id, |
60 const std::string& device_id, | 73 const std::string& device_id, |
61 const url::Origin& security_origin) { | 74 const url::Origin& security_origin) { |
62 if (factory_) { | 75 if (factory_) { |
63 media::AudioOutputDevice* const device = factory_->CreateOutputDevice( | 76 scoped_refptr<media::AudioRendererSink> sink = |
64 render_frame_id, session_id, device_id, security_origin); | 77 factory_->CreateAudioRendererMixerSink(render_frame_id, session_id, |
65 if (device) | 78 device_id, security_origin); |
66 return device; | 79 if (sink) |
| 80 return sink; |
67 } | 81 } |
68 | 82 return NewOutputDevice(render_frame_id, session_id, device_id, |
69 AudioMessageFilter* const filter = AudioMessageFilter::Get(); | 83 security_origin); |
70 scoped_refptr<media::AudioOutputDevice> device = new media::AudioOutputDevice( | |
71 filter->CreateAudioOutputIPC(render_frame_id), filter->io_task_runner(), | |
72 session_id, device_id, security_origin); | |
73 device->RequestDeviceAuthorization(); | |
74 return device; | |
75 } | 84 } |
76 | 85 |
77 // static | 86 // static |
78 scoped_refptr<media::AudioRendererSink> | 87 scoped_refptr<media::AudioRendererSink> |
79 AudioDeviceFactory::NewAudioRendererSink(SourceType source_type, | 88 AudioDeviceFactory::NewAudioRendererSink(SourceType source_type, |
80 int render_frame_id, | 89 int render_frame_id, |
81 int session_id, | 90 int session_id, |
82 const std::string& device_id, | 91 const std::string& device_id, |
83 const url::Origin& security_origin) { | 92 const url::Origin& security_origin) { |
84 if (factory_) { | 93 if (factory_) { |
85 media::AudioRendererSink* const device = factory_->CreateAudioRendererSink( | 94 scoped_refptr<media::AudioRendererSink> device = |
86 source_type, render_frame_id, session_id, device_id, security_origin); | 95 factory_->CreateAudioRendererSink(source_type, render_frame_id, |
| 96 session_id, device_id, |
| 97 security_origin); |
87 if (device) | 98 if (device) |
88 return device; | 99 return device; |
89 } | 100 } |
90 | 101 |
91 if (IsMixable(source_type)) | 102 if (IsMixable(source_type)) |
92 return NewMixableSink(render_frame_id, device_id, security_origin); | 103 return NewMixableSink(render_frame_id, device_id, security_origin); |
93 | 104 |
94 return NewUnmixableSink(render_frame_id, session_id, device_id, | 105 return NewUnmixableSink(render_frame_id, session_id, device_id, |
95 security_origin); | 106 security_origin); |
96 } | 107 } |
97 | 108 |
98 // static | 109 // static |
99 scoped_refptr<media::RestartableAudioRendererSink> | 110 scoped_refptr<media::SwitchableAudioRendererSink> |
100 AudioDeviceFactory::NewRestartableAudioRendererSink( | 111 AudioDeviceFactory::NewSwitchableAudioRendererSink( |
101 SourceType source_type, | 112 SourceType source_type, |
102 int render_frame_id, | 113 int render_frame_id, |
103 int session_id, | 114 int session_id, |
104 const std::string& device_id, | 115 const std::string& device_id, |
105 const url::Origin& security_origin) { | 116 const url::Origin& security_origin) { |
106 if (factory_) { | 117 if (factory_) { |
107 media::RestartableAudioRendererSink* const device = | 118 scoped_refptr<media::SwitchableAudioRendererSink> sink = |
108 factory_->CreateRestartableAudioRendererSink( | 119 factory_->CreateSwitchableAudioRendererSink(source_type, |
109 source_type, render_frame_id, session_id, device_id, | 120 render_frame_id, session_id, |
110 security_origin); | 121 device_id, security_origin); |
111 if (device) | 122 if (sink) |
112 return device; | 123 return sink; |
113 } | 124 } |
114 | 125 |
115 if (IsMixable(source_type)) | 126 if (IsMixable(source_type)) |
116 return NewMixableSink(render_frame_id, device_id, security_origin); | 127 return NewMixableSink(render_frame_id, device_id, security_origin); |
117 | 128 |
118 // AudioOutputDevice is not RestartableAudioRendererSink, so we can't return | 129 // AudioOutputDevice is not RestartableAudioRendererSink, so we can't return |
119 // anything for those who wants to create an unmixable sink. | 130 // anything for those who wants to create an unmixable sink. |
120 NOTIMPLEMENTED(); | 131 NOTIMPLEMENTED(); |
121 return nullptr; | 132 return nullptr; |
122 } | 133 } |
123 | 134 |
124 // static | 135 // static |
125 scoped_refptr<media::AudioInputDevice> AudioDeviceFactory::NewInputDevice( | 136 scoped_refptr<media::AudioInputDevice> AudioDeviceFactory::NewInputDevice( |
126 int render_frame_id) { | 137 int render_frame_id) { |
127 if (factory_) { | 138 if (factory_) { |
128 media::AudioInputDevice* const device = | 139 scoped_refptr<media::AudioInputDevice> device = |
129 factory_->CreateInputDevice(render_frame_id); | 140 factory_->CreateInputDevice(render_frame_id); |
130 if (device) | 141 if (device) |
131 return device; | 142 return device; |
132 } | 143 } |
133 | 144 |
134 AudioInputMessageFilter* const filter = AudioInputMessageFilter::Get(); | 145 AudioInputMessageFilter* const filter = AudioInputMessageFilter::Get(); |
135 return new media::AudioInputDevice( | 146 return new media::AudioInputDevice( |
136 filter->CreateAudioInputIPC(render_frame_id), filter->io_task_runner()); | 147 filter->CreateAudioInputIPC(render_frame_id), filter->io_task_runner()); |
137 } | 148 } |
138 | 149 |
139 // static | 150 // static |
140 // TODO(http://crbug.com/587461): Find a better way to check if device exists | 151 // TODO(http://crbug.com/587461): Find a better way to check if device exists |
141 // and is authorized. | 152 // and is authorized. |
142 media::OutputDeviceStatus AudioDeviceFactory::GetOutputDeviceStatus( | 153 media::OutputDeviceInfo AudioDeviceFactory::GetOutputDeviceInfo( |
143 int render_frame_id, | 154 int render_frame_id, |
144 int session_id, | 155 int session_id, |
145 const std::string& device_id, | 156 const std::string& device_id, |
146 const url::Origin& security_origin) { | 157 const url::Origin& security_origin) { |
147 scoped_refptr<media::AudioOutputDevice> device = | 158 scoped_refptr<media::AudioOutputDevice> device = |
148 NewOutputDevice(render_frame_id, session_id, device_id, security_origin); | 159 NewOutputDevice(render_frame_id, session_id, device_id, security_origin); |
149 media::OutputDeviceStatus status = device->GetDeviceStatus(); | |
150 | 160 |
| 161 const media::OutputDeviceInfo& device_info = device->GetOutputDeviceInfo(); |
151 device->Stop(); // Must be stopped. | 162 device->Stop(); // Must be stopped. |
152 return status; | 163 return device_info; |
153 } | 164 } |
154 | 165 |
155 AudioDeviceFactory::AudioDeviceFactory() { | 166 AudioDeviceFactory::AudioDeviceFactory() { |
156 DCHECK(!factory_) << "Can't register two factories at once."; | 167 DCHECK(!factory_) << "Can't register two factories at once."; |
157 factory_ = this; | 168 factory_ = this; |
158 } | 169 } |
159 | 170 |
160 AudioDeviceFactory::~AudioDeviceFactory() { | 171 AudioDeviceFactory::~AudioDeviceFactory() { |
161 factory_ = NULL; | 172 factory_ = NULL; |
162 } | 173 } |
163 | 174 |
164 } // namespace content | 175 } // namespace content |
OLD | NEW |