Merge ab8f3289f1281a1cb11816b31d33a753a2e5b0ca on remote branch
Change-Id: Ie6078484a923a841b73fe1ce9f3d97929d21490a
diff --git a/audiod/Android.mk b/audiod/Android.mk
index c382c9d..2092620 100644
--- a/audiod/Android.mk
+++ b/audiod/Android.mk
@@ -1,7 +1,6 @@
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
-include external/stlport/libstlport.mk
LOCAL_SRC_FILES:= \
audiod_main.cpp \
@@ -13,8 +12,7 @@
libcutils \
libutils \
libbinder \
- libmedia \
- libstlport
+ libmedia
LOCAL_ADDITIONAL_DEPENDENCIES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
diff --git a/audiod/AudioDaemon.cpp b/audiod/AudioDaemon.cpp
index b4857c4..2c9b5d0 100644
--- a/audiod/AudioDaemon.cpp
+++ b/audiod/AudioDaemon.cpp
@@ -1,5 +1,5 @@
/* AudioDaemon.cpp
-Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.
+Copyright (c) 2012-2015, The Linux Foundation. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
@@ -125,6 +125,7 @@
struct dirent* in_file;
int fd;
String8 path;
+ String8 d_name;
if ((dp = opendir(events_dir)) == NULL) {
ALOGE("Cannot open switch directory to get list of audio events %s", events_dir);
@@ -148,8 +149,9 @@
if (fd == -1) {
ALOGE("Open %s failed : %s", path.string(), strerror(errno));
} else {
- mAudioEvents.push_back(std::make_pair(in_file->d_name, fd));
- mAudioEventsStatus.push_back(std::make_pair(in_file->d_name, 0));
+ d_name = in_file->d_name;
+ mAudioEvents.push_back(std::make_pair(d_name, fd));
+ mAudioEventsStatus.push_back(std::make_pair(d_name, 0));
ALOGD("event status mAudioEventsStatus= %s",
mAudioEventsStatus[0].first.string());
}
diff --git a/hal/Android.mk b/hal/Android.mk
index e2f6cca..0edc5a3 100644
--- a/hal/Android.mk
+++ b/hal/Android.mk
@@ -126,7 +126,7 @@
endif
ifeq ($(strip $(AUDIO_FEATURE_ENABLED_EXTN_FORMATS)),true)
-LOCAL_CFLAGS += -DFORMATS_ENABLED
+LOCAL_CFLAGS += -DAUDIO_EXTN_FORMATS_ENABLED
endif
ifeq ($(strip $(AUDIO_FEATURE_ENABLED_SPKR_PROTECTION)),true)
diff --git a/hal/audio_extn/audio_defs.h b/hal/audio_extn/audio_defs.h
index 9d80112..96b0a8b 100644
--- a/hal/audio_extn/audio_defs.h
+++ b/hal/audio_extn/audio_defs.h
@@ -72,8 +72,6 @@
#define AUDIO_OFFLOAD_CODEC_APE_SAMPLE_RATE "music_offload_ape_sample_rate"
#define AUDIO_OFFLOAD_CODEC_APE_SEEK_TABLE_PRESENT "music_offload_seek_table_present"
-#define AUDIO_OFFLOAD_CODEC_VORBIS_BITSTREAM_FMT "music_offload_vorbis_bitstream_fmt"
-
/* Query handle fm parameter*/
#define AUDIO_PARAMETER_KEY_HANDLE_FM "handle_fm"
diff --git a/hal/audio_extn/audio_extn.c b/hal/audio_extn/audio_extn.c
index 72842b6..34da4fe 100644
--- a/hal/audio_extn/audio_extn.c
+++ b/hal/audio_extn/audio_extn.c
@@ -705,23 +705,25 @@
if (out->format == AUDIO_FORMAT_FLAC) {
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_FLAC_MIN_BLK_SIZE, value, sizeof(value));
if (ret >= 0) {
+ out->gapless_mdata.min_blk_size =
out->compr_config.codec->options.flac_dec.min_blk_size = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_FLAC_MAX_BLK_SIZE, value, sizeof(value));
if (ret >= 0) {
+ out->gapless_mdata.max_blk_size =
out->compr_config.codec->options.flac_dec.max_blk_size = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_FLAC_MIN_FRAME_SIZE, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.flac_dec.min_frame_size = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_FLAC_MAX_FRAME_SIZE, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.flac_dec.max_frame_size = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ALOGV("FLAC metadata: min_blk_size %d, max_blk_size %d min_frame_size %d max_frame_size %d",
out->compr_config.codec->options.flac_dec.min_blk_size,
@@ -734,63 +736,63 @@
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_FRAME_LENGTH, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.alac.frame_length = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_COMPATIBLE_VERSION, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.alac.compatible_version = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_BIT_DEPTH, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.alac.bit_depth = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_PB, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.alac.pb = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_MB, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.alac.mb = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_KB, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.alac.kb = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_NUM_CHANNELS, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.alac.num_channels = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_MAX_RUN, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.alac.max_run = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_MAX_FRAME_BYTES, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.alac.max_frame_bytes = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_AVG_BIT_RATE, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.alac.avg_bit_rate = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_SAMPLING_RATE, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.alac.sample_rate = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_ALAC_CHANNEL_LAYOUT_TAG, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.alac.channel_layout_tag = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ALOGV("ALAC CSD values: frameLength %d bitDepth %d numChannels %d"
" maxFrameBytes %d, avgBitRate %d, sampleRate %d",
@@ -806,52 +808,52 @@
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_COMPATIBLE_VERSION, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.ape.compatible_version = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_COMPRESSION_LEVEL, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.ape.compression_level = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_FORMAT_FLAGS, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.ape.format_flags = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_BLOCKS_PER_FRAME, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.ape.blocks_per_frame = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_FINAL_FRAME_BLOCKS, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.ape.final_frame_blocks = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_TOTAL_FRAMES, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.ape.total_frames = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_BITS_PER_SAMPLE, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.ape.bits_per_sample = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_NUM_CHANNELS, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.ape.num_channels = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_SAMPLE_RATE, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.ape.sample_rate = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_APE_SEEK_TABLE_PRESENT, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.ape.seek_table_present = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ALOGV("APE CSD values: compatibleVersion %d compressionLevel %d"
" formatFlags %d blocksPerFrame %d finalFrameBlocks %d"
@@ -870,59 +872,49 @@
}
else if (out->format == AUDIO_FORMAT_VORBIS) {
- ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_VORBIS_BITSTREAM_FMT, value, sizeof(value));
- if (ret >= 0) {
// transcoded bitstream mode
- out->compr_config.codec->options.vorbis_dec.bit_stream_fmt = (atoi(value) > 0) ? 1 : 0;
- out->is_compr_metadata_avail = true;
- }
+ out->compr_config.codec->options.vorbis_dec.bit_stream_fmt = 1;
+ out->send_new_metadata = 1;
}
else if (out->format == AUDIO_FORMAT_WMA || out->format == AUDIO_FORMAT_WMA_PRO) {
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_FORMAT_TAG, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->format = atoi(value);
- out->is_compr_metadata_avail = true;
- }
- ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_AVG_BIT_RATE, value, sizeof(value));
- if (ret >= 0) {
- out->compr_config.codec->options.wma.avg_bit_rate = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_BLOCK_ALIGN, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.wma.super_block_align = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_BIT_PER_SAMPLE, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.wma.bits_per_sample = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_CHANNEL_MASK, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.wma.channelmask = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_ENCODE_OPTION, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.wma.encodeopt = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_ENCODE_OPTION1, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.wma.encodeopt1 = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_WMA_ENCODE_OPTION2, value, sizeof(value));
if (ret >= 0) {
out->compr_config.codec->options.wma.encodeopt2 = atoi(value);
- out->is_compr_metadata_avail = true;
+ out->send_new_metadata = 1;
}
- ALOGV("WMA params: fmt %x, bit rate %x, balgn %x, sr %d, chmsk %x"
- " encop %x, op1 %x, op2 %x",
+ ALOGV("WMA params: fmt %x, balgn %x, sr %d, chmsk %x, encop %x, op1 %x, op2 %x",
out->compr_config.codec->format,
- out->compr_config.codec->options.wma.avg_bit_rate,
out->compr_config.codec->options.wma.super_block_align,
out->compr_config.codec->options.wma.bits_per_sample,
out->compr_config.codec->options.wma.channelmask,
diff --git a/hal/audio_extn/audio_extn.h b/hal/audio_extn/audio_extn.h
index 5028b87..9391bec 100644
--- a/hal/audio_extn/audio_extn.h
+++ b/hal/audio_extn/audio_extn.h
@@ -41,21 +41,20 @@
#include <cutils/str_parms.h>
#ifndef PCM_OFFLOAD_ENABLED
-#define AUDIO_FORMAT_PCM_OFFLOAD 0x17000000UL
+#define AUDIO_FORMAT_PCM_OFFLOAD 0x1A000000UL
#define AUDIO_FORMAT_PCM_16_BIT_OFFLOAD (AUDIO_FORMAT_PCM_OFFLOAD | AUDIO_FORMAT_PCM_SUB_16_BIT)
#define AUDIO_FORMAT_PCM_24_BIT_OFFLOAD (AUDIO_FORMAT_PCM_OFFLOAD | AUDIO_FORMAT_PCM_SUB_8_24_BIT)
#define AUDIO_OFFLOAD_CODEC_FORMAT "music_offload_codec_format"
#define audio_is_offload_pcm(format) (0)
+#define OFFLOAD_USE_SMALL_BUFFER false
+#else
+#define OFFLOAD_USE_SMALL_BUFFER ((info->format & AUDIO_FORMAT_PCM_OFFLOAD) == AUDIO_FORMAT_PCM_OFFLOAD)
#endif
#ifndef AFE_PROXY_ENABLED
#define AUDIO_DEVICE_OUT_PROXY 0x40000
#endif
-#ifndef COMPRESS_VOIP_ENABLED
-#define AUDIO_OUTPUT_FLAG_VOIP_RX 0x4000
-#endif
-
#ifndef INCALL_MUSIC_ENABLED
#define AUDIO_OUTPUT_FLAG_INCALL_MUSIC 0x8000
#endif
@@ -70,20 +69,20 @@
#endif
#ifndef FLAC_OFFLOAD_ENABLED
-#define AUDIO_FORMAT_FLAC 0x1D000000UL
+#define AUDIO_FORMAT_FLAC 0x1B000000UL
#endif
#ifndef WMA_OFFLOAD_ENABLED
-#define AUDIO_FORMAT_WMA 0x13000000UL
-#define AUDIO_FORMAT_WMA_PRO 0x14000000UL
+#define AUDIO_FORMAT_WMA 0x12000000UL
+#define AUDIO_FORMAT_WMA_PRO 0x13000000UL
#endif
#ifndef ALAC_OFFLOAD_ENABLED
-#define AUDIO_FORMAT_ALAC 0x1F000000UL
+#define AUDIO_FORMAT_ALAC 0x1C000000UL
#endif
#ifndef APE_OFFLOAD_ENABLED
-#define AUDIO_FORMAT_APE 0x20000000UL
+#define AUDIO_FORMAT_APE 0x1D000000UL
#endif
#ifndef COMPRESS_METADATA_NEEDED
@@ -93,10 +92,10 @@
struct str_parms *parms);
#endif
-#ifdef PCM_OFFLOAD_ENABLED_24
-#define PCM_OUTPUT_BIT_WIDTH (config->offload_info.bit_width)
+#ifdef AUDIO_EXTN_FORMATS_ENABLED
+#define AUDIO_OUTPUT_BIT_WIDTH (config->offload_info.bit_width)
#else
-#define PCM_OUTPUT_BIT_WIDTH (CODEC_BACKEND_DEFAULT_BIT_WIDTH)
+#define AUDIO_OUTPUT_BIT_WIDTH (CODEC_BACKEND_DEFAULT_BIT_WIDTH)
#endif
#define MAX_LENGTH_MIXER_CONTROL_IN_INT (128)
@@ -325,6 +324,9 @@
void audio_extn_dolby_set_dmid(struct audio_device *adev);
#else
#define audio_extn_dolby_set_dmid(adev) (0)
+#define AUDIO_CHANNEL_OUT_PENTA (AUDIO_CHANNEL_OUT_QUAD | AUDIO_CHANNEL_OUT_FRONT_CENTER)
+#define AUDIO_CHANNEL_OUT_SURROUND (AUDIO_CHANNEL_OUT_FRONT_LEFT | AUDIO_CHANNEL_OUT_FRONT_RIGHT | \
+ AUDIO_CHANNEL_OUT_FRONT_CENTER | AUDIO_CHANNEL_OUT_BACK_CENTER)
#endif
@@ -371,6 +373,7 @@
#define audio_extn_dolby_get_passt_buffer_size(info) (0)
#define audio_extn_dolby_set_passt_volume(out, mute) (0)
#define audio_extn_dolby_set_passt_latency(out, latency) (0)
+#define AUDIO_OUTPUT_FLAG_COMPRESS_PASSTHROUGH 0x4000
#else
int audio_extn_dolby_update_passt_formats(struct audio_device *adev,
struct stream_out *out);
@@ -475,6 +478,9 @@
#ifndef AUDIO_FORMAT_E_AC3_JOC
#define AUDIO_FORMAT_E_AC3_JOC 0x19000000UL
#endif
+#ifndef AUDIO_FORMAT_DTS_LBR
+#define AUDIO_FORMAT_DTS_LBR 0x1E000000UL
+#endif
int b64decode(char *inp, int ilen, uint8_t* outp);
int b64encode(uint8_t *inp, int ilen, char* outp);
diff --git a/hal/audio_extn/utils.c b/hal/audio_extn/utils.c
index 644300a..dac6c26 100644
--- a/hal/audio_extn/utils.c
+++ b/hal/audio_extn/utils.c
@@ -87,9 +87,6 @@
#ifdef INCALL_MUSIC_ENABLED
STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_INCALL_MUSIC),
#endif
-#ifdef COMPRESS_VOIP_ENABLED
- STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_VOIP_RX),
-#endif
STRING_TO_ENUM(AUDIO_OUTPUT_FLAG_COMPRESS_PASSTHROUGH),
};
@@ -103,7 +100,7 @@
STRING_TO_ENUM(AUDIO_FORMAT_AMR_WB),
STRING_TO_ENUM(AUDIO_FORMAT_AC3),
STRING_TO_ENUM(AUDIO_FORMAT_E_AC3),
-#ifdef FORMATS_ENABLED
+#ifdef AUDIO_EXTN_FORMATS_ENABLED
STRING_TO_ENUM(AUDIO_FORMAT_DTS),
STRING_TO_ENUM(AUDIO_FORMAT_DTS_LBR),
STRING_TO_ENUM(AUDIO_FORMAT_WMA),
diff --git a/hal/audio_hw.c b/hal/audio_hw.c
old mode 100644
new mode 100755
index 3fa45fe..e2db95b
--- a/hal/audio_hw.c
+++ b/hal/audio_hw.c
@@ -569,6 +569,9 @@
if (snd_device == SND_DEVICE_OUT_HDMI)
adev->mChannelStatusSet = false;
+ if (snd_device == SND_DEVICE_OUT_HDMI)
+ adev->mChannelStatusSet = false;
+
audio_extn_dev_arbi_release(snd_device);
audio_extn_sound_trigger_update_device_status(snd_device,
ST_EVENT_SND_DEVICE_FREE);
@@ -1046,7 +1049,9 @@
struct audio_device *adev = in->dev;
int snd_card_status = get_snd_card_state(adev);
- in->usecase = platform_update_usecase_from_source(in->source,in->usecase);
+ int usecase = platform_update_usecase_from_source(in->source,in->usecase);
+ if (get_usecase_from_list(adev, usecase) == NULL)
+ in->usecase = usecase;
ALOGD("%s: enter: stream(%p)usecase(%d: %s)",
__func__, &in->stream, in->usecase, use_case_table[in->usecase]);
@@ -1062,8 +1067,13 @@
if (ret)
goto error_config;
else
- ALOGD("%s: Updated usecase(%d: %s)",
- __func__, in->usecase, use_case_table[in->usecase]);
+ ALOGV("%s: usecase(%d)", __func__, in->usecase);
+
+ if (get_usecase_from_list(adev, in->usecase) != NULL) {
+ ALOGE("%s: use case assigned already in use, stream(%p)usecase(%d: %s)",
+ __func__, &in->stream, in->usecase, use_case_table[in->usecase]);
+ goto error_config;
+ }
in->pcm_device_id = platform_get_pcm_device_id(in->usecase, PCM_CAPTURE);
if (in->pcm_device_id < 0) {
@@ -1284,10 +1294,6 @@
ALOGE("%s: Next track returned error %d",__func__, ret);
if (ret != -ENETRESET) {
send_callback = true;
- pthread_mutex_lock(&out->lock);
- out->send_new_metadata = 1;
- out->send_next_track_params = true;
- pthread_mutex_unlock(&out->lock);
event = STREAM_CBK_EVENT_DRAIN_READY;
ALOGV("copl(%p):send drain callback, ret %d", out, ret);
} else
@@ -1611,9 +1617,6 @@
ret = -EIO;
goto error_open;
}
- /* compress_open sends params of the track, so reset the flag here */
- out->is_compr_metadata_avail = false;
-
if (out->offload_callback)
compress_nonblock(out->compr, out->non_blocking);
@@ -1788,8 +1791,6 @@
} else {
ALOGD("copl(%p):standby", out);
stop_compressed_output_l(out);
- out->send_next_track_params = false;
- out->is_compr_metadata_avail = false;
out->gapless_mdata.encoder_delay = 0;
out->gapless_mdata.encoder_padding = 0;
if (out->compr != NULL) {
@@ -1815,6 +1816,7 @@
{
int ret = 0;
char value[32];
+ bool is_meta_data_params = false;
if (!out || !parms) {
ALOGE("%s: return invalid ",__func__);
@@ -1827,19 +1829,36 @@
out->compr_config.codec->format = SND_AUDIOSTREAMFORMAT_MP4ADTS;
ALOGV("ADTS format is set in offload mode");
}
+ out->send_new_metadata = 1;
}
ret = audio_extn_parse_compress_metadata(out, parms);
+ ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_SAMPLE_RATE, value, sizeof(value));
+ if(ret >= 0)
+ is_meta_data_params = true;
+ ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_NUM_CHANNEL, value, sizeof(value));
+ if(ret >= 0)
+ is_meta_data_params = true;
+ ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_AVG_BIT_RATE, value, sizeof(value));
+ if(ret >= 0)
+ is_meta_data_params = true;
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_DELAY_SAMPLES, value, sizeof(value));
if (ret >= 0) {
+ is_meta_data_params = true;
out->gapless_mdata.encoder_delay = atoi(value); //whats a good limit check?
}
ret = str_parms_get_str(parms, AUDIO_OFFLOAD_CODEC_PADDING_SAMPLES, value, sizeof(value));
if (ret >= 0) {
+ is_meta_data_params = true;
out->gapless_mdata.encoder_padding = atoi(value);
}
+ if(!is_meta_data_params) {
+ ALOGV("%s: Not gapless meta data params", __func__);
+ return 0;
+ }
+ out->send_new_metadata = 1;
ALOGV("%s new encoder delay %u and padding %u", __func__,
out->gapless_mdata.encoder_delay, out->gapless_mdata.encoder_padding);
@@ -2136,12 +2155,6 @@
ALOGD("copl(%p):send new gapless metadata", out);
compress_set_gapless_metadata(out->compr, &out->gapless_mdata);
out->send_new_metadata = 0;
- if (out->send_next_track_params && out->is_compr_metadata_avail) {
- ALOGD("copl(%p):send next track params in gapless", out);
- compress_set_next_track_param(out->compr, &(out->compr_config.codec->options));
- out->send_next_track_params = false;
- out->is_compr_metadata_avail = false;
- }
}
ret = compress_write(out->compr, buffer, bytes);
@@ -2887,7 +2900,7 @@
else
out->compr_config.codec->id =
get_snd_codec_id(config->offload_info.format);
- if (audio_is_offload_pcm(config->offload_info.format)) {
+ if ((config->offload_info.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_PCM_OFFLOAD) {
out->compr_config.fragment_size =
platform_get_pcm_offload_buffer_size(&config->offload_info);
} else if (audio_extn_dolby_is_passthrough_stream(out->flags)) {
@@ -2905,7 +2918,7 @@
out->compr_config.codec->ch_in =
audio_channel_count_from_out_mask(config->channel_mask);
out->compr_config.codec->ch_out = out->compr_config.codec->ch_in;
- out->bit_width = PCM_OUTPUT_BIT_WIDTH;
+ out->bit_width = AUDIO_OUTPUT_BIT_WIDTH;
/*TODO: Do we need to change it for passthrough */
out->compr_config.codec->format = SND_AUDIOSTREAMFORMAT_RAW;
@@ -2921,12 +2934,12 @@
}
if (config->offload_info.format == AUDIO_FORMAT_FLAC)
- out->compr_config.codec->options.flac_dec.sample_size = PCM_OUTPUT_BIT_WIDTH;
+ out->compr_config.codec->options.flac_dec.sample_size = AUDIO_OUTPUT_BIT_WIDTH;
if (flags & AUDIO_OUTPUT_FLAG_NON_BLOCKING)
out->non_blocking = 1;
- if (config->offload_info.use_small_bufs) {
+ if (platform_use_small_buffer(&config->offload_info)) {
//this flag is set from framework only if its for PCM formats
//no need to check for PCM format again
out->non_blocking = 0;
@@ -2936,8 +2949,6 @@
}
out->send_new_metadata = 1;
- out->send_next_track_params = false;
- out->is_compr_metadata_avail = false;
out->offload_state = OFFLOAD_STATE_IDLE;
out->playback_started = 0;
diff --git a/hal/audio_hw.h b/hal/audio_hw.h
index dc11e99..45e90b7 100644
--- a/hal/audio_hw.h
+++ b/hal/audio_hw.h
@@ -213,8 +213,6 @@
void *offload_cookie;
struct compr_gapless_mdata gapless_mdata;
int send_new_metadata;
- bool send_next_track_params;
- bool is_compr_metadata_avail;
unsigned int bit_width;
struct audio_device *dev;
diff --git a/hal/msm8916/platform.c b/hal/msm8916/platform.c
index eb6b07d..d882c5f 100644
--- a/hal/msm8916/platform.c
+++ b/hal/msm8916/platform.c
@@ -2841,8 +2841,7 @@
}
}
}
- } else if (source == AUDIO_SOURCE_FM_RX ||
- source == AUDIO_SOURCE_FM_RX_A2DP) {
+ } else if (source == AUDIO_SOURCE_FM_TUNER) {
snd_device = SND_DEVICE_IN_CAPTURE_FM;
} else if (source == AUDIO_SOURCE_DEFAULT) {
goto exit;
@@ -2885,7 +2884,7 @@
} else if (in_device & AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET ||
in_device & AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET) {
snd_device = SND_DEVICE_IN_USB_HEADSET_MIC;
- } else if (in_device & AUDIO_DEVICE_IN_FM_RX) {
+ } else if (in_device & AUDIO_DEVICE_IN_FM_TUNER) {
snd_device = SND_DEVICE_IN_CAPTURE_FM;
} else {
ALOGE("%s: Unknown input device(s) %#x", __func__, in_device);
@@ -3563,7 +3562,7 @@
int platform_update_usecase_from_source(int source, int usecase)
{
ALOGV("%s: input source :%d", __func__, source);
- if(source == AUDIO_SOURCE_FM_RX_A2DP)
+ if(source == AUDIO_SOURCE_FM_TUNER)
usecase = USECASE_AUDIO_RECORD_FM_VIRTUAL;
return usecase;
}
@@ -4063,6 +4062,10 @@
done:
return ret;
}
+bool platform_use_small_buffer(audio_offload_info_t* info)
+{
+ return OFFLOAD_USE_SMALL_BUFFER;
+}
void platform_get_device_to_be_id_map(int **device_to_be_id, int *length)
{
diff --git a/hal/msm8960/platform.c b/hal/msm8960/platform.c
index a35b4f1..d8801ab 100644
--- a/hal/msm8960/platform.c
+++ b/hal/msm8960/platform.c
@@ -1107,6 +1107,11 @@
return 0;
}
+bool platform_use_small_buffer(audio_offload_info_t* info)
+{
+ return false;
+}
+
int platform_get_edid_info(void *platform __unused)
{
return -ENOSYS;
diff --git a/hal/msm8974/platform.c b/hal/msm8974/platform.c
index 142a85d..2975a00 100644
--- a/hal/msm8974/platform.c
+++ b/hal/msm8974/platform.c
@@ -2402,8 +2402,7 @@
}
}
}
- } else if (source == AUDIO_SOURCE_FM_RX ||
- source == AUDIO_SOURCE_FM_RX_A2DP) {
+ } else if (source == AUDIO_SOURCE_FM_TUNER) {
snd_device = SND_DEVICE_IN_CAPTURE_FM;
} else if (source == AUDIO_SOURCE_DEFAULT) {
goto exit;
@@ -2446,7 +2445,7 @@
} else if (in_device & AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET ||
in_device & AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET) {
snd_device = SND_DEVICE_IN_USB_HEADSET_MIC;
- } else if (in_device & AUDIO_DEVICE_IN_FM_RX) {
+ } else if (in_device & AUDIO_DEVICE_IN_FM_TUNER) {
snd_device = SND_DEVICE_IN_CAPTURE_FM;
} else {
ALOGE("%s: Unknown input device(s) %#x", __func__, in_device);
@@ -3127,7 +3126,7 @@
int platform_update_usecase_from_source(int source, int usecase)
{
ALOGV("%s: input source :%d", __func__, source);
- if(source == AUDIO_SOURCE_FM_RX_A2DP)
+ if(source == AUDIO_SOURCE_FM_TUNER)
usecase = USECASE_AUDIO_RECORD_FM_VIRTUAL;
return usecase;
}
@@ -3235,6 +3234,11 @@
return fragment_size;
}
+bool platform_use_small_buffer(audio_offload_info_t* info)
+{
+ return OFFLOAD_USE_SMALL_BUFFER;
+}
+
int platform_set_codec_backend_cfg(struct audio_device* adev,
snd_device_t snd_device,
unsigned int bit_width, unsigned int sample_rate)
diff --git a/hal/platform_api.h b/hal/platform_api.h
index 15f9225..53ddb48 100644
--- a/hal/platform_api.h
+++ b/hal/platform_api.h
@@ -94,6 +94,7 @@
struct audio_offload_info_t;
uint32_t platform_get_compress_offload_buffer_size(audio_offload_info_t* info);
uint32_t platform_get_pcm_offload_buffer_size(audio_offload_info_t* info);
+bool platform_use_small_buffer(audio_offload_info_t* info);
uint32_t platform_get_compress_passthrough_buffer_size(audio_offload_info_t* info);
bool platform_check_and_set_codec_backend_cfg(struct audio_device* adev,
diff --git a/hal/voice.c b/hal/voice.c
index 95c4e21..527856f 100644
--- a/hal/voice.c
+++ b/hal/voice.c
@@ -22,6 +22,7 @@
#define LOG_NDDEBUG 0
#include <errno.h>
+#include <stdlib.h>
#include <math.h>
#include <cutils/log.h>
#include <cutils/str_parms.h>
diff --git a/hal/voice_extn/compress_voip.c b/hal/voice_extn/compress_voip.c
index c249018..bb1caf9 100644
--- a/hal/voice_extn/compress_voip.c
+++ b/hal/voice_extn/compress_voip.c
@@ -64,17 +64,9 @@
uint32_t sample_rate;
};
-#define MODE_IS127 0x2
-#define MODE_4GV_NB 0x3
-#define MODE_4GV_WB 0x4
-#define MODE_AMR 0x5
-#define MODE_AMR_WB 0xD
#define MODE_PCM 0xC
-#define MODE_4GV_NW 0xE
#define AUDIO_PARAMETER_KEY_VOIP_RATE "voip_rate"
-#define AUDIO_PARAMETER_KEY_VOIP_EVRC_RATE_MIN "evrc_rate_min"
-#define AUDIO_PARAMETER_KEY_VOIP_EVRC_RATE_MAX "evrc_rate_max"
#define AUDIO_PARAMETER_KEY_VOIP_DTX_MODE "dtx_on"
#define AUDIO_PARAMETER_VALUE_VOIP_TRUE "true"
#define AUDIO_PARAMETER_KEY_VOIP_CHECK "voip_flag"
@@ -94,8 +86,6 @@
static int voip_set_mic_mute(struct audio_device *adev, bool state);
static int voip_set_mode(struct audio_device *adev, int format);
static int voip_set_rate(struct audio_device *adev, int rate);
-static int voip_set_evrc_min_max_rate(struct audio_device *adev, int min_rate,
- int max_rate);
static int voip_set_dtx(struct audio_device *adev, bool enable);
static int voip_stop_call(struct audio_device *adev);
static int voip_start_call(struct audio_device *adev,
@@ -103,32 +93,10 @@
static int audio_format_to_voip_mode(int format)
{
- int mode;
+ int mode = 0;
- switch(format) {
- case AUDIO_FORMAT_PCM_16_BIT:
- mode = MODE_PCM;
- break;
- case AUDIO_FORMAT_AMR_NB:
- mode = MODE_AMR;
- break;
- case AUDIO_FORMAT_AMR_WB:
- mode = MODE_AMR_WB;
- break;
- case AUDIO_FORMAT_EVRC:
- mode = MODE_IS127;
- break;
- case AUDIO_FORMAT_EVRCB:
- mode = MODE_4GV_NB;
- break;
- case AUDIO_FORMAT_EVRCWB:
- mode = MODE_4GV_WB;
- break;
- case AUDIO_FORMAT_EVRCNW:
- mode = MODE_4GV_NW;
- break;
- default:
- mode = MODE_PCM;
+ if (format == AUDIO_FORMAT_PCM_16_BIT) {
+ mode = MODE_PCM;
}
return mode;
}
@@ -233,30 +201,6 @@
return 0;
}
-static int voip_set_evrc_min_max_rate(struct audio_device *adev, int min_rate,
- int max_rate)
-{
- struct mixer_ctl *ctl;
- const char *mixer_ctl_name = "Voip Evrc Min Max Rate Config";
- uint32_t set_values[ ] = {0, 0};
-
- ALOGD("%s: enter, min_rate=%d, max_rate=%d",
- __func__, min_rate, max_rate);
-
- set_values[0] = min_rate;
- set_values[1] = max_rate;
- ctl = mixer_get_ctl_by_name(adev->mixer, mixer_ctl_name);
- if (!ctl) {
- ALOGE("%s: Could not get ctl for mixer cmd - %s",
- __func__, mixer_ctl_name);
- return -EINVAL;
- }
- mixer_ctl_set_array(ctl, set_values, ARRAY_SIZE(set_values));
-
- ALOGV("%s: exit", __func__);
- return 0;
-}
-
static int voip_set_dtx(struct audio_device *adev, bool enable)
{
struct mixer_ctl *ctl;
@@ -436,26 +380,6 @@
if (err >= 0) {
rate = atoi(value);
voip_set_rate(adev, rate);
- voip_set_evrc_min_max_rate(adev, rate, rate);
- }
-
- memset(value, 0, sizeof(value));
- err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_VOIP_EVRC_RATE_MIN,
- value, sizeof(value));
- if (err >= 0) {
- min_rate = atoi(value);
- str_parms_del(parms, AUDIO_PARAMETER_KEY_VOIP_EVRC_RATE_MIN);
- memset(value, 0, sizeof(value));
- err = str_parms_get_str(parms, AUDIO_PARAMETER_KEY_VOIP_EVRC_RATE_MAX,
- value, sizeof(value));
- if (err >= 0) {
- max_rate = atoi(value);
- voip_set_evrc_min_max_rate(adev, min_rate, max_rate);
- } else {
- ALOGE("%s: AUDIO_PARAMETER_KEY_VOIP_EVRC_RATE_MAX not found", __func__);
- ret = -EINVAL;
- goto done;
- }
}
memset(value, 0, sizeof(value));
@@ -784,13 +708,6 @@
return true;
else
return false;
- case AUDIO_FORMAT_AMR_NB:
- case AUDIO_FORMAT_AMR_WB:
- case AUDIO_FORMAT_EVRC:
- case AUDIO_FORMAT_EVRCB:
- case AUDIO_FORMAT_EVRCWB:
- case AUDIO_FORMAT_EVRCNW:
- return true;
default:
return false;
}
diff --git a/hal/voice_extn/voice_extn.c b/hal/voice_extn/voice_extn.c
index c408709..3cf370d 100644
--- a/hal/voice_extn/voice_extn.c
+++ b/hal/voice_extn/voice_extn.c
@@ -22,6 +22,7 @@
#define LOG_NDDEBUG 0
#include <errno.h>
+#include <stdlib.h>
#include <math.h>
#include <cutils/log.h>
#include <cutils/str_parms.h>
diff --git a/policy_hal/Android.mk b/policy_hal/Android.mk
index 26ee63c..2ef080b 100644
--- a/policy_hal/Android.mk
+++ b/policy_hal/Android.mk
@@ -5,81 +5,49 @@
LOCAL_SRC_FILES := AudioPolicyManager.cpp
-LOCAL_C_INCLUDES := $(TOPDIR)frameworks/av/services
+LOCAL_C_INCLUDES := $(TOPDIR)frameworks/av/services \
+ $(TOPDIR)frameworks/av/services/audioflinger \
+ $(call include-path-for, audio-effects) \
+ $(call include-path-for, audio-utils) \
+ $(TOPDIR)frameworks/av/services/audiopolicy/common/include \
+ $(TOPDIR)frameworks/av/services/audiopolicy/engine/interface \
+ $(TOPDIR)frameworks/av/services/audiopolicy \
+ $(TOPDIR)frameworks/av/services/audiopolicy/common/managerdefinitions/include \
+ $(call include-path-for, avextension)
+
LOCAL_SHARED_LIBRARIES := \
libcutils \
libutils \
liblog \
libsoundtrigger \
- libaudiopolicymanagerdefault
+ libaudiopolicymanagerdefault \
+ libserviceutility
LOCAL_STATIC_LIBRARIES := \
libmedia_helper \
- libserviceutility
-
-LOCAL_MODULE := libaudiopolicymanager
-
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_COMPRESS_VOIP)),true)
-LOCAL_CFLAGS += -DAUDIO_EXTN_COMPRESS_VOIP_ENABLED
-endif
-
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_EXTN_FORMATS)),true)
-LOCAL_CFLAGS += -DAUDIO_EXTN_FORMATS_ENABLED
-endif
-
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_FM)),true)
-LOCAL_CFLAGS += -DAUDIO_EXTN_FM_ENABLED
-endif
-
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_HDMI_SPK)),true)
-LOCAL_CFLAGS += -DAUDIO_EXTN_HDMI_SPK_ENABLED
-endif
-
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_INCALL_MUSIC)),true)
-LOCAL_CFLAGS += -DAUDIO_EXTN_INCALL_MUSIC_ENABLED
-endif
-
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_MULTIPLE_TUNNEL)), true)
-LOCAL_CFLAGS += -DMULTIPLE_OFFLOAD_ENABLED
-endif
-
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_PCM_OFFLOAD)),true)
- LOCAL_CFLAGS += -DPCM_OFFLOAD_ENABLED
-endif
-
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_PROXY_DEVICE)),true)
-LOCAL_CFLAGS += -DAUDIO_EXTN_AFE_PROXY_ENABLED
-endif
-
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_SSR)),true)
-LOCAL_CFLAGS += -DAUDIO_EXTN_SSR_ENABLED
-endif
ifeq ($(strip $(AUDIO_FEATURE_ENABLED_VOICE_CONCURRENCY)),true)
LOCAL_CFLAGS += -DVOICE_CONCURRENCY
endif
-ifeq ($(strip $(AUDIO_FEATURE_ENABLED_WFD_CONCURRENCY)),true)
-LOCAL_CFLAGS += -DWFD_CONCURRENCY
-endif
-
ifeq ($(strip $(AUDIO_FEATURE_ENABLED_RECORD_PLAY_CONCURRENCY)),true)
LOCAL_CFLAGS += -DRECORD_PLAY_CONCURRENCY
endif
-ifeq ($(strip $(DOLBY_UDC)),true)
- LOCAL_CFLAGS += -DDOLBY_UDC
-endif #DOLBY_UDC
-ifeq ($(strip $(DOLBY_DDP)),true)
- LOCAL_CFLAGS += -DDOLBY_DDP
-endif #DOLBY_DDP
-ifeq ($(strip $(DOLBY_DAP)),true)
- ifdef DOLBY_DAP_OPENSLES
- LOCAL_CFLAGS += -DDOLBY_DAP_OPENSLES
- endif
-endif #DOLBY_END
+ifeq ($(strip $(AUDIO_FEATURE_ENABLED_PCM_OFFLOAD)),true)
+ LOCAL_CFLAGS += -DPCM_OFFLOAD_ENABLED
+endif
+ifeq ($(strip $(AUDIO_FEATURE_ENABLED_PCM_OFFLOAD_24)),true)
+ LOCAL_CFLAGS += -DPCM_OFFLOAD_ENABLED_24
+endif
+
+ifeq ($(strip $(AUDIO_FEATURE_ENABLED_EXTN_FORMATS)),true)
+ LOCAL_CFLAGS += -DAUDIO_EXTN_FORMATS_ENABLED
+endif
+
+LOCAL_MODULE := libaudiopolicymanager
include $(BUILD_SHARED_LIBRARY)
diff --git a/policy_hal/AudioPolicyManager.cpp b/policy_hal/AudioPolicyManager.cpp
index 65bad3c..2791b6d 100644
--- a/policy_hal/AudioPolicyManager.cpp
+++ b/policy_hal/AudioPolicyManager.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
* Not a contribution.
*
* Copyright (C) 2009 The Android Open Source Project
@@ -17,7 +17,7 @@
* limitations under the License.
*/
-#define LOG_TAG "AudioPolicyManager"
+#define LOG_TAG "AudioPolicyManagerCustom"
//#define LOG_NDEBUG 0
//#define VERY_VERBOSE_LOGGING
@@ -26,14 +26,8 @@
#else
#define ALOGVV(a...) do { } while(0)
#endif
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
-// A device mask for all audio input devices that are considered "virtual" when evaluating
-// active inputs in getActiveInput()
-#ifdef AUDIO_EXTN_FM_ENABLED
-#define APM_AUDIO_IN_DEVICE_VIRTUAL_ALL (AUDIO_DEVICE_IN_REMOTE_SUBMIX | AUDIO_DEVICE_IN_FM_RX_A2DP)
-#else
-#define APM_AUDIO_IN_DEVICE_VIRTUAL_ALL AUDIO_DEVICE_IN_REMOTE_SUBMIX
-#endif
// A device mask for all audio output devices that are considered "remote" when evaluating
// active output devices in isStreamActiveRemotely()
#define APM_AUDIO_OUT_DEVICE_REMOTE_ALL AUDIO_DEVICE_OUT_REMOTE_SUBMIX
@@ -41,6 +35,9 @@
// type alone is not enough: the address must match too
#define APM_AUDIO_DEVICE_MATCH_ADDRESS_ALL (AUDIO_DEVICE_IN_REMOTE_SUBMIX | \
AUDIO_DEVICE_OUT_REMOTE_SUBMIX)
+// Following delay should be used if the calculated routing delay from all active
+// input streams is higher than this value
+#define MAX_VOICE_CALL_START_DELAY_MS 100
#include <inttypes.h>
#include <math.h>
@@ -52,31 +49,69 @@
#include <media/AudioParameter.h>
#include <soundtrigger/SoundTrigger.h>
#include "AudioPolicyManager.h"
+#include <policy.h>
namespace android {
+#ifdef VOICE_CONCURRENCY
+audio_output_flags_t AudioPolicyManagerCustom::getFallBackPath()
+{
+ audio_output_flags_t flag = AUDIO_OUTPUT_FLAG_FAST;
+ char propValue[PROPERTY_VALUE_MAX];
+ if (property_get("voice.conc.fallbackpath", propValue, NULL)) {
+ if (!strncmp(propValue, "deep-buffer", 11)) {
+ flag = AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
+ }
+ else if (!strncmp(propValue, "fast", 4)) {
+ flag = AUDIO_OUTPUT_FLAG_FAST;
+ }
+ else {
+ ALOGD("voice_conc:not a recognised path(%s) in prop voice.conc.fallbackpath",
+ propValue);
+ }
+ }
+ else {
+ ALOGD("voice_conc:prop voice.conc.fallbackpath not set");
+ }
+
+ ALOGD("voice_conc:picked up flag(0x%x) from prop voice.conc.fallbackpath",
+ flag);
+
+ return flag;
+}
+#endif /*VOICE_CONCURRENCY*/
// ----------------------------------------------------------------------------
// AudioPolicyInterface implementation
// ----------------------------------------------------------------------------
-
-status_t AudioPolicyManagerCustom::setDeviceConnectionState(audio_devices_t device,
- audio_policy_dev_state_t state,
- const char *device_address)
+extern "C" AudioPolicyInterface* createAudioPolicyManager(
+ AudioPolicyClientInterface *clientInterface)
{
- String8 address = (device_address == NULL) ? String8("") : String8(device_address);
+ return new AudioPolicyManagerCustom(clientInterface);
+}
- ALOGV("setDeviceConnectionState() device: %x, state %d, address %s",
- device, state, address.string());
+extern "C" void destroyAudioPolicyManager(AudioPolicyInterface *interface)
+{
+ delete interface;
+}
+
+status_t AudioPolicyManagerCustom::setDeviceConnectionStateInt(audio_devices_t device,
+ audio_policy_dev_state_t state,
+ const char *device_address,
+ const char *device_name)
+{
+ ALOGV("setDeviceConnectionStateInt() device: 0x%X, state %d, address %s name %s",
+ device, state, device_address, device_name);
// connect/disconnect only 1 device at a time
if (!audio_is_output_device(device) && !audio_is_input_device(device)) return BAD_VALUE;
+ sp<DeviceDescriptor> devDesc =
+ mHwModules.getDeviceDescriptor(device, device_address, device_name);
+
// handle output devices
if (audio_is_output_device(device)) {
SortedVector <audio_io_handle_t> outputs;
- sp<DeviceDescriptor> devDesc = new DeviceDescriptor(String8(""), device);
- devDesc->mAddress = address;
ssize_t index = mAvailableOutputDevices.indexOf(devDesc);
// save a copy of the opened output descriptors before any output is opened or closed
@@ -85,17 +120,8 @@
switch (state)
{
// handle output device connection
- case AUDIO_POLICY_DEVICE_STATE_AVAILABLE:
+ case AUDIO_POLICY_DEVICE_STATE_AVAILABLE: {
if (index >= 0) {
-#ifdef AUDIO_EXTN_HDMI_SPK_ENABLED
- if ((popcount(device) == 1) && (device & AUDIO_DEVICE_OUT_AUX_DIGITAL)) {
- if (!strncmp(device_address, "hdmi_spkr", 9)) {
- mHdmiAudioDisabled = false;
- } else {
- mHdmiAudioEvent = true;
- }
- }
-#endif
ALOGW("setDeviceConnectionState() device already connected: %x", device);
return INVALID_OPERATION;
}
@@ -103,79 +129,59 @@
// register new device as available
index = mAvailableOutputDevices.add(devDesc);
-
-#ifdef AUDIO_EXTN_HDMI_SPK_ENABLED
- if ((popcount(device) == 1) && (device & AUDIO_DEVICE_OUT_AUX_DIGITAL)) {
- if (!strncmp(device_address, "hdmi_spkr", 9)) {
- mHdmiAudioDisabled = false;
- } else {
- mHdmiAudioEvent = true;
- }
- if (mHdmiAudioDisabled || !mHdmiAudioEvent) {
- mAvailableOutputDevices.remove(devDesc);
- }
- }
-#endif
if (index >= 0) {
- sp<HwModule> module = getModuleForDevice(device);
+ sp<HwModule> module = mHwModules.getModuleForDevice(device);
if (module == 0) {
ALOGD("setDeviceConnectionState() could not find HW module for device %08x",
device);
mAvailableOutputDevices.remove(devDesc);
return INVALID_OPERATION;
}
- mAvailableOutputDevices[index]->mId = nextUniqueId();
- mAvailableOutputDevices[index]->mModule = module;
+ mAvailableOutputDevices[index]->attach(module);
} else {
return NO_MEMORY;
}
- if (checkOutputsForDevice(devDesc, state, outputs, address) != NO_ERROR) {
+ if (checkOutputsForDevice(devDesc, state, outputs, devDesc->mAddress) != NO_ERROR) {
mAvailableOutputDevices.remove(devDesc);
return INVALID_OPERATION;
}
+ // Propagate device availability to Engine
+ mEngine->setDeviceConnectionState(devDesc, state);
+
// outputs should never be empty here
ALOG_ASSERT(outputs.size() != 0, "setDeviceConnectionState():"
"checkOutputsForDevice() returned no outputs but status OK");
ALOGV("setDeviceConnectionState() checkOutputsForDevice() returned %zu outputs",
outputs.size());
- break;
+
+ // Send connect to HALs
+ AudioParameter param = AudioParameter(devDesc->mAddress);
+ param.addInt(String8(AUDIO_PARAMETER_DEVICE_CONNECT), device);
+ mpClientInterface->setParameters(AUDIO_IO_HANDLE_NONE, param.toString());
+
+ } break;
// handle output device disconnection
case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE: {
if (index < 0) {
-#ifdef AUDIO_EXTN_HDMI_SPK_ENABLED
- if ((popcount(device) == 1) && (device & AUDIO_DEVICE_OUT_AUX_DIGITAL)) {
- if (!strncmp(device_address, "hdmi_spkr", 9)) {
- mHdmiAudioDisabled = true;
- } else {
- mHdmiAudioEvent = false;
- }
- }
-#endif
ALOGW("setDeviceConnectionState() device not connected: %x", device);
return INVALID_OPERATION;
}
ALOGV("setDeviceConnectionState() disconnecting output device %x", device);
- // Set Disconnect to HALs
- AudioParameter param = AudioParameter(address);
+ // Send Disconnect to HALs
+ AudioParameter param = AudioParameter(devDesc->mAddress);
param.addInt(String8(AUDIO_PARAMETER_DEVICE_DISCONNECT), device);
mpClientInterface->setParameters(AUDIO_IO_HANDLE_NONE, param.toString());
// remove device from available output devices
mAvailableOutputDevices.remove(devDesc);
-#ifdef AUDIO_EXTN_HDMI_SPK_ENABLED
- if ((popcount(device) == 1) && (device & AUDIO_DEVICE_OUT_AUX_DIGITAL)) {
- if (!strncmp(device_address, "hdmi_spkr", 9)) {
- mHdmiAudioDisabled = true;
- } else {
- mHdmiAudioEvent = false;
- }
- }
-#endif
- checkOutputsForDevice(devDesc, state, outputs, address);
+ checkOutputsForDevice(devDesc, state, outputs, devDesc->mAddress);
+
+ // Propagate device availability to Engine
+ mEngine->setDeviceConnectionState(devDesc, state);
} break;
default:
@@ -190,7 +196,7 @@
// outputs must be closed after checkOutputForAllStrategies() is executed
if (!outputs.isEmpty()) {
for (size_t i = 0; i < outputs.size(); i++) {
- sp<AudioOutputDescriptor> desc = mOutputs.valueFor(outputs[i]);
+ sp<SwAudioOutputDescriptor> desc = mOutputs.valueFor(outputs[i]);
// close unused outputs after device disconnection or direct outputs that have been
// opened by checkOutputsForDevice() to query dynamic parameters
if ((state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) ||
@@ -204,39 +210,22 @@
}
updateDevicesAndOutputs();
- audio_devices_t newDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/);
- if (mPhoneState == AUDIO_MODE_IN_CALL) {
+ if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) {
+ audio_devices_t newDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/);
updateCallRouting(newDevice);
}
-
-#ifdef AUDIO_EXTN_FM_ENABLED
- if(device == AUDIO_DEVICE_OUT_FM) {
- if (state == AUDIO_POLICY_DEVICE_STATE_AVAILABLE) {
- mOutputs.valueFor(mPrimaryOutput)->changeRefCount(AUDIO_STREAM_MUSIC, 1);
- newDevice = (audio_devices_t)(getNewOutputDevice(mPrimaryOutput, false) | AUDIO_DEVICE_OUT_FM);
- } else {
- mOutputs.valueFor(mPrimaryOutput)->changeRefCount(AUDIO_STREAM_MUSIC, -1);
- }
-
- AudioParameter param = AudioParameter();
- param.addInt(String8("handle_fm"), (int)newDevice);
- ALOGV("setDeviceConnectionState() setParameters handle_fm");
- mpClientInterface->setParameters(mPrimaryOutput, param.toString());
- }
-#endif
for (size_t i = 0; i < mOutputs.size(); i++) {
- audio_io_handle_t output = mOutputs.keyAt(i);
- if ((mPhoneState != AUDIO_MODE_IN_CALL) || (output != mPrimaryOutput)) {
- audio_devices_t newDevice = getNewOutputDevice(mOutputs.keyAt(i),
- true /*fromCache*/);
+ sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
+ if ((mEngine->getPhoneState() != AUDIO_MODE_IN_CALL) || (desc != mPrimaryOutput)) {
+ audio_devices_t newDevice = getNewOutputDevice(desc, true /*fromCache*/);
// do not force device change on duplicated output because if device is 0, it will
// also force a device 0 for the two outputs it is duplicated to which may override
// a valid device selection on those outputs.
- bool force = !mOutputs.valueAt(i)->isDuplicated()
- && (!deviceDistinguishesOnAddress(device)
+ bool force = !desc->isDuplicated()
+ && (!device_distinguishes_on_address(device)
// always force when disconnecting (a non-duplicated device)
|| (state == AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
- setOutputDevice(output, newDevice, force, 0);
+ setOutputDevice(desc, newDevice, force, 0);
}
}
@@ -248,8 +237,6 @@
if (audio_is_input_device(device)) {
SortedVector <audio_io_handle_t> inputs;
- sp<DeviceDescriptor> devDesc = new DeviceDescriptor(String8(""), device);
- devDesc->mAddress = address;
ssize_t index = mAvailableInputDevices.indexOf(devDesc);
switch (state)
{
@@ -259,23 +246,30 @@
ALOGW("setDeviceConnectionState() device already connected: %d", device);
return INVALID_OPERATION;
}
- sp<HwModule> module = getModuleForDevice(device);
+ sp<HwModule> module = mHwModules.getModuleForDevice(device);
if (module == NULL) {
ALOGW("setDeviceConnectionState(): could not find HW module for device %08x",
device);
return INVALID_OPERATION;
}
- if (checkInputsForDevice(device, state, inputs, address) != NO_ERROR) {
+ if (checkInputsForDevice(devDesc, state, inputs, devDesc->mAddress) != NO_ERROR) {
return INVALID_OPERATION;
}
index = mAvailableInputDevices.add(devDesc);
if (index >= 0) {
- mAvailableInputDevices[index]->mId = nextUniqueId();
- mAvailableInputDevices[index]->mModule = module;
+ mAvailableInputDevices[index]->attach(module);
} else {
return NO_MEMORY;
}
+
+ // Set connect to HALs
+ AudioParameter param = AudioParameter(devDesc->mAddress);
+ param.addInt(String8(AUDIO_PARAMETER_DEVICE_CONNECT), device);
+ mpClientInterface->setParameters(AUDIO_IO_HANDLE_NONE, param.toString());
+
+ // Propagate device availability to Engine
+ mEngine->setDeviceConnectionState(devDesc, state);
} break;
// handle input device disconnection
@@ -288,13 +282,15 @@
ALOGV("setDeviceConnectionState() disconnecting input device %x", device);
// Set Disconnect to HALs
- AudioParameter param = AudioParameter(address);
+ AudioParameter param = AudioParameter(devDesc->mAddress);
param.addInt(String8(AUDIO_PARAMETER_DEVICE_DISCONNECT), device);
mpClientInterface->setParameters(AUDIO_IO_HANDLE_NONE, param.toString());
- checkInputsForDevice(device, state, inputs, address);
+ checkInputsForDevice(devDesc, state, inputs, devDesc->mAddress);
mAvailableInputDevices.remove(devDesc);
+ // Propagate device availability to Engine
+ mEngine->setDeviceConnectionState(devDesc, state);
} break;
default:
@@ -304,7 +300,7 @@
closeAllInputs();
- if (mPhoneState == AUDIO_MODE_IN_CALL) {
+ if (mEngine->getPhoneState() == AUDIO_MODE_IN_CALL && hasPrimaryOutput()) {
audio_devices_t newDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/);
updateCallRouting(newDevice);
}
@@ -316,95 +312,278 @@
ALOGW("setDeviceConnectionState() invalid device: %x", device);
return BAD_VALUE;
}
-
-audio_policy_dev_state_t AudioPolicyManagerCustom::getDeviceConnectionState(audio_devices_t device,
- const char *device_address)
+// This function checks for the parameters which can be offloaded.
+// This can be enhanced depending on the capability of the DSP and policy
+// of the system.
+bool AudioPolicyManagerCustom::isOffloadSupported(const audio_offload_info_t& offloadInfo)
{
- audio_policy_dev_state_t state = AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
- sp<DeviceDescriptor> devDesc = new DeviceDescriptor(String8(""), device);
- devDesc->mAddress = (device_address == NULL) ? String8("") : String8(device_address);
- ssize_t index;
- DeviceVector *deviceVector;
+ ALOGV("isOffloadSupported: SR=%u, CM=0x%x, Format=0x%x, StreamType=%d,"
+ " BitRate=%u, duration=%" PRId64 " us, has_video=%d",
+ offloadInfo.sample_rate, offloadInfo.channel_mask,
+ offloadInfo.format,
+ offloadInfo.stream_type, offloadInfo.bit_rate, offloadInfo.duration_us,
+ offloadInfo.has_video);
+#ifdef VOICE_CONCURRENCY
+ char concpropValue[PROPERTY_VALUE_MAX];
+ if (property_get("voice.playback.conc.disabled", concpropValue, NULL)) {
+ bool propenabled = atoi(concpropValue) || !strncmp("true", concpropValue, 4);
+ if (propenabled) {
+ if (isInCall())
+ {
+ ALOGD("\n copl: blocking compress offload on call mode\n");
+ return false;
+ }
+ }
+ }
+#endif
+#ifdef RECORD_PLAY_CONCURRENCY
+ char recConcPropValue[PROPERTY_VALUE_MAX];
+ bool prop_rec_play_enabled = false;
- if (audio_is_output_device(device)) {
- deviceVector = &mAvailableOutputDevices;
- } else if (audio_is_input_device(device)) {
- deviceVector = &mAvailableInputDevices;
- } else {
- ALOGW("getDeviceConnectionState() invalid device type %08x", device);
- return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
+ if (property_get("rec.playback.conc.disabled", recConcPropValue, NULL)) {
+ prop_rec_play_enabled = atoi(recConcPropValue) || !strncmp("true", recConcPropValue, 4);
}
- index = deviceVector->indexOf(devDesc);
- if (index >= 0) {
- return AUDIO_POLICY_DEVICE_STATE_AVAILABLE;
- } else {
- return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
+ if ((prop_rec_play_enabled) &&
+ ((true == mIsInputRequestOnProgress) || (mInputs.activeInputsCount() > 0))) {
+ ALOGD("copl: blocking compress offload for record concurrency");
+ return false;
}
+#endif
+ // Check if stream type is music, then only allow offload as of now.
+ if (offloadInfo.stream_type != AUDIO_STREAM_MUSIC)
+ {
+ ALOGV("isOffloadSupported: stream_type != MUSIC, returning false");
+ return false;
+ }
+
+ char propValue[PROPERTY_VALUE_MAX];
+ bool pcmOffload = false;
+#ifdef PCM_OFFLOAD_ENABLED
+ if ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_PCM_OFFLOAD) {
+ bool prop_enabled = false;
+ if ((AUDIO_FORMAT_PCM_16_BIT_OFFLOAD == offloadInfo.format) &&
+ property_get("audio.offload.pcm.16bit.enable", propValue, NULL)) {
+ prop_enabled = atoi(propValue) || !strncmp("true", propValue, 4);
+ }
+
+#ifdef PCM_OFFLOAD_ENABLED_24
+ if ((AUDIO_FORMAT_PCM_24_BIT_OFFLOAD == offloadInfo.format) &&
+ property_get("audio.offload.pcm.24bit.enable", propValue, NULL)) {
+ prop_enabled = atoi(propValue) || !strncmp("true", propValue, 4);
+ }
+#endif
+
+ if (prop_enabled) {
+ ALOGI("PCM offload property is enabled");
+ pcmOffload = true;
+ }
+
+ if (!pcmOffload) {
+ ALOGD("system property not enabled for PCM offload format[%x]",offloadInfo.format);
+ return false;
+ }
+ }
+#endif
+ if (!pcmOffload) {
+ // Check if offload has been disabled
+ if (property_get("audio.offload.disable", propValue, "0")) {
+ if (atoi(propValue) != 0) {
+ ALOGV("offload disabled by audio.offload.disable=%s", propValue );
+ return false;
+ }
+ }
+ //check if it's multi-channel AAC (includes sub formats) and FLAC format
+ if ((popcount(offloadInfo.channel_mask) > 2) &&
+ (((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_AAC) ||
+ ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_VORBIS))) {
+ ALOGD("offload disabled for multi-channel AAC,FLAC and VORBIS format");
+ return false;
+ }
+
+#ifdef AUDIO_EXTN_FORMATS_ENABLED
+ //check if it's multi-channel FLAC/ALAC/WMA format with sample rate > 48k
+ if ((popcount(offloadInfo.channel_mask) > 2) &&
+ (((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_FLAC) ||
+ (((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_ALAC) && offloadInfo.sample_rate > 48000) ||
+ (((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_WMA) && offloadInfo.sample_rate > 48000) ||
+ (((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_WMA_PRO) && offloadInfo.sample_rate > 48000))) {
+ ALOGD("offload disabled for multi-channel FLAC/ALAC/WMA clips with sample rate > 48kHz");
+ return false;
+ }
+#endif
+ //TODO: enable audio offloading with video when ready
+ const bool allowOffloadWithVideo =
+ property_get_bool("audio.offload.video", false /* default_value */);
+ if (offloadInfo.has_video && !allowOffloadWithVideo) {
+ ALOGV("isOffloadSupported: has_video == true, returning false");
+ return false;
+ }
+ }
+
+ //If duration is less than minimum value defined in property, return false
+ if (property_get("audio.offload.min.duration.secs", propValue, NULL)) {
+ if (offloadInfo.duration_us < (atoi(propValue) * 1000000 )) {
+ ALOGV("Offload denied by duration < audio.offload.min.duration.secs(=%s)", propValue);
+ return false;
+ }
+ } else if (offloadInfo.duration_us < OFFLOAD_DEFAULT_MIN_DURATION_SECS * 1000000) {
+ ALOGV("Offload denied by duration < default min(=%u)", OFFLOAD_DEFAULT_MIN_DURATION_SECS);
+ //duration checks only valid for MP3/AAC/ formats,
+ //do not check duration for other audio formats, e.g. dolby AAC/AC3 and amrwb+ formats
+ if ((offloadInfo.format == AUDIO_FORMAT_MP3) ||
+ ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_AAC) ||
+ ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_VORBIS) ||
+#ifdef AUDIO_EXTN_FORMATS_ENABLED
+ ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_FLAC) ||
+ ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_WMA) ||
+ ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_WMA_PRO) ||
+ ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_ALAC) ||
+ ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_APE) ||
+#endif
+ pcmOffload)
+ return false;
+
+ }
+
+ // Do not allow offloading if one non offloadable effect is enabled. This prevents from
+ // creating an offloaded track and tearing it down immediately after start when audioflinger
+ // detects there is an active non offloadable effect.
+ // FIXME: We should check the audio session here but we do not have it in this context.
+ // This may prevent offloading in rare situations where effects are left active by apps
+ // in the background.
+ if (mEffects.isNonOffloadableEffectEnabled()) {
+ return false;
+ }
+ // Check for soundcard status
+ String8 valueStr = mpClientInterface->getParameters((audio_io_handle_t)0,
+ String8("SND_CARD_STATUS"));
+ AudioParameter result = AudioParameter(valueStr);
+ int isonline = 0;
+ if ((result.getInt(String8("SND_CARD_STATUS"), isonline) == NO_ERROR)
+ && !isonline) {
+ ALOGD("copl: soundcard is offline rejecting offload request");
+ return false;
+ }
+ // See if there is a profile to support this.
+ // AUDIO_DEVICE_NONE
+ sp<IOProfile> profile = getProfileForDirectOutput(AUDIO_DEVICE_NONE /*ignore device */,
+ offloadInfo.sample_rate,
+ offloadInfo.format,
+ offloadInfo.channel_mask,
+ AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD);
+ ALOGV("isOffloadSupported() profile %sfound", profile != 0 ? "" : "NOT ");
+ return (profile != 0);
}
+audio_devices_t AudioPolicyManagerCustom::getNewOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
+ bool fromCache)
+{
+ audio_devices_t device = AUDIO_DEVICE_NONE;
+ ssize_t index = mAudioPatches.indexOfKey(outputDesc->mPatchHandle);
+ if (index >= 0) {
+ sp<AudioPatch> patchDesc = mAudioPatches.valueAt(index);
+ if (patchDesc->mUid != mUidCached) {
+ ALOGV("getNewOutputDevice() device %08x forced by patch %d",
+ outputDesc->device(), outputDesc->mPatchHandle);
+ return outputDesc->device();
+ }
+ }
+
+ // check the following by order of priority to request a routing change if necessary:
+ // 1: the strategy enforced audible is active and enforced on the output:
+ // use device for strategy enforced audible
+ // 2: we are in call or the strategy phone is active on the output:
+ // use device for strategy phone
+ // 3: the strategy for enforced audible is active but not enforced on the output:
+ // use the device for strategy enforced audible
+ // 4: the strategy sonification is active on the output:
+ // use device for strategy sonification
+ // 5: the strategy "respectful" sonification is active on the output:
+ // use device for strategy "respectful" sonification
+ // 6: the strategy accessibility is active on the output:
+ // use device for strategy accessibility
+ // 7: the strategy media is active on the output:
+ // use device for strategy media
+ // 8: the strategy DTMF is active on the output:
+ // use device for strategy DTMF
+ // 9: the strategy for beacon, a.k.a. "transmitted through speaker" is active on the output:
+ // use device for strategy t-t-s
+ if (isStrategyActive(outputDesc, STRATEGY_ENFORCED_AUDIBLE) &&
+ mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_SYSTEM) == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
+ device = getDeviceForStrategy(STRATEGY_ENFORCED_AUDIBLE, fromCache);
+ } else if (isInCall() ||
+ isStrategyActive(outputDesc, STRATEGY_PHONE)||
+ isStrategyActive(mPrimaryOutput, STRATEGY_PHONE)) {
+ device = getDeviceForStrategy(STRATEGY_PHONE, fromCache);
+ } else if (isStrategyActive(outputDesc, STRATEGY_ENFORCED_AUDIBLE)) {
+ device = getDeviceForStrategy(STRATEGY_ENFORCED_AUDIBLE, fromCache);
+ } else if (isStrategyActive(outputDesc, STRATEGY_SONIFICATION)||
+ (isStrategyActive(mPrimaryOutput,STRATEGY_SONIFICATION)
+ && (!isStrategyActive(mPrimaryOutput,STRATEGY_MEDIA)))) {
+ device = getDeviceForStrategy(STRATEGY_SONIFICATION, fromCache);
+ } else if (isStrategyActive(outputDesc, STRATEGY_SONIFICATION_RESPECTFUL)||
+ (isStrategyActive(mPrimaryOutput,STRATEGY_SONIFICATION_RESPECTFUL)
+ && (!isStrategyActive(mPrimaryOutput, STRATEGY_MEDIA)))) {
+ device = getDeviceForStrategy(STRATEGY_SONIFICATION_RESPECTFUL, fromCache);
+ } else if (isStrategyActive(outputDesc, STRATEGY_ACCESSIBILITY)) {
+ device = getDeviceForStrategy(STRATEGY_ACCESSIBILITY, fromCache);
+ } else if (isStrategyActive(outputDesc, STRATEGY_MEDIA)) {
+ device = getDeviceForStrategy(STRATEGY_MEDIA, fromCache);
+ } else if (isStrategyActive(outputDesc, STRATEGY_DTMF)) {
+ device = getDeviceForStrategy(STRATEGY_DTMF, fromCache);
+ } else if (isStrategyActive(outputDesc, STRATEGY_TRANSMITTED_THROUGH_SPEAKER)) {
+ device = getDeviceForStrategy(STRATEGY_TRANSMITTED_THROUGH_SPEAKER, fromCache);
+ } else if (isStrategyActive(outputDesc, STRATEGY_REROUTING)) {
+ device = getDeviceForStrategy(STRATEGY_REROUTING, fromCache);
+ }
+
+ ALOGV("getNewOutputDevice() selected device %x", device);
+ return device;
+}
void AudioPolicyManagerCustom::setPhoneState(audio_mode_t state)
{
- ALOGD("setPhoneState() state %d", state);
- audio_devices_t newDevice = AUDIO_DEVICE_NONE;
+ ALOGV("setPhoneState() state %d", state);
+ // store previous phone state for management of sonification strategy below
+ int oldState = mEngine->getPhoneState();
- if (state < 0 || state >= AUDIO_MODE_CNT) {
- ALOGW("setPhoneState() invalid state %d", state);
+ if (mEngine->setPhoneState(state) != NO_ERROR) {
+ ALOGW("setPhoneState() invalid or same state %d", state);
return;
}
-
- if (state == mPhoneState ) {
- ALOGW("setPhoneState() setting same state %d", state);
- return;
- }
-
+ /// Opens: can these line be executed after the switch of volume curves???
// if leaving call state, handle special case of active streams
// pertaining to sonification strategy see handleIncallSonification()
if (isInCall()) {
ALOGV("setPhoneState() in call state management: new state is %d", state);
- for (int stream = 0; stream < AUDIO_STREAM_CNT; stream++) {
- handleIncallSonification((audio_stream_type_t)stream, false, true);
+ for (size_t j = 0; j < mOutputs.size(); j++) {
+ audio_io_handle_t curOutput = mOutputs.keyAt(j);
+ for (int stream = 0; stream < AUDIO_STREAM_CNT; stream++) {
+ if (stream == AUDIO_STREAM_PATCH) {
+ continue;
+ }
+
+ handleIncallSonification((audio_stream_type_t)stream, false, true, curOutput);
+ }
}
+
+ // force reevaluating accessibility routing when call starts
+ mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
}
- // store previous phone state for management of sonification strategy below
- int oldState = mPhoneState;
- mPhoneState = state;
- bool force = false;
-
- // are we entering or starting a call
- if (!isStateInCall(oldState) && isStateInCall(state)) {
- ALOGV(" Entering call in setPhoneState()");
- // force routing command to audio hardware when starting a call
- // even if no device change is needed
- force = true;
- for (int j = 0; j < DEVICE_CATEGORY_CNT; j++) {
- mStreams[AUDIO_STREAM_DTMF].mVolumeCurve[j] =
- sVolumeProfiles[AUDIO_STREAM_VOICE_CALL][j];
- }
- } else if (isStateInCall(oldState) && !isStateInCall(state)) {
- ALOGV(" Exiting call in setPhoneState()");
- // force routing command to audio hardware when exiting a call
- // even if no device change is needed
- force = true;
- for (int j = 0; j < DEVICE_CATEGORY_CNT; j++) {
- mStreams[AUDIO_STREAM_DTMF].mVolumeCurve[j] =
- sVolumeProfiles[AUDIO_STREAM_DTMF][j];
- }
- } else if (isStateInCall(state) && (state != oldState)) {
- ALOGV(" Switching between telephony and VoIP in setPhoneState()");
- // force routing command to audio hardware when switching between telephony and VoIP
- // even if no device change is needed
- force = true;
- }
+ /**
+ * Switching to or from incall state or switching between telephony and VoIP lead to force
+ * routing command.
+ */
+ bool force = ((is_state_in_call(oldState) != is_state_in_call(state))
+ || (is_state_in_call(state) && (state != oldState)));
// check for device and output changes triggered by new phone state
checkA2dpSuspend();
checkOutputForAllStrategies();
updateDevicesAndOutputs();
- sp<AudioOutputDescriptor> hwOutputDesc = mOutputs.valueFor(mPrimaryOutput);
-
+ sp<SwAudioOutputDescriptor> hwOutputDesc = mPrimaryOutput;
#ifdef VOICE_CONCURRENCY
int voice_call_state = 0;
char propValue[PROPERTY_VALUE_MAX];
@@ -428,109 +607,141 @@
String8 valueStr = mpClientInterface->getParameters((audio_io_handle_t)0, String8("in_call"));
AudioParameter result = AudioParameter(valueStr);
if (result.getInt(String8("in_call"), voice_call_state) == NO_ERROR)
- ALOGD("SetPhoneState: Voice call state = %d", voice_call_state);
+ ALOGD("voice_conc:SetPhoneState: Voice call state = %d", voice_call_state);
}
- if (mode_in_call && voice_call_state) {
- ALOGD("Entering to call mode oldState :: %d state::%d ",oldState, state);
+ if (mode_in_call && voice_call_state && !mvoice_call_state) {
+ ALOGD("voice_conc:Entering to call mode oldState :: %d state::%d ",
+ oldState, state);
mvoice_call_state = voice_call_state;
- if (prop_playback_enabled) {
- //Call invalidate to reset all opened non ULL audio tracks
- // Move tracks associated to this strategy from previous output to new output
- for (int i = AUDIO_STREAM_SYSTEM; i < (int)AUDIO_STREAM_CNT; i++) {
- ALOGV(" Invalidate on call mode for stream :: %d ", i);
- //FIXME see fixme on name change
- mpClientInterface->invalidateStream((audio_stream_type_t)i);
- }
- }
-
if (prop_rec_enabled) {
//Close all active inputs
- audio_io_handle_t activeInput = getActiveInput();
+ audio_io_handle_t activeInput = mInputs.getActiveInput();
if (activeInput != 0) {
sp<AudioInputDescriptor> activeDesc = mInputs.valueFor(activeInput);
switch(activeDesc->mInputSource) {
case AUDIO_SOURCE_VOICE_UPLINK:
case AUDIO_SOURCE_VOICE_DOWNLINK:
case AUDIO_SOURCE_VOICE_CALL:
- ALOGD("FOUND active input during call active: %d",activeDesc->mInputSource);
+ ALOGD("voice_conc:FOUND active input during call active: %d",activeDesc->mInputSource);
break;
case AUDIO_SOURCE_VOICE_COMMUNICATION:
if(prop_voip_enabled) {
- ALOGD("CLOSING VoIP input source on call setup :%d ",activeDesc->mInputSource);
+ ALOGD("voice_conc:CLOSING VoIP input source on call setup :%d ",activeDesc->mInputSource);
stopInput(activeInput, activeDesc->mSessions.itemAt(0));
releaseInput(activeInput, activeDesc->mSessions.itemAt(0));
}
break;
default:
- ALOGD("CLOSING input on call setup for inputSource: %d",activeDesc->mInputSource);
+ ALOGD("voice_conc:CLOSING input on call setup for inputSource: %d",activeDesc->mInputSource);
stopInput(activeInput, activeDesc->mSessions.itemAt(0));
releaseInput(activeInput, activeDesc->mSessions.itemAt(0));
break;
}
}
} else if (prop_voip_enabled) {
- audio_io_handle_t activeInput = getActiveInput();
+ audio_io_handle_t activeInput = mInputs.getActiveInput();
if (activeInput != 0) {
sp<AudioInputDescriptor> activeDesc = mInputs.valueFor(activeInput);
if (AUDIO_SOURCE_VOICE_COMMUNICATION == activeDesc->mInputSource) {
- ALOGD("CLOSING VoIP on call setup : %d",activeDesc->mInputSource);
+ ALOGD("voice_conc:CLOSING VoIP on call setup : %d",activeDesc->mInputSource);
stopInput(activeInput, activeDesc->mSessions.itemAt(0));
releaseInput(activeInput, activeDesc->mSessions.itemAt(0));
}
}
}
-
- //suspend PCM (deep-buffer) output & close compress & direct tracks
- for (size_t i = 0; i < mOutputs.size(); i++) {
- sp<AudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
- if ( (outputDesc == NULL) || (outputDesc->mProfile == NULL)) {
- ALOGD("ouput desc / profile is NULL");
- continue;
- }
- if (((!outputDesc->isDuplicated() &&outputDesc->mProfile->mFlags & AUDIO_OUTPUT_FLAG_PRIMARY))
- && prop_playback_enabled) {
- ALOGD(" calling suspendOutput on call mode for primary output");
- mpClientInterface->suspendOutput(mOutputs.keyAt(i));
- } //Close compress all sessions
- else if ((outputDesc->mProfile->mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)
- && prop_playback_enabled) {
- ALOGD(" calling closeOutput on call mode for COMPRESS output");
- closeOutput(mOutputs.keyAt(i));
- }
- else if ((outputDesc->mProfile->mFlags & AUDIO_OUTPUT_FLAG_VOIP_RX)
- && prop_voip_enabled) {
- ALOGD(" calling closeOutput on call mode for DIRECT output");
- closeOutput(mOutputs.keyAt(i));
+ if (prop_playback_enabled) {
+ // Move tracks associated to this strategy from previous output to new output
+ for (int i = AUDIO_STREAM_SYSTEM; i < (int)AUDIO_STREAM_CNT; i++) {
+ ALOGV("voice_conc:Invalidate on call mode for stream :: %d ", i);
+ if (i == AUDIO_STREAM_PATCH) {
+ ALOGV("voice_conc:not calling invalidate for AUDIO_STREAM_PATCH");
+ continue;
+ }
+ if (AUDIO_OUTPUT_FLAG_DEEP_BUFFER == mFallBackflag) {
+ if ((AUDIO_STREAM_MUSIC == i) ||
+ (AUDIO_STREAM_VOICE_CALL == i) ) {
+ ALOGD("voice_conc:Invalidate stream type %d", i);
+ mpClientInterface->invalidateStream((audio_stream_type_t)i);
+ }
+ } else if (AUDIO_OUTPUT_FLAG_FAST == mFallBackflag) {
+ ALOGD("voice_conc:Invalidate stream type %d", i);
+ mpClientInterface->invalidateStream((audio_stream_type_t)i);
+ }
}
}
- }
- if ((AUDIO_MODE_IN_CALL == oldState || AUDIO_MODE_IN_COMMUNICATION == oldState) &&
- (AUDIO_MODE_NORMAL == state) && prop_playback_enabled && mvoice_call_state) {
- ALOGD("EXITING from call mode oldState :: %d state::%d \n",oldState, state);
- mvoice_call_state = 0;
- //restore PCM (deep-buffer) output after call termination
for (size_t i = 0; i < mOutputs.size(); i++) {
- sp<AudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
+ sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
if ( (outputDesc == NULL) || (outputDesc->mProfile == NULL)) {
- ALOGD("ouput desc / profile is NULL");
+ ALOGD("voice_conc:ouput desc / profile is NULL");
continue;
}
- if (!outputDesc->isDuplicated() && outputDesc->mProfile->mFlags & AUDIO_OUTPUT_FLAG_PRIMARY) {
- ALOGD("calling restoreOutput after call mode for primary output");
- mpClientInterface->restoreOutput(mOutputs.keyAt(i));
+
+ if (AUDIO_OUTPUT_FLAG_FAST == mFallBackflag) {
+ if (((!outputDesc->isDuplicated() &&outputDesc->mProfile->mFlags & AUDIO_OUTPUT_FLAG_PRIMARY))
+ && prop_playback_enabled) {
+ ALOGD("voice_conc:calling suspendOutput on call mode for primary output");
+ mpClientInterface->suspendOutput(mOutputs.keyAt(i));
+ } //Close compress all sessions
+ else if ((outputDesc->mProfile->mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD)
+ && prop_playback_enabled) {
+ ALOGD("voice_conc:calling closeOutput on call mode for COMPRESS output");
+ closeOutput(mOutputs.keyAt(i));
+ }
+ else if ((outputDesc->mProfile->mFlags & AUDIO_OUTPUT_FLAG_VOIP_RX)
+ && prop_voip_enabled) {
+ ALOGD("voice_conc:calling closeOutput on call mode for DIRECT output");
+ closeOutput(mOutputs.keyAt(i));
+ }
+ } else if (AUDIO_OUTPUT_FLAG_DEEP_BUFFER == mFallBackflag) {
+ if ((outputDesc->mProfile->mFlags & AUDIO_OUTPUT_FLAG_DIRECT)
+ && prop_playback_enabled) {
+ ALOGD("voice_conc:calling closeOutput on call mode for COMPRESS output");
+ closeOutput(mOutputs.keyAt(i));
+ }
}
- }
- //call invalidate tracks so that any open streams can fall back to deep buffer/compress path from ULL
- for (int i = AUDIO_STREAM_SYSTEM; i < (int)AUDIO_STREAM_CNT; i++) {
- ALOGD("Invalidate after call ends for stream :: %d ", i);
- //FIXME see fixme on name change
- mpClientInterface->invalidateStream((audio_stream_type_t)i);
- }
+ }
}
+
+ if ((AUDIO_MODE_IN_CALL == oldState || AUDIO_MODE_IN_COMMUNICATION == oldState) &&
+ (AUDIO_MODE_NORMAL == state) && prop_playback_enabled && mvoice_call_state) {
+ ALOGD("voice_conc:EXITING from call mode oldState :: %d state::%d \n",oldState, state);
+ mvoice_call_state = 0;
+ if (AUDIO_OUTPUT_FLAG_FAST == mFallBackflag) {
+ //restore PCM (deep-buffer) output after call termination
+ for (size_t i = 0; i < mOutputs.size(); i++) {
+ sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
+ if ( (outputDesc == NULL) || (outputDesc->mProfile == NULL)) {
+ ALOGD("voice_conc:ouput desc / profile is NULL");
+ continue;
+ }
+ if (!outputDesc->isDuplicated() && outputDesc->mProfile->mFlags & AUDIO_OUTPUT_FLAG_PRIMARY) {
+ ALOGD("voice_conc:calling restoreOutput after call mode for primary output");
+ mpClientInterface->restoreOutput(mOutputs.keyAt(i));
+ }
+ }
+ }
+ //call invalidate tracks so that any open streams can fall back to deep buffer/compress path from ULL
+ for (int i = AUDIO_STREAM_SYSTEM; i < (int)AUDIO_STREAM_CNT; i++) {
+ ALOGV("voice_conc:Invalidate on call mode for stream :: %d ", i);
+ if (i == AUDIO_STREAM_PATCH) {
+ ALOGV("voice_conc:not calling invalidate for AUDIO_STREAM_PATCH");
+ continue;
+ }
+ if (AUDIO_OUTPUT_FLAG_DEEP_BUFFER == mFallBackflag) {
+ if ((AUDIO_STREAM_MUSIC == i) ||
+ (AUDIO_STREAM_VOICE_CALL == i) ) {
+ mpClientInterface->invalidateStream((audio_stream_type_t)i);
+ }
+ } else if (AUDIO_OUTPUT_FLAG_FAST == mFallBackflag) {
+ mpClientInterface->invalidateStream((audio_stream_type_t)i);
+ }
+ }
+ }
+
#endif
#ifdef RECORD_PLAY_CONCURRENCY
char recConcPropValue[PROPERTY_VALUE_MAX];
@@ -540,7 +751,7 @@
prop_rec_play_enabled = atoi(recConcPropValue) || !strncmp("true", recConcPropValue, 4);
}
if (prop_rec_play_enabled) {
- if (AUDIO_MODE_IN_COMMUNICATION == mPhoneState) {
+ if (AUDIO_MODE_IN_COMMUNICATION == mEngine->getPhoneState()) {
ALOGD("phone state changed to MODE_IN_COMM invlaidating music and voice streams");
// call invalidate for voice streams, so that it can use deepbuffer with VoIP out device from HAL
mpClientInterface->invalidateStream(AUDIO_STREAM_VOICE_CALL);
@@ -550,7 +761,7 @@
// close compress output to make sure session will be closed before timeout(60sec)
for (size_t i = 0; i < mOutputs.size(); i++) {
- sp<AudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
+ sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
if ((outputDesc == NULL) || (outputDesc->mProfile == NULL)) {
ALOGD("ouput desc / profile is NULL");
continue;
@@ -562,72 +773,66 @@
}
}
} else if ((oldState == AUDIO_MODE_IN_COMMUNICATION) &&
- (mPhoneState == AUDIO_MODE_NORMAL)) {
+ (mEngine->getPhoneState() == AUDIO_MODE_NORMAL)) {
// call invalidate for music so that music can fallback to compress
mpClientInterface->invalidateStream(AUDIO_STREAM_MUSIC);
}
}
#endif
-
mPrevPhoneState = oldState;
-
int delayMs = 0;
if (isStateInCall(state)) {
nsecs_t sysTime = systemTime();
for (size_t i = 0; i < mOutputs.size(); i++) {
- sp<AudioOutputDescriptor> desc = mOutputs.valueAt(i);
+ sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
// mute media and sonification strategies and delay device switch by the largest
// latency of any output where either strategy is active.
// This avoid sending the ring tone or music tail into the earpiece or headset.
- if ((desc->isStrategyActive(STRATEGY_MEDIA,
- SONIFICATION_HEADSET_MUSIC_DELAY,
- sysTime) ||
- desc->isStrategyActive(STRATEGY_SONIFICATION,
- SONIFICATION_HEADSET_MUSIC_DELAY,
- sysTime)) &&
- (delayMs < (int)desc->mLatency*2)) {
- delayMs = desc->mLatency*2;
+ if ((isStrategyActive(desc, STRATEGY_MEDIA,
+ SONIFICATION_HEADSET_MUSIC_DELAY,
+ sysTime) ||
+ isStrategyActive(desc, STRATEGY_SONIFICATION,
+ SONIFICATION_HEADSET_MUSIC_DELAY,
+ sysTime)) &&
+ (delayMs < (int)desc->latency()*2)) {
+ delayMs = desc->latency()*2;
}
- setStrategyMute(STRATEGY_MEDIA, true, mOutputs.keyAt(i));
- setStrategyMute(STRATEGY_MEDIA, false, mOutputs.keyAt(i), MUTE_TIME_MS,
+ setStrategyMute(STRATEGY_MEDIA, true, desc);
+ setStrategyMute(STRATEGY_MEDIA, false, desc, MUTE_TIME_MS,
getDeviceForStrategy(STRATEGY_MEDIA, true /*fromCache*/));
- setStrategyMute(STRATEGY_SONIFICATION, true, mOutputs.keyAt(i));
- setStrategyMute(STRATEGY_SONIFICATION, false, mOutputs.keyAt(i), MUTE_TIME_MS,
+ setStrategyMute(STRATEGY_SONIFICATION, true, desc);
+ setStrategyMute(STRATEGY_SONIFICATION, false, desc, MUTE_TIME_MS,
getDeviceForStrategy(STRATEGY_SONIFICATION, true /*fromCache*/));
}
+ ALOGV("Setting the delay from %dms to %dms", delayMs,
+ MIN(delayMs, MAX_VOICE_CALL_START_DELAY_MS));
+ delayMs = MIN(delayMs, MAX_VOICE_CALL_START_DELAY_MS);
}
- // Note that despite the fact that getNewOutputDevice() is called on the primary output,
- // the device returned is not necessarily reachable via this output
- audio_devices_t rxDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/);
- // force routing command to audio hardware when ending call
- // even if no device change is needed
- if (isStateInCall(oldState) && rxDevice == AUDIO_DEVICE_NONE) {
- rxDevice = hwOutputDesc->device();
- }
-
- if (state == AUDIO_MODE_IN_CALL) {
- updateCallRouting(rxDevice, delayMs);
- } else if (oldState == AUDIO_MODE_IN_CALL) {
- if (mCallRxPatch != 0) {
- mpClientInterface->releaseAudioPatch(mCallRxPatch->mAfPatchHandle, 0);
- mCallRxPatch.clear();
+ if (hasPrimaryOutput()) {
+ // Note that despite the fact that getNewOutputDevice() is called on the primary output,
+ // the device returned is not necessarily reachable via this output
+ audio_devices_t rxDevice = getNewOutputDevice(mPrimaryOutput, false /*fromCache*/);
+ // force routing command to audio hardware when ending call
+ // even if no device change is needed
+ if (isStateInCall(oldState) && rxDevice == AUDIO_DEVICE_NONE) {
+ rxDevice = mPrimaryOutput->device();
}
- if (mCallTxPatch != 0) {
- mpClientInterface->releaseAudioPatch(mCallTxPatch->mAfPatchHandle, 0);
- mCallTxPatch.clear();
- }
- setOutputDevice(mPrimaryOutput, rxDevice, force, 0);
- } else {
- setOutputDevice(mPrimaryOutput, rxDevice, force, 0);
- }
- //update device for all non-primary outputs
- for (size_t i = 0; i < mOutputs.size(); i++) {
- audio_io_handle_t output = mOutputs.keyAt(i);
- if (output != mPrimaryOutput) {
- newDevice = getNewOutputDevice(output, false /*fromCache*/);
- setOutputDevice(output, newDevice, (newDevice != AUDIO_DEVICE_NONE));
+ if (state == AUDIO_MODE_IN_CALL) {
+ updateCallRouting(rxDevice, delayMs);
+ } else if (oldState == AUDIO_MODE_IN_CALL) {
+ if (mCallRxPatch != 0) {
+ mpClientInterface->releaseAudioPatch(mCallRxPatch->mAfPatchHandle, 0);
+ mCallRxPatch.clear();
+ }
+ if (mCallTxPatch != 0) {
+ mpClientInterface->releaseAudioPatch(mCallTxPatch->mAfPatchHandle, 0);
+ mCallTxPatch.clear();
+ }
+ setOutputDevice(mPrimaryOutput, rxDevice, force, 0);
+ } else {
+ setOutputDevice(mPrimaryOutput, rxDevice, force, 0);
}
}
@@ -635,8 +840,14 @@
// pertaining to sonification strategy see handleIncallSonification()
if (isStateInCall(state)) {
ALOGV("setPhoneState() in call state management: new state is %d", state);
- for (int stream = 0; stream < AUDIO_STREAM_CNT; stream++) {
- handleIncallSonification((audio_stream_type_t)stream, true, true);
+ for (size_t j = 0; j < mOutputs.size(); j++) {
+ audio_io_handle_t curOutput = mOutputs.keyAt(j);
+ for (int stream = 0; stream < AUDIO_STREAM_CNT; stream++) {
+ if (stream == AUDIO_STREAM_PATCH) {
+ continue;
+ }
+ handleIncallSonification((audio_stream_type_t)stream, true, true, curOutput);
+ }
}
}
@@ -648,104 +859,275 @@
mLimitRingtoneVolume = false;
}
}
-
-void AudioPolicyManagerCustom::setForceUse(audio_policy_force_use_t usage,
- audio_policy_forced_cfg_t config)
+status_t AudioPolicyManagerCustom::stopSource(sp<SwAudioOutputDescriptor> outputDesc,
+ audio_stream_type_t stream,
+ bool forceDeviceUpdate)
{
- ALOGV("setForceUse() usage %d, config %d, mPhoneState %d", usage, config, mPhoneState);
+ // always handle stream stop, check which stream type is stopping
+ handleEventForBeacon(stream == AUDIO_STREAM_TTS ? STOPPING_BEACON : STOPPING_OUTPUT);
- bool forceVolumeReeval = false;
- switch(usage) {
- case AUDIO_POLICY_FORCE_FOR_COMMUNICATION:
- if (config != AUDIO_POLICY_FORCE_SPEAKER && config != AUDIO_POLICY_FORCE_BT_SCO &&
- config != AUDIO_POLICY_FORCE_NONE) {
- ALOGW("setForceUse() invalid config %d for FOR_COMMUNICATION", config);
- return;
+ // handle special case for sonification while in call
+ if (isInCall()) {
+ if (outputDesc->isDuplicated()) {
+ handleIncallSonification(stream, false, false, outputDesc->mIoHandle);
+ handleIncallSonification(stream, false, false, outputDesc->mIoHandle);
}
- forceVolumeReeval = true;
- mForceUse[usage] = config;
- break;
- case AUDIO_POLICY_FORCE_FOR_MEDIA:
- if (config != AUDIO_POLICY_FORCE_HEADPHONES && config != AUDIO_POLICY_FORCE_BT_A2DP &&
-#ifdef AUDIO_EXTN_FM_ENABLED
- config != AUDIO_POLICY_FORCE_SPEAKER &&
-#endif
- config != AUDIO_POLICY_FORCE_WIRED_ACCESSORY &&
- config != AUDIO_POLICY_FORCE_ANALOG_DOCK &&
- config != AUDIO_POLICY_FORCE_DIGITAL_DOCK && config != AUDIO_POLICY_FORCE_NONE &&
- config != AUDIO_POLICY_FORCE_NO_BT_A2DP) {
- ALOGW("setForceUse() invalid config %d for FOR_MEDIA", config);
- return;
+ handleIncallSonification(stream, false, false, outputDesc->mIoHandle);
+ }
+
+ if (outputDesc->mRefCount[stream] > 0) {
+ // decrement usage count of this stream on the output
+ outputDesc->changeRefCount(stream, -1);
+
+ // store time at which the stream was stopped - see isStreamActive()
+ if (outputDesc->mRefCount[stream] == 0 || forceDeviceUpdate) {
+ outputDesc->mStopTime[stream] = systemTime();
+ audio_devices_t newDevice = getNewOutputDevice(outputDesc, false /*fromCache*/);
+ // delay the device switch by twice the latency because stopOutput() is executed when
+ // the track stop() command is received and at that time the audio track buffer can
+ // still contain data that needs to be drained. The latency only covers the audio HAL
+ // and kernel buffers. Also the latency does not always include additional delay in the
+ // audio path (audio DSP, CODEC ...)
+ setOutputDevice(outputDesc, newDevice, false, outputDesc->latency()*2);
+
+ // force restoring the device selection on other active outputs if it differs from the
+ // one being selected for this output
+ for (size_t i = 0; i < mOutputs.size(); i++) {
+ audio_io_handle_t curOutput = mOutputs.keyAt(i);
+ sp<AudioOutputDescriptor> desc = mOutputs.valueAt(i);
+ if (desc != outputDesc &&
+ desc->isActive() &&
+ outputDesc->sharesHwModuleWith(desc) &&
+ (newDevice != desc->device())) {
+ setOutputDevice(desc,
+ getNewOutputDevice(desc, false /*fromCache*/),
+ true,
+ outputDesc->latency()*2);
+ }
+ }
+ // update the outputs if stopping one with a stream that can affect notification routing
+ handleNotificationRoutingForStream(stream);
}
- mForceUse[usage] = config;
- break;
- case AUDIO_POLICY_FORCE_FOR_RECORD:
- if (config != AUDIO_POLICY_FORCE_BT_SCO && config != AUDIO_POLICY_FORCE_WIRED_ACCESSORY &&
- config != AUDIO_POLICY_FORCE_NONE) {
- ALOGW("setForceUse() invalid config %d for FOR_RECORD", config);
- return;
+ return NO_ERROR;
+ } else {
+ ALOGW("stopOutput() refcount is already 0");
+ return INVALID_OPERATION;
+ }
+}
+status_t AudioPolicyManagerCustom::startSource(sp<SwAudioOutputDescriptor> outputDesc,
+ audio_stream_type_t stream,
+ audio_devices_t device,
+ uint32_t *delayMs)
+{
+ // cannot start playback of STREAM_TTS if any other output is being used
+ uint32_t beaconMuteLatency = 0;
+
+ *delayMs = 0;
+ if (stream == AUDIO_STREAM_TTS) {
+ ALOGV("\t found BEACON stream");
+ if (mOutputs.isAnyOutputActive(AUDIO_STREAM_TTS /*streamToIgnore*/)) {
+ return INVALID_OPERATION;
+ } else {
+ beaconMuteLatency = handleEventForBeacon(STARTING_BEACON);
}
- mForceUse[usage] = config;
- break;
- case AUDIO_POLICY_FORCE_FOR_DOCK:
- if (config != AUDIO_POLICY_FORCE_NONE && config != AUDIO_POLICY_FORCE_BT_CAR_DOCK &&
- config != AUDIO_POLICY_FORCE_BT_DESK_DOCK &&
- config != AUDIO_POLICY_FORCE_WIRED_ACCESSORY &&
- config != AUDIO_POLICY_FORCE_ANALOG_DOCK &&
- config != AUDIO_POLICY_FORCE_DIGITAL_DOCK) {
- ALOGW("setForceUse() invalid config %d for FOR_DOCK", config);
+ } else {
+ // some playback other than beacon starts
+ beaconMuteLatency = handleEventForBeacon(STARTING_OUTPUT);
+ }
+
+ // increment usage count for this stream on the requested output:
+ // NOTE that the usage count is the same for duplicated output and hardware output which is
+ // necessary for a correct control of hardware output routing by startOutput() and stopOutput()
+ outputDesc->changeRefCount(stream, 1);
+
+ if (outputDesc->mRefCount[stream] == 1 || device != AUDIO_DEVICE_NONE) {
+ // starting an output being rerouted?
+ if (device == AUDIO_DEVICE_NONE) {
+ device = getNewOutputDevice(outputDesc, false /*fromCache*/);
}
- forceVolumeReeval = true;
- mForceUse[usage] = config;
- break;
- case AUDIO_POLICY_FORCE_FOR_SYSTEM:
- if (config != AUDIO_POLICY_FORCE_NONE &&
- config != AUDIO_POLICY_FORCE_SYSTEM_ENFORCED) {
- ALOGW("setForceUse() invalid config %d for FOR_SYSTEM", config);
+ routing_strategy strategy = getStrategy(stream);
+ bool shouldWait = (strategy == STRATEGY_SONIFICATION) ||
+ (strategy == STRATEGY_SONIFICATION_RESPECTFUL) ||
+ (beaconMuteLatency > 0);
+ uint32_t waitMs = beaconMuteLatency;
+ bool force = false;
+ for (size_t i = 0; i < mOutputs.size(); i++) {
+ sp<AudioOutputDescriptor> desc = mOutputs.valueAt(i);
+ if (desc != outputDesc) {
+ // force a device change if any other output is managed by the same hw
+ // module and has a current device selection that differs from selected device.
+ // In this case, the audio HAL must receive the new device selection so that it can
+ // change the device currently selected by the other active output.
+ if (outputDesc->sharesHwModuleWith(desc) &&
+ desc->device() != device) {
+ force = true;
+ }
+ // wait for audio on other active outputs to be presented when starting
+ // a notification so that audio focus effect can propagate, or that a mute/unmute
+ // event occurred for beacon
+ uint32_t latency = desc->latency();
+ if (shouldWait && desc->isActive(latency * 2) && (waitMs < latency)) {
+ waitMs = latency;
+ }
+ }
}
- forceVolumeReeval = true;
- mForceUse[usage] = config;
- break;
- case AUDIO_POLICY_FORCE_FOR_HDMI_SYSTEM_AUDIO:
- if (config != AUDIO_POLICY_FORCE_NONE &&
- config != AUDIO_POLICY_FORCE_HDMI_SYSTEM_AUDIO_ENFORCED) {
- ALOGW("setForceUse() invalid config %d forHDMI_SYSTEM_AUDIO", config);
+ uint32_t muteWaitMs = setOutputDevice(outputDesc, device, force);
+
+ // handle special case for sonification while in call
+ if (isInCall()) {
+ handleIncallSonification(stream, true, false, outputDesc->mIoHandle);
}
- mForceUse[usage] = config;
+
+ // apply volume rules for current stream and device if necessary
+ checkAndSetVolume(stream,
+ mStreams.valueFor(stream).getVolumeIndex(device),
+ outputDesc,
+ device);
+
+ // update the outputs if starting an output with a stream that can affect notification
+ // routing
+ handleNotificationRoutingForStream(stream);
+
+ // force reevaluating accessibility routing when ringtone or alarm starts
+ if (strategy == STRATEGY_SONIFICATION) {
+ mpClientInterface->invalidateStream(AUDIO_STREAM_ACCESSIBILITY);
+ }
+ }
+ else {
+ // handle special case for sonification while in call
+ if (isInCall()) {
+ handleIncallSonification(stream, true, false, outputDesc->mIoHandle);
+ }
+ }
+ return NO_ERROR;
+}
+void AudioPolicyManagerCustom::handleIncallSonification(audio_stream_type_t stream,
+ bool starting, bool stateChange,
+ audio_io_handle_t output)
+{
+ if(!hasPrimaryOutput()) {
+ return;
+ }
+ // no action needed for AUDIO_STREAM_PATCH stream type, it's for internal flinger tracks
+ if (stream == AUDIO_STREAM_PATCH) {
+ return;
+ }
+ // if the stream pertains to sonification strategy and we are in call we must
+ // mute the stream if it is low visibility. If it is high visibility, we must play a tone
+ // in the device used for phone strategy and play the tone if the selected device does not
+ // interfere with the device used for phone strategy
+ // if stateChange is true, we are called from setPhoneState() and we must mute or unmute as
+ // many times as there are active tracks on the output
+ const routing_strategy stream_strategy = getStrategy(stream);
+ if ((stream_strategy == STRATEGY_SONIFICATION) ||
+ ((stream_strategy == STRATEGY_SONIFICATION_RESPECTFUL))) {
+ sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
+ ALOGV("handleIncallSonification() stream %d starting %d device %x stateChange %d",
+ stream, starting, outputDesc->mDevice, stateChange);
+ if (outputDesc->mRefCount[stream]) {
+ int muteCount = 1;
+ if (stateChange) {
+ muteCount = outputDesc->mRefCount[stream];
+ }
+ if (audio_is_low_visibility(stream)) {
+ ALOGV("handleIncallSonification() low visibility, muteCount %d", muteCount);
+ for (int i = 0; i < muteCount; i++) {
+ setStreamMute(stream, starting, outputDesc);
+ }
+ } else {
+ ALOGV("handleIncallSonification() high visibility");
+ if (outputDesc->device() &
+ getDeviceForStrategy(STRATEGY_PHONE, true /*fromCache*/)) {
+ ALOGV("handleIncallSonification() high visibility muted, muteCount %d", muteCount);
+ for (int i = 0; i < muteCount; i++) {
+ setStreamMute(stream, starting, outputDesc);
+ }
+ }
+ if (starting) {
+ mpClientInterface->startTone(AUDIO_POLICY_TONE_IN_CALL_NOTIFICATION,
+ AUDIO_STREAM_VOICE_CALL);
+ } else {
+ mpClientInterface->stopTone();
+ }
+ }
+ }
+ }
+}
+void AudioPolicyManagerCustom::handleNotificationRoutingForStream(audio_stream_type_t stream) {
+ switch(stream) {
+ case AUDIO_STREAM_MUSIC:
+ checkOutputForStrategy(STRATEGY_SONIFICATION_RESPECTFUL);
+ updateDevicesAndOutputs();
break;
default:
- ALOGW("setForceUse() invalid usage %d", usage);
break;
}
-
- // check for device and output changes triggered by new force usage
- checkA2dpSuspend();
- checkOutputForAllStrategies();
- updateDevicesAndOutputs();
- if (mPhoneState == AUDIO_MODE_IN_CALL) {
- audio_devices_t newDevice = getNewOutputDevice(mPrimaryOutput, true /*fromCache*/);
- updateCallRouting(newDevice);
- }
- for (size_t i = 0; i < mOutputs.size(); i++) {
- audio_io_handle_t output = mOutputs.keyAt(i);
- audio_devices_t newDevice = getNewOutputDevice(output, true /*fromCache*/);
- if ((mPhoneState != AUDIO_MODE_IN_CALL) || (output != mPrimaryOutput)) {
- setOutputDevice(output, newDevice, (newDevice != AUDIO_DEVICE_NONE));
- }
- if (forceVolumeReeval && (newDevice != AUDIO_DEVICE_NONE)) {
- applyStreamVolumes(output, newDevice, 0, true);
- }
- }
-
- audio_io_handle_t activeInput = getActiveInput();
- if (activeInput != 0) {
- setInputDevice(activeInput, getNewInputDevice(activeInput));
- }
-
}
+status_t AudioPolicyManagerCustom::checkAndSetVolume(audio_stream_type_t stream,
+ int index,
+ const sp<SwAudioOutputDescriptor>& outputDesc,
+ audio_devices_t device,
+ int delayMs, bool force)
+{
+ // do not change actual stream volume if the stream is muted
+ if (outputDesc->mMuteCount[stream] != 0) {
+ ALOGVV("checkAndSetVolume() stream %d muted count %d",
+ stream, outputDesc->mMuteCount[stream]);
+ return NO_ERROR;
+ }
+ audio_policy_forced_cfg_t forceUseForComm =
+ mEngine->getForceUse(AUDIO_POLICY_FORCE_FOR_COMMUNICATION);
+ // do not change in call volume if bluetooth is connected and vice versa
+ if ((stream == AUDIO_STREAM_VOICE_CALL && forceUseForComm == AUDIO_POLICY_FORCE_BT_SCO) ||
+ (stream == AUDIO_STREAM_BLUETOOTH_SCO && forceUseForComm != AUDIO_POLICY_FORCE_BT_SCO)) {
+ ALOGV("checkAndSetVolume() cannot set stream %d volume with force use = %d for comm",
+ stream, forceUseForComm);
+ return INVALID_OPERATION;
+ }
+ if (device == AUDIO_DEVICE_NONE) {
+ device = outputDesc->device();
+ }
+
+ float volumeDb = computeVolume(stream, index, device);
+ if (outputDesc->isFixedVolume(device)) {
+ volumeDb = 0.0f;
+ }
+
+ outputDesc->setVolume(volumeDb, stream, device, delayMs, force);
+
+ if (stream == AUDIO_STREAM_VOICE_CALL ||
+ stream == AUDIO_STREAM_BLUETOOTH_SCO) {
+ float voiceVolume;
+ // Force voice volume to max for bluetooth SCO as volume is managed by the headset
+ if (stream == AUDIO_STREAM_VOICE_CALL) {
+ voiceVolume = (float)index/(float)mStreams.valueFor(stream).getVolumeIndexMax();
+ } else {
+ voiceVolume = 1.0;
+ }
+
+ if (voiceVolume != mLastVoiceVolume && ((outputDesc == mPrimaryOutput) ||
+ isDirectOutput(outputDesc->mIoHandle) || device & AUDIO_DEVICE_OUT_ALL_USB)) {
+ mpClientInterface->setVoiceVolume(voiceVolume, delayMs);
+ mLastVoiceVolume = voiceVolume;
+ }
+ }
+
+ return NO_ERROR;
+}
+bool AudioPolicyManagerCustom::isDirectOutput(audio_io_handle_t output) {
+ for (size_t i = 0; i < mOutputs.size(); i++) {
+ audio_io_handle_t curOutput = mOutputs.keyAt(i);
+ sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
+ if ((curOutput == output) && (desc->mFlags & AUDIO_OUTPUT_FLAG_DIRECT)) {
+ return true;
+ }
+ }
+ return false;
+}
audio_io_handle_t AudioPolicyManagerCustom::getOutputForDevice(
audio_devices_t device,
+ audio_session_t session __unused,
audio_stream_type_t stream,
uint32_t samplingRate,
audio_format_t format,
@@ -764,7 +1146,8 @@
if (mTestOutputs[mCurOutput] == 0) {
ALOGV("getOutput() opening test output");
- sp<AudioOutputDescriptor> outputDesc = new AudioOutputDescriptor(NULL);
+ sp<AudioOutputDescriptor> outputDesc = new SwAudioOutputDescriptor(NULL,
+ mpClientInterface);
outputDesc->mDevice = mTestDevice;
outputDesc->mLatency = mTestLatencyMs;
outputDesc->mFlags =
@@ -797,6 +1180,57 @@
return mTestOutputs[mCurOutput];
}
#endif //AUDIO_POLICY_TEST
+ if (((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) &&
+ (stream != AUDIO_STREAM_MUSIC)) {
+ // compress should not be used for non-music streams
+ ALOGE("Offloading only allowed with music stream");
+ return 0;
+ }
+
+ if ((stream == AUDIO_STREAM_VOICE_CALL) &&
+ (channelMask == 1) &&
+ (samplingRate == 8000 || samplingRate == 16000)) {
+ // Allow Voip direct output only if:
+ // audio mode is MODE_IN_COMMUNCATION; AND
+ // voip output is not opened already; AND
+ // requested sample rate matches with that of voip input stream (if opened already)
+ int value = 0;
+ uint32_t mode = 0, voipOutCount = 1, voipSampleRate = 1;
+ String8 valueStr = mpClientInterface->getParameters((audio_io_handle_t)0,
+ String8("audio_mode"));
+ AudioParameter result = AudioParameter(valueStr);
+ if (result.getInt(String8("audio_mode"), value) == NO_ERROR) {
+ mode = value;
+ }
+
+ valueStr = mpClientInterface->getParameters((audio_io_handle_t)0,
+ String8("voip_out_stream_count"));
+ result = AudioParameter(valueStr);
+ if (result.getInt(String8("voip_out_stream_count"), value) == NO_ERROR) {
+ voipOutCount = value;
+ }
+
+ valueStr = mpClientInterface->getParameters((audio_io_handle_t)0,
+ String8("voip_sample_rate"));
+ result = AudioParameter(valueStr);
+ if (result.getInt(String8("voip_sample_rate"), value) == NO_ERROR) {
+ voipSampleRate = value;
+ }
+
+ if ((mode == AUDIO_MODE_IN_COMMUNICATION) && (voipOutCount == 0) &&
+ ((voipSampleRate == 0) || (voipSampleRate == samplingRate))) {
+ if (audio_is_linear_pcm(format)) {
+ char propValue[PROPERTY_VALUE_MAX] = {0};
+ property_get("use.voice.path.for.pcm.voip", propValue, "0");
+ bool voipPcmSysPropEnabled = !strncmp("true", propValue, sizeof("true"));
+ if (voipPcmSysPropEnabled && (format == AUDIO_FORMAT_PCM_16_BIT)) {
+ flags = (audio_output_flags_t)((flags &~AUDIO_OUTPUT_FLAG_FAST) |
+ AUDIO_OUTPUT_FLAG_VOIP_RX | AUDIO_OUTPUT_FLAG_DIRECT);
+ ALOGD("Set VoIP and Direct output flags for PCM format");
+ }
+ }
+ }
+ }
#ifdef VOICE_CONCURRENCY
char propValue[PROPERTY_VALUE_MAX];
@@ -812,52 +1246,49 @@
if (prop_play_enabled && mvoice_call_state) {
//check if voice call is active / running in background
- if((AUDIO_MODE_IN_CALL == mPhoneState) ||
+ if((AUDIO_MODE_IN_CALL == mEngine->getPhoneState()) ||
((AUDIO_MODE_IN_CALL == mPrevPhoneState)
- && (AUDIO_MODE_IN_COMMUNICATION == mPhoneState)))
+ && (AUDIO_MODE_IN_COMMUNICATION == mEngine->getPhoneState())))
{
if(AUDIO_OUTPUT_FLAG_VOIP_RX & flags) {
if(prop_voip_enabled) {
- ALOGD(" IN call mode returing no output .. for VoIP usecase flags: %x ", flags );
- // flags = (AudioSystem::output_flags)AUDIO_OUTPUT_FLAG_FAST;
+ ALOGD("voice_conc:getoutput:IN call mode return no o/p for VoIP %x",
+ flags );
return 0;
}
}
else {
- ALOGD(" IN call mode adding ULL flags .. flags: %x ", flags );
- flags = AUDIO_OUTPUT_FLAG_FAST;
+ if (AUDIO_OUTPUT_FLAG_FAST == mFallBackflag) {
+ ALOGD("voice_conc:IN call mode adding ULL flags .. flags: %x ", flags );
+ flags = AUDIO_OUTPUT_FLAG_FAST;
+ } else if (AUDIO_OUTPUT_FLAG_DEEP_BUFFER == mFallBackflag) {
+ if (AUDIO_STREAM_MUSIC == stream) {
+ flags = AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
+ ALOGD("voice_conc:IN call mode adding deep-buffer flags %x ", flags );
+ }
+ else {
+ flags = AUDIO_OUTPUT_FLAG_FAST;
+ ALOGD("voice_conc:IN call mode adding fast flags %x ", flags );
+ }
+ }
}
}
} else if (prop_voip_enabled && mvoice_call_state) {
//check if voice call is active / running in background
//some of VoIP apps(like SIP2SIP call) supports resume of VoIP call when call in progress
//return only ULL ouput
- if((AUDIO_MODE_IN_CALL == mPhoneState) ||
+ if((AUDIO_MODE_IN_CALL == mEngine->getPhoneState()) ||
((AUDIO_MODE_IN_CALL == mPrevPhoneState)
- && (AUDIO_MODE_IN_COMMUNICATION == mPhoneState)))
+ && (AUDIO_MODE_IN_COMMUNICATION == mEngine->getPhoneState())))
{
if(AUDIO_OUTPUT_FLAG_VOIP_RX & flags) {
- ALOGD(" IN call mode returing no output .. for VoIP usecase flags: %x ", flags );
- // flags = (AudioSystem::output_flags)AUDIO_OUTPUT_FLAG_FAST;
+ ALOGD("voice_conc:getoutput:IN call mode return no o/p for VoIP %x",
+ flags );
return 0;
}
}
- }
+ }
#endif
-
-#ifdef WFD_CONCURRENCY
- audio_devices_t availableOutputDeviceTypes = mAvailableOutputDevices.types();
- if ((availableOutputDeviceTypes & AUDIO_DEVICE_OUT_PROXY)
- && (stream != AUDIO_STREAM_MUSIC)) {
- ALOGD(" WFD mode adding ULL flags for non music stream.. flags: %x ", flags );
- //For voip paths
- if(flags & AUDIO_OUTPUT_FLAG_DIRECT)
- flags = AUDIO_OUTPUT_FLAG_DIRECT;
- else //route every thing else to ULL path
- flags = AUDIO_OUTPUT_FLAG_FAST;
- }
-#endif
-
#ifdef RECORD_PLAY_CONCURRENCY
char recConcPropValue[PROPERTY_VALUE_MAX];
bool prop_rec_play_enabled = false;
@@ -866,18 +1297,18 @@
prop_rec_play_enabled = atoi(recConcPropValue) || !strncmp("true", recConcPropValue, 4);
}
if ((prop_rec_play_enabled) &&
- ((true == mIsInputRequestOnProgress) || (activeInputsCount() > 0))) {
- if (AUDIO_MODE_IN_COMMUNICATION == mPhoneState) {
+ ((true == mIsInputRequestOnProgress) || (mInputs.activeInputsCount() > 0))) {
+ if (AUDIO_MODE_IN_COMMUNICATION == mEngine->getPhoneState()) {
if (AUDIO_OUTPUT_FLAG_VOIP_RX & flags) {
// allow VoIP using voice path
// Do nothing
- } else if((flags & AUDIO_OUTPUT_FLAG_FAST) != 0) {
- ALOGD(" MODE_IN_COMM is setforcing deep buffer output for non ULL... flags: %x", flags);
+ } else if((flags & AUDIO_OUTPUT_FLAG_FAST) == 0) {
+ ALOGD("voice_conc:MODE_IN_COMM is setforcing deep buffer output for non ULL... flags: %x", flags);
// use deep buffer path for all non ULL outputs
flags = AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
}
- } else if ((flags & AUDIO_OUTPUT_FLAG_FAST) != 0) {
- ALOGD(" Record mode is on forcing deep buffer output for non ULL... flags: %x ", flags);
+ } else if ((flags & AUDIO_OUTPUT_FLAG_FAST) == 0) {
+ ALOGD("voice_conc:Record mode is on forcing deep buffer output for non ULL... flags: %x ", flags);
// use deep buffer path for all non ULL outputs
flags = AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
}
@@ -888,6 +1319,26 @@
flags = AUDIO_OUTPUT_FLAG_FAST;
}
#endif
+
+ /*
+ * WFD audio routes back to target speaker when starting a ringtone playback.
+ * This is because primary output is reused for ringtone, so output device is
+ * updated based on SONIFICATION strategy for both ringtone and music playback.
+ * The same issue is not seen on remoted_submix HAL based WFD audio because
+ * primary output is not reused and a new output is created for ringtone playback.
+ * Issue is fixed by updating output flag to AUDIO_OUTPUT_FLAG_FAST when there is
+ * a non-music stream playback on WFD, so primary output is not reused for ringtone.
+ */
+ audio_devices_t availableOutputDeviceTypes = mAvailableOutputDevices.types();
+ if ((availableOutputDeviceTypes & AUDIO_DEVICE_OUT_PROXY)
+ && (stream != AUDIO_STREAM_MUSIC)) {
+ ALOGD("WFD audio: use OUTPUT_FLAG_FAST for non music stream. flags:%x", flags );
+ //For voip paths
+ if(flags & AUDIO_OUTPUT_FLAG_DIRECT)
+ flags = AUDIO_OUTPUT_FLAG_DIRECT;
+ else //route every thing else to ULL path
+ flags = AUDIO_OUTPUT_FLAG_FAST;
+ }
// open a direct output if required by specified parameters
//force direct flag if offload flag is set: offloading implies a direct output stream
// and all common behaviors are driven by checking only the direct flag
@@ -898,10 +1349,35 @@
if ((flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) {
flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_DIRECT);
}
+ // only allow deep buffering for music stream type
+ if (stream != AUDIO_STREAM_MUSIC) {
+ flags = (audio_output_flags_t)(flags &~AUDIO_OUTPUT_FLAG_DEEP_BUFFER);
+ }
+ if (stream == AUDIO_STREAM_TTS) {
+ flags = AUDIO_OUTPUT_FLAG_TTS;
+ }
- if ((format == AUDIO_FORMAT_PCM_16_BIT) &&(popcount(channelMask) > 2)) {
- ALOGV("owerwrite flag(%x) for PCM16 multi-channel(CM:%x) playback", flags ,channelMask);
- flags = AUDIO_OUTPUT_FLAG_DIRECT;
+ // open a direct output if required by specified parameters
+ //force direct flag if offload flag is set: offloading implies a direct output stream
+ // and all common behaviors are driven by checking only the direct flag
+ // this should normally be set appropriately in the policy configuration file
+ if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
+ flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_DIRECT);
+ }
+ if ((flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) != 0) {
+ flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_DIRECT);
+ }
+ // only allow deep buffering for music stream type
+ if (stream != AUDIO_STREAM_MUSIC) {
+ flags = (audio_output_flags_t)(flags &~AUDIO_OUTPUT_FLAG_DEEP_BUFFER);
+ } else if (/* stream == AUDIO_STREAM_MUSIC && */
+ flags == AUDIO_OUTPUT_FLAG_NONE &&
+ property_get_bool("audio.deep_buffer.media", false /* default_value */)) {
+ flags = (audio_output_flags_t)AUDIO_OUTPUT_FLAG_DEEP_BUFFER;
+ }
+
+ if (stream == AUDIO_STREAM_TTS) {
+ flags = AUDIO_OUTPUT_FLAG_TTS;
}
sp<IOProfile> profile;
@@ -921,9 +1397,8 @@
// This may prevent offloading in rare situations where effects are left active by apps
// in the background.
- if ((((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) ||
- !isNonOffloadableEffectEnabled()) &&
- flags & AUDIO_OUTPUT_FLAG_DIRECT) {
+ if (((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) ||
+ !mEffects.isNonOffloadableEffectEnabled()) {
profile = getProfileForDirectOutput(device,
samplingRate,
format,
@@ -932,10 +1407,10 @@
}
if (profile != 0) {
- sp<AudioOutputDescriptor> outputDesc = NULL;
+ sp<SwAudioOutputDescriptor> outputDesc = NULL;
for (size_t i = 0; i < mOutputs.size(); i++) {
- sp<AudioOutputDescriptor> desc = mOutputs.valueAt(i);
+ sp<SwAudioOutputDescriptor> desc = mOutputs.valueAt(i);
if (!desc->isDuplicated() && (profile == desc->mProfile)) {
outputDesc = desc;
// reuse direct output if currently open and configured with same parameters
@@ -952,10 +1427,27 @@
if (outputDesc != NULL) {
closeOutput(outputDesc->mIoHandle);
}
- outputDesc = new AudioOutputDescriptor(profile);
+
+ // if the selected profile is offloaded and no offload info was specified,
+ // create a default one
+ audio_offload_info_t defaultOffloadInfo = AUDIO_INFO_INITIALIZER;
+ if ((profile->mFlags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) && !offloadInfo) {
+ flags = (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD);
+ defaultOffloadInfo.sample_rate = samplingRate;
+ defaultOffloadInfo.channel_mask = channelMask;
+ defaultOffloadInfo.format = format;
+ defaultOffloadInfo.stream_type = stream;
+ defaultOffloadInfo.bit_rate = 0;
+ defaultOffloadInfo.duration_us = -1;
+ defaultOffloadInfo.has_video = true; // conservative
+ defaultOffloadInfo.is_streaming = true; // likely
+ offloadInfo = &defaultOffloadInfo;
+ }
+
+ outputDesc = new SwAudioOutputDescriptor(profile, mpClientInterface);
outputDesc->mDevice = device;
outputDesc->mLatency = 0;
- outputDesc->mFlags =(audio_output_flags_t) (outputDesc->mFlags | flags);
+ outputDesc->mFlags = (audio_output_flags_t)(outputDesc->mFlags | flags);
audio_config_t config = AUDIO_CONFIG_INITIALIZER;
config.sample_rate = samplingRate;
config.channel_mask = channelMask;
@@ -963,7 +1455,7 @@
if (offloadInfo != NULL) {
config.offload_info = *offloadInfo;
}
- status = mpClientInterface->openOutput(profile->mModule->mHandle,
+ status = mpClientInterface->openOutput(profile->getModuleHandle(),
&output,
&config,
&outputDesc->mDevice,
@@ -983,6 +1475,10 @@
if (output != AUDIO_IO_HANDLE_NONE) {
mpClientInterface->closeOutput(output);
}
+ // fall back to mixer output if possible when the direct output could not be open
+ if (audio_is_linear_pcm(format) && samplingRate <= MAX_MIXER_SAMPLING_RATE) {
+ goto non_direct_output;
+ }
return AUDIO_IO_HANDLE_NONE;
}
outputDesc->mSamplingRate = config.sample_rate;
@@ -1005,7 +1501,6 @@
}
non_direct_output:
-
// ignoring channel mask due to downmix capability in mixer
// open a non direct output
@@ -1023,109 +1518,23 @@
ALOGW_IF((output == 0), "getOutput() could not find output for stream %d, samplingRate %d,"
"format %d, channels %x, flags %x", stream, samplingRate, format, channelMask, flags);
- ALOGV("getOutput() returns output %d", output);
+ ALOGV(" getOutputForDevice() returns output %d", output);
return output;
}
-
-status_t AudioPolicyManagerCustom::stopOutput(audio_io_handle_t output,
- audio_stream_type_t stream,
- int session)
+status_t AudioPolicyManagerCustom::getInputForAttr(const audio_attributes_t *attr,
+ audio_io_handle_t *input,
+ audio_session_t session,
+ uid_t uid,
+ uint32_t samplingRate,
+ audio_format_t format,
+ audio_channel_mask_t channelMask,
+ audio_input_flags_t flags,
+ audio_port_handle_t selectedDeviceId,
+ input_type_t *inputType)
{
- ALOGV("stopOutput() output %d, stream %d, session %d", output, stream, session);
- ssize_t index = mOutputs.indexOfKey(output);
- if (index < 0) {
- ALOGW("stopOutput() unknown output %d", output);
- return BAD_VALUE;
- }
-
- sp<AudioOutputDescriptor> outputDesc = mOutputs.valueAt(index);
-
- // handle special case for sonification while in call
- if ((isInCall()) && (outputDesc->mRefCount[stream] == 1)) {
- handleIncallSonification(stream, false, false);
- }
-
- if (outputDesc->mRefCount[stream] > 0) {
- // decrement usage count of this stream on the output
- outputDesc->changeRefCount(stream, -1);
- // store time at which the stream was stopped - see isStreamActive()
- if (outputDesc->mRefCount[stream] == 0) {
- outputDesc->mStopTime[stream] = systemTime();
- audio_devices_t newDevice = getNewOutputDevice(output, false /*fromCache*/);
- // delay the device switch by twice the latency because stopOutput() is executed when
- // the track stop() command is received and at that time the audio track buffer can
- // still contain data that needs to be drained. The latency only covers the audio HAL
- // and kernel buffers. Also the latency does not always include additional delay in the
- // audio path (audio DSP, CODEC ...)
- setOutputDevice(output, newDevice, false, outputDesc->mLatency*2);
-
- // force restoring the device selection on other active outputs if it differs from the
- // one being selected for this output
- for (size_t i = 0; i < mOutputs.size(); i++) {
- audio_io_handle_t curOutput = mOutputs.keyAt(i);
- sp<AudioOutputDescriptor> desc = mOutputs.valueAt(i);
- if (curOutput != output &&
- desc->isActive() &&
- outputDesc->sharesHwModuleWith(desc) &&
- (newDevice != desc->device())) {
- setOutputDevice(curOutput,
- getNewOutputDevice(curOutput, false /*fromCache*/),
- true,
- outputDesc->mLatency*2);
- }
- }
- // update the outputs if stopping one with a stream that can affect notification routing
- handleNotificationRoutingForStream(stream);
- }
- return NO_ERROR;
- } else {
- ALOGW("stopOutput() refcount is already 0 for output %d", output);
- return INVALID_OPERATION;
- }
-}
-
-audio_io_handle_t AudioPolicyManagerCustom::getInput(audio_source_t inputSource,
- uint32_t samplingRate,
- audio_format_t format,
- audio_channel_mask_t channelMask,
- audio_session_t session,
- audio_input_flags_t flags)
-{
- ALOGV("getInput() inputSource %d, samplingRate %d, format %d, channelMask %x, session %d, "
- "flags %#x",
- inputSource, samplingRate, format, channelMask, session, flags);
-
- audio_devices_t device = getDeviceForInputSource(inputSource);
-
- if (device == AUDIO_DEVICE_NONE) {
- ALOGW("getInput() could not find device for inputSource %d", inputSource);
- return AUDIO_IO_HANDLE_NONE;
- }
-
- /*The below code is intentionally not ported.
- It's not needed to update the channel mask based on source because
- the source is sent to audio HAL through set_parameters().
- For example, if source = VOICE_CALL, does not mean we need to capture two channels.
- If the sound recorder app selects AMR as encoding format but source as RX+TX,
- we need both in ONE channel. So we use the channels set by the app and use source
- to tell the driver what needs to captured (RX only, TX only, or RX+TX ).*/
- // adapt channel selection to input source
- /*switch (inputSource) {
- case AUDIO_SOURCE_VOICE_UPLINK:
- channelMask = AUDIO_CHANNEL_IN_VOICE_UPLINK;
- break;
- case AUDIO_SOURCE_VOICE_DOWNLINK:
- channelMask = AUDIO_CHANNEL_IN_VOICE_DNLINK;
- break;
- case AUDIO_SOURCE_VOICE_CALL:
- channelMask = AUDIO_CHANNEL_IN_VOICE_UPLINK | AUDIO_CHANNEL_IN_VOICE_DNLINK;
- break;
- default:
- break;
- }*/
-
+ audio_source_t inputSource = attr->source;
#ifdef VOICE_CONCURRENCY
char propValue[PROPERTY_VALUE_MAX];
@@ -1137,32 +1546,35 @@
if(property_get("voice.voip.conc.disabled", propValue, NULL)) {
prop_voip_enabled = atoi(propValue) || !strncmp("true", propValue, 4);
- }
+ }
if (prop_rec_enabled && mvoice_call_state) {
//check if voice call is active / running in background
//some of VoIP apps(like SIP2SIP call) supports resume of VoIP call when call in progress
//Need to block input request
- if((AUDIO_MODE_IN_CALL == mPhoneState) ||
+ if((AUDIO_MODE_IN_CALL == mEngine->getPhoneState()) ||
((AUDIO_MODE_IN_CALL == mPrevPhoneState) &&
- (AUDIO_MODE_IN_COMMUNICATION == mPhoneState)))
+ (AUDIO_MODE_IN_COMMUNICATION == mEngine->getPhoneState())))
{
switch(inputSource) {
case AUDIO_SOURCE_VOICE_UPLINK:
case AUDIO_SOURCE_VOICE_DOWNLINK:
case AUDIO_SOURCE_VOICE_CALL:
- ALOGD("Creating input during incall mode for inputSource: %d ",inputSource);
+ ALOGD("voice_conc:Creating input during incall mode for inputSource: %d",
+ inputSource);
break;
case AUDIO_SOURCE_VOICE_COMMUNICATION:
if(prop_voip_enabled) {
- ALOGD("BLOCKING VoIP request during incall mode for inputSource: %d ",inputSource);
- return 0;
+ ALOGD("voice_conc:BLOCK VoIP requst incall mode for inputSource: %d",
+ inputSource);
+ return NO_INIT;
}
break;
default:
- ALOGD("BLOCKING input during incall mode for inputSource: %d ",inputSource);
- return 0;
+ ALOGD("voice_conc:BLOCK VoIP requst incall mode for inputSource: %d",
+ inputSource);
+ return NO_INIT;
}
}
}//check for VoIP flag
@@ -1170,103 +1582,30 @@
//check if voice call is active / running in background
//some of VoIP apps(like SIP2SIP call) supports resume of VoIP call when call in progress
//Need to block input request
- if((AUDIO_MODE_IN_CALL == mPhoneState) ||
+ if((AUDIO_MODE_IN_CALL == mEngine->getPhoneState()) ||
((AUDIO_MODE_IN_CALL == mPrevPhoneState) &&
- (AUDIO_MODE_IN_COMMUNICATION == mPhoneState)))
+ (AUDIO_MODE_IN_COMMUNICATION == mEngine->getPhoneState())))
{
if(inputSource == AUDIO_SOURCE_VOICE_COMMUNICATION) {
ALOGD("BLOCKING VoIP request during incall mode for inputSource: %d ",inputSource);
- return 0;
+ return NO_INIT;
}
}
}
#endif
- audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
- bool isSoundTrigger = false;
- audio_source_t halInputSource = inputSource;
- if (inputSource == AUDIO_SOURCE_HOTWORD) {
- ssize_t index = mSoundTriggerSessions.indexOfKey(session);
- if (index >= 0) {
- input = mSoundTriggerSessions.valueFor(session);
- isSoundTrigger = true;
- flags = (audio_input_flags_t)(flags | AUDIO_INPUT_FLAG_HW_HOTWORD);
- ALOGV("SoundTrigger capture on session %d input %d", session, input);
- } else {
- halInputSource = AUDIO_SOURCE_VOICE_RECOGNITION;
- }
- }
-
- sp<IOProfile> profile = getInputProfile(device,
- samplingRate,
- format,
- channelMask,
- flags);
- if (profile == 0) {
- //retry without flags
- audio_input_flags_t log_flags = flags;
- flags = AUDIO_INPUT_FLAG_NONE;
- profile = getInputProfile(device,
- samplingRate,
- format,
- channelMask,
- flags);
- if (profile == 0) {
- ALOGW("getInput() could not find profile for device 0x%X, samplingRate %u, format %#x, "
- "channelMask 0x%X, flags %#x",
- device, samplingRate, format, channelMask, log_flags);
- return AUDIO_IO_HANDLE_NONE;
- }
- }
-
- if (profile->mModule->mHandle == 0) {
- ALOGE("getInput(): HW module %s not opened", profile->mModule->mName);
- return AUDIO_IO_HANDLE_NONE;
- }
-
- audio_config_t config = AUDIO_CONFIG_INITIALIZER;
- config.sample_rate = samplingRate;
- config.channel_mask = channelMask;
- config.format = format;
-
- status_t status = mpClientInterface->openInput(profile->mModule->mHandle,
- &input,
- &config,
- &device,
- String8(""),
- halInputSource,
- flags);
-
- // only accept input with the exact requested set of parameters
- if (status != NO_ERROR ||
- (samplingRate != config.sample_rate) ||
- (format != config.format) ||
- (channelMask != config.channel_mask)) {
- ALOGW("getInput() failed opening input: samplingRate %d, format %d, channelMask %x",
- samplingRate, format, channelMask);
- if (input != AUDIO_IO_HANDLE_NONE) {
- mpClientInterface->closeInput(input);
- }
- return AUDIO_IO_HANDLE_NONE;
- }
-
- sp<AudioInputDescriptor> inputDesc = new AudioInputDescriptor(profile);
- inputDesc->mInputSource = inputSource;
- inputDesc->mRefCount = 0;
- inputDesc->mOpenRefCount = 1;
- inputDesc->mSamplingRate = samplingRate;
- inputDesc->mFormat = format;
- inputDesc->mChannelMask = channelMask;
- inputDesc->mDevice = device;
- inputDesc->mSessions.add(session);
- inputDesc->mIsSoundTrigger = isSoundTrigger;
-
- addInput(input, inputDesc);
- mpClientInterface->onAudioPortListUpdate();
- return input;
+ return AudioPolicyManager::getInputForAttr(attr,
+ input,
+ session,
+ uid,
+ samplingRate,
+ format,
+ channelMask,
+ flags,
+ selectedDeviceId,
+ inputType);
}
-
status_t AudioPolicyManagerCustom::startInput(audio_io_handle_t input,
audio_session_t session)
{
@@ -1285,10 +1624,10 @@
}
// virtual input devices are compatible with other input devices
- if (!isVirtualInputDevice(inputDesc->mDevice)) {
+ if (!is_virtual_input_device(inputDesc->mDevice)) {
// for a non-virtual input device, check if there is another (non-virtual) active input
- audio_io_handle_t activeInput = getActiveInput();
+ audio_io_handle_t activeInput = mInputs.getActiveInput();
if (activeInput != 0 && activeInput != input) {
// If the already active input uses AUDIO_SOURCE_HOTWORD then it is closed,
@@ -1305,6 +1644,8 @@
}
}
+ // Routing?
+ mInputRoutes.incRouteActivity(session);
#ifdef RECORD_PLAY_CONCURRENCY
mIsInputRequestOnProgress = true;
@@ -1315,7 +1656,7 @@
prop_rec_play_enabled = atoi(getPropValue) || !strncmp("true", getPropValue, 4);
}
- if ((prop_rec_play_enabled) &&(activeInputsCount() == 0)){
+ if ((prop_rec_play_enabled) &&(mInputs.activeInputsCount() == 0)){
// send update to HAL on record playback concurrency
AudioParameter param = AudioParameter();
param.add(String8("rec_play_conc_on"), String8("true"));
@@ -1326,7 +1667,7 @@
// Move tracks associated to this strategy from previous output to new output
for (int i = AUDIO_STREAM_SYSTEM; i < (int)AUDIO_STREAM_CNT; i++) {
// Do not call invalidate for ENFORCED_AUDIBLE (otherwise pops are seen for camcorder)
- if (i != AUDIO_STREAM_ENFORCED_AUDIBLE) {
+ if ((i != AUDIO_STREAM_ENFORCED_AUDIBLE && (i != AUDIO_STREAM_PATCH)) {
ALOGD("Invalidate on releaseInput for stream :: %d ", i);
//FIXME see fixme on name change
mpClientInterface->invalidateStream((audio_stream_type_t)i);
@@ -1334,7 +1675,7 @@
}
// close compress tracks
for (size_t i = 0; i < mOutputs.size(); i++) {
- sp<AudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
+ sp<SwAudioOutputDescriptor> outputDesc = mOutputs.valueAt(i);
if ((outputDesc == NULL) || (outputDesc->mProfile == NULL)) {
ALOGD("ouput desc / profile is NULL");
continue;
@@ -1349,21 +1690,38 @@
}
#endif
- if (inputDesc->mRefCount == 0) {
- if (activeInputsCount() == 0) {
+ if (inputDesc->mRefCount == 0 || mInputRoutes.hasRouteChanged(session)) {
+ // if input maps to a dynamic policy with an activity listener, notify of state change
+ if ((inputDesc->mPolicyMix != NULL)
+ && ((inputDesc->mPolicyMix->mCbFlags & AudioMix::kCbFlagNotifyActivity) != 0)) {
+ mpClientInterface->onDynamicPolicyMixStateUpdate(inputDesc->mPolicyMix->mRegistrationId,
+ MIX_STATE_MIXING);
+ }
+
+ if (mInputs.activeInputsCount() == 0) {
SoundTrigger::setCaptureState(true);
}
setInputDevice(input, getNewInputDevice(input), true /* force */);
- // Automatically enable the remote submix output when input is started.
+ // automatically enable the remote submix output when input is started if not
+ // used by a policy mix of type MIX_TYPE_RECORDERS
// For remote submix (a virtual device), we open only one input per capture request.
if (audio_is_remote_submix_device(inputDesc->mDevice)) {
- setDeviceConnectionState(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
- AUDIO_POLICY_DEVICE_STATE_AVAILABLE, AUDIO_REMOTE_SUBMIX_DEVICE_ADDRESS);
+ String8 address = String8("");
+ if (inputDesc->mPolicyMix == NULL) {
+ address = String8("0");
+ } else if (inputDesc->mPolicyMix->mMixType == MIX_TYPE_PLAYERS) {
+ address = inputDesc->mPolicyMix->mRegistrationId;
+ }
+ if (address != "") {
+ setDeviceConnectionStateInt(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
+ AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
+ address, "remote-submix");
+ }
}
}
- ALOGV("AudioPolicyManagerCustom::startInput() input source = %d", inputDesc->mInputSource);
+ ALOGV("AudioPolicyManager::startInput() input source = %d", inputDesc->mInputSource);
inputDesc->mRefCount++;
#ifdef RECORD_PLAY_CONCURRENCY
@@ -1371,45 +1729,11 @@
#endif
return NO_ERROR;
}
-
status_t AudioPolicyManagerCustom::stopInput(audio_io_handle_t input,
audio_session_t session)
{
- ALOGV("stopInput() input %d", input);
- ssize_t index = mInputs.indexOfKey(input);
- if (index < 0) {
- ALOGW("stopInput() unknown input %d", input);
- return BAD_VALUE;
- }
- sp<AudioInputDescriptor> inputDesc = mInputs.valueAt(index);
-
- index = inputDesc->mSessions.indexOf(session);
- if (index < 0) {
- ALOGW("stopInput() unknown session %d on input %d", session, input);
- return BAD_VALUE;
- }
-
- if (inputDesc->mRefCount == 0) {
- ALOGW("stopInput() input %d already stopped", input);
- return INVALID_OPERATION;
- }
-
- inputDesc->mRefCount--;
- if (inputDesc->mRefCount == 0) {
-
- // automatically disable the remote submix output when input is stopped
- if (audio_is_remote_submix_device(inputDesc->mDevice)) {
- setDeviceConnectionState(AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
- AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE, AUDIO_REMOTE_SUBMIX_DEVICE_ADDRESS);
- }
-
- resetInputDevice(input);
-
- if (activeInputsCount() == 0) {
- SoundTrigger::setCaptureState(false);
- }
- }
-
+ status_t status;
+ status = AudioPolicyManager::stopInput(input, session);
#ifdef RECORD_PLAY_CONCURRENCY
char propValue[PROPERTY_VALUE_MAX];
bool prop_rec_play_enabled = false;
@@ -1418,7 +1742,7 @@
prop_rec_play_enabled = atoi(propValue) || !strncmp("true", propValue, 4);
}
- if ((prop_rec_play_enabled) && (activeInputsCount() == 0)) {
+ if ((prop_rec_play_enabled) && (mInputs.activeInputsCount() == 0)) {
//send update to HAL on record playback concurrency
AudioParameter param = AudioParameter();
@@ -1429,7 +1753,7 @@
//call invalidate tracks so that any open streams can fall back to deep buffer/compress path from ULL
for (int i = AUDIO_STREAM_SYSTEM; i < (int)AUDIO_STREAM_CNT; i++) {
//Do not call invalidate for ENFORCED_AUDIBLE (otherwise pops are seen for camcorder stop tone)
- if (i != AUDIO_STREAM_ENFORCED_AUDIBLE) {
+ if ((i != AUDIO_STREAM_ENFORCED_AUDIBLE) && (i != AUDIO_STREAM_PATCH)) {
ALOGD(" Invalidate on stopInput for stream :: %d ", i);
//FIXME see fixme on name change
mpClientInterface->invalidateStream((audio_stream_type_t)i);
@@ -1437,921 +1761,46 @@
}
}
#endif
- return NO_ERROR;
-}
-
-status_t AudioPolicyManagerCustom::setStreamVolumeIndex(audio_stream_type_t stream,
- int index,
- audio_devices_t device)
-{
-
- if ((index < mStreams[stream].mIndexMin) || (index > mStreams[stream].mIndexMax)) {
- return BAD_VALUE;
- }
- if (!audio_is_output_device(device)) {
- return BAD_VALUE;
- }
-
- // Force max volume if stream cannot be muted
- if (!mStreams[stream].mCanBeMuted) index = mStreams[stream].mIndexMax;
-
- ALOGV("setStreamVolumeIndex() stream %d, device %04x, index %d",
- stream, device, index);
-
- // if device is AUDIO_DEVICE_OUT_DEFAULT set default value and
- // clear all device specific values
- if (device == AUDIO_DEVICE_OUT_DEFAULT) {
- mStreams[stream].mIndexCur.clear();
- }
- mStreams[stream].mIndexCur.add(device, index);
-
- // compute and apply stream volume on all outputs according to connected device
- status_t status = NO_ERROR;
- for (size_t i = 0; i < mOutputs.size(); i++) {
- audio_devices_t curDevice =
- getDeviceForVolume(mOutputs.valueAt(i)->device());
-#ifdef AUDIO_EXTN_FM_ENABLED
- audio_devices_t availableOutputDeviceTypes = mAvailableOutputDevices.types();
- if (((device == AUDIO_DEVICE_OUT_DEFAULT) &&
- ((availableOutputDeviceTypes & AUDIO_DEVICE_OUT_FM) != AUDIO_DEVICE_OUT_FM)) ||
- (device == curDevice)) {
-#else
- if ((device == AUDIO_DEVICE_OUT_DEFAULT) || (device == curDevice)) {
-#endif
- status_t volStatus = checkAndSetVolume(stream, index, mOutputs.keyAt(i), curDevice);
- if (volStatus != NO_ERROR) {
- status = volStatus;
- }
- }
- }
return status;
}
-// This function checks for the parameters which can be offloaded.
-// This can be enhanced depending on the capability of the DSP and policy
-// of the system.
-bool AudioPolicyManagerCustom::isOffloadSupported(const audio_offload_info_t& offloadInfo)
+audio_devices_t AudioPolicyManagerCustom::getDeviceForStrategy(routing_strategy strategy, bool fromCache)
{
- ALOGD("copl: isOffloadSupported: SR=%u, CM=0x%x, Format=0x%x, StreamType=%d,"
- " BitRate=%u, duration=%lld us, has_video=%d",
- offloadInfo.sample_rate, offloadInfo.channel_mask,
- offloadInfo.format,
- offloadInfo.stream_type, offloadInfo.bit_rate, offloadInfo.duration_us,
- offloadInfo.has_video);
+ audio_devices_t availableOutputDeviceTypes = mAvailableOutputDevices.types();
+ audio_devices_t device = AUDIO_DEVICE_NONE;
+ switch (strategy) {
+ case STRATEGY_SONIFICATION:
+ case STRATEGY_ENFORCED_AUDIBLE:
+ case STRATEGY_ACCESSIBILITY:
+ case STRATEGY_REROUTING:
+ case STRATEGY_MEDIA:
+ if (strategy != STRATEGY_SONIFICATION){
+ // no sonification on WFD sink
+ device |= availableOutputDeviceTypes & AUDIO_DEVICE_OUT_PROXY;
+ if (device != AUDIO_DEVICE_NONE) {
+ ALOGV("Found proxy for strategy %d", strategy);
+ return device;
+ }
+ }
+ break;
+ default:
+ ALOGV("getDeviceForStrategy() unknown strategy: %d", strategy);
+ break;
+ }
+ device = AudioPolicyManager::getDeviceForStrategy(strategy, fromCache);
+ return device;
+}
+
+AudioPolicyManagerCustom::AudioPolicyManagerCustom(AudioPolicyClientInterface *clientInterface)
+ : AudioPolicyManager(clientInterface)
+{
+#ifdef RECORD_PLAY_CONCURRENCY
+ mIsInputRequestOnProgress = false;
+#endif
+
#ifdef VOICE_CONCURRENCY
- char concpropValue[PROPERTY_VALUE_MAX];
- if (property_get("voice.playback.conc.disabled", concpropValue, NULL)) {
- bool propenabled = atoi(concpropValue) || !strncmp("true", concpropValue, 4);
- if (propenabled) {
- if (isInCall())
- {
- ALOGD("\n copl: blocking compress offload on call mode\n");
- return false;
- }
- }
- }
+ mFallBackflag = getFallBackPath();
#endif
-#ifdef RECORD_PLAY_CONCURRENCY
- char recConcPropValue[PROPERTY_VALUE_MAX];
- bool prop_rec_play_enabled = false;
-
- if (property_get("rec.playback.conc.disabled", recConcPropValue, NULL)) {
- prop_rec_play_enabled = atoi(recConcPropValue) || !strncmp("true", recConcPropValue, 4);
- }
-
- if ((prop_rec_play_enabled) &&
- ((true == mIsInputRequestOnProgress) || (activeInputsCount() > 0))) {
- ALOGD("copl: blocking compress offload for record concurrency");
- return false;
- }
-#endif
- // Check if stream type is music, then only allow offload as of now.
- if (offloadInfo.stream_type != AUDIO_STREAM_MUSIC)
- {
- ALOGD("isOffloadSupported: stream_type != MUSIC, returning false");
- return false;
- }
-
- char propValue[PROPERTY_VALUE_MAX];
- bool pcmOffload = false;
-#ifdef PCM_OFFLOAD_ENABLED
- if (audio_is_offload_pcm(offloadInfo.format)) {
- if(property_get("audio.offload.pcm.enable", propValue, NULL)) {
- bool prop_enabled = atoi(propValue) || !strncmp("true", propValue, 4);
- if (prop_enabled) {
- ALOGW("PCM offload property is enabled");
- pcmOffload = true;
- }
- }
- if (!pcmOffload) {
- ALOGD("PCM offload disabled by property audio.offload.pcm.enable");
- return false;
- }
- }
-#endif
-
- if (!pcmOffload) {
- // Check if offload has been disabled
- if (property_get("audio.offload.disable", propValue, "0")) {
- if (atoi(propValue) != 0) {
- ALOGD("offload disabled by audio.offload.disable=%s", propValue );
- return false;
- }
- }
-
- //check if it's multi-channel AAC (includes sub formats), FLAC and VORBIS format
- if ((popcount(offloadInfo.channel_mask) > 2) &&
- (((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_AAC) ||
- ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_FLAC) ||
- ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_VORBIS))) {
- ALOGD("offload disabled for multi-channel AAC and FLAC format");
- return false;
- }
-
- if (offloadInfo.has_video)
- {
- if(property_get("av.offload.enable", propValue, NULL)) {
- bool prop_enabled = atoi(propValue) || !strncmp("true", propValue, 4);
- if (!prop_enabled) {
- ALOGW("offload disabled by av.offload.enable = %s ", propValue );
- return false;
- }
- } else {
- return false;
- }
-
- if(offloadInfo.is_streaming) {
- if (property_get("av.streaming.offload.enable", propValue, NULL)) {
- bool prop_enabled = atoi(propValue) || !strncmp("true", propValue, 4);
- if (!prop_enabled) {
- ALOGW("offload disabled by av.streaming.offload.enable = %s ", propValue );
- return false;
- }
- } else {
- //Do not offload AV streamnig if the property is not defined
- return false;
- }
- }
- ALOGD("copl: isOffloadSupported: has_video == true, property\
- set to enable offload");
- }
- }
-
- //If duration is less than minimum value defined in property, return false
- if (property_get("audio.offload.min.duration.secs", propValue, NULL)) {
- if (offloadInfo.duration_us < (atoi(propValue) * 1000000 )) {
- ALOGD("copl: Offload denied by duration < audio.offload.min.duration.secs(=%s)", propValue);
- return false;
- }
- } else if (offloadInfo.duration_us < OFFLOAD_DEFAULT_MIN_DURATION_SECS * 1000000) {
- ALOGD("copl: Offload denied by duration < default min(=%u)", OFFLOAD_DEFAULT_MIN_DURATION_SECS);
- //duration checks only valid for MP3/AAC/VORBIS/WMA/ALAC/APE formats,
- //do not check duration for other audio formats, e.g. dolby AAC/AC3 and amrwb+ formats
- if ((offloadInfo.format == AUDIO_FORMAT_MP3) ||
- ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_AAC) ||
- ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_FLAC) ||
- ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_VORBIS) ||
- ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_WMA) ||
- ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_WMA_PRO) ||
- ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_ALAC) ||
- ((offloadInfo.format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_APE) ||
- pcmOffload)
- return false;
- }
-
- // Do not allow offloading if one non offloadable effect is enabled. This prevents from
- // creating an offloaded track and tearing it down immediately after start when audioflinger
- // detects there is an active non offloadable effect.
- // FIXME: We should check the audio session here but we do not have it in this context.
- // This may prevent offloading in rare situations where effects are left active by apps
- // in the background.
- if (isNonOffloadableEffectEnabled()) {
- return false;
- }
-
- // See if there is a profile to support this.
- // AUDIO_DEVICE_NONE
- sp<IOProfile> profile = getProfileForDirectOutput(AUDIO_DEVICE_NONE /*ignore device */,
- offloadInfo.sample_rate,
- offloadInfo.format,
- offloadInfo.channel_mask,
- AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD);
- ALOGD("copl: isOffloadSupported() profile %sfound", profile != 0 ? "" : "NOT ");
- return (profile != 0);
}
-
-uint32_t AudioPolicyManagerCustom::nextUniqueId()
-{
- return android_atomic_inc(&mNextUniqueId);
}
-
-AudioPolicyManagerCustom::routing_strategy AudioPolicyManagerCustom::getStrategy(
- audio_stream_type_t stream) {
- // stream to strategy mapping
- switch (stream) {
- case AUDIO_STREAM_VOICE_CALL:
- case AUDIO_STREAM_BLUETOOTH_SCO:
- return STRATEGY_PHONE;
- case AUDIO_STREAM_RING:
- case AUDIO_STREAM_ALARM:
- return STRATEGY_SONIFICATION;
- case AUDIO_STREAM_NOTIFICATION:
- return STRATEGY_SONIFICATION_RESPECTFUL;
- case AUDIO_STREAM_DTMF:
- return STRATEGY_DTMF;
- default:
- ALOGE("unknown stream type");
- case AUDIO_STREAM_SYSTEM:
- // NOTE: SYSTEM stream uses MEDIA strategy because muting music and switching outputs
- // while key clicks are played produces a poor result
- case AUDIO_STREAM_TTS:
- case AUDIO_STREAM_MUSIC:
-#ifdef AUDIO_EXTN_INCALL_MUSIC_ENABLED
- case AUDIO_STREAM_INCALL_MUSIC:
-#endif
- return STRATEGY_MEDIA;
- case AUDIO_STREAM_ENFORCED_AUDIBLE:
- return STRATEGY_ENFORCED_AUDIBLE;
- }
-}
-
-void AudioPolicyManagerCustom::handleNotificationRoutingForStream(audio_stream_type_t stream) {
- switch(stream) {
- case AUDIO_STREAM_MUSIC:
- checkOutputForStrategy(STRATEGY_SONIFICATION_RESPECTFUL);
- updateDevicesAndOutputs();
- break;
- default:
- break;
- }
-}
-
-audio_devices_t AudioPolicyManagerCustom::getDeviceForStrategy(routing_strategy strategy,
- bool fromCache)
-{
- uint32_t device = AUDIO_DEVICE_NONE;
-
- if (fromCache) {
- ALOGVV("getDeviceForStrategy() from cache strategy %d, device %x",
- strategy, mDeviceForStrategy[strategy]);
- return mDeviceForStrategy[strategy];
- }
- audio_devices_t availableOutputDeviceTypes = mAvailableOutputDevices.types();
- switch (strategy) {
-
- case STRATEGY_SONIFICATION_RESPECTFUL:
- if (isInCall()) {
- device = getDeviceForStrategy(STRATEGY_SONIFICATION, false /*fromCache*/);
- } else if (isStreamActiveRemotely(AUDIO_STREAM_MUSIC,
- SONIFICATION_RESPECTFUL_AFTER_MUSIC_DELAY)) {
- // while media is playing on a remote device, use the the sonification behavior.
- // Note that we test this usecase before testing if media is playing because
- // the isStreamActive() method only informs about the activity of a stream, not
- // if it's for local playback. Note also that we use the same delay between both tests
- device = getDeviceForStrategy(STRATEGY_SONIFICATION, false /*fromCache*/);
- //user "safe" speaker if available instead of normal speaker to avoid triggering
- //other acoustic safety mechanisms for notification
- if (device == AUDIO_DEVICE_OUT_SPEAKER && (availableOutputDeviceTypes & AUDIO_DEVICE_OUT_SPEAKER_SAFE))
- device = AUDIO_DEVICE_OUT_SPEAKER_SAFE;
- } else if (isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_RESPECTFUL_AFTER_MUSIC_DELAY)) {
- // while media is playing (or has recently played), use the same device
- device = getDeviceForStrategy(STRATEGY_MEDIA, false /*fromCache*/);
- } else {
- // when media is not playing anymore, fall back on the sonification behavior
- device = getDeviceForStrategy(STRATEGY_SONIFICATION, false /*fromCache*/);
- //user "safe" speaker if available instead of normal speaker to avoid triggering
- //other acoustic safety mechanisms for notification
- if (device == AUDIO_DEVICE_OUT_SPEAKER && (availableOutputDeviceTypes & AUDIO_DEVICE_OUT_SPEAKER_SAFE))
- device = AUDIO_DEVICE_OUT_SPEAKER_SAFE;
- }
-
- break;
-
- case STRATEGY_DTMF:
- if (!isInCall()) {
- // when off call, DTMF strategy follows the same rules as MEDIA strategy
- device = getDeviceForStrategy(STRATEGY_MEDIA, false /*fromCache*/);
- break;
- }
- // when in call, DTMF and PHONE strategies follow the same rules
- // FALL THROUGH
-
- case STRATEGY_PHONE:
- // Force use of only devices on primary output if:
- // - in call AND
- // - cannot route from voice call RX OR
- // - audio HAL version is < 3.0 and TX device is on the primary HW module
- if (mPhoneState == AUDIO_MODE_IN_CALL) {
- audio_devices_t txDevice = getDeviceForInputSource(AUDIO_SOURCE_VOICE_COMMUNICATION);
- sp<AudioOutputDescriptor> hwOutputDesc = mOutputs.valueFor(mPrimaryOutput);
- if (((mAvailableInputDevices.types() &
- AUDIO_DEVICE_IN_TELEPHONY_RX & ~AUDIO_DEVICE_BIT_IN) == 0) ||
- (((txDevice & availablePrimaryInputDevices() & ~AUDIO_DEVICE_BIT_IN) != 0) &&
- (hwOutputDesc->getAudioPort()->mModule->mHalVersion <
- AUDIO_DEVICE_API_VERSION_3_0))) {
- availableOutputDeviceTypes = availablePrimaryOutputDevices();
- }
- }
- // for phone strategy, we first consider the forced use and then the available devices by order
- // of priority
- switch (mForceUse[AUDIO_POLICY_FORCE_FOR_COMMUNICATION]) {
- case AUDIO_POLICY_FORCE_BT_SCO:
- if (!isInCall() || strategy != STRATEGY_DTMF) {
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT;
- if (device) break;
- }
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET;
- if (device) break;
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_BLUETOOTH_SCO;
- if (device) break;
- // if SCO device is requested but no SCO device is available, fall back to default case
- // FALL THROUGH
-
- default: // FORCE_NONE
- // when not in a phone call, phone strategy should route STREAM_VOICE_CALL to A2DP
- if (!isInCall() &&
- (mForceUse[AUDIO_POLICY_FORCE_FOR_MEDIA] != AUDIO_POLICY_FORCE_NO_BT_A2DP) &&
- (getA2dpOutput() != 0) && !mA2dpSuspended) {
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP;
- if (device) break;
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES;
- if (device) break;
- }
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_WIRED_HEADPHONE;
- if (device) break;
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_WIRED_HEADSET;
- if (device) break;
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_USB_DEVICE;
- if (device) break;
- if (mPhoneState != AUDIO_MODE_IN_CALL) {
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_USB_ACCESSORY;
- if (device) break;
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET;
- if (device) break;
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_AUX_DIGITAL;
- if (device) break;
- }
-
- // Allow voice call on USB ANLG DOCK headset
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET;
- if (device) break;
-
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_EARPIECE;
- if (device) break;
- device = mDefaultOutputDevice->mDeviceType;
- if (device == AUDIO_DEVICE_NONE) {
- ALOGE("getDeviceForStrategy() no device found for STRATEGY_PHONE");
- }
- break;
-
- case AUDIO_POLICY_FORCE_SPEAKER:
- // when not in a phone call, phone strategy should route STREAM_VOICE_CALL to
- // A2DP speaker when forcing to speaker output
- if (!isInCall() &&
- (mForceUse[AUDIO_POLICY_FORCE_FOR_MEDIA] != AUDIO_POLICY_FORCE_NO_BT_A2DP) &&
- (getA2dpOutput() != 0) && !mA2dpSuspended) {
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER;
- if (device) break;
- }
- if (mPhoneState != AUDIO_MODE_IN_CALL) {
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_USB_ACCESSORY;
- if (device) break;
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_USB_DEVICE;
- if (device) break;
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET;
- if (device) break;
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_AUX_DIGITAL;
- if (device) break;
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET;
- if (device) break;
- }
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_LINE;
- if (device) break;
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_SPEAKER;
- if (device) break;
- device = mDefaultOutputDevice->mDeviceType;
- if (device == AUDIO_DEVICE_NONE) {
- ALOGE("getDeviceForStrategy() no device found for STRATEGY_PHONE, FORCE_SPEAKER");
- }
- break;
- }
-
- if (isInCall() && (device == AUDIO_DEVICE_NONE)) {
- // when in call, get the device for Phone strategy
- device = getDeviceForStrategy(STRATEGY_PHONE, false /*fromCache*/);
- break;
- }
-
-#ifdef AUDIO_EXTN_FM_ENABLED
- if (availableOutputDeviceTypes & AUDIO_DEVICE_OUT_FM) {
- if (mForceUse[AUDIO_POLICY_FORCE_FOR_MEDIA] == AUDIO_POLICY_FORCE_SPEAKER) {
- device = AUDIO_DEVICE_OUT_SPEAKER;
- }
- }
-#endif
- break;
-
- case STRATEGY_SONIFICATION:
-
- // If incall, just select the STRATEGY_PHONE device: The rest of the behavior is handled by
- // handleIncallSonification().
- if (isInCall()) {
- device = getDeviceForStrategy(STRATEGY_PHONE, false /*fromCache*/);
- break;
- }
- // FALL THROUGH
-
- case STRATEGY_ENFORCED_AUDIBLE:
- // strategy STRATEGY_ENFORCED_AUDIBLE uses same routing policy as STRATEGY_SONIFICATION
- // except:
- // - when in call where it doesn't default to STRATEGY_PHONE behavior
- // - in countries where not enforced in which case it follows STRATEGY_MEDIA
-
- if ((strategy == STRATEGY_SONIFICATION) ||
- (mForceUse[AUDIO_POLICY_FORCE_FOR_SYSTEM] == AUDIO_POLICY_FORCE_SYSTEM_ENFORCED)) {
- device = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_SPEAKER;
- if (device == AUDIO_DEVICE_NONE) {
- ALOGE("getDeviceForStrategy() speaker device not found for STRATEGY_SONIFICATION");
- }
- }
- // The second device used for sonification is the same as the device used by media strategy
- // FALL THROUGH
-
- case STRATEGY_MEDIA: {
- uint32_t device2 = AUDIO_DEVICE_NONE;
-
- if (isInCall() && (device == AUDIO_DEVICE_NONE)) {
- // when in call, get the device for Phone strategy
- device = getDeviceForStrategy(STRATEGY_PHONE, false /*fromCache*/);
- break;
- }
-#ifdef AUDIO_EXTN_FM_ENABLED
- if (mForceUse[AUDIO_POLICY_FORCE_FOR_MEDIA] == AUDIO_POLICY_FORCE_SPEAKER) {
- device = AUDIO_DEVICE_OUT_SPEAKER;
- break;
- }
-#endif
-
- if (strategy != STRATEGY_SONIFICATION) {
- // no sonification on remote submix (e.g. WFD)
- device2 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
- }
- if ((device2 == AUDIO_DEVICE_NONE) &&
- (mForceUse[AUDIO_POLICY_FORCE_FOR_MEDIA] != AUDIO_POLICY_FORCE_NO_BT_A2DP) &&
- (getA2dpOutput() != 0) && !mA2dpSuspended) {
- device2 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP;
- if (device2 == AUDIO_DEVICE_NONE) {
- device2 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES;
- }
- if (device2 == AUDIO_DEVICE_NONE) {
- device2 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER;
- }
- }
- if (device2 == AUDIO_DEVICE_NONE) {
- device2 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_WIRED_HEADPHONE;
- }
- if ((device2 == AUDIO_DEVICE_NONE)) {
- device2 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_LINE;
- }
- if (device2 == AUDIO_DEVICE_NONE) {
- device2 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_WIRED_HEADSET;
- }
- if (device2 == AUDIO_DEVICE_NONE) {
- device2 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_USB_ACCESSORY;
- }
- if (device2 == AUDIO_DEVICE_NONE) {
- device2 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_USB_DEVICE;
- }
- if (device2 == AUDIO_DEVICE_NONE) {
- device2 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET;
- }
- if ((strategy != STRATEGY_SONIFICATION) && (device == AUDIO_DEVICE_NONE)
- && (device2 == AUDIO_DEVICE_NONE)) {
- // no sonification on aux digital (e.g. HDMI)
- device2 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_AUX_DIGITAL;
- }
- if ((device2 == AUDIO_DEVICE_NONE) &&
- (mForceUse[AUDIO_POLICY_FORCE_FOR_DOCK] == AUDIO_POLICY_FORCE_ANALOG_DOCK)
- && (strategy != STRATEGY_SONIFICATION)) {
- device2 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET;
- }
-#ifdef AUDIO_EXTN_FM_ENABLED
- if ((strategy != STRATEGY_SONIFICATION) && (device == AUDIO_DEVICE_NONE)
- && (device2 == AUDIO_DEVICE_NONE)) {
- device2 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_FM_TX;
- }
-#endif
-#ifdef AUDIO_EXTN_AFE_PROXY_ENABLED
- if ((strategy != STRATEGY_SONIFICATION) && (device == AUDIO_DEVICE_NONE)
- && (device2 == AUDIO_DEVICE_NONE)) {
- // no sonification on WFD sink
- device2 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_PROXY;
- }
-#endif
- if (device2 == AUDIO_DEVICE_NONE) {
- device2 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_SPEAKER;
- }
- int device3 = AUDIO_DEVICE_NONE;
- if (strategy == STRATEGY_MEDIA) {
- // ARC, SPDIF and AUX_LINE can co-exist with others.
- device3 = availableOutputDeviceTypes & AUDIO_DEVICE_OUT_HDMI_ARC;
- device3 |= (availableOutputDeviceTypes & AUDIO_DEVICE_OUT_SPDIF);
- device3 |= (availableOutputDeviceTypes & AUDIO_DEVICE_OUT_AUX_LINE);
- }
-
- device2 |= device3;
- // device is DEVICE_OUT_SPEAKER if we come from case STRATEGY_SONIFICATION or
- // STRATEGY_ENFORCED_AUDIBLE, AUDIO_DEVICE_NONE otherwise
- device |= device2;
-
- // If hdmi system audio mode is on, remove speaker out of output list.
- if ((strategy == STRATEGY_MEDIA) &&
- (mForceUse[AUDIO_POLICY_FORCE_FOR_HDMI_SYSTEM_AUDIO] ==
- AUDIO_POLICY_FORCE_HDMI_SYSTEM_AUDIO_ENFORCED)) {
- device &= ~AUDIO_DEVICE_OUT_SPEAKER;
- }
-
- if (device) break;
- device = mDefaultOutputDevice->mDeviceType;
- if (device == AUDIO_DEVICE_NONE) {
- ALOGE("getDeviceForStrategy() no device found for STRATEGY_MEDIA");
- }
- } break;
-
- default:
- ALOGW("getDeviceForStrategy() unknown strategy: %d", strategy);
- break;
- }
-
- ALOGVV("getDeviceForStrategy() strategy %d, device %x", strategy, device);
- return device;
-}
-
-audio_devices_t AudioPolicyManagerCustom::getDeviceForInputSource(audio_source_t inputSource)
-{
- uint32_t device = AUDIO_DEVICE_NONE;
- audio_devices_t availableDeviceTypes = mAvailableInputDevices.types() &
- ~AUDIO_DEVICE_BIT_IN;
- switch (inputSource) {
- case AUDIO_SOURCE_VOICE_UPLINK:
- if (availableDeviceTypes & AUDIO_DEVICE_IN_VOICE_CALL) {
- device = AUDIO_DEVICE_IN_VOICE_CALL;
- break;
- }
- break;
-
- case AUDIO_SOURCE_DEFAULT:
- case AUDIO_SOURCE_MIC:
- if (availableDeviceTypes & AUDIO_DEVICE_IN_BLUETOOTH_A2DP) {
- device = AUDIO_DEVICE_IN_BLUETOOTH_A2DP;
- } else if (availableDeviceTypes & AUDIO_DEVICE_IN_WIRED_HEADSET) {
- device = AUDIO_DEVICE_IN_WIRED_HEADSET;
- } else if (availableDeviceTypes & AUDIO_DEVICE_IN_USB_DEVICE) {
- device = AUDIO_DEVICE_IN_USB_DEVICE;
- } else if (availableDeviceTypes & AUDIO_DEVICE_IN_BUILTIN_MIC) {
- device = AUDIO_DEVICE_IN_BUILTIN_MIC;
- }
- break;
-
- case AUDIO_SOURCE_VOICE_COMMUNICATION:
- // Allow only use of devices on primary input if in call and HAL does not support routing
- // to voice call path.
- if ((mPhoneState == AUDIO_MODE_IN_CALL) &&
- (mAvailableOutputDevices.types() & AUDIO_DEVICE_OUT_TELEPHONY_TX) == 0) {
- availableDeviceTypes = availablePrimaryInputDevices() & ~AUDIO_DEVICE_BIT_IN;
- }
-
- switch (mForceUse[AUDIO_POLICY_FORCE_FOR_COMMUNICATION]) {
- case AUDIO_POLICY_FORCE_BT_SCO:
- // if SCO device is requested but no SCO device is available, fall back to default case
- if (availableDeviceTypes & AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) {
- device = AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET;
- break;
- }
- // FALL THROUGH
-
- default: // FORCE_NONE
- if (availableDeviceTypes & AUDIO_DEVICE_IN_WIRED_HEADSET) {
- device = AUDIO_DEVICE_IN_WIRED_HEADSET;
- } else if (availableDeviceTypes & AUDIO_DEVICE_IN_USB_DEVICE) {
- device = AUDIO_DEVICE_IN_USB_DEVICE;
- } else if (availableDeviceTypes & AUDIO_DEVICE_IN_BUILTIN_MIC) {
- device = AUDIO_DEVICE_IN_BUILTIN_MIC;
- }
- break;
-
- case AUDIO_POLICY_FORCE_SPEAKER:
- if (availableDeviceTypes & AUDIO_DEVICE_IN_BACK_MIC) {
- device = AUDIO_DEVICE_IN_BACK_MIC;
- } else if (availableDeviceTypes & AUDIO_DEVICE_IN_BUILTIN_MIC) {
- device = AUDIO_DEVICE_IN_BUILTIN_MIC;
- }
- break;
- }
- break;
-
- case AUDIO_SOURCE_VOICE_RECOGNITION:
- case AUDIO_SOURCE_HOTWORD:
- if (mForceUse[AUDIO_POLICY_FORCE_FOR_RECORD] == AUDIO_POLICY_FORCE_BT_SCO &&
- availableDeviceTypes & AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET) {
- device = AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET;
- } else if (availableDeviceTypes & AUDIO_DEVICE_IN_WIRED_HEADSET) {
- device = AUDIO_DEVICE_IN_WIRED_HEADSET;
- } else if (availableDeviceTypes & AUDIO_DEVICE_IN_USB_DEVICE) {
- device = AUDIO_DEVICE_IN_USB_DEVICE;
- } else if (availableDeviceTypes & AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET) {
- device = AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET;
- } else if (availableDeviceTypes & AUDIO_DEVICE_IN_BUILTIN_MIC) {
- device = AUDIO_DEVICE_IN_BUILTIN_MIC;
- }
- break;
- case AUDIO_SOURCE_CAMCORDER:
- if (availableDeviceTypes & AUDIO_DEVICE_IN_BACK_MIC) {
- device = AUDIO_DEVICE_IN_BACK_MIC;
- } else if (availableDeviceTypes & AUDIO_DEVICE_IN_BUILTIN_MIC) {
- device = AUDIO_DEVICE_IN_BUILTIN_MIC;
- }
- break;
- case AUDIO_SOURCE_VOICE_DOWNLINK:
- case AUDIO_SOURCE_VOICE_CALL:
- if (availableDeviceTypes & AUDIO_DEVICE_IN_VOICE_CALL) {
- device = AUDIO_DEVICE_IN_VOICE_CALL;
- }
- break;
- case AUDIO_SOURCE_REMOTE_SUBMIX:
- if (availableDeviceTypes & AUDIO_DEVICE_IN_REMOTE_SUBMIX) {
- device = AUDIO_DEVICE_IN_REMOTE_SUBMIX;
- }
- break;
-#ifdef AUDIO_EXTN_FM_ENABLED
- case AUDIO_SOURCE_FM_RX:
- device = AUDIO_DEVICE_IN_FM_RX;
- break;
- case AUDIO_SOURCE_FM_RX_A2DP:
- device = AUDIO_DEVICE_IN_FM_RX_A2DP;
- break;
-#endif
- default:
- ALOGW("getDeviceForInputSource() invalid input source %d", inputSource);
- break;
- }
- ALOGV("getDeviceForInputSource()input source %d, device %08x", inputSource, device);
- return device;
-}
-
-bool AudioPolicyManagerCustom::isVirtualInputDevice(audio_devices_t device)
-{
- if ((device & AUDIO_DEVICE_BIT_IN) != 0) {
- device &= ~AUDIO_DEVICE_BIT_IN;
- if ((popcount(device) == 1) && ((device & ~APM_AUDIO_IN_DEVICE_VIRTUAL_ALL) == 0))
- return true;
- }
- return false;
-}
-
-bool AudioPolicyManagerCustom::deviceDistinguishesOnAddress(audio_devices_t device) {
- return ((device & APM_AUDIO_DEVICE_MATCH_ADDRESS_ALL) != 0);
-}
-
-AudioPolicyManagerCustom::device_category AudioPolicyManagerCustom::getDeviceCategory(audio_devices_t device)
-{
- switch(getDeviceForVolume(device)) {
- case AUDIO_DEVICE_OUT_EARPIECE:
- return DEVICE_CATEGORY_EARPIECE;
- case AUDIO_DEVICE_OUT_WIRED_HEADSET:
- case AUDIO_DEVICE_OUT_WIRED_HEADPHONE:
- case AUDIO_DEVICE_OUT_BLUETOOTH_SCO:
- case AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET:
- case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP:
- case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES:
-#ifdef AUDIO_EXTN_FM_ENABLED
- case AUDIO_DEVICE_OUT_FM:
-#endif
- return DEVICE_CATEGORY_HEADSET;
- case AUDIO_DEVICE_OUT_LINE:
- case AUDIO_DEVICE_OUT_AUX_DIGITAL:
- /*USB? Remote submix?*/
- return DEVICE_CATEGORY_EXT_MEDIA;
- case AUDIO_DEVICE_OUT_SPEAKER:
- case AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT:
- case AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER:
- case AUDIO_DEVICE_OUT_USB_ACCESSORY:
- case AUDIO_DEVICE_OUT_USB_DEVICE:
- case AUDIO_DEVICE_OUT_REMOTE_SUBMIX:
-#ifdef AUDIO_EXTN_AFE_PROXY_ENABLED
- case AUDIO_DEVICE_OUT_PROXY:
-#endif
- default:
- return DEVICE_CATEGORY_SPEAKER;
- }
-}
-
-float AudioPolicyManagerCustom::volIndexToAmpl(audio_devices_t device, const StreamDescriptor& streamDesc,
- int indexInUi)
-{
- device_category deviceCategory = getDeviceCategory(device);
- const VolumeCurvePoint *curve = streamDesc.mVolumeCurve[deviceCategory];
-
- // the volume index in the UI is relative to the min and max volume indices for this stream type
- int nbSteps = 1 + curve[VOLMAX].mIndex -
- curve[VOLMIN].mIndex;
- int volIdx = (nbSteps * (indexInUi - streamDesc.mIndexMin)) /
- (streamDesc.mIndexMax - streamDesc.mIndexMin);
-
- // find what part of the curve this index volume belongs to, or if it's out of bounds
- int segment = 0;
- if (volIdx < curve[VOLMIN].mIndex) { // out of bounds
- return 0.0f;
- } else if (volIdx < curve[VOLKNEE1].mIndex) {
- segment = 0;
- } else if (volIdx < curve[VOLKNEE2].mIndex) {
- segment = 1;
- } else if (volIdx <= curve[VOLMAX].mIndex) {
- segment = 2;
- } else { // out of bounds
- return 1.0f;
- }
-
- // linear interpolation in the attenuation table in dB
- float decibels = curve[segment].mDBAttenuation +
- ((float)(volIdx - curve[segment].mIndex)) *
- ( (curve[segment+1].mDBAttenuation -
- curve[segment].mDBAttenuation) /
- ((float)(curve[segment+1].mIndex -
- curve[segment].mIndex)) );
-
- float amplification = exp( decibels * 0.115129f); // exp( dB * ln(10) / 20 )
-
- ALOGVV("VOLUME vol index=[%d %d %d], dB=[%.1f %.1f %.1f] ampl=%.5f",
- curve[segment].mIndex, volIdx,
- curve[segment+1].mIndex,
- curve[segment].mDBAttenuation,
- decibels,
- curve[segment+1].mDBAttenuation,
- amplification);
-
- return amplification;
-}
-
-float AudioPolicyManagerCustom::computeVolume(audio_stream_type_t stream,
- int index,
- audio_io_handle_t output,
- audio_devices_t device)
-{
- float volume = 1.0;
- sp<AudioOutputDescriptor> outputDesc = mOutputs.valueFor(output);
- StreamDescriptor &streamDesc = mStreams[stream];
-
- if (device == AUDIO_DEVICE_NONE) {
- device = outputDesc->device();
- }
-
- // if volume is not 0 (not muted), force media volume to max on digital output
- if (stream == AUDIO_STREAM_MUSIC &&
- index != mStreams[stream].mIndexMin &&
- (device == AUDIO_DEVICE_OUT_AUX_DIGITAL ||
-#ifdef AUDIO_EXTN_AFE_PROXY_ENABLED
- device == AUDIO_DEVICE_OUT_PROXY ||
-#endif
- device == AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET)) {
- return 1.0;
- }
-
-#ifdef AUDIO_EXTN_INCALL_MUSIC_ENABLED
- if (stream == AUDIO_STREAM_INCALL_MUSIC) {
- return 1.0;
- }
-#endif
-
- volume = volIndexToAmpl(device, streamDesc, index);
-
- // if a headset is connected, apply the following rules to ring tones and notifications
- // to avoid sound level bursts in user's ears:
- // - always attenuate ring tones and notifications volume by 6dB
- // - if music is playing, always limit the volume to current music volume,
- // with a minimum threshold at -36dB so that notification is always perceived.
- const routing_strategy stream_strategy = getStrategy(stream);
- if ((device & (AUDIO_DEVICE_OUT_BLUETOOTH_A2DP |
- AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |
- AUDIO_DEVICE_OUT_WIRED_HEADSET |
- AUDIO_DEVICE_OUT_WIRED_HEADPHONE)) &&
- ((stream_strategy == STRATEGY_SONIFICATION)
- || (stream_strategy == STRATEGY_SONIFICATION_RESPECTFUL)
- || (stream == AUDIO_STREAM_SYSTEM)
- || ((stream_strategy == STRATEGY_ENFORCED_AUDIBLE) &&
- (mForceUse[AUDIO_POLICY_FORCE_FOR_SYSTEM] == AUDIO_POLICY_FORCE_NONE))) &&
- streamDesc.mCanBeMuted) {
- volume *= SONIFICATION_HEADSET_VOLUME_FACTOR;
- // when the phone is ringing we must consider that music could have been paused just before
- // by the music application and behave as if music was active if the last music track was
- // just stopped
- if (isStreamActive(AUDIO_STREAM_MUSIC, SONIFICATION_HEADSET_MUSIC_DELAY) ||
- mLimitRingtoneVolume) {
- audio_devices_t musicDevice = getDeviceForStrategy(STRATEGY_MEDIA, true /*fromCache*/);
- float musicVol = computeVolume(AUDIO_STREAM_MUSIC,
- mStreams[AUDIO_STREAM_MUSIC].getVolumeIndex(musicDevice),
- output,
- musicDevice);
- float minVol = (musicVol > SONIFICATION_HEADSET_VOLUME_MIN) ?
- musicVol : SONIFICATION_HEADSET_VOLUME_MIN;
- if (volume > minVol) {
- volume = minVol;
- ALOGV("computeVolume limiting volume to %f musicVol %f", minVol, musicVol);
- }
- }
- }
-
- return volume;
-}
-
-status_t AudioPolicyManagerCustom::checkAndSetVolume(audio_stream_type_t stream,
- int index,
- audio_io_handle_t output,
- audio_devices_t device,
- int delayMs,
- bool force)
-{
-
- // do not change actual stream volume if the stream is muted
- if (mOutputs.valueFor(output)->mMuteCount[stream] != 0) {
- ALOGVV("checkAndSetVolume() stream %d muted count %d",
- stream, mOutputs.valueFor(output)->mMuteCount[stream]);
- return NO_ERROR;
- }
-
- // do not change in call volume if bluetooth is connected and vice versa
- if ((stream == AUDIO_STREAM_VOICE_CALL &&
- mForceUse[AUDIO_POLICY_FORCE_FOR_COMMUNICATION] == AUDIO_POLICY_FORCE_BT_SCO) ||
- (stream == AUDIO_STREAM_BLUETOOTH_SCO &&
- mForceUse[AUDIO_POLICY_FORCE_FOR_COMMUNICATION] != AUDIO_POLICY_FORCE_BT_SCO)) {
- ALOGV("checkAndSetVolume() cannot set stream %d volume with force use = %d for comm",
- stream, mForceUse[AUDIO_POLICY_FORCE_FOR_COMMUNICATION]);
- return INVALID_OPERATION;
- }
-
- float volume = computeVolume(stream, index, output, device);
- // We actually change the volume if:
- // - the float value returned by computeVolume() changed
- // - the force flag is set
- if (volume != mOutputs.valueFor(output)->mCurVolume[stream] ||
- force) {
- mOutputs.valueFor(output)->mCurVolume[stream] = volume;
- ALOGVV("checkAndSetVolume() for output %d stream %d, volume %f, delay %d", output, stream, volume, delayMs);
- // Force VOICE_CALL to track BLUETOOTH_SCO stream volume when bluetooth audio is
- // enabled
- if (stream == AUDIO_STREAM_BLUETOOTH_SCO) {
- mpClientInterface->setStreamVolume(AUDIO_STREAM_VOICE_CALL, volume, output, delayMs);
-#ifdef AUDIO_EXTN_FM_ENABLED
- } else if (stream == AUDIO_STREAM_MUSIC &&
- output == mPrimaryOutput) {
- if (volume >= 0) {
- AudioParameter param = AudioParameter();
- param.addFloat(String8("fm_volume"), volume);
- ALOGV("checkAndSetVolume setParameters volume, volume=:%f delay=:%d",volume,delayMs*2);
- //Double delayMs to avoid sound burst while device switch.
- mpClientInterface->setParameters(mPrimaryOutput, param.toString(), delayMs*2);
- }
-#endif
- }
- mpClientInterface->setStreamVolume(stream, volume, output, delayMs);
- }
-
- if (stream == AUDIO_STREAM_VOICE_CALL ||
- stream == AUDIO_STREAM_BLUETOOTH_SCO) {
- float voiceVolume;
- // Force voice volume to max for bluetooth SCO as volume is managed by the headset
- if (stream == AUDIO_STREAM_VOICE_CALL) {
- voiceVolume = (float)index/(float)mStreams[stream].mIndexMax;
- } else {
- voiceVolume = 1.0;
- }
-
- if (voiceVolume != mLastVoiceVolume && ((output == mPrimaryOutput) ||
- isDirectOutput(output))) {
- mpClientInterface->setVoiceVolume(voiceVolume, delayMs);
- mLastVoiceVolume = voiceVolume;
- }
- }
-
- return NO_ERROR;
-}
-
-bool AudioPolicyManagerCustom::isStateInCall(int state) {
- return ((state == AUDIO_MODE_IN_CALL) || (state == AUDIO_MODE_IN_COMMUNICATION) ||
- ((state == AUDIO_MODE_RINGTONE) && (mPrevPhoneState == AUDIO_MODE_IN_CALL)));
-}
-
-
-extern "C" AudioPolicyInterface* createAudioPolicyManager(
- AudioPolicyClientInterface *clientInterface)
-{
- return new AudioPolicyManager(clientInterface);
-}
-
-extern "C" void destroyAudioPolicyManager(AudioPolicyInterface *interface)
-{
- delete interface;
-}
-
-}; // namespace android
diff --git a/policy_hal/AudioPolicyManager.h b/policy_hal/AudioPolicyManager.h
index e37f83f..13af8e7 100644
--- a/policy_hal/AudioPolicyManager.h
+++ b/policy_hal/AudioPolicyManager.h
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
* Not a contribution.
*
* Copyright (C) 2009 The Android Open Source Project
@@ -18,91 +18,99 @@
*/
-#include <audiopolicy/AudioPolicyManager.h>
-#include <audiopolicy/audio_policy_conf.h>
-
+#include <audiopolicy/managerdefault/AudioPolicyManager.h>
+#include <audio_policy_conf.h>
+#include <Volume.h>
namespace android {
+#ifndef AUDIO_EXTN_FORMATS_ENABLED
+#define AUDIO_FORMAT_WMA 0x12000000UL
+#define AUDIO_FORMAT_WMA_PRO 0x13000000UL
+#define AUDIO_FORMAT_FLAC 0x1B000000UL
+#define AUDIO_FORMAT_ALAC 0x1C000000UL
+#define AUDIO_FORMAT_APE 0x1D000000UL
+#endif
+#ifndef AFE_PROXY_ENABLED
+#define AUDIO_DEVICE_OUT_PROXY 0x1000000
+#endif
// ----------------------------------------------------------------------------
class AudioPolicyManagerCustom: public AudioPolicyManager
{
public:
- AudioPolicyManagerCustom(AudioPolicyClientInterface *clientInterface)
- : AudioPolicyManager(clientInterface) {
- mHdmiAudioDisabled = false;
- mHdmiAudioEvent = false; }
+ AudioPolicyManagerCustom(AudioPolicyClientInterface *clientInterface);
virtual ~AudioPolicyManagerCustom() {}
- virtual status_t setDeviceConnectionState(audio_devices_t device,
- audio_policy_dev_state_t state,
- const char *device_address);
- virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device,
- const char *device_address);
+ status_t setDeviceConnectionStateInt(audio_devices_t device,
+ audio_policy_dev_state_t state,
+ const char *device_address,
+ const char *device_name);
virtual void setPhoneState(audio_mode_t state);
- virtual void setForceUse(audio_policy_force_use_t usage,
- audio_policy_forced_cfg_t config);
- virtual status_t stopOutput(audio_io_handle_t output,
- audio_stream_type_t stream,
- int session = 0);
- virtual audio_io_handle_t getInput(audio_source_t inputSource,
- uint32_t samplingRate,
- audio_format_t format,
- audio_channel_mask_t channelMask,
- audio_session_t session,
- audio_input_flags_t flags);
+
+ virtual bool isOffloadSupported(const audio_offload_info_t& offloadInfo);
+
+ virtual status_t getInputForAttr(const audio_attributes_t *attr,
+ audio_io_handle_t *input,
+ audio_session_t session,
+ uid_t uid,
+ uint32_t samplingRate,
+ audio_format_t format,
+ audio_channel_mask_t channelMask,
+ audio_input_flags_t flags,
+ audio_port_handle_t selectedDeviceId,
+ input_type_t *inputType);
// indicates to the audio policy manager that the input starts being used.
virtual status_t startInput(audio_io_handle_t input,
audio_session_t session);
-
// indicates to the audio policy manager that the input stops being used.
virtual status_t stopInput(audio_io_handle_t input,
audio_session_t session);
- virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
- int index,
- audio_devices_t device);
- virtual bool isOffloadSupported(const audio_offload_info_t& offloadInfo);
- // true if given state represents a device in a telephony or VoIP call
- virtual bool isStateInCall(int state);
+ virtual audio_devices_t getDeviceForStrategy(routing_strategy strategy, bool fromCache);
protected:
- // return the strategy corresponding to a given stream type
- static routing_strategy getStrategy(audio_stream_type_t stream);
- // return appropriate device for streams handled by the specified strategy according to current
- // phone state, connected devices...
- // if fromCache is true, the device is returned from mDeviceForStrategy[],
- // otherwise it is determine by current state
- // (device connected,phone state, force use, a2dp output...)
- // This allows to:
- // 1 speed up process when the state is stable (when starting or stopping an output)
- // 2 access to either current device selection (fromCache == true) or
- // "future" device selection (fromCache == false) when called from a context
- // where conditions are changing (setDeviceConnectionState(), setPhoneState()...) AND
- // before updateDevicesAndOutputs() is called.
- virtual audio_devices_t getDeviceForStrategy(routing_strategy strategy,
- bool fromCache);
- // select input device corresponding to requested audio source
- virtual audio_devices_t getDeviceForInputSource(audio_source_t inputSource);
+ status_t checkAndSetVolume(audio_stream_type_t stream,
+ int index,
+ const sp<SwAudioOutputDescriptor>& outputDesc,
+ audio_devices_t device,
+ int delayMs = 0, bool force = false);
- // compute the actual volume for a given stream according to the requested index and a particular
- // device
- virtual float computeVolume(audio_stream_type_t stream, int index,
- audio_io_handle_t output, audio_devices_t device);
+ // selects the most appropriate device on output for current state
+ // must be called every time a condition that affects the device choice for a given output is
+ // changed: connected device, phone state, force use, output start, output stop..
+ // see getDeviceForStrategy() for the use of fromCache parameter
+ audio_devices_t getNewOutputDevice(const sp<AudioOutputDescriptor>& outputDesc,
+ bool fromCache);
+ // returns true if given output is direct output
+ bool isDirectOutput(audio_io_handle_t output);
- // check that volume change is permitted, compute and send new volume to audio hardware
- status_t checkAndSetVolume(audio_stream_type_t stream, int index, audio_io_handle_t output,
- audio_devices_t device, int delayMs = 0, bool force = false);
+ // if argument "device" is different from AUDIO_DEVICE_NONE, startSource() will force
+ // the re-evaluation of the output device.
+ status_t startSource(sp<SwAudioOutputDescriptor> outputDesc,
+ audio_stream_type_t stream,
+ audio_devices_t device,
+ uint32_t *delayMs);
+ status_t stopSource(sp<SwAudioOutputDescriptor> outputDesc,
+ audio_stream_type_t stream,
+ bool forceDeviceUpdate);
+ // event is one of STARTING_OUTPUT, STARTING_BEACON, STOPPING_OUTPUT, STOPPING_BEACON 313
+ // returns 0 if no mute/unmute event happened, the largest latency of the device where 314
+ // the mute/unmute happened 315
+ uint32_t handleEventForBeacon(int){return 0;}
+ uint32_t setBeaconMute(bool){return 0;}
+#ifdef VOICE_CONCURRENCY
+ static audio_output_flags_t getFallBackPath();
+ int mFallBackflag;
+#endif /*VOICE_CONCURRENCY*/
- // returns the category the device belongs to with regard to volume curve management
- static device_category getDeviceCategory(audio_devices_t device);
-
-
+ // handle special cases for sonification strategy while in call: mute streams or replace by
+ // a special tone in the device used for communication
+ void handleIncallSonification(audio_stream_type_t stream, bool starting, bool stateChange, audio_io_handle_t output);
//parameter indicates of HDMI speakers disabled
bool mHdmiAudioDisabled;
//parameter indicates if HDMI plug in/out detected
@@ -119,13 +127,13 @@
// internal method to return the output handle for the given device and format
audio_io_handle_t getOutputForDevice(
audio_devices_t device,
+ audio_session_t session,
audio_stream_type_t stream,
uint32_t samplingRate,
audio_format_t format,
audio_channel_mask_t channelMask,
audio_output_flags_t flags,
const audio_offload_info_t *offloadInfo);
-
// Used for voip + voice concurrency usecase
int mPrevPhoneState;
int mvoice_call_state;
@@ -134,6 +142,7 @@
bool mIsInputRequestOnProgress;
#endif
+
};
};
diff --git a/post_proc/Android.mk b/post_proc/Android.mk
index be70166..ed46f17 100644
--- a/post_proc/Android.mk
+++ b/post_proc/Android.mk
@@ -14,8 +14,12 @@
virtualizer.c \
reverb.c \
effect_api.c \
- effect_util.c \
- hw_accelerator.c
+ effect_util.c
+
+ifeq ($(strip $(AUDIO_FEATURE_ENABLED_HW_ACCELERATED_EFFECTS)),true)
+ LOCAL_CFLAGS += -DHW_ACCELERATED_EFFECTS
+ LOCAL_SRC_FILES += hw_accelerator.c
+endif
LOCAL_CFLAGS+= -O2 -fvisibility=hidden
diff --git a/post_proc/bundle.c b/post_proc/bundle.c
index bb21f7e..b33f2d1 100644
--- a/post_proc/bundle.c
+++ b/post_proc/bundle.c
@@ -43,7 +43,7 @@
#include <system/thread_defs.h>
#include <tinyalsa/asoundlib.h>
#include <hardware/audio_effect.h>
-
+#include <stdlib.h>
#include "bundle.h"
#include "hw_accelerator.h"
#include "equalizer.h"
@@ -69,7 +69,9 @@
&ins_env_reverb_descriptor,
&aux_preset_reverb_descriptor,
&ins_preset_reverb_descriptor,
+#ifdef HW_ACCELERATED_EFFECTS
&hw_accelerator_descriptor,
+#endif
NULL,
};
@@ -604,6 +606,7 @@
reverb_preset_init(reverb_ctxt);
}
reverb_ctxt->ctl = NULL;
+#ifdef HW_ACCELERATED_EFFECTS
} else if (memcmp(uuid, &hw_accelerator_descriptor.uuid,
sizeof(effect_uuid_t)) == 0) {
hw_accelerator_context_t *hw_acc_ctxt = (hw_accelerator_context_t *)
@@ -625,6 +628,7 @@
context->ops.process = hw_accelerator_process;
context->desc = &hw_accelerator_descriptor;
+#endif
} else {
return -EINVAL;
}
@@ -910,7 +914,7 @@
add_effect_to_output(out_ctxt, context);
} break;
-
+#ifdef HW_ACCELERATED_EFFECTS
case EFFECT_CMD_HW_ACC: {
ALOGV("EFFECT_CMD_HW_ACC cmdSize %d pCmdData %p, *replySize %d, pReplyData %p",
cmdSize, pCmdData, *replySize, pReplyData);
@@ -925,6 +929,7 @@
context->hw_acc_enabled = (value > 0) ? true : false;
break;
}
+#endif
default:
if (cmdCode >= EFFECT_CMD_FIRST_PROPRIETARY && context->ops.command)
status = context->ops.command(context, cmdCode, cmdSize,
diff --git a/post_proc/bundle.h b/post_proc/bundle.h
index 06da991..efe69ee 100644
--- a/post_proc/bundle.h
+++ b/post_proc/bundle.h
@@ -27,7 +27,9 @@
/* Retry for delay for mixer open */
#define RETRY_NUMBER 10
#define RETRY_US 500000
-
+#ifdef HW_ACCELERATED_EFFECTS
+#define EFFECT_CMD_HW_ACC 20
+#endif
#define MIXER_CARD 0
#define SOUND_CARD 0
diff --git a/post_proc/effect_api.c b/post_proc/effect_api.c
index 2fb79ed..7aef997 100644
--- a/post_proc/effect_api.c
+++ b/post_proc/effect_api.c
@@ -60,7 +60,7 @@
#include <sound/audio_effects.h>
#include <sound/devdep_params.h>
#include <linux/msm_audio.h>
-
+#include <errno.h>
#include "effect_api.h"
#ifdef DTS_EAGLE
diff --git a/post_proc/effect_util.c b/post_proc/effect_util.c
index 8f7a604..b401f6a 100644
--- a/post_proc/effect_util.c
+++ b/post_proc/effect_util.c
@@ -17,6 +17,7 @@
#include <utils/Log.h>
#include <stdlib.h>
#include "effect_util.h"
+#include <string.h>
#ifdef LOG_TAG
#undef LOG_TAG
diff --git a/voice_processing/voice_processing.c b/voice_processing/voice_processing.c
index 1d18a3d..bb9bf3b 100644
--- a/voice_processing/voice_processing.c
+++ b/voice_processing/voice_processing.c
@@ -17,6 +17,7 @@
#define LOG_TAG "voice_processing"
/*#define LOG_NDEBUG 0*/
#include <dlfcn.h>
+#include <stdlib.h>
#include <cutils/log.h>
#include <cutils/list.h>
#include <hardware/audio_effect.h>