1 /*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "AudioPolicyService"
18 //#define LOG_NDEBUG 0
19
20 #include "Configuration.h"
21 #undef __STRICT_ANSI__
22 #define __STDINT_LIMITS
23 #define __STDC_LIMIT_MACROS
24 #include <stdint.h>
25
26 #include <sys/time.h>
27 #include <binder/IServiceManager.h>
28 #include <utils/Log.h>
29 #include <cutils/properties.h>
30 #include <binder/IPCThreadState.h>
31 #include <utils/String16.h>
32 #include <utils/threads.h>
33 #include "AudioPolicyService.h"
34 #include "ServiceUtilities.h"
35 #include <hardware_legacy/power.h>
36 #include <media/AudioEffect.h>
37 #include <media/EffectsFactoryApi.h>
38 //#include <media/IAudioFlinger.h>
39
40 #include <hardware/hardware.h>
41 #include <system/audio.h>
42 #include <system/audio_policy.h>
43 #include <hardware/audio_policy.h>
44 #include <audio_effects/audio_effects_conf.h>
45 #include <media/AudioParameter.h>
46
47
48 namespace android {
49
50 /* implementation of the interface to the policy manager */
51 extern "C" {
52
aps_load_hw_module(void * service __unused,const char * name)53 audio_module_handle_t aps_load_hw_module(void *service __unused,
54 const char *name)
55 {
56 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
57 if (af == 0) {
58 ALOGW("%s: could not get AudioFlinger", __func__);
59 return 0;
60 }
61
62 return af->loadHwModule(name);
63 }
64
open_output(audio_module_handle_t module,audio_devices_t * pDevices,uint32_t * pSamplingRate,audio_format_t * pFormat,audio_channel_mask_t * pChannelMask,uint32_t * pLatencyMs,audio_output_flags_t flags,const audio_offload_info_t * offloadInfo)65 static audio_io_handle_t open_output(audio_module_handle_t module,
66 audio_devices_t *pDevices,
67 uint32_t *pSamplingRate,
68 audio_format_t *pFormat,
69 audio_channel_mask_t *pChannelMask,
70 uint32_t *pLatencyMs,
71 audio_output_flags_t flags,
72 const audio_offload_info_t *offloadInfo)
73 {
74 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
75 if (af == 0) {
76 ALOGW("%s: could not get AudioFlinger", __func__);
77 return AUDIO_IO_HANDLE_NONE;
78 }
79
80 if (pSamplingRate == NULL || pFormat == NULL || pChannelMask == NULL ||
81 pDevices == NULL || pLatencyMs == NULL) {
82 return AUDIO_IO_HANDLE_NONE;
83 }
84 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
85 config.sample_rate = *pSamplingRate;
86 config.format = *pFormat;
87 config.channel_mask = *pChannelMask;
88 if (offloadInfo != NULL) {
89 config.offload_info = *offloadInfo;
90 }
91 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
92 status_t status = af->openOutput(module, &output, &config, pDevices,
93 String8(""), pLatencyMs, flags);
94 if (status == NO_ERROR) {
95 *pSamplingRate = config.sample_rate;
96 *pFormat = config.format;
97 *pChannelMask = config.channel_mask;
98 if (offloadInfo != NULL) {
99 *((audio_offload_info_t *)offloadInfo) = config.offload_info;
100 }
101 }
102 return output;
103 }
104
105 // deprecated: replaced by aps_open_output_on_module()
aps_open_output(void * service __unused,audio_devices_t * pDevices,uint32_t * pSamplingRate,audio_format_t * pFormat,audio_channel_mask_t * pChannelMask,uint32_t * pLatencyMs,audio_output_flags_t flags)106 audio_io_handle_t aps_open_output(void *service __unused,
107 audio_devices_t *pDevices,
108 uint32_t *pSamplingRate,
109 audio_format_t *pFormat,
110 audio_channel_mask_t *pChannelMask,
111 uint32_t *pLatencyMs,
112 audio_output_flags_t flags)
113 {
114 return open_output((audio_module_handle_t)0, pDevices, pSamplingRate, pFormat, pChannelMask,
115 pLatencyMs, flags, NULL);
116 }
117
aps_open_output_on_module(void * service __unused,audio_module_handle_t module,audio_devices_t * pDevices,uint32_t * pSamplingRate,audio_format_t * pFormat,audio_channel_mask_t * pChannelMask,uint32_t * pLatencyMs,audio_output_flags_t flags,const audio_offload_info_t * offloadInfo)118 audio_io_handle_t aps_open_output_on_module(void *service __unused,
119 audio_module_handle_t module,
120 audio_devices_t *pDevices,
121 uint32_t *pSamplingRate,
122 audio_format_t *pFormat,
123 audio_channel_mask_t *pChannelMask,
124 uint32_t *pLatencyMs,
125 audio_output_flags_t flags,
126 const audio_offload_info_t *offloadInfo)
127 {
128 return open_output(module, pDevices, pSamplingRate, pFormat, pChannelMask,
129 pLatencyMs, flags, offloadInfo);
130 }
131
aps_open_dup_output(void * service __unused,audio_io_handle_t output1,audio_io_handle_t output2)132 audio_io_handle_t aps_open_dup_output(void *service __unused,
133 audio_io_handle_t output1,
134 audio_io_handle_t output2)
135 {
136 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
137 if (af == 0) {
138 ALOGW("%s: could not get AudioFlinger", __func__);
139 return 0;
140 }
141 return af->openDuplicateOutput(output1, output2);
142 }
143
aps_close_output(void * service __unused,audio_io_handle_t output)144 int aps_close_output(void *service __unused, audio_io_handle_t output)
145 {
146 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
147 if (af == 0) {
148 return PERMISSION_DENIED;
149 }
150
151 return af->closeOutput(output);
152 }
153
aps_suspend_output(void * service __unused,audio_io_handle_t output)154 int aps_suspend_output(void *service __unused, audio_io_handle_t output)
155 {
156 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
157 if (af == 0) {
158 ALOGW("%s: could not get AudioFlinger", __func__);
159 return PERMISSION_DENIED;
160 }
161
162 return af->suspendOutput(output);
163 }
164
aps_restore_output(void * service __unused,audio_io_handle_t output)165 int aps_restore_output(void *service __unused, audio_io_handle_t output)
166 {
167 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
168 if (af == 0) {
169 ALOGW("%s: could not get AudioFlinger", __func__);
170 return PERMISSION_DENIED;
171 }
172
173 return af->restoreOutput(output);
174 }
175
open_input(audio_module_handle_t module,audio_devices_t * pDevices,uint32_t * pSamplingRate,audio_format_t * pFormat,audio_channel_mask_t * pChannelMask)176 static audio_io_handle_t open_input(audio_module_handle_t module,
177 audio_devices_t *pDevices,
178 uint32_t *pSamplingRate,
179 audio_format_t *pFormat,
180 audio_channel_mask_t *pChannelMask)
181 {
182 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
183 if (af == 0) {
184 ALOGW("%s: could not get AudioFlinger", __func__);
185 return AUDIO_IO_HANDLE_NONE;
186 }
187
188 if (pSamplingRate == NULL || pFormat == NULL || pChannelMask == NULL || pDevices == NULL) {
189 return AUDIO_IO_HANDLE_NONE;
190 }
191
192 if (((*pDevices & AUDIO_DEVICE_IN_REMOTE_SUBMIX) == AUDIO_DEVICE_IN_REMOTE_SUBMIX)
193 && !captureAudioOutputAllowed()) {
194 ALOGE("open_input() permission denied: capture not allowed");
195 return AUDIO_IO_HANDLE_NONE;
196 }
197
198 audio_config_t config = AUDIO_CONFIG_INITIALIZER;;
199 config.sample_rate = *pSamplingRate;
200 config.format = *pFormat;
201 config.channel_mask = *pChannelMask;
202 audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
203 status_t status = af->openInput(module, &input, &config, pDevices,
204 String8(""), AUDIO_SOURCE_MIC, AUDIO_INPUT_FLAG_FAST /*FIXME*/);
205 if (status == NO_ERROR) {
206 *pSamplingRate = config.sample_rate;
207 *pFormat = config.format;
208 *pChannelMask = config.channel_mask;
209 }
210 return input;
211 }
212
213
214 // deprecated: replaced by aps_open_input_on_module(), and acoustics parameter is ignored
aps_open_input(void * service __unused,audio_devices_t * pDevices,uint32_t * pSamplingRate,audio_format_t * pFormat,audio_channel_mask_t * pChannelMask,audio_in_acoustics_t acoustics __unused)215 audio_io_handle_t aps_open_input(void *service __unused,
216 audio_devices_t *pDevices,
217 uint32_t *pSamplingRate,
218 audio_format_t *pFormat,
219 audio_channel_mask_t *pChannelMask,
220 audio_in_acoustics_t acoustics __unused)
221 {
222 return open_input((audio_module_handle_t)0, pDevices, pSamplingRate, pFormat, pChannelMask);
223 }
224
aps_open_input_on_module(void * service __unused,audio_module_handle_t module,audio_devices_t * pDevices,uint32_t * pSamplingRate,audio_format_t * pFormat,audio_channel_mask_t * pChannelMask)225 audio_io_handle_t aps_open_input_on_module(void *service __unused,
226 audio_module_handle_t module,
227 audio_devices_t *pDevices,
228 uint32_t *pSamplingRate,
229 audio_format_t *pFormat,
230 audio_channel_mask_t *pChannelMask)
231 {
232 return open_input(module, pDevices, pSamplingRate, pFormat, pChannelMask);
233 }
234
aps_close_input(void * service __unused,audio_io_handle_t input)235 int aps_close_input(void *service __unused, audio_io_handle_t input)
236 {
237 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
238 if (af == 0) {
239 return PERMISSION_DENIED;
240 }
241
242 return af->closeInput(input);
243 }
244
aps_invalidate_stream(void * service __unused,audio_stream_type_t stream)245 int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream)
246 {
247 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
248 if (af == 0) {
249 return PERMISSION_DENIED;
250 }
251
252 return af->invalidateStream(stream);
253 }
254
aps_move_effects(void * service __unused,int session,audio_io_handle_t src_output,audio_io_handle_t dst_output)255 int aps_move_effects(void *service __unused, int session,
256 audio_io_handle_t src_output,
257 audio_io_handle_t dst_output)
258 {
259 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
260 if (af == 0) {
261 return PERMISSION_DENIED;
262 }
263
264 return af->moveEffects(session, src_output, dst_output);
265 }
266
aps_get_parameters(void * service __unused,audio_io_handle_t io_handle,const char * keys)267 char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
268 const char *keys)
269 {
270 String8 result = AudioSystem::getParameters(io_handle, String8(keys));
271 return strdup(result.string());
272 }
273
aps_set_parameters(void * service,audio_io_handle_t io_handle,const char * kv_pairs,int delay_ms)274 void aps_set_parameters(void *service, audio_io_handle_t io_handle,
275 const char *kv_pairs, int delay_ms)
276 {
277 AudioPolicyService *audioPolicyService = (AudioPolicyService *)service;
278
279 audioPolicyService->setParameters(io_handle, kv_pairs, delay_ms);
280 }
281
aps_set_stream_volume(void * service,audio_stream_type_t stream,float volume,audio_io_handle_t output,int delay_ms)282 int aps_set_stream_volume(void *service, audio_stream_type_t stream,
283 float volume, audio_io_handle_t output,
284 int delay_ms)
285 {
286 AudioPolicyService *audioPolicyService = (AudioPolicyService *)service;
287
288 return audioPolicyService->setStreamVolume(stream, volume, output,
289 delay_ms);
290 }
291
aps_start_tone(void * service,audio_policy_tone_t tone,audio_stream_type_t stream)292 int aps_start_tone(void *service, audio_policy_tone_t tone,
293 audio_stream_type_t stream)
294 {
295 AudioPolicyService *audioPolicyService = (AudioPolicyService *)service;
296
297 return audioPolicyService->startTone(tone, stream);
298 }
299
aps_stop_tone(void * service)300 int aps_stop_tone(void *service)
301 {
302 AudioPolicyService *audioPolicyService = (AudioPolicyService *)service;
303
304 return audioPolicyService->stopTone();
305 }
306
aps_set_voice_volume(void * service,float volume,int delay_ms)307 int aps_set_voice_volume(void *service, float volume, int delay_ms)
308 {
309 AudioPolicyService *audioPolicyService = (AudioPolicyService *)service;
310
311 return audioPolicyService->setVoiceVolume(volume, delay_ms);
312 }
313
314 }; // extern "C"
315
316 }; // namespace android
317