Snap for 4560043 from 8a03c92df4685088c0a1438ee233a086dfe33ebb to pi-release (c4e46c06) · Commits · e / os / android_hardware_interfaces

audio/2.0/default/Android.mk

+4 −42

Original line number	Diff line number	Diff line
		@@ -16,45 +16,6 @@

		LOCAL_PATH := $(call my-dir)

		include $(CLEAR_VARS)
		LOCAL_MODULE := android.hardware.audio@2.0-impl
		LOCAL_MODULE_RELATIVE_PATH := hw
		LOCAL_PROPRIETARY_MODULE := true
		LOCAL_SRC_FILES := \
		Conversions.cpp \
		Device.cpp \
		DevicesFactory.cpp \
		ParametersUtil.cpp \
		PrimaryDevice.cpp \
		Stream.cpp \
		StreamIn.cpp \
		StreamOut.cpp \

		LOCAL_CFLAGS := -Wall -Werror

		LOCAL_SHARED_LIBRARIES := \
		libbase \
		libcutils \
		libfmq \
		libhardware \
		libhidlbase \
		libhidltransport \
		liblog \
		libutils \
		android.hardware.audio@2.0 \
		android.hardware.audio.common@2.0 \
		android.hardware.audio.common@2.0-util \

		LOCAL_HEADER_LIBRARIES := \
		libaudioclient_headers \
		libaudio_system_headers \
		libhardware_headers \
		libmedia_headers \

		LOCAL_WHOLE_STATIC_LIBRARIES := libmedia_helper

		include $(BUILD_SHARED_LIBRARY)

		#
		# Service
		#
		@@ -78,10 +39,11 @@ LOCAL_SHARED_LIBRARIES := \
		android.hardware.audio@2.0 \
		android.hardware.audio.common@2.0 \
		android.hardware.audio.effect@2.0 \
		android.hardware.soundtrigger@2.1 \
		android.hardware.broadcastradio@1.0 \
		android.hardware.broadcastradio@1.1
		android.hardware.soundtrigger@2.0 \
		android.hardware.soundtrigger@2.1

		# Can not switch to Android.bp until AUDIOSERVER_MULTILIB
		# is deprecated as build config variable are not supported
		ifeq ($(strip $(AUDIOSERVER_MULTILIB)),)
		LOCAL_MULTILIB := 32
		else

audio/2.0/default/service.cpp

+7 −3

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@

		#include <android/hardware/audio/2.0/IDevicesFactory.h>
		#include <android/hardware/audio/effect/2.0/IEffectsFactory.h>
		#include <android/hardware/soundtrigger/2.0/ISoundTriggerHw.h>
		#include <android/hardware/soundtrigger/2.1/ISoundTriggerHw.h>
		#include <hidl/HidlTransportSupport.h>
		#include <hidl/LegacySupport.h>
		@@ -28,7 +29,8 @@ using android::hardware::registerPassthroughServiceImplementation;

		using android::hardware::audio::effect::V2_0::IEffectsFactory;
		using android::hardware::audio::V2_0::IDevicesFactory;
		using android::hardware::soundtrigger::V2_1::ISoundTriggerHw;
		using V2_0_ISoundTriggerHw = android::hardware::soundtrigger::V2_0::ISoundTriggerHw;
		using V2_1_ISoundTriggerHw = android::hardware::soundtrigger::V2_1::ISoundTriggerHw;
		using android::hardware::registerPassthroughServiceImplementation;

		using android::OK;
		@@ -41,8 +43,10 @@ int main(int /* argc /, char /* argv */ []) {
		status = registerPassthroughServiceImplementation<IEffectsFactory>();
		LOG_ALWAYS_FATAL_IF(status != OK, "Error while registering audio effects service: %d", status);
		// Soundtrigger might be not present.
		status = registerPassthroughServiceImplementation<ISoundTriggerHw>();
		ALOGE_IF(status != OK, "Error while registering soundtrigger service: %d", status);
		status = registerPassthroughServiceImplementation<V2_1_ISoundTriggerHw>();
		ALOGW_IF(status != OK, "Registering soundtrigger V2.1 service was unsuccessful: %d", status);
		status = registerPassthroughServiceImplementation<V2_0_ISoundTriggerHw>();
		ALOGW_IF(status != OK, "Registering soundtrigger V2.0 service was unsuccessful: %d", status);
		joinRpcThreadpool();
		return status;
		}

