Merge "hal: Add support to get active microphones on input stream" (c1952b05) · Commits · e / devices / Fairphone 4 / android_hardware_qcom_audio

hal/msm8916/platform.c

+102 −15

Original line number	Diff line number	Diff line
		@@ -233,6 +233,11 @@ static bool supports_true_32_bit = false;
		static int max_be_dai_names = 0;
		static const struct be_dai_name_struct *be_dai_name_table;

		struct snd_device_to_mic_map {
		struct mic_info microphones[AUDIO_MICROPHONE_MAX_COUNT];
		size_t mic_count;
		};

		struct platform_data {
		struct audio_device *adev;
		bool fluence_in_spkr_mode;
		@@ -298,6 +303,9 @@ struct platform_data {
		struct listnode acdb_meta_key_list;
		bool use_generic_handset;
		struct acdb_init_data_v4 acdb_init_data;
		uint32_t declared_mic_count;
		struct audio_microphone_characteristic_t microphones[AUDIO_MICROPHONE_MAX_COUNT];
		struct snd_device_to_mic_map mic_map[SND_DEVICE_MAX];
		};

		static bool is_external_codec = false;
		@@ -2280,6 +2288,7 @@ void platform_init(struct audio_device adev)
		my_data->hw_dep_fd = -1;
		my_data->mono_speaker = SPKR_1;
		my_data->voice_speaker_stereo = false;
		my_data->declared_mic_count = 0;

		be_dai_name_table = NULL;

		@@ -8118,25 +8127,103 @@ static const char platform_get_mixer_control(struct mixer_ctl ctl)
		return id_string;
		}

		bool platform_set_microphone_characteristic(void *platform __unused,
		struct audio_microphone_characteristic_t mic __unused) {
		return -ENOSYS;
		bool platform_set_microphone_characteristic(void *platform,
		struct audio_microphone_characteristic_t mic) {
		struct platform_data my_data = (struct platform_data )platform;
		if (my_data->declared_mic_count >= AUDIO_MICROPHONE_MAX_COUNT) {
		ALOGE("mic number is more than maximum number");
		return false;
		}
		for (size_t ch = 0; ch < AUDIO_CHANNEL_COUNT_MAX; ch++) {
		mic.channel_mapping[ch] = AUDIO_MICROPHONE_CHANNEL_MAPPING_UNUSED;
		}
		my_data->microphones[my_data->declared_mic_count++] = mic;
		return true;
		}

		int platform_get_microphones(void *platform __unused,
		struct audio_microphone_characteristic_t *mic_array __unused,
		size_t *mic_count __unused) {
		return -ENOSYS;
		int platform_get_microphones(void *platform,
		struct audio_microphone_characteristic_t *mic_array,
		size_t *mic_count) {
		struct platform_data my_data = (struct platform_data )platform;
		if (mic_count == NULL)
		return -EINVAL;
		if (mic_array == NULL)
		return -EINVAL;

		if (*mic_count == 0) {
		*mic_count = my_data->declared_mic_count;
		return 0;
		}

		bool platform_set_microphone_map(void *platform __unused, snd_device_t in_snd_device __unused,
		const struct mic_info *info __unused) {
		size_t max_mic_count = *mic_count;
		size_t actual_mic_count = 0;
		for (size_t i = 0; i < max_mic_count && i < my_data->declared_mic_count; i++) {
		mic_array[i] = my_data->microphones[i];
		actual_mic_count++;
		}
		*mic_count = actual_mic_count;
		ALOGV("%s: returning number of mics %d", __func__, (int)*mic_count);
		return 0;
		}

		bool platform_set_microphone_map(void *platform, snd_device_t in_snd_device,
		const struct mic_info *info) {
		struct platform_data my_data = (struct platform_data )platform;
		if (in_snd_device < SND_DEVICE_IN_BEGIN \|\| in_snd_device >= SND_DEVICE_IN_END) {
		ALOGE("%s: Sound device not valid", __func__);
		return false;
		}
		size_t m_count = my_data->mic_map[in_snd_device].mic_count++;
		if (m_count >= AUDIO_MICROPHONE_MAX_COUNT) {
		ALOGE("%s: Microphone count is greater than max allowed value", __func__);
		my_data->mic_map[in_snd_device].mic_count--;
		return false;
		}
		my_data->mic_map[in_snd_device].microphones[m_count] = *info;
		return true;
		}

		int platform_get_active_microphones(void *platform, unsigned int channels,
		audio_usecase_t uc_id,
		struct audio_microphone_characteristic_t *mic_array,
		size_t *mic_count) {
		struct platform_data my_data = (struct platform_data )platform;
		struct audio_usecase *usecase = get_usecase_from_list(my_data->adev, uc_id);
		if (mic_count == NULL \|\| mic_array == NULL \|\| usecase == NULL) {
		return -EINVAL;
		}
		size_t max_mic_count = my_data->declared_mic_count;
		size_t actual_mic_count = 0;

		snd_device_t active_input_snd_device =
		platform_get_input_snd_device(platform, usecase->stream.in->device);
		if (active_input_snd_device == SND_DEVICE_NONE) {
		ALOGI("%s: No active microphones found", __func__);
		goto end;
		}

		int platform_get_active_microphones(void *platform __unused, unsigned int channels __unused,
		audio_usecase_t usecase __unused,
		struct audio_microphone_characteristic_t *mic_array __unused,
		size_t *mic_count __unused) {
		return -ENOSYS;
		size_t active_mic_count = my_data->mic_map[active_input_snd_device].mic_count;
		struct mic_info *m_info = my_data->mic_map[active_input_snd_device].microphones;

		for (size_t i = 0; i < active_mic_count; i++) {
		unsigned int channels_for_active_mic = channels;
		if (channels_for_active_mic > m_info[i].channel_count) {
		channels_for_active_mic = m_info[i].channel_count;
		}
		for (size_t j = 0; j < max_mic_count; j++) {
		if (strcmp(my_data->microphones[j].device_id,
		m_info[i].device_id) == 0) {
		mic_array[actual_mic_count] = my_data->microphones[j];
		for (size_t ch = 0; ch < channels_for_active_mic; ch++) {
		mic_array[actual_mic_count].channel_mapping[ch] =
		m_info[i].channel_mapping[ch];
		}
		actual_mic_count++;
		break;
		}
		}
		}
		end:
		*mic_count = actual_mic_count;
		return 0;
		}