Merge "Enable support for audio HAL V7 in the framework" into sc-dev (1570f85e) · Commits · e / os / android_frameworks_av

media/libaudiohal/Android.bp

+1 −1

Original line number	Diff line number	Diff line
		@@ -17,7 +17,7 @@ cc_library_shared {
		"libaudiohal@4.0",
		"libaudiohal@5.0",
		"libaudiohal@6.0",
		// "libaudiohal@7.0",
		"libaudiohal@7.0",
		],

		shared_libs: [

media/libaudiohal/impl/Android.bp

+8 −2

Original line number	Diff line number	Diff line
		@@ -60,7 +60,9 @@ cc_library_shared {
		"android.hardware.audio.common@4.0",
		"android.hardware.audio.common@4.0-util",
		"android.hardware.audio.effect@4.0",
		"android.hardware.audio.effect@4.0-util",
		"android.hardware.audio@4.0",
		"android.hardware.audio@4.0-util",
		],
		cflags: [
		"-DMAJOR_VERSION=4",
		@@ -76,7 +78,9 @@ cc_library_shared {
		"android.hardware.audio.common@5.0",
		"android.hardware.audio.common@5.0-util",
		"android.hardware.audio.effect@5.0",
		"android.hardware.audio.effect@5.0-util",
		"android.hardware.audio@5.0",
		"android.hardware.audio@5.0-util",
		],
		cflags: [
		"-DMAJOR_VERSION=5",
		@@ -92,7 +96,9 @@ cc_library_shared {
		"android.hardware.audio.common@6.0",
		"android.hardware.audio.common@6.0-util",
		"android.hardware.audio.effect@6.0",
		"android.hardware.audio.effect@6.0-util",
		"android.hardware.audio@6.0",
		"android.hardware.audio@6.0-util",
		],
		cflags: [
		"-DMAJOR_VERSION=6",
		@@ -102,14 +108,15 @@ cc_library_shared {
		}

		cc_library_shared {
		enabled: false,
		name: "libaudiohal@7.0",
		defaults: ["libaudiohal_default"],
		shared_libs: [
		"android.hardware.audio.common@7.0",
		"android.hardware.audio.common@7.0-util",
		"android.hardware.audio.effect@7.0",
		"android.hardware.audio.effect@7.0-util",
		"android.hardware.audio@7.0",
		"android.hardware.audio@7.0-util",
		],
		cflags: [
		"-DMAJOR_VERSION=7",
		@@ -117,4 +124,3 @@ cc_library_shared {
		"-include common/all-versions/VersionMacro.h",
		]
		}

media/libaudiohal/impl/ConversionHelperHidl.cpp

+0 −124

Original line number	Diff line number	Diff line
		@@ -120,129 +120,5 @@ void ConversionHelperHidl::emitError(const char* funcName, const char* descripti
		ALOGE("%s %p %s: %s (from rpc)", mClassName, this, funcName, description);
		}

		#if MAJOR_VERSION >= 4
		// TODO: Use the same implementation in the hal when it moves to a util library.
		static std::string deviceAddressToHal(const DeviceAddress& address) {
		// HAL assumes that the address is NUL-terminated.
		char halAddress[AUDIO_DEVICE_MAX_ADDRESS_LEN];
		memset(halAddress, 0, sizeof(halAddress));
		audio_devices_t halDevice = static_cast<audio_devices_t>(address.device);
		if (getAudioDeviceOutAllA2dpSet().count(halDevice) > 0 \|\|
		halDevice == AUDIO_DEVICE_IN_BLUETOOTH_A2DP) {
		snprintf(halAddress, sizeof(halAddress), "%02X:%02X:%02X:%02X:%02X:%02X",
		address.address.mac[0], address.address.mac[1], address.address.mac[2],
		address.address.mac[3], address.address.mac[4], address.address.mac[5]);
		} else if (halDevice == AUDIO_DEVICE_OUT_IP \|\| halDevice == AUDIO_DEVICE_IN_IP) {
		snprintf(halAddress, sizeof(halAddress), "%d.%d.%d.%d", address.address.ipv4[0],
		address.address.ipv4[1], address.address.ipv4[2], address.address.ipv4[3]);
		} else if (getAudioDeviceOutAllUsbSet().count(halDevice) > 0 \|\|
		getAudioDeviceInAllUsbSet().count(halDevice) > 0) {
		snprintf(halAddress, sizeof(halAddress), "card=%d;device=%d", address.address.alsa.card,
		address.address.alsa.device);
		} else if (halDevice == AUDIO_DEVICE_OUT_BUS \|\| halDevice == AUDIO_DEVICE_IN_BUS) {
		snprintf(halAddress, sizeof(halAddress), "%s", address.busAddress.c_str());
		} else if (halDevice == AUDIO_DEVICE_OUT_REMOTE_SUBMIX \|\|
		halDevice == AUDIO_DEVICE_IN_REMOTE_SUBMIX) {
		snprintf(halAddress, sizeof(halAddress), "%s", address.rSubmixAddress.c_str());
		} else {
		snprintf(halAddress, sizeof(halAddress), "%s", address.busAddress.c_str());
		}
		return halAddress;
		}

		//local conversion helpers

		static audio_microphone_channel_mapping_t channelMappingToHal(AudioMicrophoneChannelMapping mapping) {
		switch (mapping) {
		case AudioMicrophoneChannelMapping::UNUSED:
		return AUDIO_MICROPHONE_CHANNEL_MAPPING_UNUSED;
		case AudioMicrophoneChannelMapping::DIRECT:
		return AUDIO_MICROPHONE_CHANNEL_MAPPING_DIRECT;
		case AudioMicrophoneChannelMapping::PROCESSED:
		return AUDIO_MICROPHONE_CHANNEL_MAPPING_PROCESSED;
		default:
		LOG_ALWAYS_FATAL("Unknown channelMappingToHal conversion %d", mapping);
		}
		}

		static audio_microphone_location_t locationToHal(AudioMicrophoneLocation location) {
		switch (location) {
		case AudioMicrophoneLocation::UNKNOWN:
		return AUDIO_MICROPHONE_LOCATION_UNKNOWN;
		case AudioMicrophoneLocation::MAINBODY:
		return AUDIO_MICROPHONE_LOCATION_MAINBODY;
		case AudioMicrophoneLocation::MAINBODY_MOVABLE:
		return AUDIO_MICROPHONE_LOCATION_MAINBODY_MOVABLE;
		case AudioMicrophoneLocation::PERIPHERAL:
		return AUDIO_MICROPHONE_LOCATION_PERIPHERAL;
		default:
		LOG_ALWAYS_FATAL("Unknown locationToHal conversion %d", location);
		}
		}
		static audio_microphone_directionality_t directionalityToHal(AudioMicrophoneDirectionality dir) {
		switch (dir) {
		case AudioMicrophoneDirectionality::UNKNOWN:
		return AUDIO_MICROPHONE_DIRECTIONALITY_UNKNOWN;
		case AudioMicrophoneDirectionality::OMNI:
		return AUDIO_MICROPHONE_DIRECTIONALITY_OMNI;
		case AudioMicrophoneDirectionality::BI_DIRECTIONAL:
		return AUDIO_MICROPHONE_DIRECTIONALITY_BI_DIRECTIONAL;
		case AudioMicrophoneDirectionality::CARDIOID:
		return AUDIO_MICROPHONE_DIRECTIONALITY_CARDIOID;
		case AudioMicrophoneDirectionality::HYPER_CARDIOID:
		return AUDIO_MICROPHONE_DIRECTIONALITY_HYPER_CARDIOID;
		case AudioMicrophoneDirectionality::SUPER_CARDIOID:
		return AUDIO_MICROPHONE_DIRECTIONALITY_SUPER_CARDIOID;
		default:
		LOG_ALWAYS_FATAL("Unknown directionalityToHal conversion %d", dir);
		}
		}

		void microphoneInfoToHal(const MicrophoneInfo& src,
		audio_microphone_characteristic_t *pDst) {
		if (pDst != NULL) {
		snprintf(pDst->device_id, sizeof(pDst->device_id),
		"%s", src.deviceId.c_str());
		pDst->device = static_cast<audio_devices_t>(src.deviceAddress.device);
		snprintf(pDst->address, sizeof(pDst->address),
		"%s", deviceAddressToHal(src.deviceAddress).c_str());
		if (src.channelMapping.size() > AUDIO_CHANNEL_COUNT_MAX) {
		ALOGW("microphoneInfoToStruct found %zu channelMapping elements. Max expected is %d",
		src.channelMapping.size(), AUDIO_CHANNEL_COUNT_MAX);
		}
		size_t ch;
		for (ch = 0; ch < src.channelMapping.size() && ch < AUDIO_CHANNEL_COUNT_MAX; ch++) {
		pDst->channel_mapping[ch] = channelMappingToHal(src.channelMapping[ch]);
		}
		for (; ch < AUDIO_CHANNEL_COUNT_MAX; ch++) {
		pDst->channel_mapping[ch] = AUDIO_MICROPHONE_CHANNEL_MAPPING_UNUSED;
		}
		pDst->location = locationToHal(src.location);
		pDst->group = (audio_microphone_group_t)src.group;
		pDst->index_in_the_group = (unsigned int)src.indexInTheGroup;
		pDst->sensitivity = src.sensitivity;
		pDst->max_spl = src.maxSpl;
		pDst->min_spl = src.minSpl;
		pDst->directionality = directionalityToHal(src.directionality);
		pDst->num_frequency_responses = (unsigned int)src.frequencyResponse.size();
		if (pDst->num_frequency_responses > AUDIO_MICROPHONE_MAX_FREQUENCY_RESPONSES) {
		ALOGW("microphoneInfoToStruct found %d frequency responses. Max expected is %d",
		pDst->num_frequency_responses, AUDIO_MICROPHONE_MAX_FREQUENCY_RESPONSES);
		pDst->num_frequency_responses = AUDIO_MICROPHONE_MAX_FREQUENCY_RESPONSES;
		}
		for (size_t k = 0; k < pDst->num_frequency_responses; k++) {
		pDst->frequency_responses[0][k] = src.frequencyResponse[k].frequency;
		pDst->frequency_responses[1][k] = src.frequencyResponse[k].level;
		}
		pDst->geometric_location.x = src.position.x;
		pDst->geometric_location.y = src.position.y;
		pDst->geometric_location.z = src.position.z;
		pDst->orientation.x = src.orientation.x;
		pDst->orientation.y = src.orientation.y;
		pDst->orientation.z = src.orientation.z;
		}
		}
		#endif

		} // namespace CPP_VERSION
		} // namespace android

media/libaudiohal/impl/ConversionHelperHidl.h

+0 −6

Original line number	Diff line number	Diff line
		@@ -82,12 +82,6 @@ class ConversionHelperHidl {
		void emitError(const char* funcName, const char* description);
		};

		#if MAJOR_VERSION >= 4
		using ::android::hardware::audio::CPP_VERSION::MicrophoneInfo;
		void microphoneInfoToHal(const MicrophoneInfo& src,
		audio_microphone_characteristic_t *pDst);
		#endif

		} // namespace CPP_VERSION
		} // namespace android

media/libaudiohal/impl/DeviceHalHidl.cpp

+41 −66

Original line number	Diff line number	Diff line
		@@ -19,22 +19,24 @@
		#define LOG_TAG "DeviceHalHidl"
		//#define LOG_NDEBUG 0

		#include PATH(android/hardware/audio/FILE_VERSION/IPrimaryDevice.h)
		#include <cutils/native_handle.h>
		#include <hwbinder/IPCThreadState.h>
		#include <media/AudioContainers.h>
		#include <utils/Log.h>

		#include PATH(android/hardware/audio/FILE_VERSION/IPrimaryDevice.h)
		#include <HidlUtils.h>
		#include <common/all-versions/VersionUtils.h>
		#include <util/CoreUtils.h>

		#include "DeviceHalHidl.h"
		#include "EffectHalHidl.h"
		#include "HidlUtils.h"
		#include "ParameterUtils.h"
		#include "StreamHalHidl.h"
		#include "VersionUtils.h"

		using ::android::hardware::audio::common::CPP_VERSION::implementation::HidlUtils;
		using ::android::hardware::audio::common::utils::EnumBitfield;
		using ::android::hardware::audio::CPP_VERSION::implementation::CoreUtils;
		using ::android::hardware::hidl_string;
		using ::android::hardware::hidl_vec;

		@@ -46,50 +48,6 @@ using namespace ::android::hardware::audio::CPP_VERSION;

		using EffectHalHidl = ::android::effect::CPP_VERSION::EffectHalHidl;

		namespace {

		using ::android::hardware::audio::common::CPP_VERSION::AudioPort;
		using ::android::hardware::audio::common::CPP_VERSION::AudioPortConfig;

		status_t deviceAddressFromHal(
		audio_devices_t device, const char* halAddress, DeviceAddress* address) {
		address->device = AudioDevice(device);

		if (halAddress == nullptr \|\| strnlen(halAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0) {
		return OK;
		}
		if (getAudioDeviceOutAllA2dpSet().count(device) > 0
		\|\| device == AUDIO_DEVICE_IN_BLUETOOTH_A2DP) {
		int status = sscanf(halAddress,
		"%hhX:%hhX:%hhX:%hhX:%hhX:%hhX",
		&address->address.mac[0], &address->address.mac[1], &address->address.mac[2],
		&address->address.mac[3], &address->address.mac[4], &address->address.mac[5]);
		return status == 6 ? OK : BAD_VALUE;
		} else if (device == AUDIO_DEVICE_OUT_IP \|\| device == AUDIO_DEVICE_IN_IP) {
		int status = sscanf(halAddress,
		"%hhu.%hhu.%hhu.%hhu",
		&address->address.ipv4[0], &address->address.ipv4[1],
		&address->address.ipv4[2], &address->address.ipv4[3]);
		return status == 4 ? OK : BAD_VALUE;
		} else if (getAudioDeviceOutAllUsbSet().count(device) > 0
		\|\| getAudioDeviceInAllUsbSet().count(device) > 0) {
		int status = sscanf(halAddress,
		"card=%d;device=%d",
		&address->address.alsa.card, &address->address.alsa.device);
		return status == 2 ? OK : BAD_VALUE;
		} else if (device == AUDIO_DEVICE_OUT_BUS \|\| device == AUDIO_DEVICE_IN_BUS) {
		address->busAddress = halAddress;
		return OK;
		} else if (device == AUDIO_DEVICE_OUT_REMOTE_SUBMIX
		\|\| device == AUDIO_DEVICE_IN_REMOTE_SUBMIX) {
		address->rSubmixAddress = halAddress;
		return OK;
		}
		return OK;
		}

		} // namespace

		DeviceHalHidl::DeviceHalHidl(const sp<IDevice>& device)
		: ConversionHelperHidl("Device"), mDevice(device),
		mPrimaryDevice(IPrimaryDevice::castFrom(device)) {
		@@ -237,16 +195,22 @@ status_t DeviceHalHidl::openOutputStream(
		sp<StreamOutHalInterface> *outStream) {
		if (mDevice == 0) return NO_INIT;
		DeviceAddress hidlDevice;
		status_t status = deviceAddressFromHal(deviceType, address, &hidlDevice);
		if (status != OK) return status;
		if (status_t status = CoreUtils::deviceAddressFromHal(deviceType, address, &hidlDevice);
		status != OK) {
		return status;
		}
		AudioConfig hidlConfig;
		HidlUtils::audioConfigFromHal(config, false /isInput*/, &hidlConfig);
		if (status_t status = HidlUtils::audioConfigFromHal(config, false /isInput*/, &hidlConfig);
		status != OK) {
		return status;
		}
		CoreUtils::AudioOutputFlags hidlFlags;
		if (status_t status = CoreUtils::audioOutputFlagsFromHal(flags, &hidlFlags); status != OK) {
		return status;
		}
		Result retval = Result::NOT_INITIALIZED;
		Return<void> ret = mDevice->openOutputStream(
		handle,
		hidlDevice,
		hidlConfig,
		EnumBitfield<AudioOutputFlag>(flags),
		handle, hidlDevice, hidlConfig, hidlFlags,
		#if MAJOR_VERSION >= 4
		{} /* metadata */,
		#endif
		@@ -272,17 +236,30 @@ status_t DeviceHalHidl::openInputStream(
		sp<StreamInHalInterface> *inStream) {
		if (mDevice == 0) return NO_INIT;
		DeviceAddress hidlDevice;
		status_t status = deviceAddressFromHal(devices, address, &hidlDevice);
		if (status != OK) return status;
		if (status_t status = CoreUtils::deviceAddressFromHal(devices, address, &hidlDevice);
		status != OK) {
		return status;
		}
		AudioConfig hidlConfig;
		HidlUtils::audioConfigFromHal(config, true /isInput*/, &hidlConfig);
		if (status_t status = HidlUtils::audioConfigFromHal(config, true /isInput*/, &hidlConfig);
		status != OK) {
		return status;
		}
		CoreUtils::AudioInputFlags hidlFlags;
		if (status_t status = CoreUtils::audioInputFlagsFromHal(flags, &hidlFlags); status != OK) {
		return status;
		}
		Result retval = Result::NOT_INITIALIZED;
		#if MAJOR_VERSION == 2
		auto sinkMetadata = AudioSource(source);
		#elif MAJOR_VERSION >= 4
		// TODO: correctly propagate the tracks sources and volume
		// for now, only send the main source at 1dbfs
		SinkMetadata sinkMetadata = {{{ .source = AudioSource(source), .gain = 1 }}};
		AudioSource hidlSource;
		if (status_t status = HidlUtils::audioSourceFromHal(source, &hidlSource); status != OK) {
		return status;
		}
		SinkMetadata sinkMetadata = {{{ .source = std::move(hidlSource), .gain = 1 }}};
		#endif
		#if MAJOR_VERSION < 5
		(void)outputDevice;
		@@ -290,8 +267,10 @@ status_t DeviceHalHidl::openInputStream(
		#else
		if (outputDevice != AUDIO_DEVICE_NONE) {
		DeviceAddress hidlOutputDevice;
		status = deviceAddressFromHal(outputDevice, outputDeviceAddress, &hidlOutputDevice);
		if (status != OK) return status;
		if (status_t status = CoreUtils::deviceAddressFromHal(
		outputDevice, outputDeviceAddress, &hidlOutputDevice); status != OK) {
		return status;
		}
		sinkMetadata.tracks[0].destination.device(std::move(hidlOutputDevice));
		}
		#endif
		@@ -300,11 +279,7 @@ status_t DeviceHalHidl::openInputStream(
		flags = static_cast<audio_input_flags_t>(flags & ~AUDIO_INPUT_FLAG_DIRECT);
		#endif
		Return<void> ret = mDevice->openInputStream(
		handle,
		hidlDevice,
		hidlConfig,
		EnumBitfield<AudioInputFlag>(flags),
		sinkMetadata,
		handle, hidlDevice, hidlConfig, hidlFlags, sinkMetadata,
		[&](Result r, const sp<IStreamIn>& result, const AudioConfig& suggestedConfig) {
		retval = r;
		if (retval == Result::OK) {
		@@ -441,7 +416,7 @@ status_t DeviceHalHidl::getMicrophones(std::vector<media::MicrophoneInfo> *micro
		for (size_t k = 0; k < micArrayHal.size(); k++) {
		audio_microphone_characteristic_t dst;
		//convert
		microphoneInfoToHal(micArrayHal[k], &dst);
		(void)CoreUtils::microphoneInfoToHal(micArrayHal[k], &dst);
		media::MicrophoneInfo microphone = media::MicrophoneInfo(dst);
		microphonesInfo->push_back(microphone);
		}