audio/README

0 → 100644

+47 −0

Original line number	Diff line number	Diff line
		Directory structure of the audio HIDL related code.

		audio
		\|-- 2.0 <== legacy 2.0 core HIDL (.hal) can not be moved to fit
		\| the directory structure because already published
		\|
		\|-- common <== code common to audio core and effect API
		\| \|-- 2.0
		\| \| \|-- default <== code that wraps the legacy API
		\| \| `-- vts <== vts of 2.0 core and effect API common code
		\| \|-- 4.0
		\| \| \|-- default
		\| \| `-- vts
		\| \|-- ... <== The future versions should continue this structure
		\| \| \|-- default
		\| \| `-- vts
		\| `-- all_versions <== code common to all version of both core and effect API
		\| \|-- default
		\| `-- vts <== vts of core and effect API common version independent code
		\|
		\|-- core <== code relative to the core API
		\| \|-- 2.0 <== 2.0 core API code (except .hal, see audio/2.0)
		\| \| \|-- default
		\| \| `-- vts
		\| \|-- 4.0
		\| \| \|-- default <== default implementation of the core 4.0 api
		\| \| `-- vts <== vts code of the 4.0 API
		\| \|-- ...
		\| \| \|-- default
		\| \| `-- vts
		\| `-- all_versions
		\| \|-- default
		\| `-- vts <== vts of core API common version independent code
		\|
		`-- effect <== idem for the effect API
		\|-- 2.0
		\| \|-- default
		\| `-- vts
		\|-- 4.0
		\| \|-- default
		\| `-- vts
		\|-- ...
		\| \|-- default
		\| `-- vts
		`-- all_versions
		\|-- default
		`-- vts

audio/common/2.0/default/Android.bp

+7 −1

