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
48namespace android {
49
50/* implementation of the interface to the policy manager */
51extern "C" {
52
53audio_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
65static 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()
106audio_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_NONE, pDevices, pSamplingRate, pFormat, pChannelMask,
115                          pLatencyMs, flags, NULL);
116}
117
118audio_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
132audio_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
144int 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
154int 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
165int 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
176static 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(IPCThreadState::self()->getCallingPid(),
194                                          IPCThreadState::self()->getCallingUid())) {
195        ALOGE("open_input() permission denied: capture not allowed");
196        return AUDIO_IO_HANDLE_NONE;
197    }
198
199    audio_config_t config = AUDIO_CONFIG_INITIALIZER;;
200    config.sample_rate = *pSamplingRate;
201    config.format = *pFormat;
202    config.channel_mask = *pChannelMask;
203    audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
204    status_t status = af->openInput(module, &input, &config, pDevices,
205                                    String8(""), AUDIO_SOURCE_MIC, AUDIO_INPUT_FLAG_FAST /*FIXME*/);
206    if (status == NO_ERROR) {
207        *pSamplingRate = config.sample_rate;
208        *pFormat = config.format;
209        *pChannelMask = config.channel_mask;
210    }
211    return input;
212}
213
214
215// deprecated: replaced by aps_open_input_on_module(), and acoustics parameter is ignored
216audio_io_handle_t aps_open_input(void *service __unused,
217                                        audio_devices_t *pDevices,
218                                        uint32_t *pSamplingRate,
219                                        audio_format_t *pFormat,
220                                        audio_channel_mask_t *pChannelMask,
221                                        audio_in_acoustics_t acoustics __unused)
222{
223    return  open_input(AUDIO_MODULE_HANDLE_NONE, pDevices, pSamplingRate, pFormat, pChannelMask);
224}
225
226audio_io_handle_t aps_open_input_on_module(void *service __unused,
227                                                  audio_module_handle_t module,
228                                                  audio_devices_t *pDevices,
229                                                  uint32_t *pSamplingRate,
230                                                  audio_format_t *pFormat,
231                                                  audio_channel_mask_t *pChannelMask)
232{
233    return  open_input(module, pDevices, pSamplingRate, pFormat, pChannelMask);
234}
235
236int aps_close_input(void *service __unused, audio_io_handle_t input)
237{
238    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
239    if (af == 0) {
240        return PERMISSION_DENIED;
241    }
242
243    return af->closeInput(input);
244}
245
246int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream)
247{
248    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
249    if (af == 0) {
250        return PERMISSION_DENIED;
251    }
252
253    return af->invalidateStream(stream);
254}
255
256int aps_move_effects(void *service __unused, audio_session_t session,
257                                audio_io_handle_t src_output,
258                                audio_io_handle_t dst_output)
259{
260    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
261    if (af == 0) {
262        return PERMISSION_DENIED;
263    }
264
265    return af->moveEffects(session, src_output, dst_output);
266}
267
268char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
269                                     const char *keys)
270{
271    String8 result = AudioSystem::getParameters(io_handle, String8(keys));
272    return strdup(result.string());
273}
274
275void aps_set_parameters(void *service, audio_io_handle_t io_handle,
276                                   const char *kv_pairs, int delay_ms)
277{
278    AudioPolicyService *audioPolicyService = (AudioPolicyService *)service;
279
280    audioPolicyService->setParameters(io_handle, kv_pairs, delay_ms);
281}
282
283int aps_set_stream_volume(void *service, audio_stream_type_t stream,
284                                     float volume, audio_io_handle_t output,
285                                     int delay_ms)
286{
287    AudioPolicyService *audioPolicyService = (AudioPolicyService *)service;
288
289    return audioPolicyService->setStreamVolume(stream, volume, output,
290                                               delay_ms);
291}
292
293int aps_start_tone(void *service, audio_policy_tone_t tone,
294                              audio_stream_type_t stream)
295{
296    AudioPolicyService *audioPolicyService = (AudioPolicyService *)service;
297
298    return audioPolicyService->startTone(tone, stream);
299}
300
301int aps_stop_tone(void *service)
302{
303    AudioPolicyService *audioPolicyService = (AudioPolicyService *)service;
304
305    return audioPolicyService->stopTone();
306}
307
308int aps_set_voice_volume(void *service, float volume, int delay_ms)
309{
310    AudioPolicyService *audioPolicyService = (AudioPolicyService *)service;
311
312    return audioPolicyService->setVoiceVolume(volume, delay_ms);
313}
314
315}; // extern "C"
316
317}; // namespace android
318