Home | History | Annotate | Download | only in audiopolicy
      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 
     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 
     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()
    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 
    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 
    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 
    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 
    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 
    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 
    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
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    300 int aps_stop_tone(void *service)
    301 {
    302     AudioPolicyService *audioPolicyService = (AudioPolicyService *)service;
    303 
    304     return audioPolicyService->stopTone();
    305 }
    306 
    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