Original line number	Diff line number	Diff line
		@@ -21,18 +21,24 @@ cc_library_shared {
		enabled: true,
		},
		srcs: [
		"EffectMap.cpp",
		"HidlUtils.cpp",
		],

		export_include_dirs: ["."],

		static_libs: [
		],

		shared_libs: [
		"liblog",
		"libutils",
		"libhidlbase",
		"android.hardware.audio.common-util",
		"android.hardware.audio.common@2.0",
		],
		export_shared_lib_headers: [
		"android.hardware.audio.common-util"
		],

		header_libs: [
		"libaudio_system_headers",

audio/common/2.0/default/HidlUtils.cpp

+3 −319

Original line number	Diff line number	Diff line
		@@ -14,324 +14,8 @@
		* limitations under the License.
		*/

		#include <string.h>

		#include "HidlUtils.h"

		using ::android::hardware::audio::common::V2_0::AudioChannelMask;
		using ::android::hardware::audio::common::V2_0::AudioDevice;
		using ::android::hardware::audio::common::V2_0::AudioFormat;
		using ::android::hardware::audio::common::V2_0::AudioGainMode;
		using ::android::hardware::audio::common::V2_0::AudioMixLatencyClass;
		using ::android::hardware::audio::common::V2_0::AudioPortConfigMask;
		using ::android::hardware::audio::common::V2_0::AudioPortRole;
		using ::android::hardware::audio::common::V2_0::AudioPortType;
		using ::android::hardware::audio::common::V2_0::AudioSource;
		using ::android::hardware::audio::common::V2_0::AudioStreamType;
		using ::android::hardware::audio::common::V2_0::AudioUsage;

		namespace android {

		void HidlUtils::audioConfigFromHal(const audio_config_t& halConfig, AudioConfig* config) {
		config->sampleRateHz = halConfig.sample_rate;
		config->channelMask = AudioChannelMask(halConfig.channel_mask);
		config->format = AudioFormat(halConfig.format);
		audioOffloadInfoFromHal(halConfig.offload_info, &config->offloadInfo);
		config->frameCount = halConfig.frame_count;
		}

		void HidlUtils::audioConfigToHal(const AudioConfig& config, audio_config_t* halConfig) {
		memset(halConfig, 0, sizeof(audio_config_t));
		halConfig->sample_rate = config.sampleRateHz;
		halConfig->channel_mask = static_cast<audio_channel_mask_t>(config.channelMask);
		halConfig->format = static_cast<audio_format_t>(config.format);
		audioOffloadInfoToHal(config.offloadInfo, &halConfig->offload_info);
		halConfig->frame_count = config.frameCount;
		}

		void HidlUtils::audioGainConfigFromHal(
		const struct audio_gain_config& halConfig, AudioGainConfig* config) {
		config->index = halConfig.index;
		config->mode = AudioGainMode(halConfig.mode);
		config->channelMask = AudioChannelMask(halConfig.channel_mask);
		for (size_t i = 0; i < sizeof(audio_channel_mask_t) * 8; ++i) {
		config->values[i] = halConfig.values[i];
		}
		config->rampDurationMs = halConfig.ramp_duration_ms;
		}

		void HidlUtils::audioGainConfigToHal(
		const AudioGainConfig& config, struct audio_gain_config* halConfig) {
		halConfig->index = config.index;
		halConfig->mode = static_cast<audio_gain_mode_t>(config.mode);
		halConfig->channel_mask = static_cast<audio_channel_mask_t>(config.channelMask);
		memset(halConfig->values, 0, sizeof(halConfig->values));
		for (size_t i = 0; i < sizeof(audio_channel_mask_t) * 8; ++i) {
		halConfig->values[i] = config.values[i];
		}
		halConfig->ramp_duration_ms = config.rampDurationMs;
		}

		void HidlUtils::audioGainFromHal(const struct audio_gain& halGain, AudioGain* gain) {
		gain->mode = AudioGainMode(halGain.mode);
		gain->channelMask = AudioChannelMask(halGain.channel_mask);
		gain->minValue = halGain.min_value;
		gain->maxValue = halGain.max_value;
		gain->defaultValue = halGain.default_value;
		gain->stepValue = halGain.step_value;
		gain->minRampMs = halGain.min_ramp_ms;
		gain->maxRampMs = halGain.max_ramp_ms;
		}

		void HidlUtils::audioGainToHal(const AudioGain& gain, struct audio_gain* halGain) {
		halGain->mode = static_cast<audio_gain_mode_t>(gain.mode);
		halGain->channel_mask = static_cast<audio_channel_mask_t>(gain.channelMask);
		halGain->min_value = gain.minValue;
		halGain->max_value = gain.maxValue;
		halGain->default_value = gain.defaultValue;
		halGain->step_value = gain.stepValue;
		halGain->min_ramp_ms = gain.minRampMs;
		halGain->max_ramp_ms = gain.maxRampMs;
		}

		void HidlUtils::audioOffloadInfoFromHal(
		const audio_offload_info_t& halOffload, AudioOffloadInfo* offload) {
		offload->sampleRateHz = halOffload.sample_rate;
		offload->channelMask = AudioChannelMask(halOffload.channel_mask);
		offload->format = AudioFormat(halOffload.format);
		offload->streamType = AudioStreamType(halOffload.stream_type);
		offload->bitRatePerSecond = halOffload.bit_rate;
		offload->durationMicroseconds = halOffload.duration_us;
		offload->hasVideo = halOffload.has_video;
		offload->isStreaming = halOffload.is_streaming;
		offload->bitWidth = halOffload.bit_width;
		offload->bufferSize = halOffload.offload_buffer_size;
		offload->usage = static_cast<AudioUsage>(halOffload.usage);
		}

		void HidlUtils::audioOffloadInfoToHal(
		const AudioOffloadInfo& offload, audio_offload_info_t* halOffload) {
		*halOffload = AUDIO_INFO_INITIALIZER;
		halOffload->sample_rate = offload.sampleRateHz;
		halOffload->channel_mask = static_cast<audio_channel_mask_t>(offload.channelMask);
		halOffload->format = static_cast<audio_format_t>(offload.format);
		halOffload->stream_type = static_cast<audio_stream_type_t>(offload.streamType);
		halOffload->bit_rate = offload.bitRatePerSecond;
		halOffload->duration_us = offload.durationMicroseconds;
		halOffload->has_video = offload.hasVideo;
		halOffload->is_streaming = offload.isStreaming;
		halOffload->bit_width = offload.bitWidth;
		halOffload->offload_buffer_size = offload.bufferSize;
		halOffload->usage = static_cast<audio_usage_t>(offload.usage);
		}

		void HidlUtils::audioPortConfigFromHal(
		const struct audio_port_config& halConfig, AudioPortConfig* config) {
		config->id = halConfig.id;
		config->role = AudioPortRole(halConfig.role);
		config->type = AudioPortType(halConfig.type);
		config->configMask = AudioPortConfigMask(halConfig.config_mask);
		config->sampleRateHz = halConfig.sample_rate;
		config->channelMask = AudioChannelMask(halConfig.channel_mask);
		config->format = AudioFormat(halConfig.format);
		audioGainConfigFromHal(halConfig.gain, &config->gain);
		switch (halConfig.type) {
		case AUDIO_PORT_TYPE_NONE: break;
		case AUDIO_PORT_TYPE_DEVICE: {
		config->ext.device.hwModule = halConfig.ext.device.hw_module;
		config->ext.device.type = AudioDevice(halConfig.ext.device.type);
		memcpy(config->ext.device.address.data(),
		halConfig.ext.device.address,
		AUDIO_DEVICE_MAX_ADDRESS_LEN);
		break;
		}
		case AUDIO_PORT_TYPE_MIX: {
		config->ext.mix.hwModule = halConfig.ext.mix.hw_module;
		config->ext.mix.ioHandle = halConfig.ext.mix.handle;
		if (halConfig.role == AUDIO_PORT_ROLE_SOURCE) {
		config->ext.mix.useCase.source = AudioSource(halConfig.ext.mix.usecase.source);
		} else if (halConfig.role == AUDIO_PORT_ROLE_SINK) {
		config->ext.mix.useCase.stream = AudioStreamType(halConfig.ext.mix.usecase.stream);
		}
		break;
		}
		case AUDIO_PORT_TYPE_SESSION: {
		config->ext.session.session = halConfig.ext.session.session;
		break;
		}
		}
		}

		void HidlUtils::audioPortConfigToHal(
		const AudioPortConfig& config, struct audio_port_config* halConfig) {
		memset(halConfig, 0, sizeof(audio_port_config));
		halConfig->id = config.id;
		halConfig->role = static_cast<audio_port_role_t>(config.role);
		halConfig->type = static_cast<audio_port_type_t>(config.type);
		halConfig->config_mask = static_cast<unsigned int>(config.configMask);
		halConfig->sample_rate = config.sampleRateHz;
		halConfig->channel_mask = static_cast<audio_channel_mask_t>(config.channelMask);
		halConfig->format = static_cast<audio_format_t>(config.format);
		audioGainConfigToHal(config.gain, &halConfig->gain);
		switch (config.type) {
		case AudioPortType::NONE: break;
		case AudioPortType::DEVICE: {
		halConfig->ext.device.hw_module = config.ext.device.hwModule;
		halConfig->ext.device.type = static_cast<audio_devices_t>(config.ext.device.type);
		memcpy(halConfig->ext.device.address,
		config.ext.device.address.data(),
		AUDIO_DEVICE_MAX_ADDRESS_LEN);
		break;
		}
		case AudioPortType::MIX: {
		halConfig->ext.mix.hw_module = config.ext.mix.hwModule;
		halConfig->ext.mix.handle = config.ext.mix.ioHandle;
		if (config.role == AudioPortRole::SOURCE) {
		halConfig->ext.mix.usecase.source =
		static_cast<audio_source_t>(config.ext.mix.useCase.source);
		} else if (config.role == AudioPortRole::SINK) {
		halConfig->ext.mix.usecase.stream =
		static_cast<audio_stream_type_t>(config.ext.mix.useCase.stream);
		}
		break;
		}
		case AudioPortType::SESSION: {
		halConfig->ext.session.session =
		static_cast<audio_session_t>(config.ext.session.session);
		break;
		}
		}
		}

		void HidlUtils::audioPortConfigsFromHal(
		unsigned int numHalConfigs, const struct audio_port_config *halConfigs,
		hidl_vec<AudioPortConfig> *configs) {
		configs->resize(numHalConfigs);
		for (unsigned int i = 0; i < numHalConfigs; ++i) {
		audioPortConfigFromHal(halConfigs[i], &(*configs)[i]);
		}
		}

		std::unique_ptr<audio_port_config[]> HidlUtils::audioPortConfigsToHal(
		const hidl_vec<AudioPortConfig>& configs) {
		std::unique_ptr<audio_port_config[]> halConfigs(new audio_port_config[configs.size()]);
		for (size_t i = 0; i < configs.size(); ++i) {
		audioPortConfigToHal(configs[i], &halConfigs[i]);
		}
		return halConfigs;
		}

		void HidlUtils::audioPortFromHal(const struct audio_port& halPort, AudioPort* port) {
		port->id = halPort.id;
		port->role = AudioPortRole(halPort.role);
		port->type = AudioPortType(halPort.type);
		port->name.setToExternal(halPort.name, strlen(halPort.name));
		port->sampleRates.resize(halPort.num_sample_rates);
		for (size_t i = 0; i < halPort.num_sample_rates; ++i) {
		port->sampleRates[i] = halPort.sample_rates[i];
		}
		port->channelMasks.resize(halPort.num_channel_masks);
		for (size_t i = 0; i < halPort.num_channel_masks; ++i) {
		port->channelMasks[i] = AudioChannelMask(halPort.channel_masks[i]);
		}
		port->formats.resize(halPort.num_formats);
		for (size_t i = 0; i < halPort.num_formats; ++i) {
		port->formats[i] = AudioFormat(halPort.formats[i]);
		}
		port->gains.resize(halPort.num_gains);
		for (size_t i = 0; i < halPort.num_gains; ++i) {
		audioGainFromHal(halPort.gains[i], &port->gains[i]);
		}
		audioPortConfigFromHal(halPort.active_config, &port->activeConfig);
		switch (halPort.type) {
		case AUDIO_PORT_TYPE_NONE: break;
		case AUDIO_PORT_TYPE_DEVICE: {
		port->ext.device.hwModule = halPort.ext.device.hw_module;
		port->ext.device.type = AudioDevice(halPort.ext.device.type);
		memcpy(port->ext.device.address.data(),
		halPort.ext.device.address,
		AUDIO_DEVICE_MAX_ADDRESS_LEN);
		break;
		}
		case AUDIO_PORT_TYPE_MIX: {
		port->ext.mix.hwModule = halPort.ext.mix.hw_module;
		port->ext.mix.ioHandle = halPort.ext.mix.handle;
		port->ext.mix.latencyClass = AudioMixLatencyClass(halPort.ext.mix.latency_class);
		break;
		}
		case AUDIO_PORT_TYPE_SESSION: {
		port->ext.session.session = halPort.ext.session.session;
		break;
		}
		}
		}

		void HidlUtils::audioPortToHal(const AudioPort& port, struct audio_port* halPort) {
		memset(halPort, 0, sizeof(audio_port));
		halPort->id = port.id;
		halPort->role = static_cast<audio_port_role_t>(port.role);
		halPort->type = static_cast<audio_port_type_t>(port.type);
		memcpy(halPort->name,
		port.name.c_str(),
		std::min(port.name.size(), static_cast<size_t>(AUDIO_PORT_MAX_NAME_LEN)));
		halPort->num_sample_rates =
		std::min(port.sampleRates.size(), static_cast<size_t>(AUDIO_PORT_MAX_SAMPLING_RATES));
		for (size_t i = 0; i < halPort->num_sample_rates; ++i) {
		halPort->sample_rates[i] = port.sampleRates[i];
		}
		halPort->num_channel_masks =
		std::min(port.channelMasks.size(), static_cast<size_t>(AUDIO_PORT_MAX_CHANNEL_MASKS));
		for (size_t i = 0; i < halPort->num_channel_masks; ++i) {
		halPort->channel_masks[i] = static_cast<audio_channel_mask_t>(port.channelMasks[i]);
		}
		halPort->num_formats =
		std::min(port.formats.size(), static_cast<size_t>(AUDIO_PORT_MAX_FORMATS));
		for (size_t i = 0; i < halPort->num_formats; ++i) {
		halPort->formats[i] = static_cast<audio_format_t>(port.formats[i]);
		}
		halPort->num_gains = std::min(port.gains.size(), static_cast<size_t>(AUDIO_PORT_MAX_GAINS));
		for (size_t i = 0; i < halPort->num_gains; ++i) {
		audioGainToHal(port.gains[i], &halPort->gains[i]);
		}
		audioPortConfigToHal(port.activeConfig, &halPort->active_config);
		switch (port.type) {
		case AudioPortType::NONE: break;
		case AudioPortType::DEVICE: {
		halPort->ext.device.hw_module = port.ext.device.hwModule;
		halPort->ext.device.type = static_cast<audio_devices_t>(port.ext.device.type);
		memcpy(halPort->ext.device.address,
		port.ext.device.address.data(),
		AUDIO_DEVICE_MAX_ADDRESS_LEN);
		break;
		}
		case AudioPortType::MIX: {
		halPort->ext.mix.hw_module = port.ext.mix.hwModule;
		halPort->ext.mix.handle = port.ext.mix.ioHandle;
		halPort->ext.mix.latency_class =
		static_cast<audio_mix_latency_class_t>(port.ext.mix.latencyClass);
		break;
		}
		case AudioPortType::SESSION: {
		halPort->ext.session.session = static_cast<audio_session_t>(port.ext.session.session);
		break;
		}
		}
		}

		void HidlUtils::uuidFromHal(const audio_uuid_t& halUuid, Uuid* uuid) {
		uuid->timeLow = halUuid.timeLow;
		uuid->timeMid = halUuid.timeMid;
		uuid->versionAndTimeHigh = halUuid.timeHiAndVersion;
		uuid->variantAndClockSeqHigh = halUuid.clockSeq;
		memcpy(uuid->node.data(), halUuid.node, uuid->node.size());
		}

		void HidlUtils::uuidToHal(const Uuid& uuid, audio_uuid_t* halUuid) {
		halUuid->timeLow = uuid.timeLow;
		halUuid->timeMid = uuid.timeMid;
		halUuid->timeHiAndVersion = uuid.versionAndTimeHigh;
		halUuid->clockSeq = uuid.variantAndClockSeqHigh;
		memcpy(halUuid->node, uuid.node.data(), uuid.node.size());
		}

		} // namespace android
		#define AUDIO_HAL_VERSION V2_0
		#include <common/all-versions/default/HidlUtils.impl.h>
		#undef AUDIO_HAL_VERSION