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 media::AudioOutputDevice* NewOutputDevice(int render_frame_id, |
| 25 int session_id, |
| 26 const std::string& device_id, |
| 27 const url::Origin& security_origin) { |
| 28 AudioMessageFilter* const filter = AudioMessageFilter::Get(); |
| 29 media::AudioOutputDevice* device = new media::AudioOutputDevice( |
| 30 filter->CreateAudioOutputIPC(render_frame_id), filter->io_task_runner(), |
| 31 session_id, device_id, security_origin); |
| 32 device->RequestDeviceAuthorization(); |
| 33 return device; |
| 34 } |
| 35 |
24 // This is where we decide which audio will go to mixers and which one to | 36 // This is where we decide which audio will go to mixers and which one to |
25 // AudioOutpuDevice directly. | 37 // AudioOutpuDevice directly. |
26 bool IsMixable(AudioDeviceFactory::SourceType source_type) { | 38 bool IsMixable(AudioDeviceFactory::SourceType source_type) { |
27 if (source_type == AudioDeviceFactory::kSourceMediaElement) | 39 if (source_type == AudioDeviceFactory::kSourceMediaElement) |
28 return true; // Must ALWAYS go through mixer. | 40 return true; // Must ALWAYS go through mixer. |
29 | 41 |
30 // TODO(olka): make a decision for the rest of the sources basing on OS | 42 // TODO(olka): make a decision for the rest of the sources basing on OS |
31 // type and configuration parameters. | 43 // type and configuration parameters. |
32 return false; | 44 return false; |
33 } | 45 } |
34 | 46 |
35 scoped_refptr<media::RestartableAudioRendererSink> NewMixableSink( | 47 scoped_refptr<media::SwitchableAudioRendererSink> NewMixableSink( |
36 int render_frame_id, | 48 int render_frame_id, |
37 const std::string& device_id, | 49 const std::string& device_id, |
38 const url::Origin& security_origin) { | 50 const url::Origin& security_origin) { |
39 RenderThreadImpl* render_thread = RenderThreadImpl::current(); | 51 RenderThreadImpl* render_thread = RenderThreadImpl::current(); |
40 return scoped_refptr<media::AudioRendererMixerInput>( | 52 return scoped_refptr<media::AudioRendererMixerInput>( |
41 render_thread->GetAudioRendererMixerManager()->CreateInput( | 53 render_thread->GetAudioRendererMixerManager()->CreateInput( |
42 render_frame_id, device_id, security_origin)); | 54 render_frame_id, device_id, security_origin)); |
43 } | 55 } |
44 | 56 |
45 scoped_refptr<media::AudioRendererSink> NewUnmixableSink( | 57 scoped_refptr<media::AudioRendererSink> NewUnmixableSink( |
46 int render_frame_id, | 58 int render_frame_id, |
47 int session_id, | 59 int session_id, |
48 const std::string& device_id, | 60 const std::string& device_id, |
49 const url::Origin& security_origin) { | 61 const url::Origin& security_origin) { |
50 return AudioDeviceFactory::NewOutputDevice(render_frame_id, session_id, | 62 return NewOutputDevice(render_frame_id, session_id, device_id, |
51 device_id, security_origin); | 63 security_origin); |
52 } | 64 } |
53 | 65 |
54 } // namespace | 66 } // namespace |
55 | 67 |
56 // static | 68 scoped_refptr<media::AudioRendererSink> |
57 scoped_refptr<media::AudioOutputDevice> AudioDeviceFactory::NewOutputDevice( | 69 AudioDeviceFactory::NewAudioRendererMixerSink( |
58 int render_frame_id, | 70 int render_frame_id, |
59 int session_id, | 71 int session_id, |
60 const std::string& device_id, | 72 const std::string& device_id, |
61 const url::Origin& security_origin) { | 73 const url::Origin& security_origin) { |
62 if (factory_) { | 74 if (factory_) { |
63 media::AudioOutputDevice* const device = factory_->CreateOutputDevice( | 75 media::AudioRendererSink* const sink = |
64 render_frame_id, session_id, device_id, security_origin); | 76 factory_->CreateAudioRendererMixerSink(render_frame_id, session_id, |
65 if (device) | 77 device_id, security_origin); |
66 return device; | 78 if (sink) |
| 79 return sink; |
67 } | 80 } |
68 | 81 return NewOutputDevice(render_frame_id, session_id, device_id, |
69 AudioMessageFilter* const filter = AudioMessageFilter::Get(); | 82 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 } | 83 } |
76 | 84 |
77 // static | 85 // static |
78 scoped_refptr<media::AudioRendererSink> | 86 scoped_refptr<media::AudioRendererSink> |
79 AudioDeviceFactory::NewAudioRendererSink(SourceType source_type, | 87 AudioDeviceFactory::NewAudioRendererSink(SourceType source_type, |
80 int render_frame_id, | 88 int render_frame_id, |
81 int session_id, | 89 int session_id, |
82 const std::string& device_id, | 90 const std::string& device_id, |
83 const url::Origin& security_origin) { | 91 const url::Origin& security_origin) { |
84 if (factory_) { | 92 if (factory_) { |
85 media::AudioRendererSink* const device = factory_->CreateAudioRendererSink( | 93 media::AudioRendererSink* const device = factory_->CreateAudioRendererSink( |
86 source_type, render_frame_id, session_id, device_id, security_origin); | 94 source_type, render_frame_id, session_id, device_id, security_origin); |
87 if (device) | 95 if (device) |
88 return device; | 96 return device; |
89 } | 97 } |
90 | 98 |
91 if (IsMixable(source_type)) | 99 if (IsMixable(source_type)) |
92 return NewMixableSink(render_frame_id, device_id, security_origin); | 100 return NewMixableSink(render_frame_id, device_id, security_origin); |
93 | 101 |
94 return NewUnmixableSink(render_frame_id, session_id, device_id, | 102 return NewUnmixableSink(render_frame_id, session_id, device_id, |
95 security_origin); | 103 security_origin); |
96 } | 104 } |
97 | 105 |
98 // static | 106 // static |
99 scoped_refptr<media::RestartableAudioRendererSink> | 107 scoped_refptr<media::SwitchableAudioRendererSink> |
100 AudioDeviceFactory::NewRestartableAudioRendererSink( | 108 AudioDeviceFactory::NewSwitchableAudioRendererSink( |
101 SourceType source_type, | 109 SourceType source_type, |
102 int render_frame_id, | 110 int render_frame_id, |
103 int session_id, | 111 int session_id, |
104 const std::string& device_id, | 112 const std::string& device_id, |
105 const url::Origin& security_origin) { | 113 const url::Origin& security_origin) { |
106 if (factory_) { | 114 if (factory_) { |
107 media::RestartableAudioRendererSink* const device = | 115 media::SwitchableAudioRendererSink* const sink = |
108 factory_->CreateRestartableAudioRendererSink( | 116 factory_->CreateSwitchableAudioRendererSink(source_type, |
109 source_type, render_frame_id, session_id, device_id, | 117 render_frame_id, session_id, |
110 security_origin); | 118 device_id, security_origin); |
111 if (device) | 119 if (sink) |
112 return device; | 120 return sink; |
113 } | 121 } |
114 | 122 |
115 if (IsMixable(source_type)) | 123 if (IsMixable(source_type)) |
116 return NewMixableSink(render_frame_id, device_id, security_origin); | 124 return NewMixableSink(render_frame_id, device_id, security_origin); |
117 | 125 |
118 // AudioOutputDevice is not RestartableAudioRendererSink, so we can't return | 126 // AudioOutputDevice is not RestartableAudioRendererSink, so we can't return |
119 // anything for those who wants to create an unmixable sink. | 127 // anything for those who wants to create an unmixable sink. |
120 NOTIMPLEMENTED(); | 128 NOTIMPLEMENTED(); |
121 return nullptr; | 129 return nullptr; |
122 } | 130 } |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
155 AudioDeviceFactory::AudioDeviceFactory() { | 163 AudioDeviceFactory::AudioDeviceFactory() { |
156 DCHECK(!factory_) << "Can't register two factories at once."; | 164 DCHECK(!factory_) << "Can't register two factories at once."; |
157 factory_ = this; | 165 factory_ = this; |
158 } | 166 } |
159 | 167 |
160 AudioDeviceFactory::~AudioDeviceFactory() { | 168 AudioDeviceFactory::~AudioDeviceFactory() { |
161 factory_ = NULL; | 169 factory_ = NULL; |
162 } | 170 } |
163 | 171 |
164 } // namespace content | 172 } // namespace content |
OLD | NEW |