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